Powered By Blogger
Mostrando postagens com marcador Motor DC. Mostrar todas as postagens
Mostrando postagens com marcador Motor DC. Mostrar todas as postagens

terça-feira, 21 de outubro de 2014

ROVER Bot Arduino Bluetooth Controlled Tank

Esta barra, indica o nível de dificuldade encontrado para cada experiência realizada, sendo:
"VERDE", indicação de nível 1 a 5 (Fácil);
"AMARELO", indicação de nível 6 a 8 (Médio);
VERMELHO, indicação de nível 9 e 10 (Difícil);





Arduino ROVERBot



***To get this project in English language, visit the instructables website: http://www.instructables.com/id/Arduino-ROVERBot/ ***

Este post tem como objetivo apresentar a construção de um ROVER utilizando o Arduino como micro-controlador e a interface bluetooth de um celular Android como interface RC (radio controle).

O aplicativo Android utilizado é o "bluetooth RC Controller", que está disponível no "Play Store".
Este aplicativo proporciona um controle via interface de direcionamento e ou via interface de posicionamento digital (accelerômetro) do próprio celular que está sendo utilizado como controle.

Este é o link para o aplicativo de controle:
https://play.google.com/store/apps/details?id=braulio.calle.bluetoothRCcontroller&hl=pt_BR


Aplicativo para Android
Bluetooth RC Controller


Tela do controle via Teclas direcionais



MATERIAL:

1 x Tamiya Twin Motor Gear Box - KIT;
1 x Tamiya Tank Chassis - KIT;
1 x Arduino UNO;
1 x Módulo Bluetooth HC-05 ou compatível;
1 x AdaFruit-DC_Motor-Shield
1 x Bateria 11,7 V / 3500 mAh;

Para maiores informações sobre o shield controlador de motor AdaFruit, visite o website abiaxo, onde também é possível obter a biblioteca usada no projeto.
https://learn.adafruit.com/adafruit-motor-shield/overview

Você pode usar também um shield genérico, desde que tenha compatibilidade de pinos é possível utilizar a bilbioteca sem nenhum problema.


ADAFRUIT - Arduino Motor Shield


Bluetooth HC-05 Module


Tamiya Tank Chassis KIT


Tamiya Twin DC Motor Gear Box - KIT


Tamiya Twin DC Motor Gear Box - 58:1 and 203:1


Tamiya Twin DC Motor Gear Box - KIT

MONTAGEM:

Assista o video abiaxo para saber exatamente como montar o KIT Tamiya Gear BOX.

Algumas imagens da montagem:
Tamiya Twin Motors Gear Box Montado com relação 203:1




INTERLIGAÇÃO ELETRÔNICA:
Após feita a montagem dos KITs Tamiya Gear Box e do Chassis, é possível começar a interligação dos componentes eletrônicos do sistema.
A figura abaixo mostra como devem ser feitas as ligações.

