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.
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.
In questo post descrivo come ho collegato Arduino Uno (per altri tipi di Arduino i collegamenti sono simili) con un modulo JY-MCU Bluetooth che avevo comprato qualche tempo fa.
Questo modulo mi permette di collegarmi in Bluetooth attraverso il mio telefono o tablet o PC.
Il modulo viene visto da Arduino come una comunicazione seriale e quindi e' di facilissima gestione.
Ho gia' im mente un piccolo progettino per la mia casa con questo modulo, ma per il momento concentriamoci su come utilizzare il modulo.
Per utilizzare il modulo con Arduino ci sono sue passaggi da eseguire:
Effettuate i collegamenti del modulo bluettoth come in figura
Nel mio caso ho usato 4 fili di colo Nero, Marrone, Rosso ed Arancione.
I fili sono collegati in questo modo al modulo bluettoth:
nero -> VCC
marrone -> GND
rosso -> TX
arancio -> RX
Adesso ho collegato l'altra estremita' dei fili a Arduino in questo modo
nero -> pin +5V
marrone -> pin GND
rosso -> pin 10
arancio -> pin 11
E' importante collegare i fili in modo corretto siccome il software di configurazione del modulo assegna al pin 10 il ruolo RX e al pin 11 il ruolo di TX.
Quindi come si capisce dalle conenssione il collegamento e' ovviamente incrociato in modo che:
modulo TX --> Arduino RX (pin 10)
modulo RX -> Arduino TX (pin 11)
Una volta che il modulo bluetooth e' stato collegato ad Arduino come descritto sopra caricare il seguente sctach su Arduino:
#define ROBOT_NAME "YOUR ARDUINO NAME"
// If you haven't configured your device before use this
#define BLUETOOTH_SPEED 9600
// If you are modifying your existing configuration, use this:
// #define BLUETOOTH_SPEED 57600
#include
// Swap RX/TX connections on bluetooth chip
// Pin 10 --> Bluetooth TX
// Pin 11 --> Bluetooth RX
SoftwareSerial mySerial(10, 11); // RX, TX
/*
The posible baudrates are:
AT+BAUD1-------1200
AT+BAUD2-------2400
AT+BAUD3-------4800
AT+BAUD4-------9600 - Default for hc-06
AT+BAUD5------19200
AT+BAUD6------38400
AT+BAUD7------57600 - Johnny-five speed
AT+BAUD8-----115200
AT+BAUD9-----230400
AT+BAUDA-----460800
AT+BAUDB-----921600
AT+BAUDC----1382400
*/
void setup()
{
Serial.begin(9600);
while (!Serial) {
; // wait for serial port to connect. Needed for Leonardo only
}
Serial.println("Starting config");
mySerial.begin(BLUETOOTH_SPEED);
delay(1000);
// Should respond with OK
mySerial.print("AT");
waitForResponse();
// Should respond with its version
mySerial.print("AT+VERSION");
waitForResponse();
// Set pin to 0000
mySerial.print("AT+PIN0000");
waitForResponse();
// Set the name to ROBOT_NAME
mySerial.print("AT+NAME");
mySerial.print(ROBOT_NAME);
waitForResponse();
// Set baudrate to 57600
mySerial.print("AT+BAUD7");
waitForResponse();
Serial.println("Done!");
}
void waitForResponse() {
delay(1000);
while (mySerial.available()) {
Serial.write(mySerial.read());
}
Serial.write("\n");
}
void loop() {}
Se tutto ha funzionato correttamente dovreste vedere un output come questo:
A questo punto il modulo bluetooth e' correttamente configurato e pronto per essere utilizzato.
Il modulo bluetooth adersso puo' essere scollegato da Arduino in quanto per il suo utilizzo dobbiamo collegarlo in modo leggermente diverso.
Utilizzo del modulo JY-MCU
Per verificare il funzionamento del modulo ho creato un simplicissimo esempio.
Voglio poter accendere o spegnere due led dal mio cellulare inviando dei semplici comando a Arduino.
I comandi hanno il seguente formato
# PIN--COMANDO
dove
PIN: numero di pin su arduino
COMANDO: ON o OFF
Quindi per esemprio il comando: 10-ON imposta il pin 10 di Arduino a HIGH
Mentre 10-OFF impostal il pin 10 di Arduino a LOW
Circuito di prova
Ho create il semplicissimo circuito rappresentato qui sotto su una breadboard.
Ho collegato il pin 8 e 10 rispettivamente a due led inserendo una resistena per limitare la corrente. Questo e' importantissimo altrimenti quasi certamente si brucia il pin di Arduino o si puo' addirittura danneggiare tutta la scheda Arduino (io ho usato resistenze da 220 Ohm in quanto ho solo queste)
Come si vede il modulo JY-MCU bluetooth e' collegato ad Arduino in modo diverso da prima. Piu' precisamente:
nero -> pin +5V
marrone -> pin GND
rosso -> pin 0 (RX)
arancio -> pin 1 (TX)
In questo modo il modulo bluetooth viene visto da Arduino come una comunicazione seriale.
Sketch di esempio
Ho creato un semplicissimo sketch che rimane in attesa ed esegue un comando ricevuto tramite bluetoot
Ovviamente lo sketch e' solo per verificare il funzionamento e' non e' solido abbastanza per un utilizzo piu' serio, ma dovrebbe essere d'aiuto a capire meglio come usare il modulo stesso.
#include
//struttura del comando
struct CMD {
int pin; //pin da controllare
char *cmd; //comando da applicare al pin (ON|OFF)
};
int i = 0;
int readByte = 0;
char buff[255]; //contiene i dati ricevuti
struct CMD parsed_cmd; //comando ricevuto
void setup()
{
Serial.begin(57600);
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.pin = atoi(token);
token = strtok(NULL, s);
cmd.cmd = token;
return cmd;
}
int validate_cmd(struct CMD cmd)
{
return ((cmd.pin > 0) && ((String(cmd.cmd) == "ON") || (String(cmd.cmd) == "OFF")));
}
void execute_cmd(struct CMD cmd)
{
int pin = cmd.pin;
int status = (String(cmd.cmd) == "ON")?HIGH:LOW;
bt_println(String("Settin PIN: ") + String(pin) + String(" to ") + String(status));
pinMode(pin, OUTPUT);
digitalWrite(pin, status);
}
void loop()
{
clear_buff();
delay(1000);
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("Serial PIN = ") + String(parsed_cmd.pin));
bt_println(String("Serial STATUS = ") + parsed_cmd.cmd);
execute_cmd(parsed_cmd);
}
else
bt_println("ERROR: COMMAND NOT VALID!");
}
}
Verifica del funzionamento
Adesso che abbiamo completato la configurazione del modulo bluetooth, il cablaggio del semplice circuito di prova non ci resta che caricare lo sketch su Arduino.
Per verificare che il tutto funzioni in modo corretto ho installato una semplice app sul mio cellulare Android (per iOS esistono app simili).
L'app che ho installato si chiama BluetoothTerminal.
Questa app mi permette di digitare dei caratteri (comandi) e di inviarli tramite bluetooth al mio Arduino
Nel video si vede che i led si accendono e si spengono quando invio il comando corretto ad Arduino.
Il modulo che ho usato io ha un pin uguale a 0000 per l'accoppiamento del bluetooth con il cellulare.
Come sempre se avete idee per migliorare questo progetto saro' lieto di leggere i vostri commenti e di aggiornare il post.
