UCL Embedded - B0B the Linefollower: 9 Passos

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:35

Este é o B0B. *

O B0B é um carro controlado por rádio genérico, servindo temporariamente como base de um robô que segue a linha.

Como tantos robôs que seguem a linha antes dele, ele fará o possível para permanecer em uma linha causada por uma transição entre o piso e um material contrastante, em nosso caso, fita adesiva.

Ao contrário de tantos outros robôs seguidores de linha, o B0B também coleta dados e os envia via WiFi.

Completamente exagerado para um projeto de hobby, envolve uma série de assuntos que você pode achar interessantes. Este guia descreve seu nascimento, suas funções e como você pode fazer um igual a ele.

Também envolve ficar zangado com vários aparelhos eletrônicos por não funcionar como queríamos e as etapas que tomamos para superar essas dificuldades (estou olhando para você ESP 8266-01).

Existem 2 códigos para fazer o projeto funcionar. O primeiro código é para o módulo ESP8266, que usamos no Arduino como programador, e o segundo código será executado no Arduino.

Etapa 1: Componentes

Para este projeto, você precisará de:

Hardware:

• 1 carro controlador de rádio, (deve ter ESC e servo de direção).

Estávamos usando principalmente um Traxxas 1/16 E-Revo VXL padrão, principalmente porque era o que tínhamos, e estávamos bastante confiantes de que seríamos capazes de controlá-lo com um Arduino. Além disso, como ele acabará carregando uma quantidade considerável de hardware extra, estávamos confiantes de que isso não seria um problema para o 1/16 E-Revo.

No entanto, a maioria dos carros controlados por rádio (que podem ser facilmente desmontados) provavelmente poderiam ser usados, e o processo será muito semelhante.

• Uma tonelada de fita adesiva.

A cor deve contrastar o máximo possível com o piso. Em nosso ambiente de teste, usamos fita branca em um piso escuro.

• 1x Arduino Mega 2560.

Arduino menores provavelmente também funcionam, mas você será pressionado por pinos.

• 1 tábua de pão grande.

Um é o suficiente, mas também tínhamos um menor para separar as outras linhas de alimentação de tensão para reduzir o risco de erro do usuário.

• 1 sensor analógico TCRT5000 IR (usado para evitar colisões).

A marca / modelo exato não importa se é compatível com o Arduino e mede distâncias. Pesquise palavras-chave como “Distância”, sensor de “obstáculo”. Tecnicamente, um sensor digital funcionaria bem com pequenas alterações de código, mas estamos usando um analógico.

• Gravidade 1x ou 2x: Sensor analógico de escala de cinza v2

Uma é uma necessidade para o seguidor de linha. O modelo exato não importa, contanto que esteja olhando para a intensidade da luz refletida e emita um sinal analógico. O segundo para detecção de 'sala' não estava funcionando tão bem quanto o esperado e pode ser omitido, ou uma alternativa, como um sensor de cor RGB, pode ser encontrada, presumivelmente para um melhor efeito. Ainda temos que testar isso.

• 1 x ESP 8266-01.

Existem várias versões do ESP 8266 disponíveis. Temos experiência apenas com o 8266-01 e não podemos garantir que o código ESP funcionará com uma versão diferente.

• 1 escudo Wi-Fi ESP8266-01.

Tecnicamente opcional, mas se você não usar isso, tudo que envolve o módulo Wi-Fi ficará muito mais complicado. O guia, no entanto, presumirá que você tem isso (se não, encontre os guias online para conectar corretamente o ESP-01 ao Arduino), pois fazer isso incorretamente pode e provavelmente danificará o módulo.

• Baterias para o próprio veículo e baterias para alimentar os componentes eletrônicos adicionais.

Usamos um par de baterias de 2,2 AH de capacidade, 7,4 V Lipo em paralelo para alimentar tudo. Você deve poder usar quaisquer baterias que normalmente usaria no veículo de sua escolha. Se você estiver acima de 5 V, mas abaixo de 20 V, a capacidade é mais importante do que a tensão nominal.

