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