Dicas Para Melhorar sua Codificação em Arduino

Tenho programado e desativado em diferentes idiomas ao longo de minha carreira de mais de 30 anos por diferentes razões. Uma coisa que aprendi rapidamente é que todas as linguagens de programação têm uma coisa em comum. Você pode escrever um programa totalmente funcional que, 24 horas após a conclusão, ninguém consegue entender como ele funciona; até o próprio programador está completamente confuso sobre como isso poderia funcionar.

O primeiro passo para aprender uma nova linguagem de programação é como escrever código legível (na minha opinião, isso é). É difícil de fazer quando você começa a aprender, mas se você seguir as 5 dicas, verá a diferença na rapidez com que melhorará suas habilidades e poderá reutilizar seu código mesmo meses depois de concluir o projeto.

Antes de prosseguir eu gostaria de avisar que aqui abaixo eu irei dar 5 ótimas dicas, mas se você deseja se tornar um profissional da área eu recomendo que faça um curso de arduino que te ensinará o passo a passo de forma bem didática.

5 dicas para melhorar a usabilidade do seu código.

1. Use nomes descritivos de variáveis

Eu vejo isso com tanta frequência; int x = 100; ou String y = ”olá molly” ;. É completamente legal e correto fazê-lo, mas os nomes dessas variáveis ​​não dizem nada sobre o que fazem. Mesmo se x e y neste exemplo têm algo a ver com a plotagem de dados no eixo ax / y, os nomes são muito ambíguos.

Sempre dê nomes às suas variáveis ​​que façam sentido, por exemplo, int x_Axis = 100 ;. Se você declarar uma variável para um pino digital que será usado com um botão que acende um LED, use button_led_on_off_Pin. Este nome tem significado. Ele diz que tem algo a ver com um botão que liga e desliga um led.

Na minha opinião, o único lugar em que é aceitável usar variáveis ​​de caractere único está em coisas como uma variável de inicialização de loop for () ou algo semelhante.

2. Recue seu código adequadamente

Recue seu código adequadamente! Se você possui instruções if aninhadas que não são recuadas adequadamente, fica muito difícil ler seu código. Será ainda mais difícil depurar se você tiver um erro lógico (sua sintaxe do código está correta, mas o código não faz o que você esperava), veja este exemplo de código:

void  loop ( )  { 
if ( ouriço == gato ) { 
if ( gato == likehedgehog ) { 
  // ouriço e gato são amigos 
} else  if ( ouriço ! = cat ) { 
  // ouriço e gato são amigos 
} else  if ( cat  ! =  ouriço ) { 
  // ouriço e gato não são amigos 
} 
} mais { 
  // ouriço e gato não estão na mesma sala 
} 
}

Agora veja o próximo exemplo de código usando indentação:

void  loop ( )  { 
  if ( ouriço == gato ) { 
    if ( gato == likehedgehog ) { 
      // ouriço e gato são amigos 
    } else  if ( ouriço ! = cat ) { 
      // ouriço e gato são amigos 
    } else  if ( cat  ! =  ouriço ) { 
      // ouriço e gato não são amigos 
    } 
  } mais { 
    // ouriço e gato não estão na mesma sala 
  } 
}

Observe como é mais fácil ler seu código. Você pode ver como essas instruções if () estão aninhadas e facilita muito a localização do seu erro lógico. Às vezes eu esqueço de adicionar um colchete de fechamento. Você completa seu código e recebe a mensagem de erro “esperado ‘}’ antes de ‘mais'” ao compilar. No exemplo de código recuado, levaria apenas alguns segundos para descobrir qual colchete estava faltando, boa sorte para encontrar o erro no código não recuado.

3. Use elogios por favor

Os elogios fazem parte do processo de documentação (mas não são considerados documentação) Todas as linguagens de programação permitem que você faça comentários. Na minha opinião, dar uma breve explicação para que uma variável é usada (na instância da declaração) faz muito sentido e dá à pessoa que tenta entender seu código (pode ser você mesmo três meses depois de terminar) e por dentro dessa variável é usado para.

int cat = 0; // Se o gato estiver na sala, o valor é 1, caso contrário, o valor é 0