• Muitos cabos de ligação.

Desisti de contar o número exato deles. Se você acha que tem o suficiente, provavelmente não.

• Por fim, para conectar tudo, você precisará montar o Arduino, os sensores, a placa de ensaio e o módulo Wi-Fi no veículo de sua escolha. Seu resultado irá variar dependendo do que você está usando como base e dos materiais disponíveis.

Nós costumavamos:

• Gravatas.

• Um pouco de super cola.

• Pequenos pedaços de papel de rascunho / tubo de resina que tínhamos com um diâmetro adequado.

• Uma velha placa traseira Masonite de um porta-retrato, cortada no tamanho certo.

• Um pouco mais de fita adesiva.

• Todas as ferramentas necessárias para trabalhar no carro controlado por rádio de sua escolha.

Usávamos principalmente um pequeno conjunto de chaves de fenda com vários bits, mas ocasionalmente tínhamos que puxar o conjunto de ferramentas de estoque que vinha com o carro.

Programas:

• Nó vermelho

Uma parte importante da coleta de dados.

• Um servidor MQTT.

O intermediário entre o nosso veículo e o Node-red. Inicialmente, para teste, usamos test.mosquitto.org

Mais tarde usamos:

• CloudMQTT.com

Isso era muito mais confiável, o que compensava ser um pouco mais complicado de configurar.

• WampServer.

A última parte da coleta de dados. Especificamente, usaremos seu banco de dados SQL para armazenar nossos dados coletados.

Etapa 2: Diagrama elétrico

Etapa 3: Construção Física

Nossa solução tem uma abordagem direta para a montagem física.

O receptor original e sua caixa à prova d'água foram removidos do carro RC, pois não são necessários.

Descobrimos que havia um local adequado entre as rodas dianteiras para nosso sensor de acompanhamento de linha, então o seguramos no lugar, prendendo um ziptie acima da placa de proteção dianteira.

O sensor que usamos para anticolisão está meio que preso atrás do pára-choque dianteiro. Ele ainda está sendo protegido de impactos e seu ajuste por fricção. Ele acaba olhando para a frente em um ângulo ascendente muito pequeno. Isto é perfeito.

A placa Masonite, (placa traseira do porta-retratos antigo), na parte superior tem pequenas seções de tubo de papel / resina cortadas no tamanho certo e coladas na parte inferior. Estes se alinham com os suportes para os postes do corpo e simplesmente ficam no topo, segurando tudo com segurança. Supondo que a cola que fixa o tubo à placa segure, e que não se incline excessivamente, ela permanecerá no lugar. É importante notar também que a placa está dentro da esfera de proteção das rodas e dos para-choques. O Arduino Mega e as duas placas de ensaio foram fixados na placa com fita dupla-face ou com um laço de fita adesiva enrolado e colado.

Nenhuma medida especial foi tomada para proteger o módulo WiFi. Não é nosso, então colar ou prender foi considerado desnecessário, pois é tão leve que não se moverá muito e os fios são suficientes para mantê-lo no lugar.

Finalmente, temos um sensor para detectar 'quartos' que foi ziptied para os componentes da suspensão por uma das rodas traseiras. Durante a operação, isso precisa estar longe da linha de marcação que o veículo usa para navegar.

Etapa 4: Módulo ESP8266

O módulo WiFi, ESP8266, requer duas configurações de pinos diferentes. Uma configuração deve ser usada ao atualizar o módulo com um novo programa e usar o Arduino Mega 2560 como um programador. A outra configuração é para o módulo quando ele está em uso e enviando informações para o MQTT Broker.

Usando o Arduino IDE para fazer o upload do código para o módulo ESP8266, você precisará instalar um gerenciador de placas e um gerenciador de placas adicional

