git.piffa.net Git - sketchbook_andrea/blob - libraries/common/common.cpp

   1 /*  Common
   2  *
   3  *  Oggetti di uso comune
   4  */
   5
   6 #include "Arduino.h"
   7 #include "common.h"
   8
   9
  10 //////////////////////
  11 // RGB LED
  12 // Common anode / cat
  13
  14 RGBLed::RGBLed(byte pinR, byte pinG, byte pinB) {
  15     // Per un common catodo, valore max / min invertiti
  16       redPin    = pinR ;
  17       greenPin  = pinG ;
  18       bluePin   = pinB ;
  19       common    = 0 ;
  20
  21       // Equvalente del Setup() per inizializzare i PIN
  22       pinMode(redPin, OUTPUT);
  23       pinMode(greenPin, OUTPUT);
  24       pinMode(greenPin, OUTPUT);
  25 };
  26
  27 RGBLed::RGBLed(byte pinR, byte pinG, byte pinB, byte com) {
  28     // Per un common anode, valore max / min normali
  29       redPin    = pinR ;
  30       greenPin  = pinG ;
  31       bluePin   = pinB ;
  32       common    = com ;
  33
  34       // Equvalente del Setup() per inizializzare i PIN
  35       pinMode(redPin, OUTPUT);
  36       pinMode(greenPin, OUTPUT);
  37       pinMode(greenPin, OUTPUT);
  38 };
  39
  40 void RGBLed::SetColor (byte r, byte g, byte b) {
  41 // Imposta il colore di un LED RGB
  42       analogWrite(redPin,   common - r);
  43       analogWrite(greenPin, common - g);
  44       analogWrite(bluePin,  common - b);
  45     };
  46
  47 void RGBLed::Red () {
  48 // Accende il LED di rosso
  49       SetColor(0,255,255);
  50     };
  51
  52 void RGBLed::Green () {
  53 // Accende il LED di verde
  54       SetColor(255,0,255);
  55     };
  56
  57 void RGBLed::Blue () {
  58 // Accende il LED di blu
  59       SetColor(255,255,0);
  60     };
  61
  62 void RGBLed::Magenta () {
  63 // Accende il LED di magenta
  64       SetColor(0,255,0);
  65     };
  66
  67 void RGBLed::Cyano () {
  68 // Accende il LED di Cyano
  69       SetColor(255,0,0);
  70     };
  71
  72 void RGBLed::Yellow () {
  73 // Accende il LED di giallo
  74       SetColor(0,0,255);
  75     };
  76
  77 void RGBLed::White () {
  78 // Accende il LED
  79       SetColor(0,0,0);
  80     };
  81
  82 void RGBLed::Off () {
  83 // Spegne il LED
  84       SetColor(255,255,255);
  85     };
  86
  87
  88
  89 /////////////////////////////////////
  90 // Lampeggiatore
  91 // Constructor
  92 Lampeggiatore::Lampeggiatore(int pin)
  93 {
  94     ledPin = pin;
  95     pinMode(ledPin, OUTPUT);
  96     ledState = LOW;
  97     previousMillis = 0;
  98     interval = 500;
  99 };
 100
 101 // Una funzione facente parte di una classe prende il nome di "metodo" della stessa:
 102 void Lampeggiatore::Invert() {
 103     // Inverte il lampeggio
 104     ledState = HIGH ;
 105 }
 106
 107 void Lampeggiatore::Blink() {
 108     // Illumina il led a 500ms
 109
 110     if(millis() - previousMillis > interval) {
 111         // save the last time you blinked the LED
 112         previousMillis = millis();
 113
 114         // if the LED is off turn it on and vice-versa:
 115         ledState = !ledState ; // Inverti il LED
 116     }
 117     // set the LED with the ledState of the variable:
 118     digitalWrite(ledPin, ledState);
 119 };
 120
 121 void Lampeggiatore::Blink(long time) {
 122     // Illumina il led secondo un intervallo passato come argomento
 123
 124     if(millis() - previousMillis > time) {
 125         // save the last time you blinked the LED
 126         previousMillis = millis();
 127
 128         // if the LED is off turn it on and vice-versa:
 129         ledState = !ledState ; // Inverti il LED
 130     }
 131     // set the LED with the ledState of the variable:
 132     digitalWrite(ledPin, ledState);
 133 };
 134
 135 void Lampeggiatore::Blink(long up, long down) {
 136     // Illumina il ledB precisando ontime e downtime
 137
 138     if((ledState == HIGH)&& (millis() - previousMillis > up)) {
 139     // save the last time you blinked the LED
 140         previousMillis = millis();
 141         ledState = LOW  ;
 142     }
 143     else if((ledState == LOW)&& (millis() - previousMillis > down)) {
 144         previousMillis = millis();
 145         ledState = HIGH  ;
 146     }
 147
 148     // set the LED with the ledState of the variable:
 149     digitalWrite(ledPin, ledState);
 150 };
 151
 152 void Lampeggiatore::High() {
 153     // Accende il LED
 154
 155     digitalWrite(ledPin, HIGH);
 156 }
 157
 158 void Lampeggiatore::Low() {
 159     // Spegne  il LED
 160
 161     digitalWrite(ledPin, LOW);
 162 }
 163
 164 void Lampeggiatore::Swap() {
 165     // Inverte lo stato del LED
 166
 167     digitalWrite(ledPin, !digitalRead(ledPin));
 168 }
 169
 170 /////////////////////////////////////
 171 // Pwm
 172 // Constructor
 173 Pwm::Pwm(int pin)
 174     // Gestione del PWM utilizzando millis
 175     // per non bloccare il processore con delay
 176     // Warning: serialWrite puo' interferire con i tempi.
 177 {
 178     ledPin = pin;
 179     pinMode(ledPin, OUTPUT);
 180     previousMillis = 0;
 181     byte brightness = 0 ;
 182     increment = 1;
 183 };
 184
 185 void Pwm::Up(long speed) {
 186     // Aumenta linearmente la luminosita' usanndo millis()
 187     // quindi senza bloccare il processore
 188     // Viene usato un float, in alternativa un coseno
 189
 190     if (millis() != previousMillis)  { // si potrebbe togliere
 191             brightness = 255.0 /(float)speed * millis() ;
 192             analogWrite(ledPin, brightness);
 193
 194         previousMillis = millis();
 195     };
 196 }
 197
 198 void Pwm::lUp(long speed) {
 199     // Aumenta usanndo millis() con correzione luminosita' LED
 200     // quindi senza bloccare il processore
 201     // Viene usato un float, in alternativa un coseno
 202
 203     if (millis() != previousMillis)  { // si potrebbe togliere
 204             brightness = 255.0 /(float)speed * millis() ;
 205             analogWrite(ledPin, lum(brightness));
 206
 207         previousMillis = millis();
 208     };
 209 }
 210
 211 void Pwm::Down(long speed ) {
 212     // Riduce linearmente la luminosita' usanndo millis()
 213     // quindi senza bloccare il processore
 214
 215     if (millis() != previousMillis)  {
 216             brightness = 255 - 255.0 /(float)speed * millis() ;
 217             analogWrite(ledPin, brightness);
 218
 219         previousMillis = millis();
 220     };
 221 }
 222
 223 void Pwm::lDown(long speed ) {
 224     // Riduce  usanndo millis() con correzione della luminosita'
 225     // quindi senza bloccare il processore
 226
 227     if (millis() != previousMillis)  {
 228             brightness = 255 - 255.0 /(float)speed * millis() ;
 229             analogWrite(ledPin, lum(brightness));
 230
 231         previousMillis = millis();
 232     };
 233 }
 234
 235 void Pwm::UD(long speed ) {
 236     // Aumenta e riduce in sequenza la luminosita' usanndo millis()
 237     brightness = 128 + 127 * cos(2 * PI / speed * millis());
 238     analogWrite(ledPin, brightness);
 239 }
 240
 241 void Pwm::Set(byte brightness) {
 242     // Imposta il valore del PWM
 243     analogWrite(ledPin, brightness);
 244 }
 245
 246
 247 void Pwm::lSet(byte brightness) {
 248     // Imposta il valore del PWM
 249     analogWrite(ledPin, lum(brightness));
 250 }
 251
 252
 253 /////////////////////////////////////
 254 // Sequenza
 255 // Constructor
 256 Sequenza::Sequenza (byte passed[], byte dim) {
 257     ledPins = passed ;
 258     size = dim ;
 259     for (int thisPin = 0; thisPin < size; thisPin++) {
 260         pinMode(ledPins[thisPin], OUTPUT);
 261     }
 262     previousMillis = millis();
 263     digitalWrite(ledPins[0], HIGH);
 264 }
 265
 266 void Sequenza::Update(long value) {
 267     // Incrementa dal primo all'ultimo valore dell'array
 268     interval = value;
 269     if (millis() - previousMillis >= interval) {
 270         previousMillis = millis();
 271
 272         if ( i < size - 1 ) {
 273             // Spegni precedente led
 274             digitalWrite(ledPins[i], LOW);
 275
 276             // Accendi successivo led
 277             digitalWrite(ledPins[++i], HIGH);
 278         }
 279
 280         else if  (i == size - 1 )   {
 281             // Ultimo caso
 282             i = 0;
 283             previousMillis = millis();
 284             digitalWrite(ledPins[i], HIGH);
 285             digitalWrite(ledPins[ size - 1 ], LOW);
 286         }
 287     }
 288 }
 289
 290
 291 void Sequenza::Reverse(long value) {
 292     interval = value;
 293     if (millis() - previousMillis >= interval) {
 294         previousMillis = millis();
 295
 296         if  (i == 0)   { // Entry point, ultimo LED
 297             digitalWrite(ledPins[size -1],HIGH);
 298             digitalWrite(ledPins[0],LOW);
 299             i = size -1 ;
 300         }
 301         else {
 302             digitalWrite(ledPins[i],LOW);
 303             digitalWrite(ledPins[--i],HIGH);
 304         }
 305     }
 306 }
 307
 308 void Sequenza::UD(long value) {
 309     interval = value;
 310     if (millis() - previousMillis >= interval) {
 311         previousMillis = millis();
 312         // Spegni precedente led
 313         digitalWrite(ledPins[i], LOW);
 314         i = i + inc ;
 315         // Accendi successivo led
 316         digitalWrite(ledPins[i], HIGH);
 317
 318         if (i == 0 || i == size -1) {
 319             inc = -inc ;
 320         }
 321     }
 322 }
 323
 324
 325 //////////////////
 326 // Funzioni
 327
 328
 329 void brilla(byte pin, int velocita ) { // Defalt value di velocita' solo nell'Header
 330   // Accende e spegne il LED accetando un argomento
 331   // per impostare la velocita'.
 332
 333 pinMode(pin, OUTPUT);
 334   // sequenze di istruzione: accendere e spegnere il LED
 335   digitalWrite(pin, HIGH);   // turn the LED on (HIGH is the voltage level)
 336   delay(velocita);               // wait for a second
 337   digitalWrite(pin, LOW);    // turn the LED off by making the voltage LOW
 338   delay(velocita);               // wait for a second
 339 };
 340
 341
 342 byte lum(byte val) {
 343     // Mappatura dell'intervallo 0-255 con correzione di luminosita.
 344     // storata in SRAM
 345 return pgm_read_byte_near(BCORRECT + val);
 346 };