Se você tiver uma instrução if () aninhada complexa ou um loop for (), poderá fazer algo assim.

 loop vazio ( )  { 
  int  cat = 0 ; // Se o gato está na sala, o valor é 1, caso contrário, o valor é 0 
  int  hedgehog = 0 ; // Se o hedgehow estiver na sala, o valor será 1, caso contrário, o valor será 0 
  int  likehedgehog = 0 ; // Se o gato gosta do valor do ouriço é 1, caso contrário, o valor é 0 
  int  likecat ; // Se o ouriço gosta do gato, o valor é 1, caso contrário, o valor é 0
    
    / ** 
     * Este bloco if () aninhado deve verificar se o ouriço e o gato estão na mesma sala. 
     * Se eles estão na mesma sala, verificamos se eles gostam um do outro 
     * Se o gato gosta do ouriço está tudo bem, se o gato não encontrar o ouriço 
     * eles precisam ser separados 
     * / 
    if ( ouriço == gato ) { 
        if ( cat == likehedgehog ) { 
            // ouriço e gato são amigos 
        } mais  se ( ouriço ! = likecat ) { 
            // ouriço e gato são amigos 
        } mais if ( cat ! = likehedgehog ) { 
            // ouriço e gato não são amigos 
        } 
    } else { 
      // ouriço e gato não estão na mesma sala 
    } 
}

Observe que a descrição estendida ajuda a pessoa que está lendo seu código a entender a função desse bloco de código. Também coloquei uma descrição detalhada na parte superior dos meus esboços, explicando qual é a função desse código, meu nome e, às vezes, minhas informações de contato, a data em que terminei e a versão desse código atual.

/ ** 
* Autor: Ab Kurk akurk@thearduinomakerman.info 
* Data: 04 / dez / 2017 
* Versão 1.0.0 
* Descrição 
* Este esboço deve ser usado para rastrear a localização do meu gato e ouriço. 
* O objetivo é garantir que hoje meu gato goste do meu ouriço. 
* 
* /

Se mais tarde eu voltar e fizer alterações, atualizo a versão e dou uma descrição do que alterei, em que data e quem o alterou na parte inferior do bloco de descrição.

4. Use as funções () para organizar e reutilizar seu código

As funções podem ser consideradas um nível intermediário, mas mesmo como iniciante, faz sentido tentar fazer isso. Se você tiver grandes blocos de código que atendem a um propósito específico, faz sentido colocá-lo em uma função separada. Isso torna seu código mais legível e também pode reduzir a quantidade de código que você escreve, porque é mais fácil reutilizar o mesmo código em uma parte diferente do seu programa.

Como exemplo, aqui está um pedaço de código de um tutorial anterior que fiz sobre a leitura de dados fora da memória. Primeiro sem o uso de uma função;

void  loop ( )  { 
  // coloque seu código principal aqui, para executar repetidamente: 
  String  ssid = "" ; 
  Senha da string  = "" ; / **    * Lendo o ssid sem memória usando a biblioteca eeprom    * O ssid inicia na posição 0 da memória e possui 30 caracteres    * /

  for  ( int  n  =  0 ;  n  <  30 ;  ++ n ) 
    { 
     if ( char ( EEPROM . read ( n ) ) ! = ';' ) { // procurando pelo final do caractere de dados ';' 
        se ( isWhitespace ( Char ( EEPROM . ler ( n ) ) ) ) { // Remover whytespaces por exemplo, um espaço 
          // fazer nada 
        } else  SSID + =  String ( char ( EEPROM . Read ( n ) ) ) ;
      
     } mais  n = 31 ; 
    }

  / ** 
   * Lendo a senha sem memória usando a biblioteca eeprom 
   * O ssid inicia na posição 100 da memória e possui 30 caracteres 
   * /
  
  for  ( int  n  =  100 ;  n  <  130 ;  ++ n ) 
    { 
     if ( char ( EEPROM . read ( n ) ) ! = ';' ) { // procurando pelo final do caractere de dados ';' 
        se ( isWhitespace ( Char ( EEPROM . ler ( n ) ) ) ) { // Remover whytespaces por exemplo, um espaço 
          // fazer nada 
        } else ssid  + =  String ( char ( EEPROM . leia ( n ) ) ) ;
      
     } mais  n = 131 ; 
    } 
}

