Powered By Blogger

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





domingo, 27 de janeiro de 2013

LINUSBot - Robot Seguidor de linhas





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);


LINUSBot - Line Follower - Seguidor de Linhas


O funcionamento deste Robot é bastante simples.

Sensores Infra-vermelho colocados à frente do chassis (neste projeto usaremos o um chassi apropriado do tipo redondo) irão monitorar quando o nosso Robot está sobre uma linha negra ou quando está sobre um fundo  branco.
No caso de o Robot estar sobre a linha negra, ele irá sempre à frente; e no caso de sair da linha e cair em uma área branca, ele irá determinar se deverá corrigir para a esquerda ou para a direita, e assim manter-se sobre a linha negra.

Como sensores será usado o array de sensores infra-vermelho Pololu (também chamado de sensor de reflectância) QTRx8RC, constituído de 8 sensores (serão usados somente 5) QRE1113GR.
Essse array, tem uma saída digital e pode ser facilmente utilizado (usando a biblioteca apropriada da Pololu) para determinar a posição da linha em relação aos sensores.





Este array de sensores pode ser quebrado para formar um conjunto com 6 sensores e outro com 2 sensores.
Para mais informações sobre o array de sensores infra-vermelho, visite:

http://www.pololu.com/catalog/product/961

Neste primeiro projeto, usaremos um controle rudmentar para o nosso robot, ou seja nos preocuparemos em manter o robot seguindo a linha apenas...
Para isto criaremos uma pista de teste para o robot rodar, e poderemos observar que os movimentos do robot serão um tanto quanto "robóticos", ou seja: não muito suaves, porém bruscos.


Pista:
Montada conforme diagrama abaixo em um fundo branco e linha preta.

Curvas de 6".








HARDWARE E COMPONENTES:

Material necessário:
1 X Arduino UNO, MEGA, Duemilanove ou Teensy 2.0++
1 x prototype shield (opcional)(altamente recomendável)
1 x PONTE-H dupla
2 x Gear Box com relação 30:1 de transmissão e motor DC associado
2 x Rodas Polulu ou equivalente
2 x Baterias 9V 400 mA/h
2 x clip de bateria 9V
1 x Ball caster (terceira roda)
fios e cabos para as conexões
parafusos, porcas, arruelas, espaçadores para a montagem
2 x peças de acrílico para o corte do chassis
ferramentas em geral



Projeto, esquema, construção - detalhes:


Corte Circular

Recorte das Rodas

Parte Inferior

Parte Superior





Vamos às pinagens:

1 - motores ligados aos pinos de saída da Ponte-H;
2 - bateria de 9V ligado ao VCC (+) e GND (-) da Ponte-H;
3 - pinos in1, in2, in3 e in4 da Ponte-H ligado ao arduino nos pinos: 10, 11, 5 e 6 respectivamente;
4 - pinos 1, 2, 3, 4 e 5 do sensor QTR, ligar aos pinos A0, A1, A2, A3 e A4 (observar que o sensor 1 deve ser o mais à esquerda);
5- LCD ligar como no diagrama: pinos R/W - 13, Enable - 12, dados - 9, 8, 7 e 4 (depende do tipo do seu display);
6 - Botão ligado ao pino 2 do Arduino;
7 - Buzzer ligado ao pino 3 do Arduino;
8 - Sensor de bateria ligado ao pino A5
consiste de dois resistores 10K/5K ligados ao GND/VCC e no centro ligado ao arduino. Como abaixo

|GND|---/\/\/\/------/\/\/\/-----|VCC|
            10K     |    5K
                      |


Esquema geral de conexões



Chassis:

O chassi foi criado especificamente para este projeto do robot Seguidor de linhas "LINUSBot"

Abaixo está o projeto completo do chassi, com dimensões e as vistas de cortes.

Também as fotos reais das fases de montagem.

A disposição dos módulos no chassis pode ser de acordo com o seu próprio design, porém devem ser respeitados alguns critérios, tal como: o peso dos componentes deverm ser apoiados na parte traseira e nunca na frente do chassis.... etc...