Sob o gerenciador do conselho, instale o gerenciador do conselho esp8266. Ele será facilmente encontrado pesquisando "esp". É crucial que você instale a versão 2.5.0, nem mais antiga, nem mais recente.

Nas configurações de URLs adicionais do gerenciador de placas, copie nesta linha:

arduino.esp8266.com/stable/package_esp8266c…

Para poder fazer upload de qualquer coisa para o módulo ESP8266, você precisará usar uma configuração de pino específica para que possa atualizar o módulo. Isso precisa ser feito toda vez que você quiser fazer uma alteração no código atual em execução no módulo. Não se esqueça de selecionar o módulo ESP8266 correto no gerenciador de placa antes de atualizar o módulo. Neste projeto, escolhemos a placa ESP8266 genérica. A configuração do pino para piscar o módulo é encontrada na primeira imagem deste segmento.

Depois de ter atualizado o módulo ESP8266, você precisa mudar a configuração do pino. Você também pode optar por usar um adaptador para tornar a configuração mais fácil para você. Neste projeto, optamos por ter um adaptador sempre que tivéssemos o módulo em execução. A configuração do pino com adaptador é encontrada na segunda imagem deste segmento.

O código a ser flasheado no módulo ESP8266 configura a conexão com um WiFi e um MQTT Broker, neste caso com um nome de usuário e senha, mas pode ser feito sem, se você fizer as alterações necessárias descritas nos comentários do código. Para este projeto, nosso corretor solicitou um nome de usuário e uma senha para funcionar. O módulo lê as mensagens recebidas da porta serial à qual está conectado. Ele lerá cada nova linha criada pelo código do Arduino, decifrará a mensagem e recriará a mensagem. Depois disso, ele envia a mensagem para o MQTT Broker que foi especificado no código. O código para o Módulo ESP8266:

Etapa 5: Arduino

Depois de configurar o módulo WiFi, olhamos para o programa que será usado para controlar o motor e o servo no carro RC. O carro vai reagir de acordo com uma informação em escala de cinza do sensor central, também conhecido como "Detector de Linha" neste projeto. Simplesmente visa manter a informação do Detector de Linha próxima a um valor predefinido que iguala a informação registrada na mudança entre claro e escuro ou neste projeto, branco e preto. Portanto, se o valor for muito diferente, a saída correspondente ao servo conduzirá o carro perto do valor predefinido da linha.

O programa possui dois botões que funcionam como botão de partida e parada do carro RC. Tecnicamente, o botão "parar" é um botão "armar" que, em termos, é igual a um valor PWM enviado ao motor que faz com que o carro RC pare. O botão de partida envia um valor de PWM que é igual ao carro RC mal se movendo para a frente, já que ele dirigirá muito rápido se ganhar muito ímpeto.

Um detector de prevenção de colisão é adicionado ao front-end do carro RC para detectar se o caminho à frente está livre ou bloqueado. Se estiver bloqueado, o carro RC irá parar até que o obstáculo seja removido / removido. O sinal analógico do detector é usado para determinar se algo está ou não bloqueando o caminho e é um critério para ser capaz de avançar e parar.

Um sensor secundário de escala de cinza, "Detector de Sala", é usado para detectar em qual sala o carro RC entrou. Funciona de forma semelhante ao Detector de Linha, mas não procura a mudança entre claro e escuro, mas sim valores dentro de um intervalo específico que corresponde a divisões diferentes dependendo do valor visto no Detector de Sala.

Por último, o programa cria uma linha de informações dos sensores para o módulo WiFi ler e depois enviar ao MQTT Broker. A linha de informação é criada como uma string e gravada no serial correspondente ao qual o módulo WiFi está conectado. É importante que a gravação no serial só aconteça com a frequência em que o módulo WiFi puder ler a mensagem recebida, mas lembre-se de não usar atrasos neste código, pois isso interferirá na capacidade do carro RC de seguir a linha. Em vez disso, use "millis", pois isso permitirá que o programa seja executado sem atraso, mas após uma quantidade definida de millis decorrida desde que o Arduino foi ligado, ele gravará uma mensagem no serial sem bloquear o código da mesma forma que o delay.

