Powered By Blogger
Mostrando postagens com marcador controle remoto. Mostrar todas as postagens
Mostrando postagens com marcador controle remoto. Mostrar todas as postagens

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





sábado, 11 de agosto de 2012

Sensor Infra Vermelho e Controle Remoto

Arduino by my Self


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 Controle Remoto

Hoje vamos aprender a utilizar o controle Remoto Infra-Vermelho YK-001 com Arduino.

Com esta aplicação, podemos controlar ou comandar por exemplo, usando circuitos eletrônicos com Transistores MOS-FET, Darlington, acopladores ópticos ou relés, circuitos de potência para controlar lâmpadas ou pequenos motores, etc...




Usaremos a biblioteca de Infra-Vermelho  IRremote, que pode ser baixada em: http://www.4shared.com/zip/FHHwmplA/IRremote_library.html


O controle remoto utilizado, será o YK-001 com 21 teclas, muito comum no ramo de trabalhos com o Arduino.


como podemos ver na figura acima, a cada tecla temos um código numérico associado, devemos respeitar este código, que será recebido pelo Arduino e na hora de utilizar uma determinada tecla do controle remoto verificar se é a tecla correta para poder acionar un driver de dispositivo.

Neste link temos um arquivo contendo os códigos das respectivas teclas em Hexadecimal
http://www.4shared.com/file/lZO81VuK/YK-001.html

Em termos de software, iremos desenvolver dois programas; um para identificar as teclas quando apertadas e nos retornar os códigos (serve também para verificar se o controle está OK).
O outro será para acionar 7 saídas no Arduino, como se fossem 7 relés ou um outro dispositivo; neste caso será feito o acendimento de um LED (para termos uma interação com o sistema).

O receptor utilizado: Receptor IR 38 KHz TSOP4838, ou equivalente (por exemplo: IRM-3638)
No link o DataSheet do componente:
http://www.4shared.com/office/5pjFusnm/A-1551.html



COMPONENTES:

1 x Arduino Duemilanove, UNO ou MEGA
1 x Bread-Board
7 x LEDs (cores diversa e tamanho de acordo com a preferência)
7 x resistores de 220 Ohm
1 x Receptor Infra-Vermelho TSOP4838 ou equivalente (por exemplo: IRM-3638)
1 x controle remoto YK-001 de 21 teclas
Fios e Cabos para as conexões

DIAGRAMAS:

Abaixo o esquema de ligação dos componentes;
Observar que o pino onde será ligado o sensor Infra-Vermelho no Arduino, é o pino 2
Pinos 3 a 9 serão conectados aos LEDs para acionamento quando pressionado uma tecla do controle remoto.
Observar a pinagem do seu receptor Infra-Vermelho para não ligar invertido!


 É uma boa prática colocar um resistor de 10 K Ohm entre o pino "out" e o VCC para fazer pull-up do sensor (fica a seu critério usar ou não).



SOFTWARE:

Abaixo os dois programas usados;

1 - Programa para verificação dos dados recebidos a partir do controle remoto no Arduino

http://www.4shared.com/file/MHTyXGBZ/INFRA_RED_3_ino.html


/*
################################################################################
#   Arquivo:            INFRA_RED_3                                             
#       Micro-processador:  Arduino UNO         
#   Linguagem:    Wiring / C /Processing /Fritzing / Arduino IDE          
#
# Objetivo:           Scrolling LED dot Matrix
#  
# Funcionamento:    Recebe a informação do controle remoto e 
#                           mostra no console serial o código recebido
#                           
#
#   Autor:              Marcelo Moraes 
#   Data:               11/08/12
#   Local:              Sorocaba - SP
#
################################################################################
 Este exemplo é um código de domínio público.
 */


// inclui a biblioteca
#include <IRremote.h>
int RECV_PIN = 2; // define o pino do receptor infra vermelho
IRrecv irrecv(RECV_PIN);
decode_results results;
void setup()
{
Serial.begin(9600);
irrecv.enableIRIn(); // inicia o receptor infra vermelho
}
void loop() {
if (irrecv.decode(&results)) {
  Serial.println(results.value );
  irrecv.resume(); // recebe o próximo valor
}
}

// FIM DA COMPILAÇÃO


2 - acionamento de dispositivos remotamente

http://www.4shared.com/file/PwGKAHU9/INFRA_RED_4.html


