Manufaturação industrial
Internet das coisas industrial | Materiais industriais | Manutenção e reparo de equipamentos | Programação industrial |
home  MfgRobots >> Manufaturação industrial >  >> Manufacturing Technology >> Processo de manufatura

Assuma o controle das funções de poder do Lego

Componentes e suprimentos

Arduino UNO
× 1
Drivers de motor Dual H-Bridge da Texas Instruments L293D
(compre um com alfinetes longos, não a versão para montagem em superfície mostrada na foto)
× 1
Breadboard (genérico)
× 1
9V para conector Barrel Jack
× 1
Lego Power Functions Extension wire (Item:8886)
× 3
Módulo Bluetooth HC-05
× 1

Sobre este projeto


Você tem um daqueles incríveis modelos Lego Power Functions com motores elétricos e servo-motores? Neste tutorial, vou mostrar como você pode controlar seu modelo Lego com seu Arduino e um mínimo de componentes eletrônicos. Explicarei os circuitos e a programação em detalhes para tornar este tutorial fácil de entender para iniciantes. O modelo Lego que você mesmo terá que construir (se não tiver um filho), não vou te ajudar nisso.

Também aprenderemos como usar o inventor do aplicativo MIT para programar nosso próprio aplicativo Android de controle remoto. Em breve, você terá seu próprio veículo espacial Lego Mars em seu quintal!

Este é meu primeiro projeto Arduino e meu filho tem um belo modelo de carro Lego Technic (9398 4X4 Crawler) com funções de potência Lego:um servo motor Lego para direção e dois motores Lego L para dirigir. Ele me permitiu usar o carro para este projeto (desde que eu não corte nenhum cabo do motor). Aqui, testamos o protótipo concluído:





Compreendendo a fiação das funções de energia


Primeiro, compre alguns fios de extensão de funções de energia Lego (item 8886 na loja virtual da Lego). Em seguida, corte-os (sério). Faremos alguns cabos "break-out" com peças de Lego em uma extremidade e alfinetes na outra. Solde os pinos ou similar. Aqui está a fiação explicada:

GND significa Terra, que é o terminal negativo (-) da bateria (ânodo). C1 e C2 podem mudar a polaridade para fazer os motores e servos mudarem de direção. TechnicRobot fez um bom vídeo explicando tudo em detalhes. (AVISO:você está fazendo isso por sua própria responsabilidade. Eu não serei responsabilizado se você estragar algo!) Para o conector servo Lego, você precisa soldar os pinos em todos os quatro cabos. Você pode usar o plugue cinza claro. Para o cabo de alimentação que conecta a caixa da bateria com a placa de ensaio, precisamos apenas de +9 Volt e GND, mas você deve usar o plugue cinza escuro (porque você precisa de um conector macho):

Para o cabo do motor, precisamos apenas conectar C1 e C2 e você pode usar um plugue cinza claro. (Estude os esquemas para obter detalhes).





Controle de um motor Lego com o chip L293D


Queremos controle de velocidade variável para nossos motores DC e controle de posição para nosso servo Lego. Isso é obtido por modulação por largura de pulso (PWM). A linguagem de programação do Arduino torna o PWM fácil de usar; simplesmente chame analogWrite (pin, dutyCycle), onde dutyCycle é um valor de 0 a 255. Os pinos PWM são marcados com ~ em seu arduino.

Os pinos de saída do Arduino são 5 Volt e máx. 30 mA, enquanto os motores Lego precisam de 9 volts e puxam mais de 100 mA cada. Precisamos de algum tipo de "dispositivo de comutação" no meio. Também queremos ser capazes de operar os motores DC em ambas as direções. Essas funções são resolvidas por uma chamada ponte H. Usaremos o L293D, que contém duas pontes H em um chip integrado, o que significa que podemos conectar os motores Lego (M) em paralelo em um lado e o servo Lego (S) no outro lado do chip. (Se quiser controlar os dois motores independentemente, você precisará de um segundo L293D). O servo Lego também precisa ser conectado a GND e Lego +9 Volt.

O chip mantém Lego +9 Volt e Arduino +5 Volt completamente separados. Nunca os conecte ou você danificará algo! Mas você tem que conectar todas as linhas de aterramento juntas e com os pinos de aterramento do L293D.