O código do Arduino Mega 2560:

Etapa 6: banco de dados MySQL

WampServer é um ambiente de desenvolvimento web para Windows que nos permite criar aplicações com PHP e banco de dados MySQL. PhpMyAdmin nos permite gerenciar nossos bancos de dados de uma forma fácil.

Para começar, vá para:

Neste projeto usamos a versão 3.17 x64 bits para Windows. Após a instalação, certifique-se de que todos os serviços estão funcionando, o que significa que o ícone pequeno fica verde em vez de vermelho ou laranja. Se o ícone estiver verde, você pode acessar o PhpMyAdmin para gerenciar seu banco de dados MySQL.

Acesse o MySQL usando PhpMyAdmin e crie um novo banco de dados. Nomeie-o com algo apropriado que você possa lembrar, neste projeto ele foi chamado de “line_follow_log”. Depois de criar o banco de dados, você deve criar uma tabela no banco de dados. Certifique-se de que o número de colunas se encaixa. No projeto usamos 4 colunas. Uma coluna é para um carimbo de data / hora e as três últimas são usadas para armazenar dados do veículo. Use um tipo de dados adequado para cada coluna. Usamos “texto longo” para a coluna de carimbo de data / hora e “texto médio” para o resto.

Isso deve ser tudo que você precisa fazer no PhpMyAdmin e no MySQL. Lembre-se de seu banco de dados e da tabela da seção sobre Node-Red.

Etapa 7: Nó-vermelho

Para lidar com a coleta de dados, usaremos um fluxo bastante simples em Node-red. Ele se conecta ao nosso servidor MQTT e grava em nosso banco de dados MYSQL.

Para fazer isso, precisamos de algumas paletas para várias funções funcionarem e de algum código real para que ele seja executado.

Primeiras coisas primeiro. Precisaremos dos seguintes paletes.

Node-red-contrib-mqtt-broker: Esta é a conexão com nosso broker MQTT.

Node-red-dashboard: Nosso Dashboard, necessário para representar visualmente os dados coletados.

Node-red-node-mysql: Nossa conexão com o banco de dados SQL.

Este não é um guia completo para o Node-red, mas explicarei o que o fluxo do Node-red faz.

No início, tivemos problemas com o nosso servidor MQTT escolhido morrendo / desconectado, aparentemente de forma aleatória, o que tornava a realização de quaisquer alterações um esforço frustrante, pois não estava claro se as alterações tinham sido benéficas ou não quando não podíamos ver o resultado. Então o botão 'O servidor morreu?' injeta 'Não', o bloco a seguir o injeta em nosso servidor MQTT. Se não estiver morto, 'Não' aparecerá na janela Depurar. Isso é feito não apenas para testar, mas para forçar o Node-red a tentar se reconectar ao servidor MQTT.

A 'sequência de teste' envia uma sequência costum para o broker MQTT. Formatamos essa string para ser semelhante ao que obteríamos do Arduino. Isso era para ter mais facilidade para configurar a rede que decodifica as mensagens, sem precisar ter o projeto rodando, coletando dados.

O último fluxo na área de trabalho pode ser dividido em dois segmentos. A ramificação inferior simplesmente lê as mensagens de entrada, as envia para a janela de depuração e as salva no servidor SQL.

A grande rede de switches conectados seguindo um nó de função é onde a verdadeira 'mágica' acontece.

A função a seguir lê a string de entrada, dividindo-a com cada ponto-e-vírgula e passa as seções em cada uma das saídas. As opções a seguir procuram uma das duas informações de entrada diferentes. Uma informação específica é sempre passada de uma saída, a outra opção sai pela segunda saída. Em seguida, vem um segundo grupo de blocos de comutação. Eles só serão ativados com uma entrada específica e produzirão outra coisa.

