Arduino ha al suo interno 4 porte PWM che possono essere usate per i nostri scopi, le porte sono:
PIN 5
PIN 6
PIN 9
PIN 10
Ovvero gli stessi piedini usati nel codice precedente.
I piedini non sono stati scelti a caso, ma hanno una motivazione tecnica che ora vado a specificare:
I piedini per generare un segnale PWM si devono associare ad un TIMER, Arduino ha al suo interno tre TIMER differenti, uno associato alle porte 5 e 6, uno associato alle porte 9 e 10 ed il terzo associato alle porte 3 ed 11.
In questo modo il segnale PWM per spostare il robot "avanti" sarà lo stesso per spostare il robot "indietro", stesso discorso per lo sterzo.
Se si usano TIMER differenti, si rischia di avere tempi differenti quindi, i valori che indicano una velocità in "avanti" non saranno uguali ai valori per la velocità "indietro".
Per ovviare a questo problema e rendere le variazioni "avanti" "indietro" "destra" "sinistra" omogenee ho usato i piedini descritti sopra.
Ora basta variare il valore di PWM e si varierà la tensione all'uscita delle porte associate.
ATTENZIONE: La variazione di tensione non è lineare con la variazione di velocità dei motorini.
Cosa intendo dire?
Si potrebbe pensare che variando i numeri da 0 a 255 si avrà un escursione di velocità da 0 a 255, così non è.
Perchè questo?
Perchè i motorini sono progettati per muoversi in un range di tensione, facciamo un esempio:
Ho un motorino progettato per lavorare da 3 a 5 Volt e la scheda Arduino fornisce 5 Volt sul piedino.
Questo vuol dire che applicando un PWM di 127 che è circa la metà della tensione io avrò 2,5 Volt.
Questi volt non sono sufficienti a far muovere il motorini che rimarrà fermo.
Per veder muovere il motorino dovete aumentare il valore e portarlo a circa 160 (o più), ma la potenza generata dal motore, non sarà in grado di muovere il robot.
Quindi la vera escursione di velocità sarà da circa 180 a 255 (dipende dai motori).
Pertanto non vi spaventate se a bassi valori il robot non si muove, è normale.
Per lo sterzo il discorso cambia in base al modello scelto dalla macchinetta.
Nel mio caso, lo sterzo è costituito da un motore a frizione e quindi il PWM non lavora bene.
Il motore a frizione funziona nel seguente modo:
Il motore gira e la forza centrifuga fa allargare due perni in plastica, che toccheranno una frizione e sposteranno lo sterzo.
Quindi muovendo il motorino con una velocità ridotta, la frizione non si aggancerà e lo sterzo non funzionerà come previsto.
Per vedere il funzionamento, vi basta caricare il sorgente successivo e variare i valori del PWM.
//***************************************************************************
//Programma test per il robot Poor versione 2
//Setto le porte di uscita per le funzioni:
//Integrato trovato sulla macchinetta SM6135W oppure RX2-C
//Avanti PIN 10 ---- Integrato 11
//Indietro PIN 9 ---- Integrato 10
//Destra PIN 5 ---- Integrato 6
//Sinistra PIN 6 ---- Integrato 7
//
//Realizzato da: Daniele Loddo alias Ivotek
//Data: 22/08/2015
//Web: www.mignololab.org www.ivotek.it
//Email: info@mignololab.org ivotek@gmail.com
//***************************************************************************
//Dichiaro le variabili per utilizzare i nomi al posto dei numeri
//Spreco memoria ma il codice risulta leggibile al principiante
int Destra = 5;
int Sinistra = 6;
int Avanti = 10;
int Indietro = 9;
void setup() {
//Setto i PIN come out per pilotare i motori del robot.
pinMode(Avanti,OUTPUT); //Setto la porta Avanti come uscita
pinMode(Indietro,OUTPUT); //Setto la porta Indietro come uscita
pinMode(Destra,OUTPUT); //Setto la porta Destra come uscita
pinMode(Sinistra,OUTPUT); //Setto la porta Sinistra come uscita
}
void loop() {
//Vario il voltaggio per variare la velocità dei motori
//Il robot parte con la massima velocità e piano piano diminuisce sino a fermarsi
analogWrite(Avanti, 255); // Il robot cammina alla massima velocità
analogWrite(Indietro, 0);
//Attendo 2 secondi
delay(2000);
analogWrite(Avanti, 200);
//Attendo 2 secondi
delay(2000);
analogWrite(Avanti, 150);
//Attendo 2 secondi
delay(2000);
analogWrite(Avanti, 100);
//Attendo 2 secondi
delay(2000);
analogWrite(Avanti, 50);
//Attendo 2 secondi
delay(2000);
analogWrite(Avanti, 0); // Il robot si ferma
//Attendo 3 secondi prima di testare le ruote anteriori
delay(3000);
//Vario il voltaggio per variare la velocità del motorino di direzione
//Non avrò tutta l'escursione perché lo sterzo ha la meccanica a frizione
analogWrite(Destra, 255); // Il robot gira tutto a destra
analogWrite(Sinistra, 0);
//Attendo 2 secondi
delay(2000);
analogWrite(Destra, 200); // La posizione dipende dal motore a delle caratteristiche della macchina
//Attendo 2 secondi
delay(2000);
analogWrite(Destra, 150); // La posizione dipende dal motore a delle caratteristiche della macchina
//Attendo 2 secondi
delay(2000);
analogWrite(Destra, 100); // La posizione dipende dal motore a delle caratteristiche della macchina
//Attendo 2 secondi
delay(2000);
analogWrite(Destra, 50); // La posizione dipende dal motore a delle caratteristiche della macchina
//Attendo 2 secondi
delay(2000);
analogWrite(Destra, 0); // Il robot ha le ruote dritte
//Attendi 3 secondi prima di ripetere il ciclo
delay(3000);
}
Aggiunta il link al corso Linux Uno su Udemy.
Aggiunto il tutorial per la realizzazionedi un Arcade con materiale di riciclo.
Aggiunta la sezione corsi.