3 * Oggetti di uso comune
6 * Link: http://git.andreamanni.com/
15 //////////////////////
19 RGBLed::RGBLed(byte pinR, byte pinG, byte pinB) {
20 // Per un common catodo, valore max / min invertiti
26 // Equvalente del Setup() per inizializzare i PIN
27 pinMode(redPin, OUTPUT);
28 pinMode(greenPin, OUTPUT);
29 pinMode(greenPin, OUTPUT);
32 RGBLed::RGBLed(byte pinR, byte pinG, byte pinB, byte com) {
33 // Per un common anode, valore max / min normali
39 // Equvalente del Setup() per inizializzare i PIN
40 pinMode(redPin, OUTPUT);
41 pinMode(greenPin, OUTPUT);
42 pinMode(greenPin, OUTPUT);
45 void RGBLed::SetColor (byte r, byte g, byte b) {
46 // Imposta il colore di un LED RGB
48 analogWrite(redPin, r);
49 analogWrite(greenPin, g);
50 analogWrite(bluePin, b);
52 analogWrite(redPin, 255 - r);
53 analogWrite(greenPin, 255 - g);
54 analogWrite(bluePin, 255 - b);
70 void RGBLed::Rand () {
71 // Imposta il colore di un LED RGB
72 analogWrite(redPin, random(0,256));
73 analogWrite(greenPin, random(0,256));
74 analogWrite(bluePin, random(0,256));
78 // Accende il LED di rosso
82 void RGBLed::Green () {
83 // Accende il LED di verde
87 void RGBLed::Blue () {
88 // Accende il LED di blu
92 void RGBLed::Magenta () {
93 // Accende il LED di magenta
97 void RGBLed::Cyano () {
98 // Accende il LED di Cyano
102 void RGBLed::Yellow () {
103 // Accende il LED di giallo
107 void RGBLed::White () {
109 SetColor(255,255,255);
112 void RGBLed::Off () {
119 /////////////////////////////////////
123 // Esempi incrementali: https://lab.piffa.net/sketchbook_andrea/multitasking/
124 Lampeggiatore::Lampeggiatore(int pin)
127 pinMode(ledPin, OUTPUT);
133 // Una funzione facente parte di una classe prende il nome di "metodo" della stessa:
134 void Lampeggiatore::Invert() {
135 // Inverte il lampeggio
139 void Lampeggiatore::Blink() {
140 // Illumina il led a 500ms
142 if(millis() + shift - previousMillis > interval) {
144 // if the LED is off turn it on and vice-versa:
145 ledState = !ledState ; // Inverti il LED
146 // set the LED with the ledState of the variable:
147 digitalWrite(ledPin, ledState);
148 // save the last time you blinked the LED
149 previousMillis += interval;
153 void Lampeggiatore::Blink(long time, long drift ) {
154 // Illumina il led secondo un intervallo passato come argomento
157 if(millis() + shift - previousMillis > time) {
158 // if the LED is off turn it on and vice-versa:
159 ledState = !ledState ; // Inverti il LED
160 // set the LED with the ledState of the variable:
161 digitalWrite(ledPin, ledState);
162 // save the last time you blinked the LED
163 previousMillis += time;
167 void Lampeggiatore::Blink(long up, long down, long drift ) {
168 // Illumina il ledB precisando ontime e downtime
171 if((ledState == HIGH)&& (millis() + shift - previousMillis > up)) {
172 // save the last time you blinked the LED
173 previousMillis += up;
176 else if((ledState == LOW)&& (millis() + shift - previousMillis > down)) {
177 previousMillis += down;
181 // set the LED with the ledState of the variable:
182 digitalWrite(ledPin, ledState);
185 void Lampeggiatore::High() {
187 digitalWrite(ledPin, HIGH);
190 void Lampeggiatore::Low() {
192 digitalWrite(ledPin, LOW);
195 void Lampeggiatore::Swap() {
196 // Inverte lo stato del LED
197 digitalWrite(ledPin, !digitalRead(ledPin));
200 /////////////////////////////////////
204 // Gestione del PWM utilizzando millis
205 // per non bloccare il processore con delay
206 // Warning: serialWrite puo' interferire con i tempi.
209 pinMode(ledPin, OUTPUT);
211 byte brightness = 0 ;
213 int step = 0; // Pulse: stato del loop PWM
217 void Pwm::Up(long speed, long drift) {
218 // Aumenta linearmente la luminosita' usanndo millis()
219 // quindi senza bloccare il processore
220 // Viene usato un float, in alternativa un coseno
222 if (millis() != previousMillis) { // si potrebbe togliere
224 brightness = 255.0 /(float)speed * (millis() + shift);
225 analogWrite(ledPin, brightness);
227 previousMillis = millis();
231 void Pwm::lUp(long speed, long drift) {
232 // Aumenta usanndo millis() con correzione luminosita' LED
233 // quindi senza bloccare il processore
234 // Viene usato un float, in alternativa un coseno
236 if (millis() != previousMillis) { // si potrebbe togliere
238 brightness = 255.0 /(float)speed * (millis() + shift);
239 analogWrite(ledPin, lum(brightness));
241 previousMillis = millis();
245 void Pwm::Down(long speed, long drift) {
246 // Riduce linearmente la luminosita' usanndo millis()
247 // quindi senza bloccare il processore
249 if (millis() != previousMillis) {
251 brightness = 255 - 255.0 /(float)speed * (millis() + shift) ;
252 analogWrite(ledPin, brightness);
254 previousMillis = millis();
258 void Pwm::lDown(long speed, long drift) {
259 // Riduce usanndo millis() con correzione della luminosita'
260 // quindi senza bloccare il processore
262 if (millis() != previousMillis) {
264 brightness = 255 - 255.0 /(float)speed * (millis() + shift) ;
265 analogWrite(ledPin, lum(brightness));
267 previousMillis = millis();
271 void Pwm::UD(long speed, long drift ) {
272 // Aumenta e riduce in sequenza la luminosita' usanndo millis()
274 brightness = 128 + 127 * cos(2 * PI / speed * (millis() + shift));
275 analogWrite(ledPin, brightness);
278 void Pwm::Set(byte brightness) {
279 // Imposta il valore del PWM
280 analogWrite(ledPin, brightness);
284 void Pwm::Pulse(int interval, int pausa) {
285 // PWM up/down + un ciclo di pausa
286 // Interval e' la pausa tra uno step di 255 e l'altro
288 if ((millis() - previousMillis) >= interval) {
289 previousMillis = millis();
290 if (step < 256) { //UP
291 analogWrite(ledPin, lum(step));
293 } else if (step < 512 ) { // Down
294 analogWrite(ledPin, lum(511 - step));
296 } else if (step < 512 + pausa ){ // Pausa
297 analogWrite(ledPin, lum(0));
299 } else if (step >= 512 + pausa) { // Reset
305 void Pwm::RandomPulse(int min , int max, int pausa ) {
306 // PWM up/down + un ciclo di pausa
307 // L'intervallo e' random a ogni nuovo ciclo,
308 // compreso tra un min - max passato come argomento
310 if ((millis() - previousMillis) >= interval) {
311 previousMillis = millis();
312 if (step < 256) { //UP
313 analogWrite(ledPin, lum(step));
315 } else if (step < 512 ) { // Down
316 analogWrite(ledPin, lum(511 - step));
318 } else if (step < (512 + pausa )){ // Pausa
319 analogWrite(ledPin, lum(0));
321 } else if ((step >= 512 + pausa )) {
323 interval = random(min,max);
328 void Pwm::lSet(byte brightness) {
329 // Imposta il valore del PWM con correzione luminosita' LED
330 analogWrite(ledPin, lum(brightness));
334 /////////////////////////////////////
337 Sequenza::Sequenza (byte passed[], byte dim) {
340 for (int thisPin = 0; thisPin < size; thisPin++) {
341 pinMode(ledPins[thisPin], OUTPUT);
343 previousMillis = millis();
344 digitalWrite(ledPins[0], HIGH);
347 void Sequenza::Update(long value) {
348 // Incrementa dal primo all'ultimo valore dell'array
350 if (millis() - previousMillis >= interval) {
351 previousMillis = millis();
353 if ( i < size - 1 ) {
354 // Spegni precedente led
355 digitalWrite(ledPins[i], LOW);
357 // Accendi successivo led
358 digitalWrite(ledPins[++i], HIGH);
361 else if (i == size - 1 ) {
364 previousMillis = millis();
365 digitalWrite(ledPins[i], HIGH);
366 digitalWrite(ledPins[ size - 1 ], LOW);
372 void Sequenza::Reverse(long value) {
374 if (millis() - previousMillis >= interval) {
375 previousMillis = millis();
377 if (i == 0) { // Entry point, ultimo LED
378 digitalWrite(ledPins[size -1],HIGH);
379 digitalWrite(ledPins[0],LOW);
383 digitalWrite(ledPins[i],LOW);
384 digitalWrite(ledPins[--i],HIGH);
389 void Sequenza::UD(long value) {
391 if (millis() - previousMillis >= interval) {
392 previousMillis = millis();
393 // Spegni precedente led
394 digitalWrite(ledPins[i], LOW);
396 // Accendi successivo led
397 digitalWrite(ledPins[i], HIGH);
399 if (i == 0 || i == size -1) {
410 void brilla(byte pin, int velocita ) { // Defalt value di velocita' solo nell'Header
411 // Accende e spegne il LED accetando un argomento
412 // per impostare la velocita'.
414 pinMode(pin, OUTPUT);
415 // sequenze di istruzione: accendere e spegnere il LED
416 digitalWrite(pin, HIGH); // turn the LED on (HIGH is the voltage level)
417 delay(velocita); // wait for a second
418 digitalWrite(pin, LOW); // turn the LED off by making the voltage LOW
419 delay(velocita); // wait for a second
424 // Mappatura dell'intervallo 0-255 con correzione di luminosita.
426 return pgm_read_byte_near(BCORRECT + val);
430 int calibraTrim(int pin, const byte ledPin) {
431 /* START Calibrazione TRIM canale:
433 calcolo del valore medio esclusi gli 0
435 I canali come alettoni / elevatore possono avere un TRIM
436 (generalmente il throttle non ha un TRIM impostato),
437 questa funzione nel setup serve per trovare il punto medio
438 all'avvio dello sketch.
440 pinMode(ledPin,OUTPUT);
445 Serial.println(">> Calibrazione: ");
448 if (millis() > 10000) {
450 Serial.println(">> Calibrazione annullata a causa di assenza di seganle. \nAssicurarsi di accendere radio e ricevente \ne ripetere la procedura.");
452 middle = 15000; // Return value is divided by 10
455 servoValue = pulseIn(pin, HIGH, 25000);
456 if (servoValue != 0 && servoValue > 950 && servoValue <2000) {
457 middle = middle + servoValue ;
460 Serial.print(servoValue);
462 Serial.println(middle / a);
464 digitalWrite(ledPin, !digitalRead(ledPin));
469 Serial.print(">> Fine Calibrazione, media: ");
470 Serial.println(middle / 10 + 10);
473 return(middle / 10 ) ;