]> git.piffa.net Git - sketchbook_andrea/blob - libraries/common/common.cpp
e99f202804a45134155d354388719b26f8b1d0de
[sketchbook_andrea] / libraries / common / common.cpp
1 /*  Common
2  *
3  *  Oggetti di uso comune
4  *  Autore: Andrea Manni
5  *
6  *  Link: http://git.andreamanni.com/
7  *  Licenza:    GPLv3
8  */
9
10 #include "Arduino.h"
11 #include "common.h"
12
13 #define DEBUG_not
14
15 //////////////////////
16 // RGB LED
17 // Common anode / cat
18
19 RGBLed::RGBLed(byte pinR, byte pinG, byte pinB) {
20     // Per un common catodo, valore max / min invertiti
21     redPin    = pinR ;
22     greenPin  = pinG ;
23     bluePin   = pinB ;
24     common    = 255 ;
25
26     // Equvalente del Setup() per inizializzare i PIN
27     pinMode(redPin, OUTPUT);
28     pinMode(greenPin, OUTPUT);
29     pinMode(greenPin, OUTPUT);
30 };
31
32 RGBLed::RGBLed(byte pinR, byte pinG, byte pinB, byte com) {
33     // Per un common anode, valore max / min normali
34     redPin    = pinR ;
35     greenPin  = pinG ;
36     bluePin   = pinB ;
37     common    = com ;
38
39     // Equvalente del Setup() per inizializzare i PIN
40     pinMode(redPin, OUTPUT);
41     pinMode(greenPin, OUTPUT);
42     pinMode(greenPin, OUTPUT);
43 };
44
45 void RGBLed::SetColor (byte r, byte g, byte b) {
46 // Imposta il colore di un LED RGB
47     analogWrite(redPin,   common - r);
48     analogWrite(greenPin, common - g);
49     analogWrite(bluePin,  common - b);
50
51 // Debug
52 #ifdef DEBUG
53    Serial.print(common - r);
54    Serial.print("-");
55    Serial.print(common - g);
56    Serial.print("-");
57    Serial.print(common - b);
58    while(1);
59 #endif
60
61 };
62
63 void RGBLed::Rand () {
64 // Imposta il colore di un LED RGB
65     analogWrite(redPin, random(0,256));
66     analogWrite(greenPin, random(0,256));
67     analogWrite(bluePin, random(0,256));
68 };
69
70 void RGBLed::Red () {
71 // Accende il LED di rosso
72     SetColor(255,0,0);
73 };
74
75 void RGBLed::Green () {
76 // Accende il LED di verde
77     SetColor(0,255,0);
78 };
79
80 void RGBLed::Blue () {
81 // Accende il LED di blu
82     SetColor(0,0,255);
83 };
84
85 void RGBLed::Magenta () {
86 // Accende il LED di magenta
87     SetColor(255,0,255);
88 };
89
90 void RGBLed::Cyano () {
91 // Accende il LED di Cyano
92     SetColor(0,255,255);
93 };
94
95 void RGBLed::Yellow () {
96 // Accende il LED di giallo
97     SetColor(255,255,0);
98 };
99
100 void RGBLed::White () {
101 // Accende il LED
102     SetColor(255,255,255);
103 };
104
105 void RGBLed::Off () {
106 // Spegne il LED
107     SetColor(0,0,0);
108 };
109
110
111
112 /////////////////////////////////////
113 // Lampeggiatore
114 // Constructor
115 //
116 // Esempi incrementali: https://lab.piffa.net/sketchbook_andrea/multitasking/
117 Lampeggiatore::Lampeggiatore(int pin)
118 {
119     ledPin = pin;
120     pinMode(ledPin, OUTPUT);
121     ledState = LOW;
122     previousMillis = 0;
123     interval = 500;
124 };
125
126 // Una funzione facente parte di una classe prende il nome di "metodo" della stessa:
127 void Lampeggiatore::Invert() {
128     // Inverte il lampeggio
129     ledState = HIGH ;
130 }
131
132 void Lampeggiatore::Blink() {
133     // Illumina il led a 500ms
134
135     if(millis() + shift - previousMillis > interval) {
136
137         // if the LED is off turn it on and vice-versa:
138         ledState = !ledState ; // Inverti il LED
139         // set the LED with the ledState of the variable:
140         digitalWrite(ledPin, ledState);
141         // save the last time you blinked the LED
142         previousMillis += interval;
143     }
144 };
145
146 void Lampeggiatore::Blink(long time, long drift ) {
147     // Illumina il led secondo un intervallo passato come argomento
148
149     shift = drift;
150     if(millis() + shift - previousMillis > time) {
151         // if the LED is off turn it on and vice-versa:
152         ledState = !ledState ; // Inverti il LED
153     // set the LED with the ledState of the variable:
154     digitalWrite(ledPin, ledState);
155         // save the last time you blinked the LED
156         previousMillis += time;
157     }
158 };
159
160 void Lampeggiatore::Blink(long up, long down, long drift ) {
161     // Illumina il ledB precisando ontime e downtime
162
163     shift = drift;
164     if((ledState == HIGH)&& (millis() + shift - previousMillis > up)) {
165         // save the last time you blinked the LED
166         previousMillis += up;
167         ledState = LOW  ;
168     }
169     else if((ledState == LOW)&& (millis() + shift - previousMillis > down)) {
170         previousMillis += down;
171         ledState = HIGH  ;
172     }
173
174     // set the LED with the ledState of the variable:
175     digitalWrite(ledPin, ledState);
176 };
177
178 void Lampeggiatore::High() {
179     // Accende il LED
180     digitalWrite(ledPin, HIGH);
181 }
182
183 void Lampeggiatore::Low() {
184     // Spegne  il LED
185     digitalWrite(ledPin, LOW);
186 }
187
188 void Lampeggiatore::Swap() {
189     // Inverte lo stato del LED
190     digitalWrite(ledPin, !digitalRead(ledPin));
191 }
192
193 /////////////////////////////////////
194 // Pwm
195 // Constructor
196 Pwm::Pwm(int pin)
197 // Gestione del PWM utilizzando millis
198 // per non bloccare il processore con delay
199 // Warning: serialWrite puo' interferire con i tempi.
200 {
201     ledPin = pin;
202     pinMode(ledPin, OUTPUT);
203     previousMillis = 0;
204     byte brightness = 0 ;
205     increment = 1;
206 };
207
208 void Pwm::Up(long speed, long drift) {
209     // Aumenta linearmente la luminosita' usanndo millis()
210     // quindi senza bloccare il processore
211     // Viene usato un float, in alternativa un coseno
212
213     if (millis() != previousMillis)  { // si potrebbe togliere
214         shift = drift;
215         brightness = 255.0 /(float)speed * (millis() + shift);
216         analogWrite(ledPin, brightness);
217
218         previousMillis = millis();
219     };
220 }
221
222 void Pwm::lUp(long speed, long drift) {
223     // Aumenta usanndo millis() con correzione luminosita' LED
224     // quindi senza bloccare il processore
225     // Viene usato un float, in alternativa un coseno
226
227     if (millis() != previousMillis)  { // si potrebbe togliere
228         shift = drift;
229         brightness = 255.0 /(float)speed * (millis() + shift);
230         analogWrite(ledPin, lum(brightness));
231
232         previousMillis = millis();
233     };
234 }
235
236 void Pwm::Down(long speed, long drift) {
237     // Riduce linearmente la luminosita' usanndo millis()
238     // quindi senza bloccare il processore
239
240     if (millis() != previousMillis)  {
241         shift = drift;
242         brightness = 255 - 255.0 /(float)speed * (millis() + shift) ;
243         analogWrite(ledPin, brightness);
244
245         previousMillis = millis();
246     };
247 }
248
249 void Pwm::lDown(long speed, long drift) {
250     // Riduce  usanndo millis() con correzione della luminosita'
251     // quindi senza bloccare il processore
252
253     if (millis() != previousMillis)  {
254         shift = drift;
255         brightness = 255 - 255.0 /(float)speed * (millis() + shift) ;
256         analogWrite(ledPin, lum(brightness));
257
258         previousMillis = millis();
259     };
260 }
261
262 void Pwm::UD(long speed, long drift ) {
263     // Aumenta e riduce in sequenza la luminosita' usanndo millis()
264     shift = drift;
265     brightness = 128 + 127 * cos(2 * PI / speed * (millis() + shift));
266     analogWrite(ledPin, brightness);
267 }
268
269 void Pwm::Set(byte brightness) {
270     // Imposta il valore del PWM
271     analogWrite(ledPin, brightness);
272 }
273
274
275 void Pwm::lSet(byte brightness) {
276     // Imposta il valore del PWM con correzione luminosita' LED
277     analogWrite(ledPin, lum(brightness));
278 }
279
280
281 /////////////////////////////////////
282 // Sequenza
283 // Constructor
284 Sequenza::Sequenza (byte passed[], byte dim) {
285     ledPins = passed ;
286     size = dim ;
287     for (int thisPin = 0; thisPin < size; thisPin++) {
288         pinMode(ledPins[thisPin], OUTPUT);
289     }
290     previousMillis = millis();
291     digitalWrite(ledPins[0], HIGH);
292 }
293
294 void Sequenza::Update(long value) {
295     // Incrementa dal primo all'ultimo valore dell'array
296     interval = value;
297     if (millis() - previousMillis >= interval) {
298         previousMillis = millis();
299
300         if ( i < size - 1 ) {
301             // Spegni precedente led
302             digitalWrite(ledPins[i], LOW);
303
304             // Accendi successivo led
305             digitalWrite(ledPins[++i], HIGH);
306         }
307
308         else if  (i == size - 1 )   {
309             // Ultimo caso
310             i = 0;
311             previousMillis = millis();
312             digitalWrite(ledPins[i], HIGH);
313             digitalWrite(ledPins[ size - 1 ], LOW);
314         }
315     }
316 }
317
318
319 void Sequenza::Reverse(long value) {
320     interval = value;
321     if (millis() - previousMillis >= interval) {
322         previousMillis = millis();
323
324         if  (i == 0)   { // Entry point, ultimo LED
325             digitalWrite(ledPins[size -1],HIGH);
326             digitalWrite(ledPins[0],LOW);
327             i = size -1 ;
328         }
329         else {
330             digitalWrite(ledPins[i],LOW);
331             digitalWrite(ledPins[--i],HIGH);
332         }
333     }
334 }
335
336 void Sequenza::UD(long value) {
337     interval = value;
338     if (millis() - previousMillis >= interval) {
339         previousMillis = millis();
340         // Spegni precedente led
341         digitalWrite(ledPins[i], LOW);
342         i = i + inc ;
343         // Accendi successivo led
344         digitalWrite(ledPins[i], HIGH);
345
346         if (i == 0 || i == size -1) {
347             inc = -inc ;
348         }
349     }
350 }
351
352
353 //////////////////
354 // Funzioni
355
356
357 void brilla(byte pin, int velocita ) { // Defalt value di velocita' solo nell'Header
358     // Accende e spegne il LED accetando un argomento
359     // per impostare la velocita'.
360
361     pinMode(pin, OUTPUT);
362     // sequenze di istruzione: accendere e spegnere il LED
363     digitalWrite(pin, HIGH);   // turn the LED on (HIGH is the voltage level)
364     delay(velocita);               // wait for a second
365     digitalWrite(pin, LOW);    // turn the LED off by making the voltage LOW
366     delay(velocita);               // wait for a second
367 };
368
369
370 byte lum(byte val) {
371     // Mappatura dell'intervallo 0-255 con correzione di luminosita.
372     // storata in SRAM
373     return pgm_read_byte_near(BCORRECT + val);
374 };
375
376
377 int calibraTrim(int pin, const byte ledPin) {
378     /* START Calibrazione TRIM canale:
379        Lettura di 10 smaple
380        calcolo del valore medio esclusi gli 0
381
382        I canali come alettoni / elevatore possono avere un TRIM
383        (generalmente il throttle non ha un TRIM impostato),
384        questa funzione nel setup serve per trovare il punto medio
385        all'avvio dello sketch.
386      */
387     pinMode(ledPin,OUTPUT);
388     byte a              = 0;
389     int servoValue      = 0;
390     int middle = 0; 
391 #ifdef DEBUG
392     Serial.println(">> Calibrazione: ");
393 #endif 
394     while (a < 10) {
395         if (millis() > 10000) {
396 #ifdef DEBUG
397             Serial.println(">> Calibrazione annullata a causa di assenza di seganle. \nAssicurarsi di accendere radio e ricevente \ne ripetere la procedura.");
398 #endif 
399             middle = 15000; // Return value is divided by 10
400             break;
401         };
402         servoValue = pulseIn(pin, HIGH, 25000);
403         if (servoValue != 0 && servoValue > 950 && servoValue <2000)  {
404             middle = middle + servoValue ;
405             a++ ;
406 #ifdef DEBUG
407             Serial.print(servoValue);
408             Serial.print(": ");
409             Serial.println(middle / a);
410 #endif 
411             digitalWrite(ledPin, !digitalRead(ledPin));
412             delay(50);
413         }
414     }
415 #ifdef DEBUG
416     Serial.print(">> Fine Calibrazione, media: ");
417     Serial.println(middle / 10 + 10);
418     Serial.flush() ;
419 #endif 
420     return(middle / 10 ) ;
421 // END calibrazione
422 };
423