From 4f1a2108ba34533e92d1aa7e84328ea36df08f22 Mon Sep 17 00:00:00 2001 From: Andrea Manni Date: Thu, 9 Feb 2017 06:14:25 +0100 Subject: [PATCH] RGB ailerons corretto, snippet per lettura con pulsein. E stato cambiato la instanziazione di un oggetto rgb common cat in common, vedere se qualcuno la usa con 255. --- TODO | 11 + .../ailerons_state_rgb/ailerons_state_rgb.ino | 121 ++--- .../calibrazione_servo/calibrazione_servo.ino | 18 +- .../lettura_servo_ch_pulse.ino | 45 ++ libraries/common/common.cpp | 77 ++-- libraries/common/common.cpp_bak | 414 ++++++++++++++++++ libraries/common/common.h | 3 +- libraries/common/examples/rgb/rgb.ino | 13 +- pragmatica.rst | 7 +- pragmatica.txt | 23 +- 10 files changed, 614 insertions(+), 118 deletions(-) create mode 100644 esempi/snippets/lettura_servo_ch_pulse/lettura_servo_ch_pulse.ino create mode 100644 libraries/common/common.cpp_bak diff --git a/TODO b/TODO index 4acc144..43e0a49 100644 --- a/TODO +++ b/TODO @@ -1,3 +1,14 @@ +* 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) diff --git a/esempi/ailerons_state_rgb/ailerons_state_rgb.ino b/esempi/ailerons_state_rgb/ailerons_state_rgb.ino index 1f5e416..a147f0b 100644 --- a/esempi/ailerons_state_rgb/ailerons_state_rgb.ino +++ b/esempi/ailerons_state_rgb/ailerons_state_rgb.ino @@ -17,110 +17,82 @@ TODO: #include -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; @@ -132,16 +104,15 @@ sxin: 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; @@ -153,17 +124,17 @@ dxin: 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 } diff --git a/esempi/calibrazione_servo/calibrazione_servo.ino b/esempi/calibrazione_servo/calibrazione_servo.ino index 769905b..7e66708 100644 --- a/esempi/calibrazione_servo/calibrazione_servo.ino +++ b/esempi/calibrazione_servo/calibrazione_servo.ino @@ -6,21 +6,31 @@ 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 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 } diff --git a/esempi/snippets/lettura_servo_ch_pulse/lettura_servo_ch_pulse.ino b/esempi/snippets/lettura_servo_ch_pulse/lettura_servo_ch_pulse.ino new file mode 100644 index 0000000..f138c84 --- /dev/null +++ b/esempi/snippets/lettura_servo_ch_pulse/lettura_servo_ch_pulse.ino @@ -0,0 +1,45 @@ + +/* Lettura di un canale servo della RX + + Lettura tramite la finzione pulsein + Utilizzabile su qualunque PIN + +*/ + +#include + +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 +} diff --git a/libraries/common/common.cpp b/libraries/common/common.cpp index 1d9153b..de93b51 100644 --- a/libraries/common/common.cpp +++ b/libraries/common/common.cpp @@ -10,6 +10,7 @@ #include "Arduino.h" #include "common.h" +#define DEBUG_not ////////////////////// // RGB LED @@ -20,7 +21,7 @@ RGBLed::RGBLed(byte pinR, byte pinG, byte pinB) { redPin = pinR ; greenPin = pinG ; bluePin = pinB ; - common = 0 ; + common = 255 ; // Equvalente del Setup() per inizializzare i PIN pinMode(redPin, OUTPUT); @@ -46,46 +47,64 @@ void RGBLed::SetColor (byte r, byte g, byte b) { 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); }; @@ -356,7 +375,7 @@ byte lum(byte val) { }; -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 @@ -366,32 +385,40 @@ int calibraTrim(int pin, byte ledPin) { 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 -} +}; diff --git a/libraries/common/common.cpp_bak b/libraries/common/common.cpp_bak new file mode 100644 index 0000000..9392335 --- /dev/null +++ b/libraries/common/common.cpp_bak @@ -0,0 +1,414 @@ +/* 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 +}; + diff --git a/libraries/common/common.h b/libraries/common/common.h index 7f87600..9768961 100644 --- a/libraries/common/common.h +++ b/libraries/common/common.h @@ -54,6 +54,7 @@ class RGBLed { 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 (); @@ -157,7 +158,7 @@ void brilla(byte pin, int velocita = 200) ; byte lum(byte val); -int calibraTrim(int pin, byte ledPin = 13); +int calibraTrim(int pin, const byte ledPin = 13); #endif diff --git a/libraries/common/examples/rgb/rgb.ino b/libraries/common/examples/rgb/rgb.ino index 0dd3863..7e1026d 100644 --- a/libraries/common/examples/rgb/rgb.ino +++ b/libraries/common/examples/rgb/rgb.ino @@ -11,13 +11,13 @@ void setup() { } // 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: @@ -28,7 +28,10 @@ void loop() { 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" . */ diff --git a/pragmatica.rst b/pragmatica.rst index 5664066..ec08538 100644 --- a/pragmatica.rst +++ b/pragmatica.rst @@ -40,7 +40,7 @@ Sequenziali * 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 @@ -77,11 +77,12 @@ Orientamento 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 ============= diff --git a/pragmatica.txt b/pragmatica.txt index 8e6fa77..0b2032e 100644 --- a/pragmatica.txt +++ b/pragmatica.txt @@ -31,8 +31,8 @@ RGB 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) @@ -70,11 +70,24 @@ Orientamento 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 -- 2.39.2