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