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 #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 Lampeggiatore::Lampeggiatore(int pin)
 116 {
 117     ledPin = pin;
 118     pinMode(ledPin, OUTPUT);
 119     ledState = LOW;
 120     previousMillis = 0;
 121     interval = 500;
 122 };
 123
 124 // Una funzione facente parte di una classe prende il nome di "metodo" della stessa:
 125 void Lampeggiatore::Invert() {
 126     // Inverte il lampeggio
 127     ledState = HIGH ;
 128 }
 129
 130 void Lampeggiatore::Blink() {
 131     // Illumina il led a 500ms
 132
 133     if(millis() + shift - previousMillis > interval) {
 134
 135         // if the LED is off turn it on and vice-versa:
 136         ledState = !ledState ; // Inverti il LED
 137         // set the LED with the ledState of the variable:
 138         digitalWrite(ledPin, ledState);
 139         // save the last time you blinked the LED
 140         previousMillis += interval;
 141     }
 142 };
 143
 144 void Lampeggiatore::Blink(long time, long drift ) {
 145     // Illumina il led secondo un intervallo passato come argomento
 146
 147     shift = drift;
 148     if(millis() + shift - previousMillis > time) {
 149         // if the LED is off turn it on and vice-versa:
 150         ledState = !ledState ; // Inverti il LED
 151     // set the LED with the ledState of the variable:
 152     digitalWrite(ledPin, ledState);
 153         // save the last time you blinked the LED
 154         previousMillis += time;
 155     }
 156 };
 157
 158 void Lampeggiatore::Blink(long up, long down, long drift ) {
 159     // Illumina il ledB precisando ontime e downtime
 160
 161     shift = drift;
 162     if((ledState == HIGH)&& (millis() + shift - previousMillis > up)) {
 163         // save the last time you blinked the LED
 164         previousMillis += up;
 165         ledState = LOW  ;
 166     }
 167     else if((ledState == LOW)&& (millis() + shift - previousMillis > down)) {
 168         previousMillis += down;
 169         ledState = HIGH  ;
 170     }
 171
 172     // set the LED with the ledState of the variable:
 173     digitalWrite(ledPin, ledState);
 174 };
 175
 176 void Lampeggiatore::High() {
 177     // Accende il LED
 178
 179     digitalWrite(ledPin, HIGH);
 180 }
 181
 182 void Lampeggiatore::Low() {
 183     // Spegne  il LED
 184
 185     digitalWrite(ledPin, LOW);
 186 }
 187
 188 void Lampeggiatore::Swap() {
 189     // Inverte lo stato del LED
 190
 191     digitalWrite(ledPin, !digitalRead(ledPin));
 192 }
 193
 194 /////////////////////////////////////
 195 // Pwm
 196 // Constructor
 197 Pwm::Pwm(int pin)
 198 // Gestione del PWM utilizzando millis
 199 // per non bloccare il processore con delay
 200 // Warning: serialWrite puo' interferire con i tempi.
 201 {
 202     ledPin = pin;
 203     pinMode(ledPin, OUTPUT);
 204     previousMillis = 0;
 205     byte brightness = 0 ;
 206     increment = 1;
 207 };
 208
 209 void Pwm::Up(long speed, long drift) {
 210     // Aumenta linearmente la luminosita' usanndo millis()
 211     // quindi senza bloccare il processore
 212     // Viene usato un float, in alternativa un coseno
 213
 214     if (millis() != previousMillis)  { // si potrebbe togliere
 215         shift = drift;
 216         brightness = 255.0 /(float)speed * (millis() + shift);
 217         analogWrite(ledPin, brightness);
 218
 219         previousMillis = millis();
 220     };
 221 }
 222
 223 void Pwm::lUp(long speed, long drift) {
 224     // Aumenta usanndo millis() con correzione luminosita' LED
 225     // quindi senza bloccare il processore
 226     // Viene usato un float, in alternativa un coseno
 227
 228     if (millis() != previousMillis)  { // si potrebbe togliere
 229         shift = drift;
 230         brightness = 255.0 /(float)speed * (millis() + shift);
 231         analogWrite(ledPin, lum(brightness));
 232
 233         previousMillis = millis();
 234     };
 235 }
 236
 237 void Pwm::Down(long speed, long drift) {
 238     // Riduce linearmente la luminosita' usanndo millis()
 239     // quindi senza bloccare il processore
 240
 241     if (millis() != previousMillis)  {
 242         shift = drift;
 243         brightness = 255 - 255.0 /(float)speed * (millis() + shift) ;
 244         analogWrite(ledPin, brightness);
 245
 246         previousMillis = millis();
 247     };
 248 }
 249
 250 void Pwm::lDown(long speed, long drift) {
 251     // Riduce  usanndo millis() con correzione della luminosita'
 252     // quindi senza bloccare il processore
 253
 254     if (millis() != previousMillis)  {
 255         shift = drift;
 256         brightness = 255 - 255.0 /(float)speed * (millis() + shift) ;
 257         analogWrite(ledPin, lum(brightness));
 258
 259         previousMillis = millis();
 260     };
 261 }
 262
 263 void Pwm::UD(long speed, long drift ) {
 264     // Aumenta e riduce in sequenza la luminosita' usanndo millis()
 265     shift = drift;
 266     brightness = 128 + 127 * cos(2 * PI / speed * (millis() + shift));
 267     analogWrite(ledPin, brightness);
 268 }
 269
 270 void Pwm::Set(byte brightness) {
 271     // Imposta il valore del PWM
 272     analogWrite(ledPin, brightness);
 273 }
 274
 275
 276 void Pwm::lSet(byte brightness) {
 277     // Imposta il valore del PWM con correzione luminosita' LED
 278     analogWrite(ledPin, lum(brightness));
 279 }
 280
 281
 282 /////////////////////////////////////
 283 // Sequenza
 284 // Constructor
 285 Sequenza::Sequenza (byte passed[], byte dim) {
 286     ledPins = passed ;
 287     size = dim ;
 288     for (int thisPin = 0; thisPin < size; thisPin++) {
 289         pinMode(ledPins[thisPin], OUTPUT);
 290     }
 291     previousMillis = millis();
 292     digitalWrite(ledPins[0], HIGH);
 293 }
 294
 295 void Sequenza::Update(long value) {
 296     // Incrementa dal primo all'ultimo valore dell'array
 297     interval = value;
 298     if (millis() - previousMillis >= interval) {
 299         previousMillis = millis();
 300
 301         if ( i < size - 1 ) {
 302             // Spegni precedente led
 303             digitalWrite(ledPins[i], LOW);
 304
 305             // Accendi successivo led
 306             digitalWrite(ledPins[++i], HIGH);
 307         }
 308
 309         else if  (i == size - 1 )   {
 310             // Ultimo caso
 311             i = 0;
 312             previousMillis = millis();
 313             digitalWrite(ledPins[i], HIGH);
 314             digitalWrite(ledPins[ size - 1 ], LOW);
 315         }
 316     }
 317 }
 318
 319
 320 void Sequenza::Reverse(long value) {
 321     interval = value;
 322     if (millis() - previousMillis >= interval) {
 323         previousMillis = millis();
 324
 325         if  (i == 0)   { // Entry point, ultimo LED
 326             digitalWrite(ledPins[size -1],HIGH);
 327             digitalWrite(ledPins[0],LOW);
 328             i = size -1 ;
 329         }
 330         else {
 331             digitalWrite(ledPins[i],LOW);
 332             digitalWrite(ledPins[--i],HIGH);
 333         }
 334     }
 335 }
 336
 337 void Sequenza::UD(long value) {
 338     interval = value;
 339     if (millis() - previousMillis >= interval) {
 340         previousMillis = millis();
 341         // Spegni precedente led
 342         digitalWrite(ledPins[i], LOW);
 343         i = i + inc ;
 344         // Accendi successivo led
 345         digitalWrite(ledPins[i], HIGH);
 346
 347         if (i == 0 || i == size -1) {
 348             inc = -inc ;
 349         }
 350     }
 351 }
 352
 353
 354 //////////////////
 355 // Funzioni
 356
 357
 358 void brilla(byte pin, int velocita ) { // Defalt value di velocita' solo nell'Header
 359     // Accende e spegne il LED accetando un argomento
 360     // per impostare la velocita'.
 361
 362     pinMode(pin, OUTPUT);
 363     // sequenze di istruzione: accendere e spegnere il LED
 364     digitalWrite(pin, HIGH);   // turn the LED on (HIGH is the voltage level)
 365     delay(velocita);               // wait for a second
 366     digitalWrite(pin, LOW);    // turn the LED off by making the voltage LOW
 367     delay(velocita);               // wait for a second
 368 };
 369
 370
 371 byte lum(byte val) {
 372     // Mappatura dell'intervallo 0-255 con correzione di luminosita.
 373     // storata in SRAM
 374     return pgm_read_byte_near(BCORRECT + val);
 375 };
 376
 377
 378 int calibraTrim(int pin, const byte ledPin) {
 379     /* START Calibrazione TRIM canale:
 380        Lettura di 10 smaple
 381        calcolo del valore medio esclusi gli 0
 382
 383        I canali come alettoni / elevatore possono avere un TRIM
 384        (generalmente il throttle non ha un TRIM impostato),
 385        questa funzione nel setup serve per trovare il punto medio
 386        all'avvio dello sketch.
 387      */
 388     pinMode(ledPin,OUTPUT);
 389     byte a              = 0;
 390     int servoValue      = 0;
 391     int middle = 0;
 392 #ifdef DEBUG
 393     Serial.println(">> Calibrazione: ");
 394 #endif
 395     while (a < 10) {
 396         if (millis() > 10000) {
 397 #ifdef DEBUG
 398             Serial.println(">> Calibrazione annullata a causa di assenza di seganle. \nAssicurarsi di accendere radio e ricevente \ne ripetere la procedura.");
 399 #endif
 400             middle = 15000; // Return value is divided by 10
 401             break;
 402         };
 403         servoValue = pulseIn(pin, HIGH, 25000);
 404         if (servoValue != 0 && servoValue > 950 && servoValue <2000)  {
 405             middle = middle + servoValue ;
 406             a++ ;
 407 #ifdef DEBUG
 408             Serial.print(servoValue);
 409             Serial.print(": ");
 410             Serial.println(middle / a);
 411 #endif
 412             digitalWrite(ledPin, !digitalRead(ledPin));
 413             delay(50);
 414         }
 415     }
 416 #ifdef DEBUG
 417     Serial.print(">> Fine Calibrazione, media: ");
 418     Serial.println(middle / 10 + 10);
 419     Serial.flush() ;
 420 #endif
 421     return(middle / 10 + 10) ;
 422 // END calibrazione
 423 };
 424