--- /dev/null
+
+* aggiungere un displace temporale ai blink / pwm
+* Flasher con sequenza arbitraria di lampeggio
+* oggetti che lavorino contemporaneamente su piu' PIN
+* Link a Schemi / Schemi
+* esempio con state machine per flight modes
+** battery voltage reader -> RGB
+** digital compass e RGB
+** barometer
+** 6 axis
+** Neopixel
--- /dev/null
+/* Common
+ *
+ * Oggetti di uso comune
+ * Autore: Andrea Manni
+ *
+ * Link: http://git.andreamanni.com/
+ * Licenza: GPLv3
+ */
+
+#include "Arduino.h"
+#include "common.h"
+
+#define DEBUG_not
+
+//////////////////////
+// RGB LED
+// Common anode / cat
+
+RGBLed::RGBLed(byte pinR, byte pinG, byte pinB) {
+ // Per un common catodo, valore max / min invertiti
+ redPin = pinR ;
+ greenPin = pinG ;
+ bluePin = pinB ;
+ common = 255 ;
+
+ // Equvalente del Setup() per inizializzare i PIN
+ pinMode(redPin, OUTPUT);
+ pinMode(greenPin, OUTPUT);
+ pinMode(greenPin, OUTPUT);
+};
+
+RGBLed::RGBLed(byte pinR, byte pinG, byte pinB, byte com) {
+ // Per un common anode, valore max / min normali
+ redPin = pinR ;
+ greenPin = pinG ;
+ bluePin = pinB ;
+ common = com ;
+
+ // Equvalente del Setup() per inizializzare i PIN
+ pinMode(redPin, OUTPUT);
+ pinMode(greenPin, OUTPUT);
+ pinMode(greenPin, OUTPUT);
+};
+
+void RGBLed::SetColor (byte r, byte g, byte b) {
+// Imposta il colore di un LED RGB
+ analogWrite(redPin, common - r);
+ analogWrite(greenPin, common - g);
+ analogWrite(bluePin, common - b);
+
+// Debug
+#ifdef DEBUG
+ Serial.print(common - r);
+ Serial.print("-");
+ Serial.print(common - g);
+ Serial.print("-");
+ Serial.print(common - b);
+ while(1);
+#endif
+
+};
+
+void RGBLed::Rand () {
+// Imposta il colore di un LED RGB
+ analogWrite(redPin, random(0,256));
+ analogWrite(greenPin, random(0,256));
+ analogWrite(bluePin, random(0,256));
+};
+
+void RGBLed::Red () {
+// Accende il LED di rosso
+ SetColor(255,0,0);
+};
+
+void RGBLed::Green () {
+// Accende il LED di verde
+ SetColor(0,255,0);
+};
+
+void RGBLed::Blue () {
+// Accende il LED di blu
+ SetColor(0,0,255);
+};
+
+void RGBLed::Magenta () {
+// Accende il LED di magenta
+ SetColor(255,0,255);
+};
+
+void RGBLed::Cyano () {
+// Accende il LED di Cyano
+ SetColor(0,255,255);
+};
+
+void RGBLed::Yellow () {
+// Accende il LED di giallo
+ SetColor(255,255,0);
+};
+
+void RGBLed::White () {
+// Accende il LED
+ SetColor(255,255,255);
+};
+
+void RGBLed::Off () {
+// Spegne il LED
+ SetColor(0,0,0);
+};
+
+
+
+/////////////////////////////////////
+// Lampeggiatore
+// Constructor
+//
+// Esempi incrementali: https://lab.piffa.net/sketchbook_andrea/multitasking/
+Lampeggiatore::Lampeggiatore(int pin)
+{
+ ledPin = pin;
+ pinMode(ledPin, OUTPUT);
+ ledState = LOW;
+ previousMillis = 0;
+ interval = 500;
+};
+
+// Una funzione facente parte di una classe prende il nome di "metodo" della stessa:
+void Lampeggiatore::Invert() {
+ // Inverte il lampeggio
+ ledState = HIGH ;
+}
+
+void Lampeggiatore::Blink() {
+ // Illumina il led a 500ms
+
+ if(millis() + shift - previousMillis > interval) {
+
+ // if the LED is off turn it on and vice-versa:
+ ledState = !ledState ; // Inverti il LED
+ // set the LED with the ledState of the variable:
+ digitalWrite(ledPin, ledState);
+ // save the last time you blinked the LED
+ previousMillis += interval;
+ }
+};
+
+void Lampeggiatore::Blink(long time, long drift ) {
+ // Illumina il led secondo un intervallo passato come argomento
+
+ shift = drift;
+ if(millis() + shift - previousMillis > time) {
+ // if the LED is off turn it on and vice-versa:
+ ledState = !ledState ; // Inverti il LED
+ // set the LED with the ledState of the variable:
+ digitalWrite(ledPin, ledState);
+ // save the last time you blinked the LED
+ previousMillis += time;
+ }
+};
+
+void Lampeggiatore::Blink(long up, long down, long drift ) {
+ // Illumina il ledB precisando ontime e downtime
+
+ shift = drift;
+ if((ledState == HIGH)&& (millis() + shift - previousMillis > up)) {
+ // save the last time you blinked the LED
+ previousMillis += up;
+ ledState = LOW ;
+ }
+ else if((ledState == LOW)&& (millis() + shift - previousMillis > down)) {
+ previousMillis += down;
+ ledState = HIGH ;
+ }
+
+ // set the LED with the ledState of the variable:
+ digitalWrite(ledPin, ledState);
+};
+
+void Lampeggiatore::High() {
+ // Accende il LED
+
+ digitalWrite(ledPin, HIGH);
+}
+
+void Lampeggiatore::Low() {
+ // Spegne il LED
+
+ digitalWrite(ledPin, LOW);
+}
+
+void Lampeggiatore::Swap() {
+ // Inverte lo stato del LED
+
+ digitalWrite(ledPin, !digitalRead(ledPin));
+}
+
+/////////////////////////////////////
+// Pwm
+// Constructor
+Pwm::Pwm(int pin)
+// Gestione del PWM utilizzando millis
+// per non bloccare il processore con delay
+// Warning: serialWrite puo' interferire con i tempi.
+{
+ ledPin = pin;
+ pinMode(ledPin, OUTPUT);
+ previousMillis = 0;
+ byte brightness = 0 ;
+ increment = 1;
+};
+
+void Pwm::Up(long speed, long drift) {
+ // Aumenta linearmente la luminosita' usanndo millis()
+ // quindi senza bloccare il processore
+ // Viene usato un float, in alternativa un coseno
+
+ if (millis() != previousMillis) { // si potrebbe togliere
+ shift = drift;
+ brightness = 255.0 /(float)speed * (millis() + shift);
+ analogWrite(ledPin, brightness);
+
+ previousMillis = millis();
+ };
+}
+
+void Pwm::lUp(long speed, long drift) {
+ // Aumenta usanndo millis() con correzione luminosita' LED
+ // quindi senza bloccare il processore
+ // Viene usato un float, in alternativa un coseno
+
+ if (millis() != previousMillis) { // si potrebbe togliere
+ shift = drift;
+ brightness = 255.0 /(float)speed * (millis() + shift);
+ analogWrite(ledPin, lum(brightness));
+
+ previousMillis = millis();
+ };
+}
+
+void Pwm::Down(long speed, long drift) {
+ // Riduce linearmente la luminosita' usanndo millis()
+ // quindi senza bloccare il processore
+
+ if (millis() != previousMillis) {
+ shift = drift;
+ brightness = 255 - 255.0 /(float)speed * (millis() + shift) ;
+ analogWrite(ledPin, brightness);
+
+ previousMillis = millis();
+ };
+}
+
+void Pwm::lDown(long speed, long drift) {
+ // Riduce usanndo millis() con correzione della luminosita'
+ // quindi senza bloccare il processore
+
+ if (millis() != previousMillis) {
+ shift = drift;
+ brightness = 255 - 255.0 /(float)speed * (millis() + shift) ;
+ analogWrite(ledPin, lum(brightness));
+
+ previousMillis = millis();
+ };
+}
+
+void Pwm::UD(long speed, long drift ) {
+ // Aumenta e riduce in sequenza la luminosita' usanndo millis()
+ shift = drift;
+ brightness = 128 + 127 * cos(2 * PI / speed * (millis() + shift));
+ analogWrite(ledPin, brightness);
+}
+
+void Pwm::Set(byte brightness) {
+ // Imposta il valore del PWM
+ analogWrite(ledPin, brightness);
+}
+
+
+void Pwm::lSet(byte brightness) {
+ // Imposta il valore del PWM con correzione luminosita' LED
+ analogWrite(ledPin, lum(brightness));
+}
+
+
+/////////////////////////////////////
+// Sequenza
+// Constructor
+Sequenza::Sequenza (byte passed[], byte dim) {
+ ledPins = passed ;
+ size = dim ;
+ for (int thisPin = 0; thisPin < size; thisPin++) {
+ pinMode(ledPins[thisPin], OUTPUT);
+ }
+ previousMillis = millis();
+ digitalWrite(ledPins[0], HIGH);
+}
+
+void Sequenza::Update(long value) {
+ // Incrementa dal primo all'ultimo valore dell'array
+ interval = value;
+ if (millis() - previousMillis >= interval) {
+ previousMillis = millis();
+
+ if ( i < size - 1 ) {
+ // Spegni precedente led
+ digitalWrite(ledPins[i], LOW);
+
+ // Accendi successivo led
+ digitalWrite(ledPins[++i], HIGH);
+ }
+
+ else if (i == size - 1 ) {
+ // Ultimo caso
+ i = 0;
+ previousMillis = millis();
+ digitalWrite(ledPins[i], HIGH);
+ digitalWrite(ledPins[ size - 1 ], LOW);
+ }
+ }
+}
+
+
+void Sequenza::Reverse(long value) {
+ interval = value;
+ if (millis() - previousMillis >= interval) {
+ previousMillis = millis();
+
+ if (i == 0) { // Entry point, ultimo LED
+ digitalWrite(ledPins[size -1],HIGH);
+ digitalWrite(ledPins[0],LOW);
+ i = size -1 ;
+ }
+ else {
+ digitalWrite(ledPins[i],LOW);
+ digitalWrite(ledPins[--i],HIGH);
+ }
+ }
+}
+
+void Sequenza::UD(long value) {
+ interval = value;
+ if (millis() - previousMillis >= interval) {
+ previousMillis = millis();
+ // Spegni precedente led
+ digitalWrite(ledPins[i], LOW);
+ i = i + inc ;
+ // Accendi successivo led
+ digitalWrite(ledPins[i], HIGH);
+
+ if (i == 0 || i == size -1) {
+ inc = -inc ;
+ }
+ }
+}
+
+
+//////////////////
+// Funzioni
+
+
+void brilla(byte pin, int velocita ) { // Defalt value di velocita' solo nell'Header
+ // Accende e spegne il LED accetando un argomento
+ // per impostare la velocita'.
+
+ pinMode(pin, OUTPUT);
+ // sequenze di istruzione: accendere e spegnere il LED
+ digitalWrite(pin, HIGH); // turn the LED on (HIGH is the voltage level)
+ delay(velocita); // wait for a second
+ digitalWrite(pin, LOW); // turn the LED off by making the voltage LOW
+ delay(velocita); // wait for a second
+};
+
+
+byte lum(byte val) {
+ // Mappatura dell'intervallo 0-255 con correzione di luminosita.
+ // storata in SRAM
+ return pgm_read_byte_near(BCORRECT + val);
+};
+
+
+int calibraTrim(int pin, const byte ledPin) {
+ /* START Calibrazione TRIM canale:
+ Lettura di 10 smaple
+ calcolo del valore medio esclusi gli 0
+
+ I canali come alettoni / elevatore possono avere un TRIM
+ (generalmente il throttle non ha un TRIM impostato),
+ questa funzione nel setup serve per trovare il punto medio
+ all'avvio dello sketch.
+ */
+ pinMode(ledPin,OUTPUT);
+ byte a = 0;
+ int servoValue = 0;
+ int middle = 0;
+#ifdef DEBUG
+ Serial.println(">> Calibrazione: ");
+#endif
+ while (a < 10) {
+ if (millis() > 10000) {
+#ifdef DEBUG
+ Serial.println(">> Calibrazione annullata a causa di assenza di seganle. \nAssicurarsi di accendere radio e ricevente \ne ripetere la procedura.");
+#endif
+ middle = 15000; // Return value is divided by 10
+ break;
+ };
+ servoValue = pulseIn(pin, HIGH, 25000);
+ if (servoValue != 0 && servoValue > 950 && servoValue <2000) {
+ middle = middle + servoValue ;
+ a++ ;
+#ifdef DEBUG
+ Serial.print(servoValue);
+ Serial.print(": ");
+ Serial.println(middle / a);
+#endif
+ digitalWrite(ledPin, !digitalRead(ledPin));
+ delay(50);
+ }
+ }
+#ifdef DEBUG
+ Serial.print(">> Fine Calibrazione, media: ");
+ Serial.println(middle / 10 + 10);
+ Serial.flush() ;
+#endif
+ return(middle / 10 + 10) ;
+// END calibrazione
+};
+
--- /dev/null
+/*
+ Common Class
+
+ Oggetti comuni
+
+Autore: Andrea Manni
+
+Link: http://git.andreamanni.com/
+Licenza: GPLv3
+
+*/
+
+#include "Arduino.h"
+#include <avr/pgmspace.h>
+
+#ifndef common_h
+#define common_h
+
+// Variabili
+const uint8_t BCORRECT[256] PROGMEM = { // Tabella per correzione luminosita' LED a 8bit
+ 0,0,0,1,1,1,2,1,1,2,1,2,2,2,3,2,
+ 2,2,3,2,2,3,2,3,3,3,4,3,3,3,4,4,
+ 4,5,4,5,4,5,5,6,5,5,6,5,6,6,7,6,
+ 7,7,8,7,8,8,9,8,9,10,9,10,10,11,10,11,
+ 11,12,11,12,13,12,13,13,14,14,15,15,15,16,16,17,
+ 17,17,18,18,19,19,20,20,21,21,22,22,23,23,24,24,
+ 25,25,26,26,27,28,28,29,29,30,31,31,32,32,33,34,
+ 34,35,36,37,37,38,39,39,40,41,42,43,43,44,45,46,
+ 47,47,48,49,50,51,52,53,54,54,55,56,57,58,59,60,
+ 61,62,63,64,65,66,67,68,70,71,72,73,74,75,76,77,
+ 79,80,81,82,83,85,86,87,88,90,91,92,94,95,96,98,
+ 99,100,102,103,105,106,108,109,110,112,113,115,116,118,120,121,
+ 123,124,126,128,129,131,132,134,136,138,139,141,143,145,146,148,
+ 150,152,154,155,157,159,161,163,165,167,169,171,173,175,177,179,
+ 181,183,185,187,189,191,193,196,198,200,202,204,207,209,211,214,
+ 216,218,220,223,225,228,230,232,235,237,240,242,245,247,251,255
+};
+
+// Inserirne una con 32 valori
+
+
+class RGBLed {
+ // Classe rappresentativa di un LED RGB
+ protected: // Vedi esempio Ereditarieta'
+ byte redPin ;
+ byte greenPin ;
+ byte bluePin ;
+ byte redValue ;
+ byte greenValue ;
+ byte blueValue ;
+ byte common ;
+
+ public:
+ RGBLed (byte pinR, byte pinG, byte pinB) ;
+ RGBLed (byte pinR, byte pinG, byte pinB, byte com) ;
+ void SetColor (byte r, byte g, byte b) ;
+ void Rand ();
+ void Red ();
+ void Green ();
+ void Blue ();
+ void Magenta ();
+ void Cyano ();
+ void White ();
+ void Yellow ();
+ void Off ();
+};
+
+
+
+class Lampeggiatore {
+ // Lampeggia un LED utilizzando millis()
+ // Variabili
+ int ledPin ; // il numero del LED pin
+ long interval ; // milliseconds di intervallo nel lampeggiare
+ unsigned long previousMillis ; // precedente cambio di stato
+ int ledState ; // stato attuale del LED, pubblico per invertirlo
+
+ // Constructor: come viene instanziato un oggetto facente parte della classe
+public:
+ Lampeggiatore(int pin);
+ void Invert(); // Inverte il lampeggio
+ void Blink(); // Lampeggia ogni 500ms
+ void Blink(long interval, long drift = 0); // Lampeggia inpostando l'intervallo
+ void Blink(long on, long down, long drift); // Imposta il tempo acceso e il tempo spento
+ void High(); // Accende il LED
+ void Low(); // Spegne il LED
+ void Swap(); // Inverte lo stato del LED
+ unsigned long shift ; // anticipo / ritardo
+};
+
+
+
+////////////////////////////
+class Pwm {
+ /*
+ PWM per un LED: aumentare progressivamente la luminosita'.
+ Utilizza la funzione millis() invece che un delay()
+ in modo da non blocare il processore.
+ */
+ // Variabili
+ int ledPin ; // il numero del LED pin
+ int speed ; // velocita' del ciclo in ms
+ unsigned long previousMillis ; //precedente cambio di stato
+ byte increment ; // aumenta brighteness nel loop UD
+
+ // Constructor: come viene instanziato un oggetto facente parte della classe
+public:
+ Pwm(int pin); // numero di pin, velocita' di ciclo
+ void Up(long speed, long drift = 0);
+ void lUp(long speed, long drift = 0);
+ void Down(long speed, long drift = 0);
+ void lDown(long speed, long drift = 0);
+ void UD(long speed, long drift = 0);
+ void Set(byte brighteness);
+ void lSet(byte brighteness);
+ byte brightness ; // luminostia' iniziale
+ unsigned long shift ; // anticipo / ritardo
+};
+
+
+
+////////////////////////////
+class Sequenza {
+ // Lampeggia LED in sequenza utilizzando millis()
+ unsigned long previousMillis ;
+ byte i = 0;
+ byte *ledPins;
+ byte size;
+ int inc = 1;
+ long interval;
+
+ public:
+ Sequenza (byte passed[], byte dim) ; // Array contentente i PINS, dimensioni array
+ void Update(long value) ; // Accende in sequenza
+ void Reverse(long value) ; // Invertita
+ void UD(long value) ; // Up & Down
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//////////////////////
+// Funzioni
+
+void brilla(byte pin, int velocita = 200) ;
+
+byte lum(byte val);
+
+int calibraTrim(int pin, const byte ledPin = 13);
+
+
+#endif
--- /dev/null
+/* Funzione Invert
+
+ Due LED con lampeggio alternato
+*/
+
+#include <common.h>
+
+Lampeggiatore right = 3;
+Lampeggiatore left = 5;
+
+void setup() {
+ left.Invert(); // Parte da stato invertito rispetto al default
+}
+
+void loop() {
+ // Due LED con lampeggio alternato:
+ right.Blink();
+ left.Blink();
+ // Si possono usare i soliti metodi dell'oggetto blink
+}
--- /dev/null
+/* Esempio
+
+ Utilizzo dell'oggetto Lampeggiatore:
+ Lampeggia un LED utilizzando millis()
+*/
+
+#include <common.h>
+
+// Instanziamo un LED fuori dal loop
+Lampeggiatore led = 13;
+
+void setup() {
+// I PINs vengono impostati dal constructor al momento
+// della dichiarazione dell'ogetto.
+
+//led.Invert() ; // Opzionale: inverte l'ordine del lampeggio da
+ // HI -> LOW --> LOW -> HI
+ // per avere 2 LED che lampeggiano alternativamente
+}
+
+void loop() {
+ led.Blink(); // Lampeggia con un default di 1sec (0.5 HI 0.5 LOW)
+// led.Blink(400); // Lampeggia ogni 400ms
+// led.Blink(400,200); // Imposta il tempo acceso a 400ms, 200ms di ritardo
+// led.Blink(300,700,0); // acceso per 300ms, spento per 700 ms, ritardo = 0ms
+// led.Blink(300,700,500); // acceso per 300ms, spento per 700 ms, ritardo = 500s
+// led.High(); // Stato su HI
+// led.Low(); // Stato su LOW
+// led.Swap(); // Inverte lo Stato
+}
--- /dev/null
+/* Ereditarieta'
+
+ La classe SuperLED definita in questo sketch
+ eredita le caratteristiche di RGBLed e introduce un nuovo metodo
+ per un nuovo colore custom.
+
+*/
+
+#include <common.h> // L'orine e' importante: prima l'include,
+ // poi la dichiarazione della nuova classe (non a fondo pagina)
+ // poi potremo usare la nuova classe
+
+class SuperLED : public RGBLed { // Ereditamo dalla classe RGBLed
+ // Nuovi colori per RGBLed
+
+ using RGBLed::RGBLed ; // Richiamiamo il constructor del genitore
+ public:
+ void Violet () { // Nuovo metodo
+ // Accende il LED di viola
+
+ analogWrite(redPin, 255 - 238);
+ analogWrite(greenPin, 255 - 130);
+ analogWrite(bluePin, 255 - 238);
+ };
+};
+
+void setup() {
+ // I PINs vengono impostati dalla dichiarazione dell'ogetto.
+}
+
+// Instanziamo un LED
+SuperLED led(11, 10, 9); //Istanziamo un oggetto led facente parte
+ // della inuova classe SuperLed che eredita da RGBLed
+
+void loop() {
+ led.Violet(); // Nuovo metodo
+ delay(1000);
+ led.Off(); // Vecchio metodo
+ delay(1000);
+}
+
--- /dev/null
+/* Esempio
+
+ Utilizzo dell'oggetto PWM:
+ Gestione del PWM utilizzando millis
+ per non bloccare il processore con delay
+*/
+
+#include <common.h>
+
+// Instanziamo un LED fuori dal loop
+Pwm led = 9;
+
+void setup() {
+ // I PINs vengono impostati dal constructor al momento
+ // della dichiarazione dell'ogetto.
+}
+
+void loop() {
+led.Up(2000); // Aumenta la luminosita' linearmente in 2 sec
+//led.Up(2000,1000); // Aumenta la luminosita' linearmente in 2 sec, 1sec di ritardo
+
+//led.lUp(2000); // Aumenta la luminosita' con correzione luminosita' per LED
+// led.Down(1000); // Diminuisce la luminosita' in 1 sec
+// led.lDown(1000); // Diminuisce la luminosita' con correzione luminosita'
+// led.UD(4000); // Aumenta e poi diminuisce la luminostia' in 4 sec (coseno)
+// Tutti questi metodi accettano un valore opzionale per il ritardo
+
+// led.set(100); // Imposta il valore del PWM da 0-255
+// led.lSet(100); // Imposta il valore del PWM con correzione luminosita'
+// analogWrite(lum100); // Equivalente a sopra
+}
--- /dev/null
+/* Esempio
+
+ Come caricare e usare un oggetto e una funzione
+ facente parte della libreria.
+*/
+
+#include <common.h>
+
+void setup() {
+ // I PINs vengono impostati dalla dichiarazione dell'ogetto.
+}
+
+// Instanziamo un LED
+RGBLed led(11, 10,9); //Istanziamo un oggetto led (default common catodo)
+// facente parte della classe RGBLed
+// RGBLed led(11, 10,9,255); // Stessa cosa: 255 = common catodo = (255 - value)
+//RGBLed led(10,9,11,0); // Inizializzazione Common anodo
+
+void loop() {
+ led.Red();
+}
+
+/* Colori disponibili:
+ Red
+ Green
+ Blue
+ Magenta
+ Cyano
+ White
+ Yellow
+ Off
+ Rand = random
+ SetColor(byte r, byte g, byte b)
+
+Nota: per aggiungerne un colore senza modificare la libreria originale
+si potrebbe usara l'ereditarieta': vedi esempio "eredita.ino" .
+*/
--- /dev/null
+/*
+ For Loop with millis()
+
+Blink di un array di led in sucessione,
+utilizzando millis() per non blocking.
+L'array puo' contenere un numero arbitrario di led
+(l'ordine in cui compaiono e' l'ordine in cui brillano).
+
+OOP version.
+
+ Schemi:
+ - http://lab.piffa.net/schemi/8_led_single_res_bb.png
+ - http://lab.piffa.net/schemi/8_led_single_res_schem.png
+
+ http://www.arduino.cc/en/Tutorial/ForLoop
+ */
+#include <common.h>
+void setup() {
+};
+
+byte pins[] = { // PIN dei LED che compongono la sequenza
+ 2, 3, 4, 5, 6, 7
+};
+Sequenza seq = Sequenza(pins,sizeof(pins)); // Array dei PINs, quanti elementi compongono l'array
+
+void loop() {
+ seq.Update(200); // Passa al segmento successivo ogni 200ms
+};
+
+
+
--- /dev/null
+RGBLed KEYWORD1
+Red KEYWORD2
+Green KEYWORD2
+Blue KEYWORD2
+Magenta KEYWORD2
+Cyano KEYWORD2
+White KEYWORD2
+Yellow KEYWORD2
+Off KEYWORD2
+SetColor KEYWORD2
+brilla KEYWORD2
+Lampeggiatore KEYWORD1
+Invert KEYWORD2
+Blink KEYWORD2
+Blink KEYWORD2
+Blink KEYWORD2
+High KEYWORD2
+Low KEYWORD2
+Swap KEYWORD2
+Pwm KEYWORD1
+Up KEYWORD2
+lUp KEYWORD2
+Down KEYWORD2
+lDown KEYWORD2
+UD KEYWORD2
+Set KEYWORD2
+lSet KEYWORD2
+lum KEYWORD2
+Sequenza KEYWORD1
+Update KEYWORD2
+calibraTrim KEYWORD2
projects / common / commitdiff