X-Git-Url: http://git.piffa.net/web?a=blobdiff_plain;ds=sidebyside;f=libraries%2Fcommon%2Fcommon.cpp;h=e99f202804a45134155d354388719b26f8b1d0de;hb=0662b12752ee761efee7077b63c77f294e98deda;hp=b29cd95019044d917bae8c8699eb3c263a64fea5;hpb=936436ad4b665bc2504a74346e5820962ace5bd4;p=sketchbook_andrea diff --git a/libraries/common/common.cpp b/libraries/common/common.cpp index b29cd95..e99f202 100644 --- a/libraries/common/common.cpp +++ b/libraries/common/common.cpp @@ -1,79 +1,119 @@ /* Common * * Oggetti di uso comune + * Autore: Andrea Manni + * + * Link: http://git.andreamanni.com/ + * Licenza: GPLv3 */ #include "Arduino.h" #include "common.h" +#define DEBUG_not ////////////////////// // RGB LED -// Common anode +// Common anode / cat RGBLed::RGBLed(byte pinR, byte pinG, byte pinB) { - redPin = pinR ; - greenPin = pinG ; - bluePin = pinB ; + // Per un common catodo, valore max / min invertiti + redPin = pinR ; + greenPin = pinG ; + bluePin = pinB ; + common = 255 ; + + // Equvalente del Setup() per inizializzare i PIN + pinMode(redPin, OUTPUT); + pinMode(greenPin, OUTPUT); + pinMode(greenPin, OUTPUT); +}; - // Equvalente del Setup() per inizializzare i PIN - pinMode(redPin, OUTPUT); - pinMode(greenPin, OUTPUT); - pinMode(greenPin, OUTPUT); +RGBLed::RGBLed(byte pinR, byte pinG, byte pinB, byte com) { + // Per un common anode, valore max / min normali + redPin = pinR ; + greenPin = pinG ; + bluePin = pinB ; + common = com ; + + // Equvalente del Setup() per inizializzare i PIN + pinMode(redPin, OUTPUT); + pinMode(greenPin, OUTPUT); + pinMode(greenPin, OUTPUT); }; void RGBLed::SetColor (byte r, byte g, byte b) { // Imposta il colore di un LED RGB - analogWrite(redPin, r); - analogWrite(greenPin, g); - analogWrite(bluePin, b); - }; + analogWrite(redPin, common - r); + analogWrite(greenPin, common - g); + analogWrite(bluePin, common - b); + +// Debug +#ifdef DEBUG + Serial.print(common - r); + Serial.print("-"); + Serial.print(common - g); + Serial.print("-"); + Serial.print(common - b); + while(1); +#endif + +}; + +void RGBLed::Rand () { +// Imposta il colore di un LED RGB + analogWrite(redPin, random(0,256)); + analogWrite(greenPin, random(0,256)); + analogWrite(bluePin, random(0,256)); +}; void RGBLed::Red () { // Accende il LED di rosso - SetColor(0,255,255); - }; + SetColor(255,0,0); +}; void RGBLed::Green () { // Accende il LED di verde - SetColor(255,0,255); - }; + SetColor(0,255,0); +}; void RGBLed::Blue () { // Accende il LED di blu - SetColor(255,255,0); - }; + SetColor(0,0,255); +}; void RGBLed::Magenta () { // Accende il LED di magenta - SetColor(0,255,0); - }; + SetColor(255,0,255); +}; void RGBLed::Cyano () { // Accende il LED di Cyano - SetColor(255,0,0); - }; + SetColor(0,255,255); +}; void RGBLed::Yellow () { // Accende il LED di giallo - SetColor(0,0,255); - }; + SetColor(255,255,0); +}; void RGBLed::White () { -// Accende il LED - SetColor(0,0,0); - }; +// Accende il LED + SetColor(255,255,255); +}; void RGBLed::Off () { -// Spegne il LED - SetColor(255,255,255); - }; +// Spegne il LED + SetColor(0,0,0); +}; ///////////////////////////////////// // Lampeggiatore // Constructor +// +// Esempi incrementali: https://lab.piffa.net/sketchbook_andrea/multitasking/ Lampeggiatore::Lampeggiatore(int pin) { ledPin = pin; @@ -83,9 +123,6 @@ Lampeggiatore::Lampeggiatore(int pin) interval = 500; }; - - - // Una funzione facente parte di una classe prende il nome di "metodo" della stessa: void Lampeggiatore::Invert() { // Inverte il lampeggio @@ -95,41 +132,42 @@ void Lampeggiatore::Invert() { void Lampeggiatore::Blink() { // Illumina il led a 500ms - if(millis() - previousMillis > interval) { - // save the last time you blinked the LED - previousMillis = millis(); + if(millis() + shift - previousMillis > interval) { // if the LED is off turn it on and vice-versa: ledState = !ledState ; // Inverti il LED + // set the LED with the ledState of the variable: + digitalWrite(ledPin, ledState); + // save the last time you blinked the LED + previousMillis += interval; } - // set the LED with the ledState of the variable: - digitalWrite(ledPin, ledState); }; -void Lampeggiatore::Blink(long time) { +void Lampeggiatore::Blink(long time, long drift ) { // Illumina il led secondo un intervallo passato come argomento - if(millis() - previousMillis > time) { - // save the last time you blinked the LED - previousMillis = millis(); - + shift = drift; + if(millis() + shift - previousMillis > time) { // if the LED is off turn it on and vice-versa: ledState = !ledState ; // Inverti il LED - } // set the LED with the ledState of the variable: digitalWrite(ledPin, ledState); + // save the last time you blinked the LED + previousMillis += time; + } }; -void Lampeggiatore::Blink(long up, long down) { +void Lampeggiatore::Blink(long up, long down, long drift ) { // Illumina il ledB precisando ontime e downtime - if((ledState == HIGH)&& (millis() - previousMillis > up)) { - // save the last time you blinked the LED - previousMillis = millis(); + shift = drift; + if((ledState == HIGH)&& (millis() + shift - previousMillis > up)) { + // save the last time you blinked the LED + previousMillis += up; ledState = LOW ; } - else if((ledState == LOW)&& (millis() - previousMillis > down)) { - previousMillis = millis(); + else if((ledState == LOW)&& (millis() + shift - previousMillis > down)) { + previousMillis += down; ledState = HIGH ; } @@ -137,10 +175,28 @@ void Lampeggiatore::Blink(long up, long down) { digitalWrite(ledPin, ledState); }; +void Lampeggiatore::High() { + // Accende il LED + digitalWrite(ledPin, HIGH); +} + +void Lampeggiatore::Low() { + // Spegne il LED + digitalWrite(ledPin, LOW); +} + +void Lampeggiatore::Swap() { + // Inverte lo stato del LED + digitalWrite(ledPin, !digitalRead(ledPin)); +} + ///////////////////////////////////// // Pwm // Constructor Pwm::Pwm(int pin) +// Gestione del PWM utilizzando millis +// per non bloccare il processore con delay +// Warning: serialWrite puo' interferire con i tempi. { ledPin = pin; pinMode(ledPin, OUTPUT); @@ -149,49 +205,149 @@ Pwm::Pwm(int pin) increment = 1; }; -void Pwm::Up(long speed) { - // Aumenta progressivamente la luminosita' usanndo millis() +void Pwm::Up(long speed, long drift) { + // Aumenta linearmente la luminosita' usanndo millis() // quindi senza bloccare il processore + // Viene usato un float, in alternativa un coseno - analogWrite(ledPin, brightness); // La funziona analogWrite utilizza il PWM - // a 8 bit integrato nel MCU: simula un serie di valori intermedi - // nell'intervallo discreto con minimo 0 (spento) e massimo 255 (acceso). + if (millis() != previousMillis) { // si potrebbe togliere + shift = drift; + brightness = 255.0 /(float)speed * (millis() + shift); + analogWrite(ledPin, brightness); - if ((millis() - previousMillis) > speed / 256) { - brightness++; // Incrementiamo la luminosita' previousMillis = millis(); - Serial.println(brightness); }; } -void Pwm::Down(long speed ) { - // Riduce progressivamente la luminosita' usanndo millis() +void Pwm::lUp(long speed, long drift) { + // Aumenta usanndo millis() con correzione luminosita' LED // quindi senza bloccare il processore + // Viene usato un float, in alternativa un coseno - analogWrite(ledPin, brightness); // La funziona analogWrite utilizza il PWM - // a 8 bit integrato nel MCU: simula un serie di valori intermedi - // nell'intervallo discreto con minimo 0 (spento) e massimo 255 (acceso). + if (millis() != previousMillis) { // si potrebbe togliere + shift = drift; + brightness = 255.0 /(float)speed * (millis() + shift); + analogWrite(ledPin, lum(brightness)); - if ((millis() - previousMillis) > speed / 256) { - brightness--; // Incrementiamo la luminosita' previousMillis = millis(); - Serial.println(brightness); }; } -void Pwm::UD(long speed ) { - // Aumenta e riduce in sequenza la luminosita' usanndo millis() - if ((millis() - previousMillis) > speed / 512) { - brightness = brightness + increment; // Incrementiamo la luminosita' - previousMillis = millis(); - Serial.println(brightness); +void Pwm::Down(long speed, long drift) { + // Riduce linearmente la luminosita' usanndo millis() + // quindi senza bloccare il processore + + if (millis() != previousMillis) { + shift = drift; + brightness = 255 - 255.0 /(float)speed * (millis() + shift) ; analogWrite(ledPin, brightness); - if (brightness == 0 || brightness == 255) { // Reverse direction - increment = -increment ; - }; + + previousMillis = millis(); + }; +} + +void Pwm::lDown(long speed, long drift) { + // Riduce usanndo millis() con correzione della luminosita' + // quindi senza bloccare il processore + + if (millis() != previousMillis) { + shift = drift; + brightness = 255 - 255.0 /(float)speed * (millis() + shift) ; + analogWrite(ledPin, lum(brightness)); + + previousMillis = millis(); }; } +void Pwm::UD(long speed, long drift ) { + // Aumenta e riduce in sequenza la luminosita' usanndo millis() + shift = drift; + brightness = 128 + 127 * cos(2 * PI / speed * (millis() + shift)); + analogWrite(ledPin, brightness); +} + +void Pwm::Set(byte brightness) { + // Imposta il valore del PWM + analogWrite(ledPin, brightness); +} + + +void Pwm::lSet(byte brightness) { + // Imposta il valore del PWM con correzione luminosita' LED + analogWrite(ledPin, lum(brightness)); +} + + +///////////////////////////////////// +// Sequenza +// Constructor +Sequenza::Sequenza (byte passed[], byte dim) { + ledPins = passed ; + size = dim ; + for (int thisPin = 0; thisPin < size; thisPin++) { + pinMode(ledPins[thisPin], OUTPUT); + } + previousMillis = millis(); + digitalWrite(ledPins[0], HIGH); +} + +void Sequenza::Update(long value) { + // Incrementa dal primo all'ultimo valore dell'array + interval = value; + if (millis() - previousMillis >= interval) { + previousMillis = millis(); + + if ( i < size - 1 ) { + // Spegni precedente led + digitalWrite(ledPins[i], LOW); + + // Accendi successivo led + digitalWrite(ledPins[++i], HIGH); + } + + else if (i == size - 1 ) { + // Ultimo caso + i = 0; + previousMillis = millis(); + digitalWrite(ledPins[i], HIGH); + digitalWrite(ledPins[ size - 1 ], LOW); + } + } +} + + +void Sequenza::Reverse(long value) { + interval = value; + if (millis() - previousMillis >= interval) { + previousMillis = millis(); + + if (i == 0) { // Entry point, ultimo LED + digitalWrite(ledPins[size -1],HIGH); + digitalWrite(ledPins[0],LOW); + i = size -1 ; + } + else { + digitalWrite(ledPins[i],LOW); + digitalWrite(ledPins[--i],HIGH); + } + } +} + +void Sequenza::UD(long value) { + interval = value; + if (millis() - previousMillis >= interval) { + previousMillis = millis(); + // Spegni precedente led + digitalWrite(ledPins[i], LOW); + i = i + inc ; + // Accendi successivo led + digitalWrite(ledPins[i], HIGH); + + if (i == 0 || i == size -1) { + inc = -inc ; + } + } +} ////////////////// @@ -199,14 +355,69 @@ void Pwm::UD(long speed ) { void brilla(byte pin, int velocita ) { // Defalt value di velocita' solo nell'Header - // Accende e spegne il LED accetando un argomento - // per impostare la velocita'. - -pinMode(pin, OUTPUT); - // sequenze di istruzione: accendere e spegnere il LED - digitalWrite(pin, HIGH); // turn the LED on (HIGH is the voltage level) - delay(velocita); // wait for a second - digitalWrite(pin, LOW); // turn the LED off by making the voltage LOW - delay(velocita); // wait for a second + // Accende e spegne il LED accetando un argomento + // per impostare la velocita'. + + pinMode(pin, OUTPUT); + // sequenze di istruzione: accendere e spegnere il LED + digitalWrite(pin, HIGH); // turn the LED on (HIGH is the voltage level) + delay(velocita); // wait for a second + digitalWrite(pin, LOW); // turn the LED off by making the voltage LOW + delay(velocita); // wait for a second +}; + + +byte lum(byte val) { + // Mappatura dell'intervallo 0-255 con correzione di luminosita. + // storata in SRAM + return pgm_read_byte_near(BCORRECT + val); +}; + + +int calibraTrim(int pin, const byte ledPin) { + /* START Calibrazione TRIM canale: + Lettura di 10 smaple + calcolo del valore medio esclusi gli 0 + + I canali come alettoni / elevatore possono avere un TRIM + (generalmente il throttle non ha un TRIM impostato), + questa funzione nel setup serve per trovare il punto medio + all'avvio dello sketch. + */ + pinMode(ledPin,OUTPUT); + byte a = 0; + int servoValue = 0; + int middle = 0; +#ifdef DEBUG + Serial.println(">> Calibrazione: "); +#endif + while (a < 10) { + if (millis() > 10000) { +#ifdef DEBUG + Serial.println(">> Calibrazione annullata a causa di assenza di seganle. \nAssicurarsi di accendere radio e ricevente \ne ripetere la procedura."); +#endif + middle = 15000; // Return value is divided by 10 + break; + }; + servoValue = pulseIn(pin, HIGH, 25000); + if (servoValue != 0 && servoValue > 950 && servoValue <2000) { + middle = middle + servoValue ; + a++ ; +#ifdef DEBUG + Serial.print(servoValue); + Serial.print(": "); + Serial.println(middle / a); +#endif + digitalWrite(ledPin, !digitalRead(ledPin)); + delay(50); + } + } +#ifdef DEBUG + Serial.print(">> Fine Calibrazione, media: "); + Serial.println(middle / 10 + 10); + Serial.flush() ; +#endif + return(middle / 10 ) ; +// END calibrazione };