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