Interface de linha de comando simples

Componentes e suprimentos

Arduino UNO

Sobre este projeto

Linha de Comando

Chega um momento em que você precisa encontrar o valor de um sensor ou quer dizer ao seu robô para fazer algo como "mover para a esquerda". Talvez você precise pedir ao seu programa o valor do tempo de execução de uma variável ou definir o valor de um potenciômetro digital.

O que você precisa é de uma linha de comando. Sim, é fácil fazer seu Arduino responder a comandos de texto.

Aqui está um em que você pode construir. É uma Interface de linha de comando simples, rápida e com muito uso de memória (CLI) que você pode recortar e colar em alguns minutos em seu próprio código e estar pronto e funcionando. Os comandos consistem em um nome seguido por vários argumentos. Ele até suporta backspace quando você está digitando seus comandos.

Visão geral rápida

Cada esboço tem um loop () função. O seu pode ser tão simples quanto o que está abaixo. Ele chama duas rotinas em uma guia separada chamada CommandLine.h . Vou guiá-lo por esses dois arquivos e você estará pronto e funcionando.

Loop

O que faz: Cada vez que loop () executa, verifica se temos um comando da porta serial, chamando getCommandLineFromSerialPort () . A variável CommandLine é declarado em CommandLine.h mas estilisticamente você pode querer movê-lo para a guia Loop principal. Quando um comando completo chega à porta serial e é copiado para o buffer de comando:

  char commandLine [COMMAND_BUFFER_LENGTH + 1];

Em seguida, loop () chama DoMyCommand () para executar o comando adequado.

Agora vamos dar uma olhada no que está em CommandLine.h . Devo ressaltar que coloquei todo o código em CommandLine.h , porque então tudo que você precisa fazer é recortar e colar esse código em uma nova guia em seu IDE Arduino (certifique-se de dar à guia um nome que termine com " .h "). Em seguida, inclua esse arquivo em seu arquivo principal, ou seja,

  #include "CommandLine.h"

O que isso faz é permitir que você coloque todo o código da linha de comando em uma guia e ainda consulte suas rotinas em outro lugar em seu programa sem nenhum código extra.

Procurando em CommandLine.h

O arquivo CommandLine.h está incluído no final desta postagem. Em CommandLine.h , cada linha que você precisa modificar é marcada com o comentário, // Modifique aqui . O arquivo inclui dois comandos de amostra add e sub e mostra como eles são chamados de dentro do DoMyCommand .

Para muitos de vocês, isso é tudo de que precisam. Basta acessar CommandLine.h . Para quem deseja um visual mais detalhado, continue lendo.

Olhando mais profundamente

Em CommandLine.h primeiro incluímos . String.h é uma biblioteca padrão C . Se você ainda não encontrou bibliotecas C antes, faça uma busca rápida na Internet por "The C Programming Language". A Bíblia C foi escrita anos atrás por Brian Kernigan e Dennis Ritchie e foi mantida atualizada. A maioria das pessoas possui uma cópia, mas você pode encontrá-la online gratuitamente.

Usaremos apenas o strtok () rotina (string para token) de . Esta rotina lê um token, ou seja, uma palavra delimitada por certos caracteres (o segundo parâmetro de strtok ) Funciona assim.

Ao chamá-lo pela primeira vez, você passa uma string ptr e ele retornará o primeiro token

Em chamadas subsequentes, (aqui vem a gloriosa parte do hack) passe NULL em vez de uma string ptr e continuará de onde parou com a string inicial, obtendo assim um token (aproximadamente uma palavra) por vez.

Também incluímos da qual usamos apenas atoi () para conversão ascii-para-inteiro. Não se preocupe, o compilador incluirá apenas essa rotina, não a biblioteca inteira, mas você pode querer verificar as outras rotinas dessas bibliotecas, pois são úteis.

A seguir está uma pequena macro opcional que escrevi chamada print2:

  #define print2 (x, y) (Serial.print (x), Serial.println (y)

