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