/*
################################################################################
#   Arquivo:            INFRA_RED_4                                             
#       Micro-processador:  Arduino UNO         
#   Linguagem:    Wiring / C /Processing /Fritzing / Arduino IDE          
#
# Objetivo:           Scrolling LED dot Matrix
#  
# Funcionamento:    Recebe a informação do controle remoto e 
#                           aciona os dispositivos de saída (LEDs)
#                           
#
#   Autor:              Marcelo Moraes 
#   Data:               11/08/12
#   Local:              Sorocaba - SP
#
################################################################################
 Este exemplo é um código de domínio público.
 */

// inclui bliblioteca para Infra-Vermelho
#include <IRremote.h>

// definição de pinos
int RECV_PIN = 2;

int Relay1_PIN = 3;
int Relay2_PIN = 4;
int Relay3_PIN = 5;
int Relay4_PIN = 6;
int Relay5_PIN = 7;
int Relay6_PIN = 8;
int Relay7_PIN = 9;

// definição de variáveis
IRrecv irrecv(RECV_PIN);
decode_results results;

// executado na inicialização do sistema
void setup()
{
  // definição de modo dos pinos
  pinMode(Relay1_PIN, OUTPUT);
  pinMode(Relay2_PIN, OUTPUT);
  pinMode(Relay3_PIN, OUTPUT);
  pinMode(Relay4_PIN, OUTPUT);
  pinMode(Relay5_PIN, OUTPUT);
  pinMode(Relay6_PIN, OUTPUT);
  pinMode(Relay7_PIN, OUTPUT);
  
  pinMode(6, OUTPUT);
  irrecv.enableIRIn(); // Inicialização do receptor Infra-vermelho
}

int on = 1;


// loop principal do programa
void loop() {
  if (irrecv.decode(&results)) {
    if (results.value == 16724175) { // YK-001 button 1
       {
        on = !on;
        digitalWrite(Relay1_PIN, on ? HIGH : LOW);
      }
     }
{
    if (results.value == 16718055) { // YK-001 button 2
      
       {
        on = !on;
        digitalWrite(Relay2_PIN, on ? HIGH : LOW);
      }
      }    
  {
    if (results.value == 16743045) { // YK-001 button 3
     {
        on = !on;
        digitalWrite(Relay3_PIN, on ? HIGH : LOW);
      }
     }    
  {
    if (results.value == 16716015) { // YK-001 button 4
     {
        on = !on;
        digitalWrite(Relay4_PIN, on ? HIGH : LOW);
      }
     }
   {
    if (results.value == 16726215) { // YK-001 button 5
       {
        on = !on;
        digitalWrite(Relay5_PIN, on ? HIGH : LOW);
      }
     }
   {     
    if (results.value == 16734885) { // YK-001 button 6
       {
        on = !on;
        digitalWrite(Relay6_PIN, on ? HIGH : LOW);
      }
     }
   {  
    if (results.value == 16728765) { // YK-001 button 7
       {
        on = !on;
        digitalWrite(Relay7_PIN, on ? HIGH : LOW);
      }
     }
{     
//
//
//  COLOQUE MAIS IFs COM VALORES A SEREM IDENTIFICADOS E PINOS DEINIDOS
//
//
   
     
    irrecv.resume(); // recebe o próximo valor
  }
}}}}}}}}

// FIM DA COMPILAÇÃO




Atualização de MARÇO / 2023

CÓDIGO ATUALIZADO PARA TRABALHAR COM NOVAS VERSÕES DA BIBLIOTECA IRremote.h

A instrução irrecv.decode(&results) não mais está em funcionamento....

Este novo código é preser usado com o controle remoto YK-001

/*
 * SimpleReceiver.cpp
 *
 * Demonstrates receiving NEC IR codes with IRrecv
 *
 *  Copyright (C) 2020-2021  Armin Joachimsmeyer
 *  armin.joachimsmeyer@gmail.com
 *
 *  This file is part of Arduino-IRremote https://github.com/Arduino-IRremote/Arduino-IRremote.
 *
 *  MIT License
 */

/*
 * Specify which protocol(s) should be used for decoding.
 * If no protocol is defined, all protocols are active.
 */
