+* aggiungere uno snippet per sniffing canale RX con interrupt
+* mettere questo e quello in pulsein in una funzione / oggetto
+* Ailerons RGB: creare un metodo per lo stato intermedio
+ es. un RGB lampeggiante
+
+Calibrazione:
+ allo stato attuale la radio deve essere accesa quando parte lo sketch,
+ se non c'e' segnale non avviene la calibrazione.
+ Far si che se la calibrazione avviene il valore viene salvato in EPROM,
+ se la calibrazione fallisce viene caricato il precedente valore da EPROM.
+
* Aggiungere time displacement a Sequenza
* Esempi:
* FSM con gestione degli stati interna (da Zeta)
#include <common.h>
-enum { // Stati della FMS
- middle, // centrale
- sxin, // transizione a sx
- sx, // sx
- dxin, // transizione a dx
- dx // dx
-} ailstate = middle;
+// Variabili:
+unsigned long currentMillis; // timestamp reference per millis per tutto il loop
// Un LED RGB
-RGBLed ailerons(11,10,9);
+RGBLed ailerons(11,10,9,255);
+// Variabili per lettura canale servo
const byte ailPin = A4;
int ail ; // Valore a 8bit per ailerons
int ailIn ; // Valore rilevato del 4 Ch della RX
+unsigned long ailTimer ; // millis per ail
-unsigned long now; // timestamp reference for millis
-unsigned long pausa = 1000;
+// FSM gestione alettoni
+enum { // Stati della FMS
+ middle, // centrale
+ sxin, // transizione a sx
+ sx, // sx
+ dxin, // transizione a dx
+ dx // dx
+} ailstate = middle;
-int mid_point = 1500 ; // centro del segnale, trimmato nel setup
-const int deviation = 50 ; // deviazione per entrare nello stato succiessivo
+unsigned long FSM_lastMillis = 0 ; // Timestamp per la FSM degli alettoni
+unsigned long pausa = 1000; // Pausa per la transizione durante gli stati 2, 4 della FSM
+int mid_point = 1560 ; // centro del segnale, trimmato nel setup
+const int deviation = 50 ; // deviazione dal punto medio
+ //per entrare nello stato successivo dal centro
+///////////////////////////////////////////////////////////
void setup() {
- /* Bisognerebbe introdurre una calibrazione per compensare i TRIM
- ed eventualmente i dual rates.
-
- - attivarla se allo start un ale e' al massimo
- - fargli leggere i valori massimi
- - salvarli in eprom
- - per i dual rates: si potrebbe intercettare valori oltre al max
- e in base a questi traslare le soglie automaticamente
-
- Hint: leggere la soglia di rollio significativo in volo
- e inserirla nei riferimenti.
- */
-
- Serial.begin(9600);
-
-/* START Calibrazione TRIM canale:
- Lettura di 10 smaple
- calcolo del valore medio esclusi gli 0
- */
- byte a = 0;
- Serial.println(">> Calibrazione: ");
- while (a < 10) {
- ailIn = pulseIn(ailPin, HIGH, 25000);
- if (ailIn != 0 ) {
- ail = ail + ailIn ;
- a++ ;
- Serial.print(a);
- Serial.print(": ");
- Serial.println(ail);
- digitalWrite(13, !digitalRead(13));
- delay(10);
- }
- }
- mid_point = ail / 10 ;
- Serial.print(">> Fine Calibrazione: ");
- Serial.print(mid_point);
- Serial.println("--");
-// END calibrazione
+
+// Serial.begin(9600);
+// #define DEBUG
// Funzione relativa a calibrazione:
-//mid_point = calibraTrim(ailPin) ; // Pin a cui e' collegato il canale
-//mid_point = calibraTrim(aliPin,11) ; // + LED di servizio per monitor calibrazione
+ mid_point = calibraTrim(ailPin) ; // + LED di servizio per monitor calibrazione
}
void loop() {
+ currentMillis = millis(); // Timestamp per tutto il loop
+// Lettura ailerons channel ogni 200ms
+ if (currentMillis - ailTimer>= 200) {
+ ailTimer = currentMillis ;
+
+ ailIn = pulseIn(ailPin, HIGH, 25000);
+ if (ailIn != 0 && ailIn > 1000 && ailIn <2000) {
+ // get only resonable values
+ ail = ailIn;
+ } ;
// Lettura Aileron channel: FAKE con un potenziometro 10K
-//ailIn = analogRead(3);
-//ail = constrain(aliIn * 2 , 0, 2000) ;
+// ailIn = analogRead(3);
+// ail = 1000 + ailIn
+ }
-// Lettura ailerons channel
- ailIn = pulseIn(ailPin, HIGH, 25000);
- if (ailIn != 0) {
- ail = constrain(ailIn, 1000, 2000);
- } ;
- // con un altra ricevente, fare una calibrazione nel caso.
- // Middle = 1512
switch (ailstate) {
case middle:
// Alettoni piatti
if (ail > mid_point + deviation + deviation /3) {
+ // extra margine per avere un po' di gioco
ailstate = sxin;
- now = millis() ;
- goto sxin ;
+ FSM_lastMillis = currentMillis;
}
else if (ail < mid_point - deviation - deviation / 3) {
ailstate = dxin;
- now = millis() ;
- goto dxin ;
+ FSM_lastMillis = currentMillis ;
} ;
- ailerons.White();
-
+ ailerons.Red();
break;
case sxin:
-sxin:
// Transizione a sx
ailerons.Off();
- if (millis() - pausa > now ) {
+ if (currentMillis - pausa > FSM_lastMillis ) {
ailstate = sx;
}
break;
ailstate = middle;
}
else if (ail < mid_point - deviation) {
- now = millis() ;
+ FSM_lastMillis = currentMillis;
ailstate = dxin;
} ;
break;
case dxin:
// Transizione a dx
-dxin:
ailerons.Off();
- if (millis() - pausa > now ) {
+ if (currentMillis - pausa > FSM_lastMillis ) {
ailstate = dx;
}
break;
ailstate = middle;
}
else if (ail > mid_point + deviation) {
- now = millis() ;
+ FSM_lastMillis = currentMillis;
ailstate = dxin;
} ;
break;
}
-
+#ifdef DEBUG
Serial.print("ailIn: ");
Serial.print(ailIn);
Serial.print("\tail: ");
Serial.print(ail);
Serial.print("\t ailstate:");
Serial.println(ailstate);
- // delay(200);
+#endif
}
questa funzione nel setup serve per trovare il punto medio
all'avvio dello sketch.
+Nota: questa funzione usa PULSEIN in modo da poter lavorare su
+qualunque PIN, considerando che in genere viene eseguita
+una sola volta nel SETUP.
+
+Se si vuole qualcosa non blocking sostituire PULSEIN con
+un interrupt.
+
*/
#include <common.h>
const byte ailPin = A4;
-// int ail ; // Valore a 8bit per ailerons
-// int ailIn ; // Valore rilevato del 4 Ch della RX
int mid_point = 1500 ; // centro del segnale, trimmato nel setup
void setup() {
Serial.begin(9600); // Se abilitato la calibrazione viene tracciata su seriale
+ // Abilitando anche DEBUG nella libreria
+
+// mid_point = calibraTrim(ailPin) ; // Pin a cui e' collegato il canale
+mid_point = calibraTrim(ailPin,11) ; // + LED di servizio per calibrazione
+
+Serial.print("Valore calibrato: ");
+Serial.println(mid_point);
- mid_point = calibraTrim(ailPin) ; // Pin a cui e' collegato il canale
-//mid_point = calibraTrim(aliPin,11) ; // + LED di servizio per calibrazione
while(1); // Stoppa Arduino
}
--- /dev/null
+
+/* Lettura di un canale servo della RX
+
+ Lettura tramite la finzione pulsein
+ Utilizzabile su qualunque PIN
+
+*/
+
+#include <common.h>
+
+unsigned long currentMillis; // timestamp reference per millis per tutto il loop
+
+// Variabili
+const byte chPin = A4; // PIN su cui e' collegato il canale
+long unsigned chStamp = 0; // Timestamp per
+unsigned int chIn = 1500; // Valore catturato
+unsigned int chValue = 1500; // Valore computato
+unsigned int freq = 200 ; // Ogni quanti millisecondi leggere il valore
+// Attenzione che pulsein e' blocking
+
+void setup() {
+ // Funzione relativa a calibrazione:
+// mid_point = calibraTrim(chPin) ; // + LED di servizio per monitor calibrazione
+} ;
+
+void loop() {
+ currentMillis = millis(); // Timestamp per tutto il loop
+
+// Lettura ailerons channel ogni 200ms
+ if (currentMillis - chStamp >= freq) {
+ chStamp = currentMillis ;
+
+ chIn = pulseIn(chPin, HIGH, 25000);
+ if (chIn != 0 && chIn > 1000 && chIn <2000) {
+ // get only resonable values
+ chValue = chIn;
+ } ;
+// Lettura Aileron channel: FAKE con un potenziometro 10K
+// chIn = analogRead(chPin);
+// chValue = 1000 + chIn
+ };
+
+
+// do something with chValue
+}
#include "Arduino.h"
#include "common.h"
+#define DEBUG_not
//////////////////////
// RGB LED
redPin = pinR ;
greenPin = pinG ;
bluePin = pinB ;
- common = 0 ;
+ common = 255 ;
// Equvalente del Setup() per inizializzare i PIN
pinMode(redPin, OUTPUT);
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(0,255,255);
+ SetColor(255,0,0);
};
void RGBLed::Green () {
// Accende il LED di verde
- SetColor(255,0,255);
+ SetColor(0,255,0);
};
void RGBLed::Blue () {
// Accende il LED di blu
- SetColor(255,255,0);
+ SetColor(0,0,255);
};
void RGBLed::Magenta () {
// Accende il LED di magenta
- SetColor(0,255,0);
+ SetColor(255,0,255);
};
void RGBLed::Cyano () {
// Accende il LED di Cyano
- SetColor(255,0,0);
+ SetColor(0,255,255);
};
void RGBLed::Yellow () {
// Accende il LED di giallo
- SetColor(0,0,255);
+ SetColor(255,255,0);
};
void RGBLed::White () {
// Accende il LED
- SetColor(0,0,0);
+ SetColor(255,255,255);
};
void RGBLed::Off () {
// Spegne il LED
- SetColor(255,255,255);
+ SetColor(0,0,0);
};
};
-int calibraTrim(int pin, byte ledPin) {
+int calibraTrim(int pin, const byte ledPin) {
/* START Calibrazione TRIM canale:
Lettura di 10 smaple
calcolo del valore medio esclusi gli 0
questa funzione nel setup serve per trovare il punto medio
all'avvio dello sketch.
*/
+ pinMode(ledPin,OUTPUT);
byte a = 0;
- int ail = 0;
- int ailIn = 0;
+ int servoValue = 0;
+ int middle = 0;
+#ifdef DEBUG
Serial.println(">> Calibrazione: ");
+#endif
while (a < 10) {
if (millis() > 10000) {
- Serial.print(">> Calibrazione annullata: segnale assente.");
- ail = 1500;
+#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;
};
- ailIn = pulseIn(pin, HIGH, 25000);
- if (ailIn != 0 ) {
- ail = ail + ailIn ;
+ servoValue = pulseIn(pin, HIGH, 25000);
+ if (servoValue != 0 && servoValue > 1000 && servoValue <2000) {
+ middle = middle + servoValue ;
a++ ;
- Serial.print(a);
+#ifdef DEBUG
+ Serial.print(servoValue);
Serial.print(": ");
- Serial.println(ail);
+ Serial.println(middle / a);
+#endif
digitalWrite(ledPin, !digitalRead(ledPin));
- delay(10);
+ delay(100);
}
}
- Serial.println(">> Fine Calibrazione: ");
- Serial.print(ail / 10);
- Serial.println("--");
+#ifdef DEBUG
+ Serial.print(">> Fine Calibrazione, media: ");
+ Serial.println(middle / 10);
Serial.flush() ;
- return(ail / 10) ;
+#endif
+ return(middle / 10) ;
// END calibrazione
-}
+};
--- /dev/null
+/* Common
+ *
+ * Oggetti di uso comune
+ * Autore: Andrea Manni
+ *
+ * Link: http://git.andreamanni.com/
+ * Licenza: GPLv3
+ */
+
+#include "Arduino.h"
+#include "common.h"
+
+
+//////////////////////
+// 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
+// Serial.print(common - r);
+// Serial.print("-");
+// Serial.print(common - g);
+// Serial.print("-");
+// Serial.print(common - b);
+// while(1);
+
+};
+
+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
+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) {
+ /* 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.
+ */
+ const byte ledPin = 13;
+ pinMode(ledPin,OUTPUT);
+ byte a = 0;
+ int servoValue = 0;
+ int middle = 0;
+ Serial.println(">> Calibrazione: ");
+ while (a < 10) {
+ if (millis() > 10000) {
+ Serial.println(">> Calibrazione annullata a causa di assenza di seganle. \nAssicurarsi di accendere radio e ricevente \ne ripetere la procedura.");
+ middle = 15000; // Return value is divided by 10
+ break;
+ };
+ servoValue = pulseIn(pin, HIGH, 25000);
+ if (servoValue != 0 && servoValue > 1000 && servoValue <2000) {
+ middle = middle + servoValue ;
+ a++ ;
+ Serial.print(servoValue);
+ Serial.print(": ");
+ Serial.println(middle / a);
+ digitalWrite(ledPin, !digitalRead(ledPin));
+ delay(100);
+ }
+ }
+ Serial.print(">> Fine Calibrazione, media: ");
+ Serial.println(middle / 10);
+ Serial.flush() ;
+ return(middle / 10) ;
+// END calibrazione
+};
+
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 ();
byte lum(byte val);
-int calibraTrim(int pin, byte ledPin = 13);
+int calibraTrim(int pin, const byte ledPin = 13);
#endif
}
// Instanziamo un LED
-RGBLed led(11, 10,9); //Istanziamo un oggetto led (common catodo)
+RGBLed led(11, 10,9); //Istanziamo un oggetto led (default common catodo)
// facente parte della classe RGBLed
-//RGBLed led(10,9,11,255); // Inizializzazione Common anodo, valori invertiti
+// 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.White();
-
+ led.Red();
}
/* Colori disponibili:
Cyano
White
Yellow
+ Off
+ Rand = random
+ SetColor(byte r, byte g, byte b)
-Nota: per aggiungerne uno senza modificare la libreria originale
+Nota: per aggiungerne un colore senza modificare la libreria originale
si potrebbe usara l'ereditarieta': vedi esempio "eredita.ino" .
*/
* il minimo per un sequenziale e' 3 segmenti
- * questi possono essere messi in serie a 3 canali RGB
+ * questi si potrebbero mettere in serie a 3 canali RGB
* I segmenti posso essere ripetuti
* I segmenti posso essere messi in mirror (es. dal centro all'esterno per le ali)
* si puo' variare il rapporto tra accesi / spenti
Serve distinguere principalmente tra sopra e sotto, davanti e dietro. Secondariamente tra destra e sinistra.
Quindi prevalentemente usare il bianco per il sotto e per le estremita'.
-Il rosso essendo il secondo colore predominante si puo' usare per il sopra.
+Il rosso essendo il secondo colore predominante (purche' si disponga di LED con una luminosita' adeguata) si puo' usare per il sopra. In genere sui multicotteri su usa indicare in bianco il davanti e in rosso il dietro, gli aerei avendo un'unica direzione di movimento ed essendo sempre in movimento non danno problemi a identificarla direzione. Comunque si puo' usare una bussola digitale (vedi esempi) per indicare l'orientamento nei 3 assi dell'aereo.
Verde e blu per i lati.
-Per dare un'indicazione della direzione usare segmenti sequenziali: sotto l'aereo per indicare il moto orizzontale
+Per dare un'indicazione della direzione usare segmenti sequenziali: sotto l'aereo per indicare il moto orizzontale, la velocia' di aggiornamento puo' essere proporzionale al throttle. Per i tutt'ala (fusoliera corta) si puo ottenere effetto analogo con due segmenti in mirror dall'interno all'esterno delle ali.
+Il roll si puo' indicare con una striscia RGB per la lunghezza delle ali, un colore per il volo piatto, colori differenti per i roll (vedi esempi / ailerons_state_rgb ).
Hardware
=============
Sequenziali
- * il minimo per un sequenziale e' 3 segmenti * questi possono essere
- messi in serie a 3 canali RGB
+ * il minimo per un sequenziale e' 3 segmenti
+ ** questi potrebbero essere messi in serie ai 3 canali di un RGB
* I segmenti posso essere ripetuti
* I segmenti posso essere messi in mirror (es. dal centro all'esterno
per le ali)
Secondariamente tra destra e sinistra.
Quindi prevalentemente usare il bianco per il sotto e per le
- estremita'. Il rosso essendo il secondo colore predominante si puo'
- usare per il sopra. Verde e blu per i lati.
+ estremita'. Il rosso essendo il secondo colore predominante (purche' si
+ disponga di LED con una luminosita' adeguata) si puo' usare per il
+ sopra. In genere sui multicotteri su usa indicare in bianco il davanti
+ e in rosso il dietro, gli aerei avendo un'unica direzione di movimento
+ ed essendo sempre in movimento non danno problemi a identificarla
+ direzione. Comunque si puo' usare una bussola digitale (vedi esempi)
+ per indicare l'orientamento nei 3 assi dell'aereo. Verde e blu per i
+ lati.
Per dare un'indicazione della direzione usare segmenti sequenziali:
- sotto l'aereo per indicare il moto orizzontale
+ sotto l'aereo per indicare il moto orizzontale, la velocia' di
+ aggiornamento puo' essere proporzionale al throttle. Per i tutt'ala
+ (fusoliera corta) si puo ottenere effetto analogo con due segmenti in
+ mirror dall'interno all'esterno delle ali.
+
+ Il roll si puo' indicare con una striscia RGB per la lunghezza delle
+ ali, un colore per il volo piatto, colori differenti per i roll (vedi
+ esempi / ailerons_state_rgb ).
Hardware
projects / aerei / commitdiff