Em nosso Arduino, usaremos o pino 9 para controlar a velocidade do motor e os pinos 2 e 5 para controlar a direção de rotação. O servo Lego é controlado como um motor:conectamos o pino 3 para a posição e os pinos 6 e 8 para a direção (esquerda ou direita).

No início do nosso programa, definimos os pinos do Arduino usados ​​como constantes. Além disso, definimos algumas variáveis ​​que usaremos para controlar os motores:
  // Pinos de saída digital de controle do motor definidos como constantes globaisconst int controlPin1A =2; const int controlPin2A =5; const int ENablePin =9; // Pinos de saída digital do servo controle definidos como constantes globais const int controlPin3A =6; const int controlPin4A =8; const int servoENablePin =3; // Variáveis ​​globais de controle do motor:int motorSpeed ​​=0; // Velocidade do motor 0..255int motorDirection =1; // Avanço (1) ou reverso (0) // Variáveis ​​globais do servo controle:int direção =0; // Posição do servo 0..255int directionDirection =0; // Esquerda (0) e Direita (1)  

Na configuração, definimos esses pinos como saídas com o comando pinmode () e, em seguida, os configuramos para 0 Volt com digitalWrite ().
  void setup () {// outras coisas .... // Declara pinos de saída digital:pinMode (controlPin1A, OUTPUT); // 1A pinMode (controlPin2A, OUTPUT); // 2A pinMode (ENablePin, OUTPUT); // EN1,2 pinMode (controlPin3A, OUTPUT); // 3A pinMode (controlPin4A, OUTPUT); // 4A pinMode (servoENablePin, OUTPUT); // EN3,4 digitalWrite (ENablePin, LOW); // motor desligado digitalWrite (servoENablePin, LOW); // direção centrada}  

Agora precisamos entender como o chip L293D controla a direção de rotação dos motores. Temos que fornecer os seguintes sinais (Alto ==5 Volt; Baixo ==0 Volt):
  • EN1,2 1A 2A
  • Alto Alto Baixo Motor vira à esquerda (para frente; motorDirection ==1)
  • Alto Baixo Alto Motor vira à direita (Reverso; motorDirection ==0)
  • EN3,4 3A 4A
  • High High Low Servo vira à esquerda (directionDirection ==0)
  • High Low High Servo vira à direita (directionDirection ==1)

OK. Estamos prontos para escrever uma sub-rotina que lê as variáveis ​​globais de direção e velocidade / posição e controla os motores e servo:
  void SetMotorControl () {if (motorDirection ==1) // Forward {digitalWrite (controlPin1A, HIGH); digitalWrite (controlPin2A, LOW); } else // Reverse {digitalWrite (controlPin1A, LOW); digitalWrite (controlPin2A, HIGH); } analogWrite (ENablePin, motorSpeed); // Velocidade if (directionDirection ==0) // Left {digitalWrite (controlPin3A, HIGH); digitalWrite (controlPin4A, LOW); } else // Right {digitalWrite (controlPin3A, LOW); digitalWrite (controlPin4A, HIGH); } analogWrite (servoENablePin, direção); // Posição do servo}  





Aplicativo RC simples para Android com joystick


A seguir, vamos construir um aplicativo Android simples para controlar o modelo. (Se você quiser testar o aplicativo concluído primeiro:Eu o disponibilizei para você na Google Play Store. Aqui está o link:Arduino RC car bluetooth).

Usaremos o MIT app inventor 2. MIT App Inventor é uma introdução inovadora para iniciantes à programação e criação de aplicativos. Mark Friedman do Google e o professor Hal Abelson do MIT co-lideraram o desenvolvimento do App Inventor. Ele funciona como um serviço da web administrado pela equipe do Centro de Aprendizagem Móvel do MIT.

Em seu telefone Android, acesse o Google Play e instale o aplicativo MIT AI2 Companion. No seu computador, abra o link para meu aplicativo RC no navegador Firefox ou Chrome (Internet Explorer não compatível). Você terá que fazer login usando seu endereço do Gmail e criar uma conta para ver o código-fonte. Se você abrir o aplicativo complementar em seu telefone, poderá ver o código-fonte no navegador, alterá-lo e testá-lo imediatamente em seu telefone.

No navegador, você verá agora a visualização Designer do aplicativo:

Na parte inferior, vemos o painel laranja com o joystick azul nele. Agora mude para a visualização de blocos para ver o programa. O coração do programa é um bloco quando que mantém o controle dos movimentos de seu dedo tocando e arrastando a bola azul do joystick:

A posição do seu dedo é rastreada nas duas variáveis ​​ currentX e atualY e é usado para calcular valores para as duas variáveis ​​de direção e velocidade (intervalo:-100..0 .. + 100). Primeiro, o programa verifica se seu dedo está fora do pad e limita os valores a +/- 100. Se o dedo estiver dentro do pad, o programa calcula os valores para direção e velocidade . Em seguida, o programa gera uma string de comando no formato:

O comando começa com "RC" para controle remoto (a ideia é que, no futuro, você queira ter mais comandos) seguido por uma vírgula. Em seguida, enviamos os valores para direção e velocidade . O caractere de nova linha ('\ n') no final do comando é um sinal para o Arduino de que o comando está completo. Esta string de comando é enviada por bluetooth para o Arduino. Para sua referência, a string também é exibida na tela.





Lendo comandos bluetooth no Arduino


Para ler as strings de comando do Bluetooth, precisamos conectar um módulo HC-05 Bluetooth. Dê uma olhada em seu módulo:

O meu tem 6 pinos. Precisamos apenas de quatro pinos. VCC é a tensão de alimentação (positiva) e GND é o aterramento. O módulo tolera uma tensão de alimentação de 6 volts, o que significa que podemos conectá-lo ao pino de alimentação de 5 volts do arduino. TXD e RXD são os sinais seriais. Temos que cruzar as linhas e conectar o TXD ao arduino RXD (pino 0) e vice-versa. Tenha cuidado: Afirma NÍVEL:3,3 V, o que significa que o RXD não pode ser conectado diretamente ao 5V arduino TXD (pino 1). Temos que construir um divisor de tensão com três resistores de 1 kOhm para produzir uma tensão de saída que é 2/3 de 5 V (veja o esquema). Por outro lado, o sinal TXD de 3,3 V pode ser conectado diretamente ao Arduino RXD. O Arduino reconhecerá 3,3 Volt como ALTO.

Como os pinos 0 e 1 são compartilhados com a porta USB do seu Arduino, você terá que desconectar os sinais RXD e TXD dos pinos 0 e 1 enquanto carrega o programa via USB para a placa. O upload não funcionará se você não desconectar os cabos.

Em seguida, você deve emparelhar o módulo HC-05 com o seu dispositivo Android. Ligue o Bluetooth; inicie o aplicativo; pressione "conexão Bluetooth"; torne seu telefone visível e procure um dispositivo chamado HC-05 ou similar. Selecione o dispositivo. Será solicitado um código. Pressione "1234". Quando você retornar à tela do joystick, deverá indicar "conectado" em verde.

Agora, vamos examinar o código:
  // Tamanho do buffer serial:calcule com base no tamanho máximo de entrada esperado para um comando # define INPUT_SIZE 30 void loop () {// Obtenha o próximo comando do bluetooth serial (adicione 1 byte para 0 final) entrada de caracteres [ INPUT_SIZE + 1]; // array do tipo char (C-string) // lê Serial até a nova linha ou buffer cheio ou tempo limite byte size =Serial.readBytesUntil ('\ n', input, INPUT_SIZE); // Adicione o 0 final para encerrar a string C input [size] =0; // Divide a string que tem a forma:"RC, direção, velocidade, \ n \ 0" char * command =strtok (input, ","); // comando (RC) // RCsteering no intervalo:-100 (esquerda) .. 0 .. 100 (direita) char * RCsteering =strtok (NULL, ","); // RCspeed in Range:-100 (full speed reverse) .. 0 .. 100 (full speed forward) char * RCspeed =strtok (NULL, ","); int iRCsteering =atoi (RCsteering); // converte string em inteiro int iRCspeed =atoi (RCspeed); // converte string em inteiro // resto do programa}  

A string enviada pelo aplicativo Android é lida em uma construção de string especial:uma string C com terminação nula. (O caractere 0 informa ao programa que chegou ao fim da string). Isso é feito usando a função Serial.readBytesUntil ('\ n', input, ...), que lê da interface serial (bluetooth) até obter um caractere de nova linha ('\ n'). Dessa forma, continuamos lendo bytes até que tenhamos um comando completo em input :

Uma maneira muito eficiente de processar a entrada é a função de token de string, que corta a string em partes usando a vírgula como delimitador. A primeira chamada para strtok () retorna "RC". As partes subsequentes do comando são lidas passando NULL para strtok (). Os valores de retorno são armazenados em RCsteering e RCspeed . Essas variáveis ​​são, na verdade, ponteiros para posições na entrada . A função atoi () os converte finalmente em inteiros. Agora, temos:

Estamos quase terminando agora. Temos que multiplicar esses valores por 2,55 antes de passá-los para nossa rotina SetMotorControl () (Lembre-se de que a velocidade do motor estava na faixa de 0..255). Estude o resto do programa na seção CODE, construa o circuito e teste seu modelo Lego com controle remoto!





O que vem a seguir?


Agora que você tem um Arduino controlando seu modelo Lego, você pode querer usar esse modelo como uma plataforma robótica:adicione alguns sensores ultrassônicos de ping, programe sua própria lógica para evitar obstáculos e faça seu próprio Mars rover robótico autônomo. Ou adicione mais comandos ao controle remoto e mais funções ao modelo. Mas, primeiro, encontre um método para o Arduino descobrir que o modelo saiu do alcance da conexão bluetooth e pare o modelo. Conte-me sobre sua solução.

Em breve, você descobrirá que prototipagem de protoboard e cabos soltos não são uma boa ideia para um modelo móvel. Obtenha um protetor de motor adafruit com grandes conectores de bloco de terminais e religue e reprograme. Isso também irá liberar sinais digitais que você pode usar como entradas. Você também pode considerar uma blindagem de sensor para melhor conexão de seus sensores.

Deixe-me saber de seus projetos existentes!

Código

  • Legocar_v3_bluetooth
Legocar_v3_bluetooth Arduino
 / * Modelo de carro Lego Powerfunctions controlado por bluetooth Arduino Uno controla motores e servo Controle remoto com app Android desenvolvido com MIT App Inventor 2 Circuito:* Comunicação serial (usa Uno pino 0,1) Módulo Bluetooth está conectado (tem que ser desconectado ao carregar o programa por USB) * L293D com motor (usa pinos digitais Uno 2,5,9) * L293D com servo (usa pinos digitais Uno 6,8,3) * /// Bibliotecas usadas:#include  // Serial Peripheral Interface Library # include  // contém a função strtok:dividir string em tokens // Tamanho do buffer serial:calcular com base no tamanho máximo de entrada esperado para um comando na interface serial bluetooth # define INPUT_SIZE 30 / / Pinos de saída digital de controle do motor definidos como constantes globais (tração nas 4 rodas com 2 motores Lego):const int controlPin1A =2; // entrada 1A do driver L293D no pino nº 2 http://www.ti.com/lit/ds/symlink/l293.pdf conectado à saída digital Arduino pino 2const int controlPin2A =5; // Entrada do driver L293D 2A no pino nº 7 conectado ao pino 5const da saída digital do Arduino int ENablePin =9; // L293D ENable (1,2) entrada no pino nº 1 conectado ao pino 9 de saída digital do Arduino // Pinos de saída digital de controle servo definidos como constantes globais (servo direção com 1 servo Lego):const int controlPin3A =6; // Entrada do driver L293D 3A no pino nº 10 conectado ao pino de saída digital do Arduino 6const int controlPin4A =8; // Entrada do driver L293D 4A no pino nº 15 conectado à saída digital do Arduino pino 8 const int servoENablePin =3; // Entrada L293D ENable (3,4) no pino nº 9 conectada à saída digital do Arduino pino 3 // Variáveis ​​globais de controle do motor:int motorSpeed ​​=0; // Velocidade do motor 0..255int motorDirection =1; // Avanço (1) ou reverso (0) // Variáveis ​​globais do servo controle:int direção =0; // Posição do servo 0..255int directionDirection =0; // Esquerda (0) e Direita (1) void setup () {Serial.begin (9600); // inicializa a comunicação serial Serial.setTimeout (1000); // Tempo limite de 1000 ms // Declara os pinos de saída digital:pinMode (controlPin1A, OUTPUT); // 1A pinMode (controlPin2A, OUTPUT); // 2A pinMode (ENablePin, OUTPUT); // EN1,2 pinMode (controlPin3A, OUTPUT); // 3A pinMode (controlPin4A, OUTPUT); // 4A pinMode (servoENablePin, OUTPUT); // EN3,4 digitalWrite (ENablePin, LOW); // motor desligado digitalWrite (servoENablePin, LOW); // direção centrada} void loop () {// Obter próximo comando do bluetooth serial (adicionar 1 byte para 0 final) char input [INPUT_SIZE + 1]; // array do tipo char (string C) com terminação nula (https://www.arduino.cc/en/Reference/String) byte size =Serial.readBytesUntil ('\ n', entrada, INPUT_SIZE); // lê Serial até a nova linha ou buffer ficarem cheios ou expirarem // Adicione o 0 final para terminar a string C input [size] =0; // Comando de leitura que é uma string C no formato:"RC, RCsteering, RCspeed, \ n \ 0" (termina com um caractere de nova linha e um nulo) char * command =strtok (input, ","); // ignorar o comando por enquanto (RC para controle remoto é o único comando enviado pelo aplicativo por enquanto) char * RCsteering =strtok (NULL, ","); // em seguida vem RCsteering que está no intervalo:-100 (esquerda) .. 0 .. 100 (direita) char * RCspeed =strtok (NULL, ","); // em seguida vem a velocidade RC que está no intervalo:-100 (velocidade total reversa) .. 0 .. 100 (velocidade total para frente) int iRCsteering =atoi (RCsteering); // converte string RCsteering em inteiro iRCsteering int iRCspeed =atoi (RCspeed); // converte string RCspeed em inteiro iRCspeed // Define as variáveis ​​de controle do motor e do servo if (iRCsteering> 0) directionDirection =1; // vire à direita se iRCsteering =1..100 else directionDirection =0; // vire à esquerda se iRCsteering =-100..0 direction =int (2.55 * abs (iRCsteering)); // Posição do servo 0..255 com base no comando 0..100 if (iRCspeed> 0) motorDirection =1; // Define o carro para frente se iRCspeed =1..100 else motorDirection =0; // Define o carro para trás se iRCspeed =-100..0 motorSpeed ​​=int (2.55 * abs (iRCspeed)); // Define a velocidade 0..255 com base no comando 0..100 SetMotorControl (); // adjust motor direction and speed }void SetMotorControl()/*L293 logic:EN1,2 1A 2A H H L Motor turns left (Forward; motorDirection ==1) H L H Motor turns right (Reverse; motorDirection ==0) EN3,4 3A 4A H H L Servo turns left (steeringDirection ==0) H L H Servo turns right (steeringDirection ==1)Motor speed:PWM signal on EN1,2 (490 Hz; digital output value 0..255 for motorSpeed)Servo position:PWM signal on EN3,4 (490 Hz; digital output value 0..255 for position; 0 is straight ahead)*/{ if (motorDirection ==1) //Forward { digitalWrite(controlPin1A, HIGH); digitalWrite(controlPin2A, LOW); } else //Reverse { digitalWrite(controlPin1A, LOW); digitalWrite(controlPin2A, HIGH); } analogWrite(ENablePin, motorSpeed); //Speed if (steeringDirection ==0) //Left { digitalWrite(controlPin3A, HIGH); digitalWrite(controlPin4A, LOW); } else //Right { digitalWrite(controlPin3A, LOW); digitalWrite(controlPin4A, HIGH); } analogWrite(servoENablePin, steering); //Servo position}
Github Lego-car-Arduino
Contains source code Arduino; Fritzing diagram; source code android app for uploading to MIT app inventorhttps://github.com/Notthemarsian/Lego-car-Arduino

Esquemas

Github Lego-car-Arduino
Contains source code Arduino; Fritzing diagram; source code android app for upload to MIT app inventorhttps://github.com/Notthemarsian/Lego-car-Arduino Lego%20rc%20car%20v2.fzz

Processo de manufatura

  1. Assuma o controle da espada SaaS de dois gumes
  2. Derivadas das funções de poder de e
  3. Antiderivadas das Funções de Poder de e
  4. Estratégias para componentes de transmissão de energia mais confiáveis ​​
  5. Noções básicas de painéis de controle elétrico
  6. Força do vento
  7. Fabricantes do Reino Unido gastam mais de £ 2,5 milhões para corrigir erros
  8. Energia e HVAC/Controle climático
  9. 8 etapas para depurar seu sistema de controle de processos
  10. Controle de tensão no manuseio da web – componentes-chave