Um exemplo, 'obstáculo', como todos os outros são uma escolha binária, ou é claro para dirigir ou não. Portanto, ele receberá um 0 ou 1. Um 0 será enviado para o ramal 'limpo', um 1 será enviado para o ramal 'Obstruído'. Os interruptores 'Limpar', 'Obstruído', se ativados, produzirão algo específico, Limpar ou obstruído, respectivamente. Os blocos de procedimento verdes serão postados na janela de depuração, os azuis serão gravados em nosso painel.

Os ramos 'status' e 'localização' funcionam exatamente da mesma forma.

Etapa 8: MQTT Broker

Um Broker é um servidor que roteia mensagens de clientes para os clientes de destino apropriados. Um MQTT Broker é aquele em que os clientes usam uma biblioteca MQTT para se conectar ao broker em uma rede.

Para este projeto, criamos um MQTT Broker usando o serviço CloudMQTT com a assinatura gratuita para uma versão "Cute Cat". Tem suas limitações, mas não excedemos as deste projeto. O módulo WiFi pode se conectar ao corretor e o corretor então roteia as mensagens para um cliente de destino apropriado. Nesse caso, o cliente é nosso Node-Red. O serviço CloudMQTT configura um nome de usuário e senha para seu servidor, por isso temos a garantia de maior segurança. Basicamente significa que apenas aqueles com o nome de usuário e senha podem acessar este serviço CloudMQTT específico. O nome de usuário e a senha são cruciais ao configurar a conexão no código ESP8266, bem como no Node-Red.

As estatísticas contínuas para as mensagens que o Broker recebe é um recurso agradável, que pode ser usado para ver como o seu plano de assinatura está lidando com as informações que encaminha.

Um recurso interessante é a possibilidade de enviar mensagens do Broker para o módulo WiFi, mas não as usamos neste projeto.

Etapa 9: Eletrônicos de passatempo

Antes de começar, sabíamos de um projeto anterior que o servo de direção das ações poderia ser controlado a partir de um Arduino com um sinal PWM, tendo fiação semelhante e conectando-se a canais diferentes no mesmo receptor de rádio padrão, assumimos o Controle Eletrônico de Velocidade, (ESC de agora ligado), que controla o motor, poderia ser controlado de forma semelhante via PWM do Arduino.

Para testar essa teoria, criamos um pequeno esboço do Arduino. O esboço lê uma entrada analógica de um potenciômetro, remapeia o valor de 0, 1024 a 0, 255 e produz o valor resultante para um pino PWM, usando analogWrite () enquanto tinha o carro R / C em uma pequena caixa e tinha o rodas removidas.

Depois de varrer a faixa do medidor de potenciômetro, o ESC pareceu 'acordar' e pudemos acelerá-lo para cima e para baixo, também fizemos com que o Arduino imprimisse os valores na conexão serial para que pudéssemos monitorá-los.

O ESC parecia não gostar de valores abaixo de um certo limite, neste caso 128. Ele viu o sinal 191 como acelerador neutro e 255 como acelerador máximo.

Não precisávamos variar a velocidade do veículo e estávamos perfeitamente fazendo-o girar na velocidade mais lenta que o faria se mover. 192 era o menor valor que giraria o motor, porém ainda temos que montar tudo e não temos certeza se essa saída seria suficiente para movimentar o veículo após a montagem final, porém inserir um valor um pouco maior deve ser trivial.

Contornar o potenciômetro e inserir um valor fixo no código, no entanto, não funcionou. O ESC de estoque simplesmente piscava e não girava o motor, 'ajuste o trim do acelerador' de acordo com o manual.

Solucionando problemas furiosos, jogando vários valores nele, usando fios diferentes e até mesmo experimentando mudar a frequência PWM que o Arduino usa, tudo resultou em mais estranheza.

