mercoledì 10 dicembre 2014

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