Primeiro protótipo:
Feito em madeirite fino de 3 mm.  Funcionou muito bem, poderia ser um projeto final.

Vejamos algumas fotos:


2 partes circulares de madeirite cortadas


Corte nas laterias para acomodação das rodas
Detalhe de fixação dos motores/rodas (parte de baixo), sensores e ball caster (taxinha)

Detalhe de fixação do array Pololu

Detalhe de fixação dos motores (parte de  cima)

Fixação dos espaçadores das camadas inferior e superior

Disposição inicial dos módulos na parte superior

Parte inferior


Parte superior, disposição de espaçadores dos módulos

Modulos fixados


Parte superior cabeada, segundo o diagrama esquemático

Pronto para o primeiro teste

Testado e aprovado, faltando alguns ajustes no software

Detalhe dos sensores cabeados; um grupo de 6 sensores e um grupo de 3 alimentação e controle dos LEDs infra

Detalhe da parte superior

Detalhe da parte inferior e sensores

Detalhe das baterias e ball caster (ainda a taxinha)

Uma grande solução para o Ball casters, é usar um roll-on de um batton de brilho.  Isso a Pololu cobra 2$, e você pode adquirir por R$1,00

Este é o original Pololu.
http://www.pololu.com/catalog/product/174

Ficou excelente esta solução... Recomendo!



Ball caster feito de Batton tipo Roll-on

Detalhe do caster-ball, um pingo de cola tudo e resolvido.

Rodas:
Pololu $7
http://www.pololu.com/catalog/product/1088




Diâmetro - 32 x 7 mm

Uma solução usada, foi comprar uma moto de plastico cuja roda é aproximadamente o mesmo diâmetro, e revestila com uma fita isolante de pressão plástica. R$5,00.
Vejam nas fotos que ficou muito boa a solução.



Motores:
SolarBotics Pololu $20 cada
http://www.pololu.com/catalog/product/641

Se você puder gastar, Recomendo!
Estes motores e gearbox são excelentes, pequenos, baixo cosumo, grande torque, relação 30:1, etc...

Solução encontrada R$30,00 kit com dois
motor, roda off-road, gearbox 30:1
http://seriallink.com.br/loja/product_info.php?cPath=55&products_id=188&language=pt&osCsid=o5b62h3u44ohs0bkh9v57r9up0



Bem eficaz!
A adaptação das rodas utilizadas, ficou perfeitamente ajustada.



Segundo protótipo:

Feito em acrílico.


Corte das duas placas de acrílico no formato circular



Recorte para as rodas

Posicionamento do sensor
 Notar que o sensor do meio, deve ficar alinhado ao centro da placa


Detalhe da ranhura para os pinos do sensor

Furação e inserção do sensor na ranhura

Fixação com parafusos

Posicionamento dos módulos


Detalhe de pinagem dos sesnores



Pista de teste


Detalhe de pinagem do LCD




Após o primeiro teste, bem sucedido de primeira




SOFTWARE E PROGRAMAÇÃO:

No link abaixo você encontra a versão completa e explicada do software utilizado.

http://www.4shared.com/file/8yKb70LD/LINUSBot_9_3pi_modelo.html

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

O projeto foi desenvolvido, nos moldes do Robot 3pi da Pololu.

Nove versões foram desenvolvidas com vários tipos de sensores LDRs, Infra-vermelho TCRT5000, TIL32/TIL78 e o array QTR-8RC da pololu.

Para este primeiro protótipo, o desempenho foi muito bom.

Vejam o vídeo para confirmação.







VÍDEOS E TESTES:

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

Primeiro Protótipo:
screencast: http://www.screencast.com/t/mVXhRPWH
youtube: http://www.youtube.com/watch?v=YEzRKP34UGs&feature=youtu.be


Segundo protótipo:

screencast: http://www.screencast.com/t/6LN3XlDg3cJ
youtube: http://youtu.be/Z046AKObE34









Aguarde o próximo post, onde veremos um controle mais preciso do LINUSBot, utilizando controle PID (Proporcional Integral Derivativo).


E o próximo projeto de um Maze Solver (LINUSBot resolvendo labirintos...)

Até lá......... vai ser Show!