//#define DECODE_DENON
//#define DECODE_SHARP        // the same as DECODE_DENON
//#define DECODE_JVC
//#define DECODE_KASEIKYO
//#define DECODE_PANASONIC    // the same as DECODE_KASEIKYO
//#define DECODE_LG
//#define DECODE_NEC
//#define DECODE_SAMSUNG
//#define DECODE_SONY
//#define DECODE_RC5
//#define DECODE_RC6

//#define DECODE_BOSEWAVE
//#define DECODE_LEGO_PF
//#define DECODE_MAGIQUEST
//#define DECODE_WHYNTER

//#define DECODE_HASH         // special decoder for all protocols

#include <Arduino.h>

#include <IRremote.h>

#define IR_RECEIVE_PIN 2
#define LED_1 3
//int LED_1 = 3;
bool LED_1_FLAG = false;
int value = 0;

void setup() {
    pinMode(IR_RECEIVE_PIN, INPUT);
    pinMode(LED_1, OUTPUT);
    
    Serial.begin(9600);
    // Just to know which program is running on my Arduino

    Serial.println(F("INICIALIZANDO ...  " __DATE__ "\r\nUSando biblioteca versião " VERSION_IRREMOTE));

    /*
     * Start the receiver, enable feedback LED and take LED feedback pin from the internal boards definition
     */

    IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);

}

void loop() {
    if(IrReceiver.decode()){
        //value = String(IrReceiver.decodedIRData.command, DEC).toInt();
        value = IrReceiver.decodedIRData.command;
        IrReceiver.resume();
        delay(100);
        //Serial.println("recebido: " + String(value));


        switch(value){
          
          case 69: Serial.print("Recebido valor: " + String(value) + "  POWER\r\n"); LED_1_FLAG = !LED_1_FLAG; break; 
          case 70: Serial.print("Recebido valor: " + String(value) + "  MODE\r\n"); break;
          case 71: Serial.print("Recebido valor: " + String(value) + "  MUTE\r\n"); break;
          case 68: Serial.print("Recebido valor: " + String(value) + "  BACKWARD\r\n"); break;
          case 64: Serial.print("Recebido valor: " + String(value) + "  FORWARD\r\n"); break;
          case 67: Serial.print("Recebido valor: " + String(value) + "  PLAY/PAUSE\r\n"); break;
          case 7: Serial.print("Recebido valor: " + String(value) + "  MINUS\r\n"); break;
          case 21: Serial.print("Recebido valor: " + String(value) + "  PLUS\r\n"); break;
          case 9: Serial.print("Recebido valor: " + String(value) + "  EQ\r\n"); break;
          case 22: Serial.print("Recebido valor: " + String(value) + "  0\r\n"); break;
          case 25: Serial.print("Recebido valor: " + String(value) + "  100+\r\n"); break;
          case 13: Serial.print("Recebido valor: " + String(value) + "  UNDO\r\n"); break;
          case 12: Serial.print("Recebido valor: " + String(value) + "  1\r\n"); break;
          case 24: Serial.print("Recebido valor: " + String(value) + "  2\r\n"); break;
          case 94: Serial.print("Recebido valor: " + String(value) + "  3\r\n"); break;
          case 8: Serial.print("Recebido valor: " + String(value) + "  4\r\n"); break;
          case 28: Serial.print("Recebido valor: " + String(value) + "  5\r\n"); break;
          case 90: Serial.print("Recebido valor: " + String(value) + "  6\r\n"); break;
          case 66: Serial.print("Recebido valor: " + String(value) + "  7\r\n"); break;
          case 82: Serial.print("Recebido valor: " + String(value) + "  8\r\n"); break;
          case 74: Serial.print("Recebido valor: " + String(value) + "  9\r\n"); break;
          
        }
        resetLEDs();
    }
}

void resetLEDs(){
  digitalWrite(LED_1, LED_1_FLAG);
// FIM DA COMPILAÇÃO


OBS.: Estes sketches não funcionam bem com a versão 1.0 e 1.01 da IDE do Arduino, por favor utilizem a versão 0023 da IDE.
Provavelmente problema com a versão da biblioteca IRremote, que não foi detectado pela equipe de desenvovimento

Assistam ao vídeo!


TESTES E VÍDEOS:

Abaixo o complemento com o "dump" e "raw code" de controle remotos:
Esse sketch é da própria biblioteca IRremote.
http://www.youtube.com/watch?v=eNw-_KqS2Pc



Então é isso!
Até o próximo projeto!

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