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