Você vê que temos dois blocos de código fazendo exatamente a mesma coisa. Aqui está um exemplo do mesmo código, mas usando uma função;

void  loop ( )  { 
  // coloque seu código principal aqui, para executar repetidamente: 
  String  ssid = "" ; 
  Senha da string  = "" ; / **    * Lendo uma string com falta de memória usando a biblioteca eeprom    * O read_string (comprimento dos dados int, posição na memória int) é uma função    * que você chama para ler dados da memória. Você fornece a posição inicial    * na memória e o comprimento e ele retorna uma string contendo os dados    * / ssid = read_string ( 0 , 30 ) ; // lê ssid sem memória
  
  senha = string de leitura ( 100 , 30 ) ; // lê a senha sem memória

/ ** 
* Lê uma string com memória insuficiente, l é o comprimento dos dados a serem lidos na memória, 
* p é a posição na memória onde começar a ler 
* / 
String  read_string ( int  l ,  int  p ) { 
  String  temp ; 
  for  ( int  n  =  p ;  n  <  l + p ;  ++ n ) 
    { 
     if ( char ( EEPROM . read ( n ) ) ! = ';') { 
        Se ( isWhitespace ( carvão animal ( EEPROM . Lido ( n ) ) ) ) { 
          // faz nada 
        } else  Temp  + =  Cadeia ( carvão animal ( EEPROM . Lido ( n ) ) ) ;
      
     } mais  n = l + p ;
     
    } 
  retornar  temperatura ; 
}

Você pode ver que eu reutilizei o código criando uma função. Isso facilita a leitura e usa menos memória na placa controladora. Se você se familiarizar com o uso de funções, economizará tempo e criará um código mais amigável que poderá reutilizar em seu próximo projeto.

5. Documento, documento, documento

A documentação do seu projeto é provavelmente a coisa mais difícil e chata do seu projeto. Para mim, sempre parecia uma tarefa irritante que não era realmente necessária. Para clientes e empregadores, é frequentemente visto como um desperdício de tempo e dinheiro. A realidade é que sempre economizará tempo e dinheiro no back-end de um projeto.

 Na minha documentação, sempre tenho uma seção de software e outra de hardware do meu projeto do arduino.

O SOFTWARE:

  • As bibliotecas que usei, as versões e de onde as peguei se as baixasse.
  • Todas as funções que eu criei e uma descrição de sua função e qual linha você pode encontrá-las.
  • Quaisquer métodos e seus filhos
  • Uma explicação completa sobre o que o esboço faz e como usá-lo.

A SEÇÃO DE HARDWARE:

  • Eu coloquei um esquema de como conectá-lo à minha placa de desenvolvimento. Costumo usar o programa fritzing para isso. É fácil de usar e gratuito.
  •  Cada placa de interrupção e sensores usados ​​no projeto, em quais pinos eu os conecto. Também anoto quais bibliotecas de software são necessárias para esse hardware.
  • Se for um sensor exótico ou placa de fuga, também anoto onde o comprei

Em Fechamento

Se você adotar todas ou algumas dessas dicas, você se tornará um programador / criador melhor. Isso também significa que, se 6 meses depois, você fizer o mesmo tipo de projeto, poderá olhar para os projetos concluídos anteriormente e reutilizar seu código e idéias e não precisará reinventar a roda constantemente.

Sei por experiência própria que parece muito mais fácil e gastou menos tempo sem fazer tudo isso e apenas escrever código sem formatação e documentação, mas você estaria errado. Muitas vezes, perdi tanto tempo tentando entender por que fiz algo de uma certa maneira, ou tentando descobrir por que uma variável alterava os valores apenas porque eu a reutilizei da maneira errada.

Se você gostou deste post e gostaria de ver mais do mesmo tipo, assine meu boletim informativo usando o formulário abaixo ou curta minha página no Facebook. Dessa forma, você será notificado quando uma nova postagem estiver disponível. Se você tiver dúvidas ou sugestões, por favor me escreva ou deixe nos comentários abaixo. Tenha um ótimo dia e até a próxima