Shield MODKIT
MotoProto
Test Motori
ultimo aggiornamento 29 marzo 2014


 

Lo Shield Modkit MotoProto  per Arduino rende facile il controllo di due motori DC tramite l'integrato L298 (massima corrente 2A per motore) e un display LCD 16X2 caratteri .
Nell'esempio si è testata la scheda per il comando di due motoriduttori inseriti all'interno di una base robotica tipo Rover 5

 

homotix

PCBA

OurPCB

Schema della sezione driver dei motori

Il circuito pilota del motore è basato sull'integrato  H-bridge L298  che può pilotare motori con assorbimento sino a 2A per canale. La scheda è alimentata dalla stessa linea Vin proveniente dalla scheda Arduino, include dei LED blu e gialli per indicare la direzione attiva, e tutte le linee in uscita sono protette da diodi Schottky tipo MBRA140

Schema della sezione LCD

Il circuito pilota display prevede la modalità a 4 bit (DB4…DB7), modalità che permette di collegare solo 7 pin, invece che 11. Vediamo come sono connessi

LCD RS →  

 pin digitale 6

LCD R/W →  

 GND

LCD Enable →  

 pin digitale 7

LCD D4 →  

 pin digitale 8

LCD D5 →  

 pin digitale 9

LCD D6 →  

 pin digitale 10

LCD D7 →  

 pin digitale 11

Oltre a è presente il collegamento all'alimentazione e al trimmer per la regolazione del contrasto. I pin D0, D1, D2, D3 sono posti a massa.
Nel circuito è inoltre presente il collegamento per l'accensione dell'eventuale retroilluminazione.      E' inoltre visualizzato nello schema il pulsante S2, a disposizione per eventuale interazione con il programma.   Tale pulsante non è dotato di resistenza di pull-up o pull-down.


Programma test H-Bridge

/*
 MotoPropto_motore_LCD_test.pde
 Il programma permette il test della parte controllo
 motore. Sul display LCD dello shield, viene mostrato 
 il comando in esecuzione.
 
 Vengono utilizzati i seguenti pin
 Pin +5V     -> Alimentazione logica
 Pin GND     -> Alimentazione
 Pin Vin     -> Alimentazione motori 
 Pin 2       -> Direzione Motore A
 Pin 3       -> PWM - Velocità Motore A
 Pin 4       -> Direzione Motore B
 Pin 5       -> PWM - Velocità Motore B
 Pin 6       -> LCD RS
 Pin 7       -> LCD Enable
 Pin 8       -> LCD D4
 Pin 9       -> LCD D5
 Pin 10      -> LCD D6
 Pin 11      -> LCD D7
 Pin 12      -> Pulsante
 Pin 13      -> Led su scheda
 
 Creato il 26/11/2011
 da Adriano Gandolfo <https://www.adrirobot.it>
 This example code is in the public domain.
 */

// include il codice della libreria:
#include <LiquidCrystal.h>

// inizializzare la libreria con i numeri dei pin interfaccia
LiquidCrystal lcd(6, 7, 8, 9, 10, 11);

int M1_PWM = 3;  //PWM controllo velocità per motore 1 - pin digitale 3 
int M2_PWM = 5;  //PWM controllo velocità per motore 2 - pin digitale 3 
int M1 = 2;      //Controllo direzione per motore 1 - pin digitale 2
int M2 = 4;      //Controllo direzione per motore 2 - pin digitale 4

int speed_val(255);        //imposta velocità - valore massimo
const int buttonPin = 12;  // Numero della porta a cui è collegato il pulsante
const int ledPin =  13;    // Numero della porta a cui è collegato il led
int buttonState = 0;       // Variable per la lettura dello stato del pulsante

void setup()
{
  pinMode(M1_PWM, OUTPUT);  //Imposta i pin come uscite
  pinMode(M2_PWM, OUTPUT);
  pinMode(M1, OUTPUT);
  pinMode(M2, OUTPUT);

  pinMode(ledPin, OUTPUT);       // Inizializza il pin del LED come uscita     
  pinMode(buttonPin, INPUT);     // Inizializza il pin del pulsante come ingresso 
  digitalWrite(buttonPin, HIGH); // Attiva resistenza di pull-up

  // ferma per default entambi i motori
  M1_stop();
  M2_stop();
  delay(500);

  // Imposta lcd per 16 caratteri per 2 linee
  lcd.begin(16, 2);
  // Scrittura prima linea
  lcd.print("Test H-bridge");
  lcd.setCursor(0, 1);
  lcd.print ("Robot FERMO!");
  delay(500);
}

void loop()
{
  lcd.setCursor(0, 1);
  lcd.print ("Premi un tasto");
  // Controlla se il pulsante è premuto.
  // Se è premuto il livello è basso
  // collegato a GND
   buttonState = digitalRead(buttonPin);
  if (buttonState == LOW) {         
    // Accende il LED ed esegue il programma:       
    digitalWrite(ledPin, HIGH);  

    // Robot AVANTI
    lcd.setCursor(0, 1);
    lcd.print("                ");
    lcd.setCursor(0, 1);
    lcd.print("Robot AVANTI    ");
    delay (1000);
    M1_avanti(speed_val);
    M2_avanti(speed_val);
    delay (1000);
    M1_stop();
    M2_stop();
    delay (2000);

    // Robot INDIETRO
    lcd.setCursor(0, 1);
    lcd.print("                ");
    lcd.setCursor(0, 1);
    lcd.print("Robot INDIETRO  ");
    delay (1000);
    M1_indietro(speed_val);
    M2_indietro(speed_val);
    delay (1000);
    M1_stop();
    M2_stop();
    delay (2000);

    // Robot DESTRA
    lcd.setCursor(0, 1);
    lcd.print("                ");
    lcd.setCursor(0, 1);
    lcd.print("Robot DESTRA    ");
    delay (1000);
    M1_avanti(speed_val);
    M2_indietro(speed_val);
    delay (1000);
    M1_stop();
    M2_stop();
    delay (2000);

    // Robot SINSITRA
    lcd.setCursor(0, 1);
    lcd.print("                ");
    lcd.setCursor(0, 1);
    lcd.print("Robot SINISTRA  ");
    delay (1000);
    M1_indietro(speed_val);
    M2_avanti(speed_val);
    delay (1000);
    M1_stop();
    M2_stop();
    delay (2000);
  }
  else {    
    // Spegne il LED:
    digitalWrite(ledPin, LOW); 
  }
}

/////////// Impostazione motori ////////////////

void M1_indietro(int x){
  digitalWrite(M1, LOW);
  analogWrite(M1_PWM, x);
}

void M1_avanti(int x){
  digitalWrite(M1, HIGH);
  analogWrite(M1_PWM, x);
}

void M1_stop(){
  digitalWrite(M1_PWM, LOW);
}

void M2_avanti(int y){
  digitalWrite(M2, LOW);
  analogWrite(M2_PWM, y);
}

void M2_indietro(int y){
  digitalWrite(M2, HIGH);
  analogWrite(M2_PWM, y);
}

void M2_stop(){
  digitalWrite(M2_PWM, LOW);
}

 

Elenco revisioni
29/03/2015 Realizzata pagina singola
28/11/2011 Emissione preliminare
Private Policy Cookie Policy Termini e Condizioni