Estou sempre querendo imprimir uma etiqueta e um barbante. Você o usa assim:

  print2 ("myVar =", myVar);

Se myVar for 25, isso será impresso na janela serial:

  myVar =25

CommandLine.h contém getCommandLineFromSerialPort () que monta uma linha de comando da porta serial. Cada vez que é chamado, ele lê da porta serial e armazena a entrada no buffer de entrada global, CommandLine [] . Quando atinge um return caractere que significa o fim do comando, ele retorna true .

O buffer totalmente montado agora é passado para DoMyCommand () que descobre qual função o usuário está solicitando e a chama. Com um grande número de comandos, você pode obter uma instrução if-the-else bastante complicada.

Se você tem um número realmente enorme de comandos, há várias maneiras de acelerar as coisas, como adotar o que é chamado de função de hashing. Alternativamente, você pode tornar os comandos apenas um caractere e, em seguida, usar esse caractere como o rótulo de uma instrução switch-case. Acho que nenhum desses é necessário com muita freqüência. Uma palavra é muito mais fácil de lembrar do que um único caractere e, visto que se trata de um Arduino, quantos comandos você pode realmente ter antes de ficar sem espaço no chip?

Adicionar e Sub

Cada função de comando é responsável por analisar seus próprios argumentos. Esta é uma maneira simples de fazer isso e fácil de modificar. Uma alternativa para isso é ler todos os argumentos imediatamente em DoMyCommand . Você pode colocar argumentos individuais em uma matriz global de strings argv [] .

Para os fins deste exemplo, defini dois comandos: add e sub . Ambos usam argumentos numéricos, mas eu incluí readWord (que pode ser chamado de readStringToken ) para retornar uma palavra. Você também pode modificar este readStringToken para permitir strings como " this is a string ". Considere-o um exercício deixado para o leitor.

A maneira mais rápida de correr

Se você tiver um arquivo de loop principal como mostrado acima, crie uma nova guia usando o triângulo apontando para baixo à direita da janela do Arduino IDE e copie CommandLine.h (abaixo) arquivo nele, você deve ser capaz de digitar add e sub comandos.

Agora é com você!

Código

Intérprete de linha de comando simples para Arduino

Intérprete de linha de comando simples para Arduino C / C ++

Veja os comentários neste artigo ou no código para adicionar uma linha de comando simples ao seu esboço do Arduino.

Você pode adicionar comandos como este:
adicione 5, 10
subtraia 10, 5

