1. // versione 2
2. #define TIC_STERZO       10 // millisecondi di intervallo per ogni grado di movimento sterzo
3. #define TIC_MOTORE      100 // mililsecondi di durata singolo passo movimento motore
4. #define TRATTO_MOTORE  2000 // millisecondi di durata totale azionamento motore
5.  
6. // un paio di costanti per rendere chiaro il senso del movimento
7. #define AVANTI   1
8. #define INDIETRO 0
9.  
10. #include <Servo.h>
11. Servo myservo;
12.  
13. #include <IRremote.h>;
14.  
15. IRrecv irrecv(11);
16. decode_results res;
17.  
18.  
19. #define ENABLE 5
20. #define DIRA 3
21. #define DIRB 4
22. #define ENABLE2 8
23. #define DIRA2 6
24. #define DIRB2 7
25.  
26. // variabili globali per le temporizzazioni e per la gestione dello stato
27. long istanteUltimoMovSterzo = 0;
28. long istantePartenzaMotore = 0;
29. long istanteUltimoMovMotore = 0;
30.  
31. int destinazioneSterzo = 90;
32. boolean motoreMovimento = false;
33. byte direzioneMotore = AVANTI;
34.  
35.  
36. int led = 10 ;
37. int buzzer = 12 ;
38. int i;
39. int pos = 0;
40.  
41.  
42.  
43. void setup() {
44.   pinMode(led,OUTPUT);
45.   pinMode(buzzer,OUTPUT);
46.   pinMode(ENABLE2,OUTPUT);
47.   pinMode(DIRA2,OUTPUT);
48.   pinMode(DIRB2,OUTPUT);
49.   pinMode(ENABLE,OUTPUT);
50.   pinMode(DIRA,OUTPUT);
51.   pinMode(DIRB,OUTPUT);
52.   Serial.begin(9600);
53.   irrecv.enableIRIn();
54.  
55.   // inizializzo servo su pin 9
56.   myservo.attach(9);
57.  
58.   // IMPORTANTE: porto il servo nella posizione centrale
59.   myservo.write(90);
60.  
61.  
62. }
63.  
64.  
65.  
66. void loop() {
67.   if(irrecv.decode(&res)){
68.     Serial.println(res.value,HEX);
69.     irrecv.resume();
70.  
71.     switch( res.value ) {
72.       case 0xAD586662:   // tasto avanzamento: motore avanti per TRATTO_MOTORE millisecondi
73.  
74.         // abilitiamo le uscite per il motore
75.         digitalWrite(ENABLE2,HIGH);
76.         digitalWrite(ENABLE,HIGH); // enable on
77.  
78.         // impostiamo l'istante di partenza del motore, così potremo fermarlo a fine intervallo
79.         istantePartenzaMotore = millis();
80.  
81.         // impostiamo la direzione
82.         direzioneMotore = AVANTI;
83.  
84.         // dichiariamo il motore in movimento
85.         motoreMovimento = true;
86.        
87.         break;
88.  
89.       case 0x6825E53E:   // tasto retromarcia: motore indietro per TRATTO_MOTORE millisecondi
90.         // abilitiamo le uscite per il motore
91.         digitalWrite(ENABLE2,HIGH);
92.         digitalWrite(ENABLE,HIGH); // enable on
93.  
94.         // impostiamo l'istante di partenza del motore
95.         istantePartenzaMotore = millis();
96.  
97.         // impostiamo la direzione
98.         direzioneMotore = INDIETRO;
99.  
100.         // dichiariamo il motore in movimento
101.         motoreMovimento = true;
102.        
103.         break;  
104.  
105.       case 0xE13DDA28:    // tasto stop: ferma il motore
106.         // disabilitiamo le uscite per il motore
107.         digitalWrite(ENABLE2,LOW);
108.         digitalWrite(ENABLE,LOW); // disable
109.  
110.         // dichiariamo il motore fermo
111.         motoreMovimento = false;
112.         break;  
113.  
114.        
115.  
116.       case  0x2C452C6C:   // tasto sterza tutto a DESTRA
117.         // imposto il punto di arrivo dello sterzo: 0 gradi -> tutto a sinistra
118.         destinazioneSterzo = 0;    
119.        
120.         break;
121.  
122.       case 0xF5999288:   // tasto sterza tutto a SINISTRA
123.         // imposto il punto di arrivo dello sterzo: 180 gradi -> tutto a sinistra
124.         destinazioneSterzo = 180;  
125.      
126.         break;
127.  
128.       case  0x731A3E02 :    // tasto porta lo sterzo al centro
129.  
130.         // imposto il punto di arrivo dello sterzo: 180 gradi -> tutto a sinistra
131.         destinazioneSterzo = 90;  
132.        
133.         break;
134.  
135.        case  0xF4BA2988 :
136.        
137.          digitalWrite (led,HIGH);
138.  
139.         break;
140.  
141.        case  0x2D25D203 :
142.        
143.          digitalWrite (led,LOW);
144.  
145.         break;
146.  
147.        case  0xAE2FF30 :
148.          for(int i = 0; i<3; i++){
149.          digitalWrite (buzzer,HIGH);
150.          delay(200);
151.          digitalWrite (buzzer,LOW);
152.          }
153.         break;
154.  
155.  
156.          
157.      
158.     }  // switch
159.  
160.    
161.  
162.   }  // if(irrecv.decode(&res))
163.  
164.   manageSterzo();    // gestione movimento sterzo
165.  
166.   manageMotore();    // gestione movimento motore
167.  
168.  
169. } // loop
170.  
171. void manageSterzo() {
172.   /*
173.    * questa funzione è richiamata da dentro al loop. Quindi deve durare pochissimo, fare una singola operazione e ritornare
174.    * in particolare, se la destinazione dello sterzo non coincide con la posizione attuale, muove lo sterzo di 1 grado nella destinazione giusta,
175.    * comunque solo se è passato abbastanza tempo (TIC_STERZO) dall'ultimo movimento dello sterzo
176.    */
177.   int posizioneAttuale;
178.   int passo;
179.  
180.   // se abbiamo già mosso lo sterzo da troppo poco tempo non facciamo nulla e ritorniamo
181.   if (( millis() - istanteUltimoMovSterzo ) < TIC_STERZO ) return;
182.  
183.   // è passato abbastanza tempo dall'ultimo movimento dello sterzo. Vediamo se è necessario muoverlo, cominciando a leggere dove si trova
184.   posizioneAttuale = myservo.read();
185.  
186.   // se si trova già dove deve essere non facciamo nulla e usciamo
187.   if ( posizioneAttuale == destinazioneSterzo ) return;
188.  
189.   // arriviamo qui se lo sterzo non è ancora dove deve essere; decidiamo se il passo deve essere positivo o negativo
190.   if ( destinazioneSterzo > posizioneAttuale ) passo = 1;
191.   else passo = -1;
192.  
193.   // ora muoviamo lo sterzo di 1 grado nella direzione già decisa
194.   myservo.write( posizioneAttuale + passo );
195.  
196.   // prendiamo il  tempo in cui lo abbiamo mosso
197.   istanteUltimoMovSterzo = millis();
198.  
199. }
200.  
201.  
202. void manageMotore() {
203.   /*
204.    * questa funzione è richiamata da dentro al loop. Quindi deve durare pochissimo, fare una singola operazione e ritornare
205.    * in pratica move il motore nella direzione giusta per un passo.  
206.    * I passi verranno ripetuto ogni TIC_MOTORE millisecondi, sino a una durata massima di TRATTO_MOTORE millisecondi
207.    */
208.   // se il motore non è dichiarato in movimento non facciamo nulla e ritorniamo subito
209.   if ( !motoreMovimento ) return;
210.  
211.   // se il motore ha già girato per tutto il tempo previsto lo fermiamo
212.   if (( millis() - istantePartenzaMotore ) > TRATTO_MOTORE ) {
213.     // fine del tratto, spegnere il motore
214.     digitalWrite(ENABLE2,LOW);
215.     digitalWrite(ENABLE,LOW); // disable
216.  
217.     // dichiariamo che il motore è fermo
218.     motoreMovimento = false;
219.  
220.     return;
221.   }
222.  
223.   // se abbiamo già fatto un passo per il motore da troppo poco tempo non facciamo nulla e ritorniamo
224.   if (( millis() - istanteUltimoMovMotore ) < TIC_MOTORE ) return;
225.  
226.   // OK, arriviamo qui se c'è da fare un movimento del motore, in una direzione o nell'altra
227.   if ( direzioneMotore == AVANTI ) {
228.     // muoviamo il motore IN avanti
229.     digitalWrite(DIRA,LOW); //one way
230.     digitalWrite(DIRB,HIGH);
231.     digitalWrite(DIRA2,LOW); //one way
232.     digitalWrite(DIRB2,HIGH);
233.   }
234.   else {
235.     // direzioneMotore deve essere INDIETRO
236.     digitalWrite(DIRA,HIGH); //one way
237.     digitalWrite(DIRB,LOW);
238.     digitalWrite(DIRA2,HIGH); //one way
239.     digitalWrite(DIRB2,LOW);
240.   }
241.   // in ogni caso prendiamo il tempo dell'ultimo azionamento del motore
242.   istanteUltimoMovMotore = millis();
243.      
244. } // manageMotore