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);

}

LEZIONE6
LEZIONE4