Ou qualquer outra coisa que você precise

 / **************************************** ************************************* Como usar CommandLine:Crie um esboço. Veja abaixo um exemplo de configuração e código de loop principal e copie e cole no novo esboço. Crie uma nova guia. (Use o menu suspenso (pequeno triângulo) na extremidade direita do Editor do Arduino. Nomeie a guia CommandLine.h Cole este arquivo nela. Teste:Baixe o esboço que você acabou de criar para o seu Arduino como de costume e abra a janela serial. Digite estes comandos seguidos de return:add 5, 10 subtract 10, 5 Olhe para os comandos add e subtract incluídos e escreva o seu próprio! ********************* *************************************************** ****** Aqui está o que está acontecendo nos bastidores ************************************* ****************************************** Interpretador de linha de comando simples e claro Este arquivo permitirá você digitar comandos na janela serial, como adicionar 23.599 blink 5 playSong Yesterday ao seu esboço em execução no Arduino e executá-los. Nota de implementação:isso usará strings C em oposição a objetos de string com base na suposição de que, se você precisar de uma linha de comando intérprete, provavelmente você também tem pouco espaço e o objeto String tende a ser ineficiente em termos de espaço. 1) Comandos de protocolo simples são palavras e números com espaço ou vírgula A primeira palavra é o comando, cada palavra adicional é um argumento "\ n" termina cada comando 2) Usando a rotina da biblioteca C strtok:Um comando é uma palavra separada por espaços ou vírgulas. Uma palavra separada por certos caracteres (como espaço ou vírgula) é chamada de token. Para obter os tokens um por um, eu uso o strtok de roteamento C lib (parte do C stdlib.h veja abaixo como incluí-lo). É parte da biblioteca de linguagem C  que você pode consultar online. Basicamente, você:1) passa uma string (e os delimitadores que você usa, ou seja, espaço e comman) e ele retornará o primeiro token da string 2) nas chamadas subsequentes, passe NULL (em vez da string ptr) e ele irá continue de onde parou com a string inicial. Eu escrevi algumas rotinas auxiliares básicas:readNumber:usa strtok e atoi (atoi:ascii para int, novamente parte de C stdlib.h) para retornar um inteiro. Observe que atoi retorna um int e se você estiver usando ints de 1 byte como uint8_t, você terá que obter o lowByte (). readWord:retorna um ptr para uma palavra de texto 4) DoMyCommand:Uma lista de if-then-elses para cada comando. Você poderia tornar esta uma declaração de caso se todos os comandos fossem um único caractere. Usar uma palavra é mais legível. Para os fins deste exemplo, temos:Add Subtract nullCommand * // ******************* exemplo de código de loop principal ************* ************************ #incluir "CommandLine.h" void setup () {Serial.begin (115200); } void loop () {bool recebido =getCommandLineFromSerialPort (CommandLine); // CommandLine global é definido em CommandLine.h if (received) DoMyCommand (CommandLine); } ************************************************** ********************************** /// Nomeie esta guia:CommandLine.h # include  #include  // esta macro a seguir é boa para depuração, por exemplo print2 ("minhaVar =", minhaVar); # define print2 (x, y) (Serial.print (x), Serial.println (y)) # define CR '\ r' # define LF '\ n' # define BS '\ b' # define NULLCHAR '\ 0' # define SPACE '' #define COMMAND_BUFFER_LENGTH 25 // comprimento do buffer serial para commandschar de entrada CommandLine [COMMAND_BUFFER_LENGTH + 1]; // Lê comandos para este buffer a partir de Serial. +1 de comprimento para uma terminação charconst char * delimiters =", \ n"; // os comandos podem ser separados por retorno, espaço ou vírgula / ************************************* *************************************************** ********************** seus nomes de comando aqui * / const char * addCommandToken ="add"; // Modificar hereconst char * subtractCommandToken ="sub"; // Modifique aqui / ********************************************* *************************************************** ************** getCommandLineFromSerialPort () Retorna a string do próximo comando. Os comandos são delimitados por return "Handle BackSpace character Tornar todos os caracteres em minúsculas ************************************** *************************************************** *********************** / boolgetCommandLineFromSerialPort (char * commandLine) {static uint8_t charsRead =0; // nota:COMAND_BUFFER_LENGTH deve ter menos de 255 caracteres // ler de forma assíncrona até a entrada do comando completo enquanto (Serial.available ()) {char c =Serial.read (); switch (c) {case CR:// provavelmente tem o comando completo no buffer agora, os comandos são encerrados por CR e / ou LS case LF:commandLine [charsRead] =NULLCHAR; // null termina nosso comando char array if (charsRead> 0) {charsRead =0; // charsRead é estático, então tem que redefinir Serial.println (commandLine); return true; } break; case BS:// manipula backspace na entrada:coloca um espaço no último caractere if (charsRead> 0) {// e ajusta commandLine e charsRead commandLine [- charsRead] =NULLCHAR; Serial < A soma é =", resultado); } else {if (strcmp (ptrToCommandName, subtractCommandToken) ==0) {// Modificar aqui result =subtractCommand (); // string K e R.h pg. 251 print2 ("> A diferença é =", resultado); } else {nullCommand (ptrToCommandName); }}}

Mini Radar com Arduino Robô seguidor de linha de controle PID

Processo de manufatura

impressao 3D

Sistema de controle de automação

Tecnologia industrial