Arduino e motore DC con H-bridge L293D

Nel precedente post http://mancusoa74.blogspot.it/2014/12/arduino-e-motore-dc.html ho spiegato con pilotare un motore DC con Arduino.

Tuttavia in quel post il motore poteva girare in un solo verso siccome ho usato un ULN2003.

In questo post uso un L293D, cioe' un chip che implementa due circuiti Half-Bridge (per maggiori info: http://www.rakeshmondal.info/L293D-Motor-Driver

In questo modo e' possibile controllare il verso di rotazione del motore.

Circuito

Ho implementato il circuito riportato qui sopra

Sketch

Ho implemetato questo semplicissimop sketch che fa ruotare il motore in un versoper  1 secondo e poi nel verso opposto per 1 secondo

void setup() {
  Serial.begin(9600);
  Serial.println("Staring");

  pinMode(2, OUTPUT);
  pinMode(7, OUTPUT);
}



void loop() {

  digitalWrite(2, HIGH);
  digitalWrite(7, LOW);
  delay(1000);          

  digitalWrite(2, LOW);
  digitalWrite(7, LOW);
  delay(2000);
  
  digitalWrite(2, LOW);
  digitalWrite(7, HIGH);
  delay(1000);

  digitalWrite(2, LOW);
  digitalWrite(7, LOW);
  delay(2000);  
}

Come si vede dal codice il motore e' controllato dai pin 2 e 7:

• Se i pin sono entrambi HIGH o LOW il motore e' fermo.
• Se il pin 2 e' HIGH e il 7 e' LOW il motore gira in senso orario
• Se il pin 2 e' LOWe il 7 e' HIGH il motore gira in senso antiorario

Verifica Funzionamento

Come sempre verifichiamo che il tutto funzioni come previsto

Arduino e motore DC

In questo post spiego brevemente come pilotare un motore in corrente continua con Arduino.

Il controllo e' molto piu' semplice rispetto ad un motore passo-passo (Arduino e Motore Passo Passo)

Nel caso del motore DC non ci sono fasi da alimentare in sequenza.
Basta applicare una tensione ai morsetti ed il motore gira. Se si inverte la tensione il motore gira in senso contrario.

Questa minor complessita' nel far ruotare il motore rispetto ad un passo-passo ha pero' lo svantaggio che con un motore DC non si ottiene una rotazione precisa e controllata come con il passo-passo.

Mentre nel motore passo-passo si puo' far ruotare il motore di un numero di step o gradi ben determinato con un motore DC si possono solo specificare la tensione da applicare e la durata dell'impulso di alimentazione.

Quindi normalmente i motori DC e passo-passo vengono utilizzati in applicazioni diverse.

Come nel caso del motore passo-passo, Arduino non puo' alimentare il motore direttamente. Si rischia seriamente di bruciare la scheda Arduino.

Anche in questo caso ci vuole un driver per il motore.
Normalmente si usa un transistor di potenza in configurazione Darlington, per esempio TIP 120.

Siccome io non ho un TIP 120 o simile o pensato di utilizzare il ULN2003  che e' un chip che racchiude 7 transistor Darlington.

Quindi funzionalmente il ULN2003 equivale a 7 TIP 120, percio' perfetto per qusto uso

Il ULN2003 l'ho riciclato dalla scheda di controllo per motore passo-passo che ho usato in un mio precedente post

In aggiunta al ULN2003 ho anche usato un piccolo condensatore applicato ai poli del motore a spazzole in corrente continua.

Anche in questo caso ho utilizzato un semplice 7805 per ricavare i 5V necessari a questo circuito partendo da una batteria a 9V. (Nel post relativo ai motori passo-passo spiego meglio come realizzarlo).

A questo punto ho tutti gli elementi necessari a realizzare il semplice circuito.

Ecco come ho cablato il tutto su una breadboard.

Adesso che il circuito e' pronto vediamo il software.

Sketch di controllo

Ho creato un semplice sketch per Arduino (basato sullo sketch usato per il post relativo al controllo bluetooth)

#include <string.h>

//struttura del comando
struct CMD {
  int  speed;  //speed of the motor
  int  time; //timeof the impulse
};

int i = 0;
int readByte = 0;
char buff[255]; //contiene i dati ricevuti
struct CMD parsed_cmd; //comando ricevuto

void setup()
{
  Serial.begin(9600); 
  bt_println("Init!!!!");
}

//pulisce il buffer dopo che e' stato utilizzato
void clear_buff()
{
  for (i=0; i < 255; i++)
    buff[i] = 0;
}

//println verso bluetooth
void bt_println(String str)
{
  Serial.println(str);
  delay(10);
}

//print verso bluetooth
void bt_print(String str)
{
  Serial.print(str);
  delay(10);
}

//parsing della stringa ricevuta in un comando da eseguire
//comando ha il seguente formato:  PIN--COMANDO. esempio: 13--OFF; 13--ON
struct CMD read_command(char *command)
{
  struct CMD cmd;
  const char s[3] = "--";
  char *token;
 
  token = strtok(command, s);
  cmd.speed = atoi(token);
  
  token = strtok(NULL, s);
  cmd.time = atoi(token);  

  return cmd;
}

int validate_cmd(struct CMD cmd)
{
  return ((cmd.speed > 0) && (cmd.speed < 256) && (cmd.time > 0));
}

void execute_cmd(struct CMD cmd)
{
  int speed = cmd.speed;
  int time = cmd.time;
  
  analogWrite(3, speed);
  delay(time);
  analogWrite(3, 0);
}

