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