]> git.piffa.net Git - aerei/commitdiff
RGB LED per alettoni
authorAndrea Manni <andrea@piffa.net>
Sun, 5 Feb 2017 01:15:56 +0000 (02:15 +0100)
committerAndrea Manni <andrea@piffa.net>
Sun, 5 Feb 2017 01:18:04 +0000 (02:18 +0100)
aerei/zeta/zeta/zeta.ino
aerei/zeta/zeta_prot/zeta_prot.ino
esempi/ailerons_state_rgb/ailerons_state_rgb.ino
esempi/calibrazione_servo/calibrazione_servo.ino [new file with mode: 0644]
libraries/common/common.cpp
libraries/common/common.h

index 9d0b2fa0eee907dc5add8544aa0c12994667d797..7d0fbdbe962f27ecd033686046a545812425a594 100644 (file)
@@ -1,6 +1,6 @@
-/* Zeta test
+/* Zeta
 
-Nota: rovedere i PWM per come calcolano le pause:
+Nota: rivedere i PWM per come calcolano le pause:
 non possono schendere sotto a 1ms
 */
 
@@ -13,18 +13,18 @@ enum states_available { // Stati della FMS
 states_available state  ;
 
 // Due LED con lampeggio alternato:
-Lampeggiatore right = 3;
+Lampeggiatore right = 3; // Lampeggiatori superiori a lato fusoliera
 Lampeggiatore left = 5;
-const byte rtail = 6;
+const byte rtail = 6; // Luci del motore posteriore
 const byte ltail = 9;
-const byte thrPin = A3;
+const byte thrPin = A3; 
 byte pausa ;
 byte thr ;
 int thrIn ;
 
-Pwm rwhite = 3;
-Pwm lwhite = 5;
-Pwm rtp = 6 ;
+Pwm rwhite = 3; // PWM sui lampeggiatori
+Pwm lwhite = 5; 
+Pwm rtp = 6 ;   // PWM sulla coda
 Pwm ltp = 9 ;
 
 RGBLed rgb(7,8,4,255);
@@ -52,7 +52,6 @@ void loop() {
 
   thrIn = pulseIn(thrPin, HIGH, 25000);
   thr = constrain(map(thrIn, 983, 2000, 0, 255), 0, 255) ;
-  // Inserire necro delay
   delay(10); // Se si abilita il serial debug
   // togliere il delay
 
@@ -70,7 +69,7 @@ void loop() {
     rgb.Green();
     
       rwhite.UD(2000);  // Utilizza il coseno
-      lwhite.UD(2000);  // Bisognerebbe evitare di calcolarlo 4 volte uguale
+      lwhite.UD(2000);  // Bisognerebbe evitare di calcolarli 4 volte uguale
       ltp.shift = 500;
       ltp.lUp(1000);
       rtp.lUp(1000);
index 1927f1b1532dd98edbc37d38292b497098db9f6f..7243b22c7805a11b8f8c4427adb138a95b50b9a5 100644 (file)
@@ -1,6 +1,7 @@
 /* Zeta prototipo
 
-   Sketch da breadboard, il throttle e' simulato con un potenziometro.
+   Sketch da breadboard, il throttle e' simulato con un potenziometro
+   o con una RX.
 
 */
 
index 0c188ee6fa2381cbd0d6e4604dc4cfb28b42fd1d..1ec982e1b31a2f9d43dead0ee45031afc49368c7 100644 (file)
@@ -7,19 +7,22 @@ Pilotare un LED RGB in base al canale degli alettoni:
 - roll a sx
 - roll a dx
 
-Trasizioni per accentuare il cambio di assetto (ad esempio con dei blink
-e introdurre un po' di inerzia temporale per il cambio di stato
+NOTE: uso di goto all'interno dell FSM.
+
+TODO:
+
+* clean up magic numbers
 
 */
 
 #include <common.h>
 
 enum  { // Stati della FMS
-  middle,   // centrale
-  sxin,     // transizione a sx
-  sx,       // sx
-  dxin,     // transizione a dx
-  dx        // dx
+    middle,   // centrale
+    sxin,     // transizione a sx
+    sx,       // sx
+    dxin,     // transizione a dx
+    dx        // dx
 } ailstate  = middle;
 
 // Un LED RGB
@@ -27,82 +30,138 @@ RGBLed ailerons(11,10,9);
 
 const byte ailPin = A4;
 int ail ; // Valore a 8bit per ailerons
-int ailIn ; // Valore rilevato del 4 Ch della RX 
+int ailIn ; // Valore rilevato del 4 Ch della RX
 
 
+unsigned long now; // timestamp reference for millis
+unsigned long pausa = 1000;
 
-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.
-*/
+int mid_point = 1500 ; // centro del segnale, trimmato nel setup
+const int deviation = 50 ; // deviazione per entrare nello stato succiessivo
 
-  Serial.begin(9600);
+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
+
+    // Funzione relativa a calibrazione:
+//mid_point =  calibraTrim(ailPin) ; // Pin a cui e' collegato il canale
+//mid_point =  calibraTrim(aliPin,11) ; // + LED di servizio per calibrazione
 }
 
 void loop() {
 
- // Lettura Aileron channel: FAKE con un potenziometro
- //ailIn = analogRead(3);
- //ail = constrain(aliIn / 4 , 0, 255) ;
-
- // 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 > 1600) { ailstate = sxin; } ;
-       if (ail < 1400) { ailstate = dxin; } ;
-       ailerons.White();
-
-     break;
-
-   case sxin:
-   // Transizione a sx
-       ailerons.Off();
-       delay(1000);
-       ailstate = sx;
-     break;
-
-   case sx:
-   // dx
-       ailerons.Green();
-       if (ail < 1600) { ailstate = middle; } ;
-       if (ail < 1400) { ailstate = dxin; } ;
-     break;
-
-   case dxin:
-   // Transizione a dx
-       ailerons.Off();
-       delay(1000);
-       ailstate = dx;
-     break;
-
-   case dx:
-   // sx
-       ailerons.Blue();
-       if (ail > 1400) { ailstate = middle; } ;
-       if (ail > 1600) { ailstate = dxin; } ;
-     break;
-  }
-
-  Serial.print("ailIn: ");
-  Serial.print(ailIn);
-  Serial.print("\tail: ");
-  Serial.print(ail);
-  Serial.print("\t ailstate:");
-  Serial.println(ailstate);
-  //  delay(200);
- }
+// Lettura Aileron channel: FAKE con un potenziometro 10K
+//ailIn = analogRead(3);
+//ail = constrain(aliIn * 2 , 0, 2000) ;
+
+// 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) {
+            ailstate = sxin;
+            now = millis() ;
+            goto sxin ;
+        }
+        else if (ail < mid_point - deviation - deviation / 3) {
+            ailstate = dxin;
+            now = millis() ;
+            goto dxin ;
+        } ;
+        ailerons.White();
+
+        break;
+
+    case sxin:
+sxin:
+        // Transizione a sx
+        ailerons.Off();
+        if (millis() - pausa > now ) {
+            ailstate = sx;
+        }
+        break;
+
+    case sx:
+        // dx
+        ailerons.Green();
+        if (ail < mid_point + deviation) {
+            ailstate = middle;
+        }
+        else if (ail < mid_point - deviation) {
+            ailstate = dxin;
+        } ;
+        break;
+
+    case dxin:
+        // Transizione a dx
+dxin:
+        ailerons.Off();
+        if (millis() - pausa > now ) {
+            ailstate = dx;
+        }
+        break;
+
+    case dx:
+        // sx
+        ailerons.Blue();
+        if (ail > mid_point - deviation) {
+            ailstate = middle;
+        }
+        else if (ail > mid_point + deviation) {
+            ailstate = dxin;
+        } ;
+        break;
+    }
+
+    Serial.print("ailIn: ");
+    Serial.print(ailIn);
+    Serial.print("\tail: ");
+    Serial.print(ail);
+    Serial.print("\t ailstate:");
+    Serial.println(ailstate);
+    //  delay(200);
+}
diff --git a/esempi/calibrazione_servo/calibrazione_servo.ino b/esempi/calibrazione_servo/calibrazione_servo.ino
new file mode 100644 (file)
index 0000000..769905b
--- /dev/null
@@ -0,0 +1,28 @@
+/* Calibrazione Trim servo
+
+   Esempio su come calibrare il segnale di un servo.
+   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.
+
+*/
+
+#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
+
+    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
+}
+
+void loop() {
+}
index 01f07cfffe1cfac49bde493fc59b02cb3d3100b1..413b86f4d0e9302bcdbc94328ddc5ff9c39bc0be 100644 (file)
@@ -355,3 +355,39 @@ byte lum(byte val) {
     // storata in SRAM
 return pgm_read_byte_near(BCORRECT + val);
 };
+
+
+int calibraTrim(int pin, 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.
+ */
+    byte a             = 0;
+       int ail         = 0;
+       int ailIn       = 0;
+    Serial.println(">> Calibrazione: ");
+    while (a < 10) {
+        ailIn = pulseIn(pin, HIGH, 25000);
+        if (ailIn != 0 ) {
+            ail = ail + ailIn ;
+            a++ ;
+            Serial.print(a);
+            Serial.print(": ");
+            Serial.println(ail);
+            digitalWrite(ledPin, !digitalRead(ledPin));
+            delay(10);
+        }
+    }
+    Serial.print(">> Fine Calibrazione: ");
+    Serial.print(ail / 10);
+    Serial.println("--");
+       Serial.flush() ;
+    return(ail / 10) ;
+// END calibrazione
+}
+
index 97893fcd75d1b68e23de76d079a9e74be417fb1b..7f87600b466749d4a3476037c691ce2df212fdeb 100644 (file)
@@ -154,6 +154,10 @@ class Sequenza {
 // Funzioni
 
 void brilla(byte pin, int velocita = 200) ;
-#endif
 
 byte lum(byte val);
+
+int calibraTrim(int pin, byte ledPin = 13);
+
+
+#endif