void loop()
{
  clear_buff();  
  delay(100);
  
  if ((readByte = Serial.available()) > 0) {
    bt_println("-------------------------");
    
    Serial.readBytes(buff, readByte);
    
    bt_println(String("Parsing commnand: ") + buff);
        
    parsed_cmd = read_command(buff);
    
    if (validate_cmd(parsed_cmd)) {   
      bt_println(String("SPEED = ") + String(parsed_cmd.speed));
      bt_println(String("TIME = ") + String(parsed_cmd.time));
      execute_cmd(parsed_cmd);
    }
    else
      bt_println("ERROR: COMMAND NOT VALID!");
  }
}

Per utilizzare lo sketch basta inserire un semplice comando nel monitor seriale seguendo questo formato:

V--T

dove

• V = velocita' di rotazione (1 -- 255)
• T =  durata dell'inpuslo in millisecondi

Quindi per esempio il comando 128--500 fara' ruotare il motore a meta' della sua velocita' massima per 500 ms.

Allo stesso modo 255-1000 lo fara' ruotare alla massima velocita' per 1 secondo

Verifica Funzionamento

Come sempre verifichiamo che il tutto funzioni come previsto

Arduino e Motore Passo Passo

In questo post spiego brevemente come pilotare un motore passo-passo con Arduino.

Ci sono vari modi per pilotare un motore passo-passo. Nel mio caso ho un motore 28BYJ-48

e una scheda di controllo ULN2003

In questo modo e' facilissimo pilotare il motore passo-passo.

Come si vede la scheda di controllo richiede:

• +5V
• GND
• 4 GPIO di Arduino (per controllare i 4 avvoglimenti del motore in questione)

E' imporante notare che l'alimentazione della scheda e quindi del motore non deve essere prelevata da Arduino, altrimenti quasi certamente lo friggiamo.

L'alimentazione deve essere esterna ad Arduino


Nel mio caso siccome ho una batteria a 9V ho creato un semplice regolatore DC-DC di tensione in modo da ottenere i 5V richiesti per l'alimentazione del motore.

Regolatore DC-DC

Lo schema del circuito di un semplice regolatore DC-DC e' semplicissimo

Come si vede dalla figura ho usato un 7805 e due condensatori. Nel mio caso il condensatore Ci all'ingresso ha una capacita' di 100 uF e Co all'uscita una capacita' di 10 uF.

Qui sotto un semplice schema di come ho montato il regolatore su una breadboard:

Ecco come ho realizzato velocemente il regolatore sulla basetta:

Ok a questo punto sulle due piste in basso (filo giallo e bianco) ho i +5V e GND con cui alimentero' il motore passo passo e la scheda di controllo.

Collegamento motore ad Arduino

Adesso ho collegato il motore alla scheda di controllo e questa ad Arduino come spiegato qui sotto.

Il motore ha un connettore con 5 fili. Lo collego alla scheda (entra in una sola direzione).

Dopo di cio' ho inserito i fili dell'alimentazione in questo modo:

• filo rosso -> GND
• filo marrone -> +5V

Adesso collego questi due fili alla breadboard all'uscita del regolatore DC-DC

Il filo rosso in corrispondenza del filo giallo sulla breadboard (GND)

Il filo marrone in corrispondenza del filo bianco sulla breadboard (+5V)

A questo punto ho collegato la scheda di controllo del motore ad Arduino come spiegato qui sotto.

• filo nero         --> pin IN1 della scheda motore
• filo marrone   --> pin IN2 della scheda motore
• filo rosso        --> pin IN3 della scheda motore
• filo arancione --> pin IN4 della scheda motore

Dal lato Arduino:

• filo nero         --> pin 8
• filo rosso        --> pin 9
• filo marrone   --> pin 10
• filo arancione --> pin 11

Nota
Come notate i pin 9 e 10 sono invertiti per far si che il motore possa giare in senso orario e antiorario.
Immagino che queso sia un problema della schedina da 2$.
Quindi tutto sommato solo invertendo i fili abbiamo risolto il problema.

A questo punto ho collegato la batteria alla breadboard rispettando la polarita'.

Arduino Sketch

Ho creato questo semplice sketch (basato su stepper_oneRevolution) che rimane in attesa di input dal monitor seriale di arduino

#include <Stepper.h>

const int stepsPerRevolution = 4;  

int readByte = 0;
char buff[255]; //contiene i dati ricevuti
int steps = 0;

// initialize the stepper library on pins 8 through 11:
Stepper myStepper(stepsPerRevolution, 8,9,10,11);            

void setup() {
  // set the speed
  myStepper.setSpeed(4096);
  // initialize the serial port:
  Serial.begin(9600);
}

void clear_buff()
{
  int i = 0;
  for (i=0; i < 255; i++)
    buff[i] = 0;
}

void loop() {
  clear_buff();  
  delay(100);
  
  if ((readByte = Serial.available()) > 0) {
    // insert the number of step (+ or -) manually trhough serial monitor  
    Serial.readBytes(buff, readByte);
    steps = atoi(buff);  
    Serial.println(steps);
    myStepper.step(steps);
  }
}

Inserisci il numero di step e il verso in cui si vuole che il motore giri:

• 2048 : il motore compie un giro completo in senso orario
• -2048: il motore compie un giro completo in senso antiorario
• 1024: il motore compie mezzo giro in senso orario

Dopo varie prove ho verificato che i valori 4 per stepsPerRevolution e 4096 per la velocita' di rotazione sono i migliori. In questo modo il motore compie un giro completo in circa 6 secondi.

Potete variare questi due valori ma fate in modo che il prodotto dei due valori sia sempre 16384.

Verifica Funzionamento

Come sempre verifichiamo che il tutto funzione come previsto!!!

Come sempre chiunque abbia idee e migliorie e' il benvenuto.