Parecia ser um problema intermitente, às vezes funcionava, outras vezes se recusava a fazer qualquer coisa. Simplesmente continuou piscando. Um teste com o controlador e receptor originais confirmou que o ESC ainda estava funcionando exatamente como pretendido, o que tornou as questões ainda mais estranhas. Valores mais altos, ele ignorou e continuou piscando, valores mais baixos o ESC voltou a brilhar com um verde feliz, mas ainda assim não girou.

O que foi diferente da configuração com o potenciômetro, ou o transmissor e receptor padrão, e a versão que fornecia valores fixos?

Às vezes, trabalhar como pretendido e como esperado não se sobrepõe muito no diagrama de Venn. Neste caso, sendo um brinquedo, não deve haver chance do modelo simplesmente decolar ou quebrar dedos ou ficar com o cabelo preso nas rodas ou trem de força conforme o modelo liga, mesmo que algo como segurar o transmissor estranhamente tenha o acelerador qualquer outra posição que não seja neutra.

'Ajuste o trim do acelerador', é exatamente o que isso significa. O ESC espera um sinal neutro ao ser ligado, antes de saber que não fará nada. Normalmente, o transmissor estaria sempre em neutro quando o ESC é ligado e, a partir daí, conduzirá com prazer. Caso não esteja, provavelmente ele estará de volta ao ponto morto pelo menos uma vez quando o modelo estiver firme no solo e o operador se sentir pronto para correr.

Enquanto usamos o potenciômetro, estávamos 'varrendo' os intervalos e então ele começava a funcionar. Ele simplesmente foi armado quando o potenciômetro passou da posição neutra e funcionou.

Faixas mais baixas, no entanto, ainda pareciam desagradar o ESC. Acontece que isso é um produto dos ciclos de trabalho PWM.

Tanto pelo projeto quanto por motivos técnicos, tanto o servo de direção quanto o ESC ignoram os sinais abaixo dos ciclos de trabalho de 50%. Isso poderia ser caso o receptor / transmissor parasse de funcionar ou ficasse sem energia, o modelo voltaria ao neutro e não decolaria para longe em aceleração total à ré. Da mesma forma, o servo gira apenas 180 graus e não precisa de toda a gama.

Com esse novo conhecimento em mãos, um novo esboço do Arduino foi criado. A versão inicial aceita strings inseridas no monitor Serial, converte-o em um inteiro e move-o para o pino PWM, usando a biblioteca servo e write () *. Se um novo valor for inserido no monitor serial, o valor write () é atualizado.

Durante o teste, o estoque Traxxas ESC foi substituído por um Mtroniks G2 Micro, no entanto, eles devem funcionar da mesma forma, embora os valores exatos possam ser ligeiramente diferentes.

Esta biblioteca trata o ESC como um servo, aparentemente isso está bom. A função write () da biblioteca Servo.h vai de 0 a 180, o sinal de arme esperado deve estar em torno do meio.

O G2 Micro é armado em uma gravação () em uma faixa de valores próximos a 90, no entanto, foi difícil identificar, pois parece 'lembrar' de ter sido armado.

Espera-se que o Traxxas VXL-s3 arme a um valor write () de 91.

Após o sinal de arme, qualquer um dos ESC aceita alegremente os sinais PWM, independentemente das funções do Arduino chamadas para gerá-los, e controla o motor de acordo.

Falando de funções; o analogWrite () padrão, bem como write () e writeMicroseconds () da biblioteca Servo.h podem ser usados alternadamente, basta ter em mente o que faz o quê e, em última análise, nada além do ciclo de trabalho importa. WriteMicroseconds () pode ser usado se maior granularidade for necessária, apenas tenha em mente que o intervalo aqui é de 1000 a 2000, com armar ou 'neutro' esperado em 1500. Com o analogWrite () padrão, espera-se que o intervalo utilizável seja ser de 128 a 255 com cerca de 191 sendo neutro.