Basicamente deve-se:
1 - Plugar o AdaFruit Motor Shield no Arduino;
2 - Conectar o módulo bluetooth:-
RX do módulo bluetooth no TX do Arduino (pino 0)
TX do módulo bluetooth no RX do Arduino (pino 1)
GND do módulo bluetooth no GND do Arduino
VCC do módulo bluetooth no +5V do Arduino
3 - Conectar o motor direito do Tamyia Gear Kit no Motor 1 do AdaFruit Motor Shield;
4 - Conectar p motor esquerdo do Tamiya Gear Kit no Motor 3 do AdaFruit Motor Shield;
Aqui vale uma observação: O sentido de rotação deve ser testado, caso esteja invertido, inverter os fios do motor para assim inverter o sentido de rotação.
5 - Conectar a bateria Li-ion aos pinos GND e +M do AdaFruit Motor Shield.
No AdaFruit Motor Shield o Junp PWR deve estar fechado (assim o Arduino será alimentado pela bateria de 11,1V bem como os motores.






CODIFICAÇÃO:

Obtenha todos os arquivos no GitHub abaixo:
https://github.com/Arduinobymyself/ArduinoRoverBot.git


O Arduino deve ser programado sem que o TX/RX do módulo Bluetooth esteja conectado aos pinos 0 e 1 do arduino. Isso impediria o Arduino de receber os dados compilados da IDE.



Caso tenha algum problema com os arquivos mencionados, solicite via email para:
arduinobymyself@gmail.com



FUNCIONAMENTO:
Primeiramente, ligue o Arduino ROVERBot. O módulo bluetooth irá começar a piscar o LED vermelho (indicando que não está conectado a nenhum computador ou componente de controle MASTER);

Abra o Aplicativo de controle no seu celular Android, inicialmente ele estará desconectado o que será idnicado por um aviso vermelho piscante;
Ao abrir, será perguntado se você deseja ativar o bluetooth do dispositivo (caso ele ainda não esteja ativado), responda sim;
No menu de opções do aplicativo, selecione a opção "connect";
Irão aparecer os dispositivos disponíveis para conexão (geralmente o módulo o bluetooth par Arduino chama-se LINVOR), selecione o dispositivo e efetue a conexão. O LED verde deve acender no módulo bluetooth e também no aplicavo irá aparecer uma indicação verde de conexão.

Pronto agora o celular e o ROVERBot estão conectados via bluetooth.

Use as teclas direcionais para movimentar nas diversas direções permitidas.

É possível também usar o acelerômetro do celular para controlar o ROVERBot por movimentação do celular nas diversas direções.



Agora é só se divertir com este excelente ROVER, Forte, Rápido e Robusto.




FOTOS:
Algumas fotos reais do projeto em execução.
























domingo, 17 de março de 2013

LINUSBot - Line Follower Robot - Controle PID






LINUSBot - Controle PID


Este é um complemento do primeiro posto do LINUSBot.

Agora o controle dos movimentos do seguidor de linha é com PID; controle Proporcional, Integral, Derivativo. Isso torna os movimentos durantes as curvas muito mais suave e durante as retas, ele pode desenvolver maior velocidade, chegando à velocidade máxima.
O controle PID proporciona ao Robot uma "aprendizagem", fazendo com que o robot possa desenvolver melhor nas curvas e retas do circuito.

Agora vamos a uma breve introdução e resumo sobre o controle PID.
Basicamente, este tipo de controlador efetua as seguintes ações:


Sistema PID básico


1 - Controle Proporcional:
Multiplica o "erro" corrente por uma constante Kp.
O "erro", é a diferença entre a saída real e a saída desejada e é realimentado no sistema, ou seja: 
A saída real é subtraída da saída desejada (set point), assim, é calculado o erro.  Esse erro é inserido no controlador PID como entrada, e o controlador PID (calculando os termos P I D), comanda o sistema para tentar eliminar esse erro.
Garantindo assim o ganho necessário para chegar próximo do sinal de saída desejado o mais rápido possível e com a melhor estabilidade do sistema.

2 - Controle Integral:
O termo Integral, multiplica o erro corrente e sua duração por uma constante Ki, fazendo uma somátorio de toda essa informação.
O termo Integral quando somado ao termo Proporcional; acelera o processo de chegar ao estado estacionário do seu sistema, além de proporcionar um sinal mais próximo da saída desejada. Em outras palavras, ele também elimina (ou pelo menos tenta eliminar) a parcela residual de erro e chega mais rápido ao resultado desejado.


3 - Controle Derivativo:
O termo Derivativo, faz com que a razão de mudança do sinal de erro seja multiplicada por uma constante Kd. A intensão é predizer o erro e assim diminuir a taxa com que os erros produzem mudanças no sistema.



Podemos usar os 3 termos juntos para formar um controlador PID, ou suas variaçãoes, tais como:


Controlador P (algumas vezes utilizado):
Neste caso o uso de pequenos vlores da constante Kp é a melhor maneira de conseguir chegar ao valor desejado, mas o seu controle será lento (ele demora pra chegar ao valor desejado).  Se você aumentar o valor de Kp, sobre-impulsos podem ocorrer e o seu sistema ficará estável.



Controlador PI (mais usado):

Ele remove a parcela residual de erro no caso estacionário (melhorando a resposta a transientes), mas neste caso você poderá ter sobre-impulso e também inversão de estado, ocorrendo oscilação do sistema e causando instabilidade, podendo o sistema ser sobre-amortecido,  ou sub-amortecido, ou oscilatório.
Este tipo de controle deixa o sistema mais lento. Usando valores maiores de Ki, é possível deixar o sistema mais rápido, porem aumenta o sobre-impulso diminuíndo a margem de estabilidade do seu sistema.


Controlador PD (raramente utilizado):
Usado para diminuir a magnetude do sobre-impulso dos sistemas que usam Controlador Integral e melhorar a estabilidade do sistema. Porém o controle Derivativo, amplifica a magnetude de ruído do termo de erro do sistema e pode deixar o processo instável. O controlador PD diminui o tempo para chegar ao valor desejado, consideravelmente.... para isso o ganho derivativo Kd deve ser alto. Isso diminui o tempo de controle, porém aumenta a largura de banda do sistema, deixando o sistema susceptível a ruídos.


Controlador PID (algumas vezes utilizado):
Usando PID (combinação de PI+PD), removemos a razão de erro do sistema e diminuímos  o tempo da resposta com uma resposta transistória razoável (sem oscilações ou instabilidades).


Este estudo pode ser encontrado no link: http://www.youtube.com/watch?v=wbmEUi2p-nA




Esta é  o modo básico de implementação de um PID via software:


previous_error = 0
integral = 0 
start:
  error = setpoint - measured_value
  integral = integral + error*dt
  derivative = (error - previous_error)/dt
  output = Kp*error + Ki*integral + Kd*derivative
  previous_error = error
  wait(dt)
  goto start


Veja Mais em: http://en.wikipedia.org/wiki/PID_controller

No projeto do LINUSBot, foi usado os seguintes parãmetros:
Kp = 1/20 
Ki  = 1/10000
Kd = 3/2

O código completo pode ser baixado do link:



http://www.4shared.com/file/iPVAVCwy/LINUSBot_9_3pi_modelo_PID.html


Obtenha todos os arquivos necessários no GitHub:
https://github.com/Arduinobymyself/LINUSBot.git


Veja o vídeo do LINUSBot em ação e confira os resultados.

http://www.youtube.com/watch?v=FKq6WeBBH14




Dúvidas e sugestões para: arduinobymyself@gmail.com





domingo, 17 de fevereiro de 2013

L298N Ponte H Dupla - Breakout board feito em casa








L298N Breakout Board


Este é o projeto da Ponte H dupla com o CI L298N Multiwatt15.

A ponte H já foi discutida em outros tópicos deste blog, dessa forma não é objetivo deste posto entrar em detalhes. Vou ensinar, como construir uma Ponte H usando o CI L298 diretamente numa placa padrão perfurada, sem corroer uma placa de circuito impresso. Vamos então diretamente ao assunto.

Veja o original no meu Instructables: http://www.instructables.com/id/Dual-H-Bridge-L298-Breakout-Board-Homemade/

Passo 1 - Reúna todos os materiais necessários:

1 x placa perfurada padrão com 13x26 furos ou 3,5x7,0 cm;
1 x circuito integrado L298N;
1 x dissipador de calor (se for usar a ponte H para grandes correntes);
2 x AK300/3 - conector borne aparafusável;
1 x pin Header 8 vias, femea (como o do Arduino);
8 x diodos 1N4001;
2 x resistores de 0,47Ohm/2W;
2 x capacitores 100nF poliéster metalizado;
Fios, cabos, solda e ferramentas.



Passo 2 - Preparação da placa e componentes:

Corte, desbaste, lime, lixe e limpe a placa perfurada a ser utilizada.

Dobre e limpe os contatos/terminais dos componentes a ser utilizado.






Passo 3 - Identificar Furação:

Identifique na placa perfurada, toda a furação que será utilizada. Use o diagrama do projeto para esta etapa.







Passo 4 - Soldar Componentes:

Solde os componentes na placa, de acordo com o posicionamento indicado no projeto.
Solde-os em grupo, como por exemplo:
Primeiro os diodos; depois os conectores AK300/3 e PinHead; depois os resistores e capacitores; por último o CI L298N.



















Passo 5 - Trilhas Soldadas:

Use o diagrama do projeto para soldar os pontos da placa perfurada de modo a fazer as trilhas entre os componentes.












Passo 6 - Trilhas Fiadas:

Use o diagrama do projeto para soldar os fios nas camadas superior e inferior, de modo a formar as trilhas com fios.







Passo 7 - Testes:



Para testar, foi usado o chassis do BUGBot para formar um carro controlado via BlueTooth o "Carro_BT-Bot (para o controle via android foi usado o programa "Blue Control" disponível no Market.

Conexões do arduino ao módulo BlueTooth:
Arduino -> BlueTooth
0 RX -> TX
1 TX -> RX
GND -> GND
VCC -> VCC

Conexões do Arduino ao módulo PONTE-H:
Arduino -> Ponte H
10 -> IN1
11 -> IN2
5   -> IN3
6   -> IN4
VCC -> VCC
GND -> GND

Conexões da PONTE-H aos Motores:
O1 -> pino 1 do motor 1 (direita)
O2 -> pino 2 do motor 1 (direita)
O3 -> pino 1 do motor 2 (esquerda)
O4 -> pino 2 do motor 2 (esquerda)

Conexões da PONTE-H:
VS -> +9V
GND -> GND

Diagrama esquemático:


Na figura você pode observar o diagrama da Ponte-H
e no link você pode baixar o original para Eagle Cad de uma versão mais aprimorada.

http://www.4shared.com/file/T17oVW-z/PONTE_H_L298N.html

http://www.4shared.com/file/6VdOTgv5/PONTE_H_L298N.html



Software utilizado:

Abaixo o software completo, e também o link para download.


http://www.4shared.com/file/YJX6-1UT/BlueTooth_Bot_R1.html




/*
#################################################################################
#   File:                          BlueTooth_Bot_R1.pde                                     
#   Micro controller:     Arduino UNO ou Teensy++ 2.0
#   Language:               Wiring / C /Processing /Fritzing / Arduino IDE  
#
# Objectives:               A bluetooth controlled cart
#          
# Funcionamento:       Just a simple test of the home L298N breakout Board
#
#
#   Author:             Marcelo Moraes
#   Date:                13/02/13
#   Place:              Sorocaba - SP - Brazil
#
#################################################################################

  
This project contains code to the public domain.
The modification is permitted without notice.

*/




// definição de variáveis, constantes e valores

int inA1 = 10; // Pins for the PONTE-H
int inA2 = 11;
int inB1 = 5;
int inB2 = 6;



// Arduino initialization
void setup(){
  // Serial communication initialization
  Serial.begin(9600);
  // 
at the beginning motors stopped
  set_motors(0,0);
}

// loop principal do programa
void loop(){

  if (Serial.available() > 0){// if serial data are available
    char varC = Serial.read(); // reading the serial port data

    if(varC == 'U'){ // move forward
      set_motors(80,75);
      delay(1000);
      set_motors(0,0);
    }
    if(varC == 'D'){ // move backward
      set_motors(-80,-75);
      delay(1000);
      set_motors(0,0);
    }
    if(varC == 'C'){ // stopped
      set_motors(0,0);
    }
    if(varC == 'R'){ // turn right
      set_motors(80,-80);
      delay(500);
      set_motors(0,0);
    }
    if(varC == 'L'){ // turn left
      set_motors(-80,80);
      delay(500);
      set_motors(0,0);
    }
  }
}
//FIM DA COMPILAÇÃO


// running motors
void set_motors(int left_speed, int right_speed){
  if(right_speed >= 0 && left_speed >= 0){
    analogWrite(inA1, 0);
    analogWrite(inA2, right_speed);
    analogWrite(inB1, 0);
    analogWrite(inB2, left_speed);
  }
  if(right_speed >= 0 && left_speed < 0){
    left_speed = -left_speed;
    analogWrite(inA1, 0);
    analogWrite(inA2, right_speed);
    analogWrite(inB1, left_speed);
    analogWrite(inB2, 0);
  }
  if(right_speed < 0 && left_speed >= 0){
    right_speed = -right_speed;
    analogWrite(inA1, right_speed);
    analogWrite(inA2, 0);
    analogWrite(inB1, 0);
    analogWrite(inB2, left_speed);
  }
  if(right_speed < 0 && left_speed < 0){
    right_speed = -right_speed;
    left_speed = -left_speed;
    analogWrite(inA1, right_speed);
    analogWrite(inA2, 0);
    analogWrite(inB1, left_speed);
    analogWrite(inB2, 0);
  }
}





Vídeo:

Como fiz originalmente para o site Instructables, o vídeo está num Inglês (um tanto quanto pobre), mas é entendível.

Assista no youtube: http://youtu.be/0conwkmiAoM

Dúvidas e sugestões para: arduinobymyself@gmail.com