Fabrice Teissier

22 juillet 2019

Va voir par là:

2 juillet 2019

@dragonlost Cool ! Impatient de connaître la suite...

2 juillet 2019

@dragonlost Wouha... Impressionné je suis ! Bravo pour ces trois cartes !

Moi même sur le chemin de la nafabox et en attendant de finaliser mon flip flat et des retours sur la nouvelle Raspberry Pi4, je fais le tour des accessoires nécessaires à un setup complet. Je dois dire que ta carte nafabox alim board me fait de l'oeil.

N'existe-il pas une doc un peu plus explicative concernant cette carte ? Le lien vers EasyEDA est très intéressant mais cela manque un peu d'explications.

Il semblerait que cette carte gère aussi des résistances anti-buée.

En tout cas, elle me plait bien...

Encore bravo !

26 juin 2019

Petite question à ceux qui ont opté pour des bandes LED plutôt que des panneaux EL :

N'avez-vous pas de problème d'uniformité lumineuse sur le plexi ? Du genre vignettage inversé...

25 juin 2019

Je crois qu’ils n’ont pas le même ship USB

25 juin 2019

@ursus Ça ne viendrait pas du fameux petit délai à mettre devant le 1er « if » de la routine void handelserial ?

Voir le lien proposé par cedric02700 en haut de cette page.

23 juin 2019

Voilà la dernière version du code documenté là ou je suis sur de ce qui se passe.

Révélation


 

#include <Arduino.h>
#include <Servo.h>
 
 
Servo ServoCapot;// Assignation du servo Capot
Servo ServoRotation;// Assignation du servo Rotation
Servo ServoTranslation;// Assignation du servo Translation

const int btn_capot = A0;//Bouton de commande d'ouverture et fermeture du capot
const int btn_voltmetre = A2;//Bouton pour vérifier l'état des piles
const int btn_ELpan = A1;//Bouton de commande du panneau lumineux
const int btn_park = A5;//Switch d'ouverture neutralisant la sécu de fermeture auto pour démontage
const int ctc_capot_ouvert = A3;//Contacteur de position ouvert
const int ctc_capot_ferme = A4;//Contacteur de position fermé

const int led_1 = 4;//Visu du niveau du panneau lumineux en commande local et niveau de piles
const int led_2 = 5;
const int led_3 = 6;
const int led_4 = 7;
const int ELpan = 3;//Panneau lumineux

const int relais_ELpan = 13;//Relais d'alimentation du panneau lumineux
const int relais_secu = 8;//Relais d'alimentation secours par les piles
const int relais_servo = 12;//Relais d'alimentation des servos


int AngleServoCapot= 0;// Angle du servo capot lorsque le capot est fermé
int AngleServoRotation= 137;// Angle du servo rotation lorsque le capot est fermé
int AngleServoTranslation= 47;// Angle du servo translation lorsque le capot est fermé
int compte_btn_ELpan = 0; // Variable du nombre qui sera incrémenté et décrémenté lors de l'appui du bouton ELpan
int etat_btn_ELpan = LOW; // Variable de lecture de l'état du bouton ELpan (un seul à la fois donc une variable suffit)
int etatprecedent_btn_ELpan = LOW; // Variable de l'état précèdent du bouton ELpan. Relâché par défaut
int real_vin(); // Variable de la tension mesuré par le voltmetre

const byte BROCHE_CAPTEUR_VIN = A7; // Le numéro de broche analogique pour la mesure de la tension en VIN
const float COEFF_PONT_DIVISEUR_VIN = 1.95; // Coefficient diviseur du pont de résistance et calibration du voltmetre
String commande;


 //Alnitak init
int brightness = 0;// Variable de la puissance lumineuse de l'ELpan (0-255). Eteind par défaut

enum devices // Variable définissant le modèle du Flip flat Alnitak
{
  FLAT_MAN_L = 10,
  FLAT_MAN_XL = 15,
  FLAT_MAN = 19,
  FLIP_FLAT = 99
};

enum motorStatuses // Variable définissant le statu des servo
{
  STOPPED = 0,
  RUNNING
};

enum lightStatuses // Variable définissant l'état du panneau EL (off-on)
{
  OFF = 0,
  ON
};

enum coverStatuses // Variable définissant la position du capot
{
  UNKNOWN = 0, // ie not open or closed...could be moving
  CLOSED,
  OPEN
};

// Ecriture par défaut de l'état des variables à l'allumage
int deviceId = FLIP_FLAT;
int motorStatus = STOPPED;
int lightStatus = OFF;
int coverStatus = UNKNOWN;

    
void setup()// Routine setup au démarrage
{
    Serial.begin(9600);// Réglage du débit de la communication série
    
    ServoCapot.attach(9, 500, 2475); // Le servo capot est branché à la pin 9 avec réglage du débattement
    ServoRotation.attach(10, 500, 2475); // Le servo rotation est branché à la pin 10 avec réglage du débattement
    ServoTranslation.attach(11, 500, 2475); // Le servo translation est branché à la pin 11 avec réglage du débattement

    ServoCapot.write(AngleServoCapot);// On positionne le servo capot à la valeur définie dans la variable (0°)
    ServoRotation.write(AngleServoRotation);// On positionne le servo rotation à la valeur définie dans la variable (137°)
    ServoTranslation.write(AngleServoTranslation);// On positionne le servo translation à la valeur définie dans la variable (47°)

    // Définition des entrées/sorties
    pinMode(btn_capot,INPUT);     
    pinMode(btn_voltmetre,INPUT);
    pinMode(btn_ELpan, INPUT);
    pinMode(btn_park, INPUT);
    pinMode(ctc_capot_ouvert, INPUT);
    pinMode(ctc_capot_ferme, INPUT);    
    pinMode(led_1, OUTPUT);
    pinMode(led_2, OUTPUT);
    pinMode(led_3, OUTPUT);
    pinMode(led_4, OUTPUT);
    pinMode(ELpan, OUTPUT);
    pinMode(relais_ELpan, OUTPUT);
    pinMode(relais_secu,OUTPUT);   
    pinMode(relais_servo,OUTPUT);   

    attachInterrupt(digitalPinToInterrupt(2), secu, FALLING);// Fonction de détection de la chute de tension déclenchant l'alimentation secours
    
}
 
unsigned int analogReadReference(void) // Mesure la référence interne à 1.1 volts
{
  
// Elimine toutes charges résiduelles
#if defined(__AVR_ATmega328P__)
    ADMUX = 0x4F;
#elif defined(__AVR_ATmega2560__)
    ADCSRB &= ~(1 << MUX5);
    ADMUX = 0x5F;
#elif defined(__AVR_ATmega32U4__)
    ADCSRB &= ~(1 << MUX5);
    ADMUX = 0x5F;
#endif
    delayMicroseconds(5);
  
// Sélectionne la référence interne à 1.1 volts comme point de mesure, avec comme limite haute VCC
#if defined(__AVR_ATmega328P__)
    ADMUX = 0x4E;
#elif defined(__AVR_ATmega2560__)
    ADCSRB &= ~(1 << MUX5);
    ADMUX = 0x5E;
#elif defined(__AVR_ATmega32U4__)
    ADCSRB &= ~(1 << MUX5);
    ADMUX = 0x5E;
#endif
    delayMicroseconds(200);

  
  ADCSRA |= (1 << ADEN); // Active le convertisseur analogique -> numérique
  
  ADCSRA |= (1 << ADSC); // Lance une conversion analogique -> numérique
  
  while(ADCSRA & (1 << ADSC)); // Attend la fin de la conversion
  
  return ADCL | (ADCH << 8); // Récupère le résultat de la conversion
}

void loop() // Routine principale
{           
if (digitalRead(ctc_capot_ouvert) == HIGH)// Si le contacteur du capot ouvert est ON
    {
    coverStatus = OPEN; // On écrit que la variable coverStatus est OPEN
    }
    
if (digitalRead(ctc_capot_ferme) == HIGH)// Si le contacteur du capot fermé est ON
    {
    coverStatus = CLOSED;  // On écrit que la variable coverStatus est CLOSED
    }

handleSerial();// On joue la sous routine handelSerial servant à communiquer en USB avec l'ordinateur

// Fonctions d'Ouverture Fermeture du capot en local 
if((digitalRead(btn_capot) == HIGH) && (digitalRead(ctc_capot_ouvert) == HIGH) && (digitalRead(btn_park) == LOW))// Si on appuit sur le bouton capot et que le contacteur du capot ouvert est ON et que le switch park est OFF
    {
    fermeture(); // On joue la sous-routine fermeture
    }
    
if((digitalRead(btn_capot) == HIGH) && (digitalRead(ctc_capot_ferme) == HIGH) && (digitalRead(btn_park) == LOW))// Si on appuit sur le bouton capot et que le contacteur du capot fermé est ON et que le switch park est OFF
    {    
    ouverture(); // On joue la sous-routine ouverture
    }
    
if((digitalRead(btn_park) == HIGH) && (digitalRead(ctc_capot_ferme) == HIGH)) // Si le switch park est ON et que le contacteur du capot fermé est ON
    {      
    ouverture(); // On joue la sous-routine ouverture
    }

 // Fonction de Fermeture automatique en cas de coupure de courant 
if (digitalRead(relais_secu)==(HIGH))// Si le relais sécu est ON
    {  
     if (digitalRead(ctc_capot_ouvert) == HIGH)// Et que le contacteur du capot ouvert est ON
        {
        fermeture();// On joue la sous-routine fermeture
        }
        
     if(digitalRead(ctc_capot_ferme) == HIGH)// Au retour de la sous-routine fermeture, on controle l'état du contacteur du capot fermé et si il est ON
        {    
        delay(1000); // On attend 1s   
        digitalWrite(relais_secu,LOW);// On éteind le relais sécu
        }    
    }
  
 

// Fonction du control local du panneau EL
etat_btn_ELpan = digitalRead(btn_ELpan);// On indique à la variable l'état du bouton ELpan

if (etat_btn_ELpan != etatprecedent_btn_ELpan) // si l'état du bouton a changé
    {
    if (etat_btn_ELpan == HIGH) // et qu'il est haut (= on appuie dessus)
        {
        compte_btn_ELpan++; // on incrémente le compteur
        if (compte_btn_ELpan > 5) // sauf s'il a dépassé 5...
            {
            compte_btn_ELpan = 0; // ...auquel cas on le réinitialise
            }
        }
    }
    
progELpan(); // on execute la sous-routine progELpan
etatprecedent_btn_ELpan = etat_btn_ELpan; // Au retour de la sous-routine progELpan on stocke l'état du bouton pour le prochain tour 
         

 
// Fonction du Voltmetre : control local du niveau des piles 9v
if (digitalRead(btn_voltmetre) == HIGH)// Si le bouton du voltmetre est appuyé
    {
     delay(100);// On attend 100ms
     voltmetre(); // On execute la sous-routine volmetre
    }
    
else// Si non et au retour de la sous routine-voltmetre on s'assure d'éteindre les LED
    {
     analogWrite(led_1,0);
     analogWrite(led_2,0);
     analogWrite(led_3,0);
     analogWrite(led_4,0);
    }
} 

void ouverture() // Sous-routine ouverture capot
{ 
if (compte_btn_ELpan >= 1)// Si le panneau EL est allumé
    {
    compte_btn_ELpan = 0; // On l'éteind          
    analogWrite(led_1,0);
    analogWrite(led_2,0);
    analogWrite(led_3,0);
    analogWrite(led_4,0);
    analogWrite(ELpan,0);
    digitalWrite(relais_ELpan,LOW);
    Serial.println("EL panel éteind");  
    }
  
digitalWrite(relais_servo,HIGH);// On allume le relais d'alimentation des servo
delay(500); // On attend 500ms
motorStatus = RUNNING; // On indique que le statu des moteurs est RUNNING
coverStatus = UNKNOWN; // On indique que le statu du capot est UNKNOWN
  
while(!(((AngleServoTranslation)==(137))))// Jusqu'a ce que le servo translation soit à 137°
    {
    ServoTranslation.write((AngleServoTranslation) + (1)); // On lui demande d'avancer de 1°
    AngleServoTranslation += 1;// On ajoute 1° à la variable de la position translation
    delay(20);//_delay(0.02);//Réglage de la vitesse du servo
    }
       
delay(1000);// On attend 1s
        
while(!(((AngleServoCapot)==(180))))// Jusqu'a ce que le servo capot soit à 180°
    {
    ServoCapot.write((AngleServoCapot) + (1));  // On lui demande d'avancer de 1°
    AngleServoCapot += 1;// On ajoute 1° à la variable de la position capot
    delay(20);//_delay(0.02);//Réglage de la vitesse du servo
    }
        
delay(1000);// On attend 1s

while(!(((AngleServoRotation)==(47))))// Jusqu'a ce que le servo rotation soit à 47°
    {
    ServoRotation.write((AngleServoRotation) - (1));  // On lui demande de reculer de 1°
    AngleServoRotation += -1; // On soustrait 1° à la variable de la position rotation
    delay(20);//_delay(0.02);//Réglage de la vitesse du servo
    }
    
delay(500); // On attend 500ms
  
if (digitalRead(ctc_capot_ouvert) == HIGH)// On controle que l'état du capteur du capot ouvert est bien en position ON
    {
    digitalWrite(relais_servo,LOW);// On éteind le relais d'alimentation des servo
    motorStatus = STOPPED; // On indique que le statu des moteurs est STOPPED   
    coverStatus = OPEN; // On indique que le statu du capot est OPEN   
    } 
}
 
 void fermeture() // Sous-routine fermeture capot 
{ 
digitalWrite(relais_servo,HIGH);
motorStatus = RUNNING; // On indique que le statu des moteurs est RUNNING
coverStatus = UNKNOWN; // On indique que le statu du capot est UNKNOWN
delay(500);  // On attend 500ms
  
while(!(((AngleServoRotation)==(137))))// Jusqu'a ce que le servo rotation soit à 137°
    {
    ServoRotation.write((AngleServoRotation) + (1));   // On lui demande d'avancer de 1°
    AngleServoRotation += 1;// On ajoute 1° à la variable de la position rotation
    delay(20);// _delay(0.02);//Réglage de la vitesse du servo
    }

delay(1000);// On attend 1s

while(!(((AngleServoCapot)==(0))))// Jusqu'a ce que le servo capot soit à 0°
    {
    ServoCapot.write((AngleServoCapot) - (1));  // On lui demande de reculer de 1°
    AngleServoCapot += -1; // On soustrait 1° à la variable de la position capot
    delay(20);// _delay(0.02);//Réglage de la vitesse du servo
    }

delay(1000);// On attend 1s

while(!(((AngleServoTranslation)==(47))))// Jusqu'a ce que le servo translation soit à 47°
    {
    ServoTranslation.write((AngleServoTranslation) - (1));  // On lui demande de reculer de 1°
    AngleServoTranslation += -1; // On soustrait 1° à la variable de la position translation
    delay(20);// _delay(0.02);//Réglage de la vitesse du servo
    }
    
delay(500);// On attend 500ms
  
if (digitalRead(ctc_capot_ferme) == HIGH)// On controle que l'état du capteur du capot fermé est bien en position ON
    {
    digitalWrite(relais_servo,LOW);// On éteind le relais d'alimentation des servo
    motorStatus = STOPPED; // On indique que le statu des moteurs est STOPPED   
    coverStatus = OPEN; // On indique que le statu du capot est OPEN   
    }    
}
 
void handleSerial() // Communication usb/serie protocol Alnitak
{

if( Serial.available() >= 5 )  // all incoming communications are fixed length at 6 bytes including the \n
    {
    char* cmd;
    char* data;
    char temp[10];   
    int len = 0;
    char str[20];
    memset(str, 0, 20);
    Serial.readBytesUntil('\n', str, 20);  
    cmd = str + 1;
    data = str + 2;

    if( false ) // useful for debugging to make sure your commands came through and are parsed correctly.
       {
       sprintf( temp, "cmd = >%s%s;", cmd, data);
       Serial.println(temp);
       } 

    switch( *cmd )
       {
      case 'P':// Ping device
      sprintf(temp, "*P%d000\n", deviceId);
      Serial.print(temp);
      break;

      case 'O': // Open shutter
      sprintf(temp, "*O%d000\n", deviceId);
      Serial.print(temp); 
      analogWrite(ELpan,0);// On éteind le panneau EL
      digitalWrite(relais_ELpan,LOW);// On éteind le relais d'alimentation du panneau EL
      lightStatus = OFF; // On indique que le statu du panneau EL est OFF
      ouverture(); // On joue la sous-routine ouverture
      motorStatus = STOPPED; // On indique que le statu des moteurs est STOPPED   
      coverStatus = OPEN; // On indique que le statu du capot est OPEN   
      Serial.print(temp); 
      break;

      case 'C':// Close shutter
      sprintf(temp, "*C%d000\n", deviceId); 
      Serial.print(temp);  
      fermeture(); // On joue la sous-routine fermeture     
      compte_btn_ELpan = 0;// On met la variable du compteur du bouton ELpan à 0. Cela évite que le panneau se rallume si il était resté en position ON avant l'ouverture
      motorStatus = STOPPED; // On indique que le statu des moteurs est STOPPED   
      coverStatus = CLOSED; // On indique que le statu du capot est OPEN   
      Serial.print(temp);  
      break;

      case 'L':// Turn light on
      sprintf(temp, "*L%d000\n", deviceId);
      Serial.print(temp);
      compte_btn_ELpan = 5;// On met la variable du compteur du bouton ELpan à 5. Etat du bouton spécifique à la commande du panneau EL par la commande usb/série
      digitalWrite(relais_ELpan,HIGH);// On allume le relais ELpan
      lightStatus = ON;  // On indique que le statu du du panneau EL est ON
      break;

      case 'D':// Turn light off
      sprintf(temp, "*D%d000\n", deviceId);
      Serial.print(temp);
      lightStatus = OFF;lightStatus = ON;  // On indique que le statu du du panneau EL est OFF
      compte_btn_ELpan = 0;// On met la variable du compteur du bouton ELpan à 0. Ce qui éteind le panneau EL et son relais d'alimentation.
      break;

      case 'B':// Set brightness
      brightness = atoi(data);    
      if( lightStatus == ON )  // Si le statu du panneau lumineus est ON
      sprintf( temp, "*B%d%03d\n", deviceId, brightness );
      Serial.print(temp);
      analogWrite(ELpan,brightness);// On écrite la valeur de la luminosité dans la variable brightness
      break;

      case 'J':// Get brightness
      sprintf( temp, "*J%d%03d\n", deviceId, brightness);
      Serial.print(temp);
      break;
      
      case 'S':// Get device status    
      sprintf( temp, "*S%d%d%d%d\n",deviceId, motorStatus, lightStatus, coverStatus);
      Serial.print(temp);
      break;

      case 'V': // get firmware version
      sprintf(temp, "*V%d001\n", deviceId);
      Serial.print(temp);
      break;
        }    
    
    while( Serial.available() > 0 )
    Serial.read();

     }
}

void progELpan() // Sous-routine de commande du panneau EL en mode local
{
if ((compte_btn_ELpan >= 1) && (digitalRead(ctc_capot_ferme) == HIGH))// Si le compteur du bouton ELpan est supérieur ou égal à 1
     {
     digitalWrite(relais_ELpan,HIGH); // on allume le relais d'alimentation du panneau EL
     }
     
else // Si non
     {
     digitalWrite(relais_ELpan,LOW); // on eteind le relais d'alimentation du panneau EL
     } 
     
if (compte_btn_ELpan == 0)// Si le compteur du bouton ELpan est égal à 0
     {
     analogWrite(led_1,0);// On éteind toutes les LED
     analogWrite(led_2,0);
     analogWrite(led_3,0);
     analogWrite(led_4,0);
     analogWrite(ELpan,0);// On éteind le panneau EL
     digitalWrite(relais_ELpan,LOW); // on eteind le relais d'alimentation du panneau EL
     } 

if ((compte_btn_ELpan == 1) && (digitalRead(ctc_capot_ferme) == HIGH))// Si le compteur du bouton ELpan est égal à 1 et que le capteur de position du capot fermé est ON
     {
     analogWrite(led_1,255);// On allume la LED n°1
     analogWrite(led_2,0);
     analogWrite(led_3,0);
     analogWrite(led_4,0);
     analogWrite(ELpan,27);// On allume le panneau EL à une valeur de 27/255
     }
     
if ((compte_btn_ELpan == 2) && (digitalRead(ctc_capot_ferme) == HIGH))// Si le compteur du bouton ELpan est égal à 2 et que le capteur de position du capot fermé est ON
     {
     analogWrite(led_1,255);// On allume la LED n°1
     analogWrite(led_2,255);// On allume la LED n°2
     analogWrite(led_3,0);
     analogWrite(led_4,0);
     analogWrite(ELpan,50);// On allume le panneau EL à une valeur de 50/255
     }
     
if ((compte_btn_ELpan == 3) && (digitalRead(ctc_capot_ferme) == HIGH))// Si le compteur du bouton ELpan est égal à 3 et que le capteur de position du capot fermé est ON
     {
     analogWrite(led_1,255);// On allume la LED n°1
     analogWrite(led_2,255);// On allume la LED n°2
     analogWrite(led_3,255);// On allume la LED n°3
     analogWrite(led_4,0);
     analogWrite(ELpan,90);// On allume le panneau EL à une valeur de 90/255
     }
     
if ((compte_btn_ELpan == 4) && (digitalRead(ctc_capot_ferme) == HIGH))// Si le compteur du bouton ELpan est égal à 4 et que le capteur de position du capot fermé est ON
     {
     analogWrite(led_1,255);// On allume la LED n°1
     analogWrite(led_2,255);// On allume la LED n°2
     analogWrite(led_3,255);// On allume la LED n°3
     analogWrite(led_4,255);// On allume la LED n°4
     analogWrite(ELpan,255);// On allume le panneau EL à une valeur de 255/255
     }
     
if ((compte_btn_ELpan == 5) && (digitalRead(ctc_capot_ferme) == HIGH))// Si le compteur du bouton ELpan est égal à 5 et que le capteur de position du capot fermé est ON
     {
     analogWrite(ELpan,brightness);// On allume le panneau EL à une valeur envoyé par la liaison usb/série
     }   
}

void voltmetre() // Sous-routine voltmetre
{
// Mesure la tension en VIN et la référence interne à 1.1 volts
unsigned int raw_vin = analogRead(BROCHE_CAPTEUR_VIN);
unsigned int raw_ref = analogReadReference();
  
// Calcul de la tension réel avec un produit en croix
float real_vin = ((raw_vin * 1.1) / raw_ref) * COEFF_PONT_DIVISEUR_VIN;
  
if (real_vin >= 6)// Si la tension mesurée est supérieur ou égale à 6v
     {
     analogWrite(led_1,255);// On allume la LED n°1
     analogWrite(led_2,0);
     analogWrite(led_3,0);
     analogWrite(led_4,0);
     }
     
if (real_vin >= 7)// Si la tension mesurée est supérieur ou égale à 7v
     {
     analogWrite(led_1,255);// On allume la LED n°1
     analogWrite(led_2,255);// On allume la LED n°2
     analogWrite(led_3,0);
     analogWrite(led_4,0);
     }
     
if (real_vin >= 8)// Si la tension mesurée est supérieur ou égale à 8v
     {
     analogWrite(led_1,255);// On allume la LED n°1
     analogWrite(led_2,255);// On allume la LED n°2
     analogWrite(led_3,255);// On allume la LED n°3
     analogWrite(led_4,0);
     }
     
if (real_vin >= 9)// Si la tension mesurée est supérieur ou égale à 8v
     {
     analogWrite(led_1,255);// On allume la LED n°1
     analogWrite(led_2,255);// On allume la LED n°2
     analogWrite(led_3,255);// On allume la LED n°3
     analogWrite(led_4,255);// On allume la LED n°4
     }
  
delay(1000);// On attend 1s
}

void secu() // Sous-routine Secu fermeture automatique si coupure de courant 
{  
if (digitalRead(btn_park) == LOW)// Si le switch park est en position LOW
     {
     digitalWrite(relais_secu,HIGH);// On allume le relais d'alimentation secours
     }
}

23 juin 2019

Ah... Ça c’es Vraiment cool !

Je vais tacher de le documenter un peu plus, du coup, pour que ce soit un peu plus clair pour toi.

23 juin 2019

@Alarcon yves heu... Merci pour cette leçon de délais mais je croit que ça commence à dépasser mes compétences en programmation 😱

Mon « problème » effectivement, c’est que j’en ai mis partout et je ne vois pas comment arriver à les remplacer tous avec ce que tu proposes 😳

je croyais l’arduino monotache, c’est à dire que lorsqu’il joue une routine void, il ne fait rien d’autre avant la fin de son exécution et qu’ensuite seulement il revient dans loop pour continuer sa boucle de programme. Donc peu importe les délais dans les routines void. Je veux dire par là que je pensais que les délais dans un void n’affectaient pas les autres void.

Donc ma question : dois je réécrire tous mes délais de chaque routine avec millis() ou avec la lib. MsTimer2 ? Et dans ce cas, c’est mort. Je ne m’en sens pas capable et du coup, tant pis, il y aura des Time Out.

Ou bien dois je seulement modifier les délais dans la routine void handelSerial() ? Un peu plus accessible pour moi 😅

22 juin 2019

@gehelem Encore merci !

Effectivement, je n'ai plus d'erreur en écrivant directement les commandes. Mais cela ne change toujours rien.

J'ai toujours ces time out.

Ce que je remarque, c'est qu'a aucun moment, les statuts du capot et moteur sont en UNKNOWN ou RUNNING dans la fenêtre de contrôle INDI.

Le moteur est toujours STOPPED et le capot soit OPEN ou CLOSED.

Est-ce normal ?

22 juin 2019

@gehelem Merci pour ces infos.

Concernant le handshake, j'ai résolu le problème avec mon nano en dessoudant un micro-condensateur sur sa carte.

J'ai essayé de placer les motorStatus et coverStatus là ou tu me dis de les placer dans mes routines d'ouverture et fermeture mais cela ne change rien. Mais j'ai toujours un time out en fin d'ouverture et de fermeture.

Voilà la dernière version du code:

Révélation


 

#include <Arduino.h>
#include <Servo.h>
 
 
Servo ServoCapot;
Servo ServoRotation;
Servo ServoTranslation;

const int btn_capot = A0;//Bouton de commande d'ouverture et fermeture du capot
const int btn_voltmetre = A2;//Bouton pour vérifier l'état des plies
const int btn_ELpan = A1;//Bouton de commande du panneau lumineux
const int btn_park = A5;//Switch d'ouverture neutralisant la sécu de fermeture auto pour démontage
const int ctc_capot_ouvert = A3;//Contacteur de position ouvert
const int ctc_capot_ferme = A4;//Contacteur de position fermé

const int led_1 = 4;//Visu du niveau du panneau lumineux en commande local et niveau de piles
const int led_2 = 5;
const int led_3 = 6;
const int led_4 = 7;
const int ELpan = 3;//Panneau lumineux

const int relais_ELpan = 13;//Relais d'alimentation du panneau lumineux
const int relais_secu = 8;//Relais d'alimentation secours par les piles
const int relais_servo = 12;//Relais d'alimentation des servos


int AngleServoCapot= 0;
int AngleServoRotation= 137;
int AngleServoTranslation= 47;
int reception;
int compte_btn_ELpan = 0; // le nombre qui sera incrémenté et décrémenté
int etat_btn_ELpan = LOW; // lecture de l'état des boutons (un seul à la fois donc une variable suffit)
int etatprecedent_btn_ELpan = LOW; // état relâché par défaut
int real_vin(); // Variable de la tension mesuré par le voltmetre

const byte BROCHE_CAPTEUR_VIN = A7; // Le numéro de broche analogique pour la mesure de la tension en VIN
const float COEFF_PONT_DIVISEUR_VIN = 1.95; // Coefficient diviseur du pont de résistance
String commande;


 //Alnitak init
int brightness = 0;

enum devices
{
  FLAT_MAN_L = 10,
  FLAT_MAN_XL = 15,
  FLAT_MAN = 19,
  FLIP_FLAT = 99
};

enum motorStatuses
{
  STOPPED = 0,
  RUNNING
};

enum lightStatuses
{
  OFF = 0,
  ON
};

enum coverStatuses
{
  UNKNOWN = 0, // ie not open or closed...could be moving
  CLOSED,
  OPEN
};


int deviceId = FLIP_FLAT;
int motorStatus = STOPPED;
int lightStatus = OFF;
int coverStatus = UNKNOWN;

    
void setup()
{
    Serial.begin(9600);
    
    ServoCapot.attach(9, 500, 2475); // init pin
    ServoRotation.attach(10, 500, 2475); // init pin
    ServoTranslation.attach(11, 500, 2475); // init pin

    ServoCapot.write(AngleServoCapot);
    ServoRotation.write(AngleServoRotation);
    ServoTranslation.write(AngleServoTranslation);
    
    pinMode(btn_capot,INPUT);     
    pinMode(btn_voltmetre,INPUT);
    pinMode(btn_ELpan, INPUT);
    pinMode(btn_park, INPUT);
    pinMode(ctc_capot_ouvert, INPUT);
    pinMode(ctc_capot_ferme, INPUT);    
    pinMode(led_1, OUTPUT);
    pinMode(led_2, OUTPUT);
    pinMode(led_3, OUTPUT);
    pinMode(led_4, OUTPUT);
    pinMode(ELpan, OUTPUT);
    pinMode(relais_ELpan, OUTPUT);
    pinMode(relais_secu,OUTPUT);   
    pinMode(relais_servo,OUTPUT);   

    attachInterrupt(digitalPinToInterrupt(2), secu, FALLING);
    
}
 
unsigned int analogReadReference(void) // Mesure la référence interne à 1.1 volts
{
  
// Elimine toutes charges résiduelles
#if defined(__AVR_ATmega328P__)
    ADMUX = 0x4F;
#elif defined(__AVR_ATmega2560__)
    ADCSRB &= ~(1 << MUX5);
    ADMUX = 0x5F;
#elif defined(__AVR_ATmega32U4__)
    ADCSRB &= ~(1 << MUX5);
    ADMUX = 0x5F;
#endif
    delayMicroseconds(5);
  
// Sélectionne la référence interne à 1.1 volts comme point de mesure, avec comme limite haute VCC
#if defined(__AVR_ATmega328P__)
    ADMUX = 0x4E;
#elif defined(__AVR_ATmega2560__)
    ADCSRB &= ~(1 << MUX5);
    ADMUX = 0x5E;
#elif defined(__AVR_ATmega32U4__)
    ADCSRB &= ~(1 << MUX5);
    ADMUX = 0x5E;
#endif
    delayMicroseconds(200);

  
  ADCSRA |= (1 << ADEN); // Active le convertisseur analogique -> numérique
  
  ADCSRA |= (1 << ADSC); // Lance une conversion analogique -> numérique
  
  while(ADCSRA & (1 << ADSC)); // Attend la fin de la conversion
  
  return ADCL | (ADCH << 8); // Récupère le résultat de la conversion
}

void loop() 
{           
if (digitalRead(ctc_capot_ouvert) == HIGH)
    {
    coverStatus = OPEN; 
    }
    
if (digitalRead(ctc_capot_ferme) == HIGH)
    {
    coverStatus = CLOSED; 
    }

handleSerial();

// Ouverture Fermeture capot  en local 
if((digitalRead(btn_capot) == HIGH) && (digitalRead(ctc_capot_ouvert) == HIGH) && (digitalRead(btn_park) == LOW))
    {
    fermeture(); 
    }
    
if((digitalRead(btn_capot) == HIGH) && (digitalRead(ctc_capot_ferme) == HIGH) && (digitalRead(btn_park) == LOW))
    {    
    ouverture();
    }
    
if((digitalRead(btn_park) == HIGH) && (digitalRead(ctc_capot_ferme) == HIGH))
    {      
    ouverture();
    }

 // Fermeture automatique en cas de coupure de courant 
if (digitalRead(relais_secu)==(HIGH))
    {  
     if (digitalRead(ctc_capot_ouvert) == HIGH)
        {
        fermeture();
        }
        
     if(digitalRead(ctc_capot_ferme) == HIGH)
        {    
        delay(1000);    
        digitalWrite(relais_secu,LOW);
        }    
    }
  
 

// ELpan : control local du panneau EL
etat_btn_ELpan = digitalRead(btn_ELpan);

if (etat_btn_ELpan != etatprecedent_btn_ELpan) // si l'état du bouton a changé
    {
    if (etat_btn_ELpan == HIGH) // et qu'il est haut (= on appuie dessus)
        {
        compte_btn_ELpan++; // on incrémente le compteur
        if (compte_btn_ELpan > 5) // sauf s'il a dépassé 5...
            {
            compte_btn_ELpan = 0; // ...auquel cas on le réinitialise
            }
        }
    }
    
progELpan(); // on execute progELpan
etatprecedent_btn_ELpan = etat_btn_ELpan; // et on stocke l'atat du bouton pour le prochain tour 
         

 
// Voltmetre : control local du niveau des piles 9v
if (digitalRead(btn_voltmetre) == HIGH)
    {
     delay(100);
     voltmetre(); // On execute volmetre
    }
    
else
    {
     analogWrite(led_1,0);
     analogWrite(led_2,0);
     analogWrite(led_3,0);
     analogWrite(led_4,0);
    }
} 

void ouverture() // Routine ouverture capot
{ 
if (compte_btn_ELpan >= 1)// Si le panneau EL est allumé
    {
    compte_btn_ELpan = 0; // On l'éteind          
    analogWrite(led_1,0);
    analogWrite(led_2,0);
    analogWrite(led_3,0);
    analogWrite(led_4,0);
    analogWrite(ELpan,0);
    digitalWrite(relais_ELpan,LOW);
    Serial.println("EL panel éteind");  
    }
  
digitalWrite(relais_servo,HIGH);
motorStatus = RUNNING;
coverStatus = UNKNOWN;
delay(500); 
  
while(!(((AngleServoTranslation)==(137))))
    {
    ServoTranslation.write((AngleServoTranslation) + (1)); 
    AngleServoTranslation += 1;
    delay(20);//_delay(0.02);//Réglage de la vitesse du servo
    }
       
delay(1000);//_delay(1);
        
while(!(((AngleServoCapot)==(180))))
    {
    ServoCapot.write((AngleServoCapot) + (1)); 
    AngleServoCapot += 1;
    delay(20);//_delay(0.02);//Réglage de la vitesse du servo
    }
        
delay(1000);//_delay(1);

while(!(((AngleServoRotation)==(47))))
    {
    ServoRotation.write((AngleServoRotation) - (1)); 
    AngleServoRotation += -1;
    delay(20);//_delay(0.02);//Réglage de la vitesse du servo
    }
    
delay(500); 
  
if (digitalRead(ctc_capot_ouvert) == HIGH)
    {
    digitalWrite(relais_servo,LOW);
    Serial.println("Capot ouvert");
    motorStatus = STOPPED;    
    coverStatus = OPEN;
    } 
}
 
 void fermeture() // Routine fermeture capot 
{ 
digitalWrite(relais_servo,HIGH);
motorStatus = RUNNING;
coverStatus = UNKNOWN;
delay(500); 
  
while(!(((AngleServoRotation)==(137))))
    {
    ServoRotation.write((AngleServoRotation) + (1)); 
    AngleServoRotation += 1;
    delay(20);// _delay(0.02);//Réglage de la vitesse du servo
    }

delay(1000);//_delay(1);

while(!(((AngleServoCapot)==(0))))
    {
    ServoCapot.write((AngleServoCapot) - (1));
    AngleServoCapot += -1;
    delay(20);// _delay(0.02);//Réglage de la vitesse du servo
    }

delay(1000);//_delay(1);

while(!(((AngleServoTranslation)==(47))))
    {
    ServoTranslation.write((AngleServoTranslation) - (1));
    AngleServoTranslation += -1;
    delay(20);// _delay(0.02);//Réglage de la vitesse du servo
    }
    
delay(500); 
  
if (digitalRead(ctc_capot_ferme) == HIGH)
    {
    digitalWrite(relais_servo,LOW);
    Serial.println("Capot fermé");
    motorStatus = STOPPED;    
    coverStatus = OPEN;
    }    
}
 
void handleSerial() // Communication serie protocol Alnitak
{
delay(300);
if( Serial.available() >= 5 )  // all incoming communications are fixed length at 6 bytes including the \n
    {
    char* cmd;
    char* data;
    char temp[10];   
    int len = 0;
    char str[20];
    memset(str, 0, 20);
    Serial.readBytesUntil('\n', str, 20);  
    cmd = str + 1;
    data = str + 2;

    if( false ) // useful for debugging to make sure your commands came through and are parsed correctly.
       {
       sprintf( temp, "cmd = >%s%s;", cmd, data);
       Serial.println(temp);
       } 

    switch( *cmd )
       {
      case 'P':// Ping device
      sprintf(temp, "*P%d000\n", deviceId);
      Serial.print(temp);
      break;

      case 'O': // Open shutter
      sprintf(temp, "*O%d000\n", deviceId);
      Serial.print(temp); 
      analogWrite(ELpan,0);
      digitalWrite(relais_ELpan,LOW);
      lightStatus = OFF;
      ouverture();     
      break;

      case 'C':// Close shutter
      sprintf(temp, "*C%d000\n", deviceId);    
      Serial.print(temp);      
      fermeture();    
      compte_btn_ELpan = 0;
      break;

      case 'L':// Turn light on
      sprintf(temp, "*L%d000\n", deviceId);
      Serial.print(temp);
      compte_btn_ELpan = 5;
      digitalWrite(relais_ELpan,HIGH);
      lightStatus = ON; 
      break;

      case 'D':// Turn light off
      sprintf(temp, "*D%d000\n", deviceId);
      Serial.print(temp);
      lightStatus = OFF;
      compte_btn_ELpan = 0;
      break;

      case 'B':// Set brightness
      brightness = atoi(data);    
      if( lightStatus == ON )  
      sprintf( temp, "*B%d%03d\n", deviceId, brightness );
      Serial.print(temp);
      analogWrite(ELpan,brightness);
      break;

      case 'J':// Get brightness
      sprintf( temp, "*J%d%03d\n", deviceId, brightness);
      Serial.print(temp);
      break;
      
      case 'S':// Get device status     
      sprintf( temp, "*S%d%d%d%d\n",deviceId, motorStatus, lightStatus, coverStatus);
      Serial.print(temp);
      break;

      case 'V': // get firmware version
      sprintf(temp, "*V%d001\n", deviceId);
      Serial.print(temp);
      break;
        }    
    
    while( Serial.available() > 0 )
    Serial.read();

     }
}

void progELpan() // Routine éclairage EL panel
{
if ((compte_btn_ELpan >= 1) && (digitalRead(ctc_capot_ferme) == HIGH))
     {
     digitalWrite(relais_ELpan,HIGH); // on allume le relai
     }
     
else 
     {
     digitalWrite(relais_ELpan,LOW); // on eteind le relai
     } 
     
if (compte_btn_ELpan == 0)
     {
     analogWrite(led_1,0);
     analogWrite(led_2,0);
     analogWrite(led_3,0);
     analogWrite(led_4,0);
     analogWrite(ELpan,0);
     digitalWrite(relais_ELpan,LOW); // on eteind le relai  
     } 

if ((compte_btn_ELpan == 1) && (digitalRead(ctc_capot_ferme) == HIGH))
     {
     analogWrite(led_1,255);
     analogWrite(led_2,0);
     analogWrite(led_3,0);
     analogWrite(led_4,0);
     analogWrite(ELpan,27);
     }
     
if ((compte_btn_ELpan == 2) && (digitalRead(ctc_capot_ferme) == HIGH))
     {
     analogWrite(led_1,255);
     analogWrite(led_2,255);
     analogWrite(led_3,0);
     analogWrite(led_4,0);
     analogWrite(ELpan,50);
     }
     
if ((compte_btn_ELpan == 3) && (digitalRead(ctc_capot_ferme) == HIGH))
     {
     analogWrite(led_1,255);
     analogWrite(led_2,255);
     analogWrite(led_3,255);
     analogWrite(led_4,0);
     analogWrite(ELpan,90);
     }
     
if ((compte_btn_ELpan == 4) && (digitalRead(ctc_capot_ferme) == HIGH))
     {
     analogWrite(led_1,255);
     analogWrite(led_2,255);
     analogWrite(led_3,255);
     analogWrite(led_4,255);
     analogWrite(ELpan,255);
     }
     
if (compte_btn_ELpan == 5)
     {
     analogWrite(ELpan,brightness);//
     }   
}

void voltmetre() // Routine voltmetre
{
// Mesure la tension en VIN et la référence interne à 1.1 volts
unsigned int raw_vin = analogRead(BROCHE_CAPTEUR_VIN);
unsigned int raw_ref = analogReadReference();
  
// Calcul de la tension réel avec un produit en croix
float real_vin = ((raw_vin * 1.1) / raw_ref) * COEFF_PONT_DIVISEUR_VIN;
  
if (real_vin >= 6)
     {
     analogWrite(led_1,255);
     analogWrite(led_2,0);
     analogWrite(led_3,0);
     analogWrite(led_4,0);
     }
     
if (real_vin >= 7)
     {
     analogWrite(led_1,255);
     analogWrite(led_2,255);
     analogWrite(led_3,0);
     analogWrite(led_4,0);
     }
     
if (real_vin >= 8)
     {
     analogWrite(led_1,255);
     analogWrite(led_2,255);
     analogWrite(led_3,255);
     analogWrite(led_4,0);
     }
     
if (real_vin >= 9)
     {
     analogWrite(led_1,255);
     analogWrite(led_2,255);
     analogWrite(led_3,255);
     analogWrite(led_4,255);
     }
  
/* Affichage */
Serial.println(real_vin, 3);
delay(1000);
}

void secu() // Secu fermeture automatique si coupure de courant 
{  
if (digitalRead(btn_park) == LOW)
     {
     digitalWrite(relais_secu,HIGH);
     }
}

J'ai essayer des les placer dans la routine "void handelSerial()" mais là, je ne peux pas compiler le code. IDE me donne des erreurs. Bizard !

21 juin 2019

Bah... J'ai beau essayer toutes les valeurs de delay entre 50ms à 1s et rien n'y fait.

Effectivement, il semblerait qu'INDI n'arrive pas à connaitre le statu du flip flat au bon moment.

Mais pour quelle raison ?

21 juin 2019

J'ai enfin trouvé le problème ! Pfff...

En fait, cela n'avait rien à voir avec l'USB. J'avais juste fait une bêtise en voulant rendre mon code propre visuellement.

J'avais effacé deux lignes essentielles à la communication série dans la partie "void handleSerial()"

memset(str, 0, 20);

Serial.readBytesUntil('\n', str, 20);

C'est pour cette raison que INDI ne pouvait plus communiquer avec le Flip flat.

En revanche, je n'arrive pas à régler le souci du "Time out". J'ai essayé la manip proposé par @Cedric02700 mais cela ne change rien.

En fait le "time out" n'intervient pas à la connexion mais après les commandes d'ouverture et fermeture du capot.

Je pense que cela vient du fait que j'ai trois servos à commander les uns après les autres et que la séquence complète dure 10 secondes, sans doute trop long pour le drivers INDI.

J'ai essayé en doublant la vitesse des servos pour accélérer la séquence et là, j'ai un autre message : "Read Overflow"

Mystère...

A priori, cela ne gène en rien le bon fonctionnement mais j'aurais bien aimé trouver un truc pour supprimer ces erreurs.

En tout cas, merci à tous pour votre aide...

20 juin 2019

Dois je prendre la version Linux 64bit ou la version Linux ARM 64bit ?

20 juin 2019

@Raphael_OD Bonne idée ! J'essaie...

20 juin 2019

Apparement si, quand je lance la commande, j'ai ça:

nafa@NAFABox:~$ lsusb
Bus 001 Device 003: ID 1a86:7523 QinHeng Electronics HL-340 USB-Serial adapter
Bus 001 Device 002: ID 80ee:0021 VirtualBox USB Tablet
Bus 001 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
nafa@NAFABox:~$

Et dans les settings usb de Vbox j'ai ça :

20 juin 2019

@Raphael_OD C'est surtout Linux qui n'est pas user friendly 😰 comparé à l'Unix d'Apple 😉

Mais bon, je te l'accorde, se serait certainement plus simple avec une Tinker S.

19 juin 2019

@Cedric02700 Merci ! J'essaie dès que j'arrive, de nouveau, à connecter l'arduino à INDI dans ma VirtualBox.

19 juin 2019

@Alarcon yves la commande dmesg me donne ça concernât l'USB:

Révélation


               00:00:00.000092 main     Log opened 2019-06-19T17:18:45.375580000Z
[   10.851547] 00:00:00.000691 main     OS Product: Linux
[   10.851615] 00:00:00.000763 main     OS Release: 4.15.0-45-generic
[   10.851687] 00:00:00.000832 main     OS Version: #48-Ubuntu SMP Tue Jan 29 16:28:13 UTC 2019
[   10.851808] 00:00:00.000902 main     Executable: /opt/VBoxGuestAdditions-5.2.18/sbin/VBoxService
               00:00:00.000903 main     Process ID: 1159
               00:00:00.000904 main     Package type: LINUX_64BITS_GENERIC
[   10.854749] 00:00:00.003868 main     5.2.18 r124319 started. Verbose level = 0
[  503.263195] usb 1-2: USB disconnect, device number 3
[  503.263271] usb 1-2: ch341_read_int_callback - usb_submit_urb failed: -19
[  503.265134] ch341-uart ttyUSB0: ch341-uart converter now disconnected from ttyUSB0
[  503.265156] ch341 1-2:1.0: device disconnected
[  506.992533] usb 1-2: new full-speed USB device number 4 using ohci-pci
[  507.334776] usb 1-2: New USB device found, idVendor=1a86, idProduct=7523
[  507.334779] usb 1-2: New USB device strings: Mfr=0, Product=2, SerialNumber=0
[  507.334781] usb 1-2: Product: USB2.0-Serial
[  507.377405] ch341 1-2:1.0: ch341-uart converter detected
[  507.400333] usb 1-2: ch341-uart converter now attached to ttyUSB1
[  840.809187] usb 1-2: USB disconnect, device number 4
[  840.814874] ch341-uart ttyUSB1: ch341-uart converter now disconnected from ttyUSB1
[  840.814887] ch341 1-2:1.0: device disconnected
[  846.056032] usb 1-2: new full-speed USB device number 5 using ohci-pci
[  846.376809] usb 1-2: New USB device found, idVendor=1a86, idProduct=7523
[  846.376813] usb 1-2: New USB device strings: Mfr=0, Product=2, SerialNumber=0
[  846.376814] usb 1-2: Product: USB2.0-Serial
[  846.419467] ch341 1-2:1.0: ch341-uart converter detected
[  846.442432] usb 1-2: ch341-uart converter now attached to ttyUSB0
[ 1145.377658] ch341-uart ttyUSB0: usb_serial_generic_read_bulk_callback - urb stopped: -32
[ 1145.493579] usb 1-2: USB disconnect, device number 5
[ 1145.499647] ch341-uart ttyUSB0: ch341-uart converter now disconnected from ttyUSB0
[ 1145.499658] ch341 1-2:1.0: device disconnected
[ 1234.517081] usb 1-2: new full-speed USB device number 6 using ohci-pci
[ 1234.843684] usb 1-2: New USB device found, idVendor=1a86, idProduct=7523
[ 1234.843687] usb 1-2: New USB device strings: Mfr=0, Product=2, SerialNumber=0
[ 1234.843688] usb 1-2: Product: USB2.0-Serial
[ 1234.886352] ch341 1-2:1.0: ch341-uart converter detected
[ 1234.911624] usb 1-2: ch341-uart converter now attached to ttyUSB1
[ 1552.326377] ch341-uart ttyUSB1: usb_serial_generic_read_bulk_callback - urb stopped: -32
[ 1552.436149] usb 1-2: USB disconnect, device number 6
[ 1552.448696] ch341-uart ttyUSB1: ch341-uart converter now disconnected from ttyUSB1
[ 1552.448709] ch341 1-2:1.0: device disconnected
[ 1557.143623] usb 1-2: new full-speed USB device number 7 using ohci-pci
[ 1557.477897] usb 1-2: New USB device found, idVendor=1a86, idProduct=7523
[ 1557.477900] usb 1-2: New USB device strings: Mfr=0, Product=2, SerialNumber=0
[ 1557.477901] usb 1-2: Product: USB2.0-Serial
[ 1557.520685] ch341 1-2:1.0: ch341-uart converter detected
[ 1557.543335] usb 1-2: ch341-uart converter now attached to ttyUSB0
[ 3286.080171] ohci-pci 0000:00:06.0: frame counter not updating; disabled
[ 3286.080191] ohci-pci 0000:00:06.0: HC died; cleaning up
[ 3286.082554] usb 1-1: USB disconnect, device number 2
[ 3286.189070] usb 1-2: USB disconnect, device number 7
[ 3286.189474] ch341-uart ttyUSB0: ch341-uart converter now disconnected from ttyUSB0
[ 3286.189491] ch341 1-2:1.0: device disconnected
nafa@NAFABox:~$

Et me donne ça pour la commande "lsusb":

Bus 001 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub

19 juin 2019

@Alarcon yves Merci !

Oui, j'aimerais bien avoir une petite Nafabox sur TinkerS, mais en attendant, pour me faire la main gratuitement au monde Linux, la VirtualBox est une bonne solution, d'autant que j'ai réussi à faire marcher mon Flip flat dessus.

J'ai essayé la commande que tu m'as donné et j'ai eu ça comme réponse :

chmod: impossible d'accéder à '/dev/ttyACM0': Aucun fichier ou dossier de ce type

17 juin 2019

Ayé ! J'ai trouvé !

Pour essayer de comprendre ce qui se passe, j'ai supprimé une à une toutes les parties de mon programme qui s'occupe des commandes en local avec les boutons. Et quand je supprime la partie concernant la commande du panneau EL, cela fonctionne très bien en remote. J'ai donc un conflit entre ma programmation de la commande en local du panneau avec celle de la commande en remote.

Plus qu'à trouver...

@Alarcon yves Merci ! Je vais regarder au plus prêt et faire les motifs nécessaires.

Voila ! J'ai enfin réussit à assembler le code de commandes séries Alnitak avec le mien.

J'ai donc accès à toutes les commandes en local avec des boutons et en remote avec les softs Optec, INDI et ascom.

J'ai même testé mon Flip flat avec Ekos dans KStars et ça a marché nickel à part un petit message de "time out" que j'aimerais bien régler.

Je dis que ça a marché parce que je n'y arrive plus. En fait, ma config est un peu particulière. N'ayant pas encore de Nafabox, et étant sur Mac, j'utilise VirtualBox pour émuler un PC sous Linux sur lequel j'ai installé une image disque Nafabox compatible. Lors du premier essai, j'ai réussi à faire reconnaitre la liaison USB de mon Arduino Flip flat avec la Virtual machine et donc par Eko/INDI. J'étais presque impressionné que ça fonctionne du premier coup.

Seulement voilà, je n'y arrive plus. INDI ne voit plus ma connection USB Arduino. J'ai essayé plein de trucs dans les settings VirtualBox sans succès.

Et je n'arrive pas à ouvrir le "Serial port assistant" dans Ekos. Si quelqu'un a une idée, je suis preneur.

En attendant, voilà le code de mon Flip flat Arduino compatible Alnitak :

Révélation


 

#include <Arduino.h>
#include <Servo.h>
 
 
Servo ServoCapot;
Servo ServoRotation;
Servo ServoTranslation;

const int btn_capot = A0;//Bouton de commande d'ouverture et fermeture du capot
const int btn_voltmetre = A2;//Bouton pour vérifier l'état des plies
const int btn_ELpan = A1;//Bouton de commande du panneau lumineux
const int btn_park = A5;//Switch d'ouverture neutralisant la sécu de fermeture auto pour démontage
const int ctc_capot_ouvert = A3;//Contacteur de position ouvert
const int ctc_capot_ferme = A4;//Contacteur de position fermé

const int led_1 = 4;//Visu du niveau du panneau lumineux en commande local et niveau de piles
const int led_2 = 5;
const int led_3 = 6;
const int led_4 = 7;
const int ELpan = 3;//Panneau lumineux

const int relais_ELpan = 13;//Relais d'alimentation du panneau lumineux
const int relais_secu = 8;//Relais d'alimentation secours par les piles
const int relais_servo = 12;//Relais d'alimentation des servos


int AngleServoCapot= 0;
int AngleServoRotation= 137;
int AngleServoTranslation= 47;
int reception;
int compte_btn_ELpan = 0; // le nombre qui sera incrémenté et décrémenté
int etat_btn_ELpan = LOW; // lecture de l'état des boutons (un seul à la fois donc une variable suffit)
int etatprecedent_btn_ELpan = LOW; // état relâché par défaut
int real_vin(); // Variable de la tension mesuré par le voltmetre

const byte BROCHE_CAPTEUR_VIN = A7; // Le numéro de broche analogique pour la mesure de la tension en VIN
const float COEFF_PONT_DIVISEUR_VIN = 1.95; // Coefficient diviseur du pont de résistance
String commande;


 //Alnitak init
int brightness = 0;

enum devices
{
  FLAT_MAN_L = 10,
  FLAT_MAN_XL = 15,
  FLAT_MAN = 19,
  FLIP_FLAT = 99
};

enum motorStatuses
{
  STOPPED = 0,
  RUNNING
};

enum lightStatuses
{
  OFF = 0,
  ON
};

enum coverStatuses
{
  UNKNOWN = 0, // ie not open or closed...could be moving
  CLOSED,
  OPEN
};


int deviceId = FLIP_FLAT;
int motorStatus = STOPPED;
int lightStatus = OFF;
int coverStatus = UNKNOWN;

    
void setup()
{
    Serial.begin(9600);
    
    ServoCapot.attach(9, 500, 2475); // init pin
    ServoRotation.attach(10, 500, 2475); // init pin
    ServoTranslation.attach(11, 500, 2475); // init pin

    ServoCapot.write(AngleServoCapot);
    ServoRotation.write(AngleServoRotation);
    ServoTranslation.write(AngleServoTranslation);
    
    pinMode(btn_capot,INPUT);     
    pinMode(btn_voltmetre,INPUT);
    pinMode(btn_ELpan, INPUT);
    pinMode(btn_park, INPUT);
    pinMode(ctc_capot_ouvert, INPUT);
    pinMode(ctc_capot_ferme, INPUT);    
    pinMode(led_1, OUTPUT);
    pinMode(led_2, OUTPUT);
    pinMode(led_3, OUTPUT);
    pinMode(led_4, OUTPUT);
    pinMode(ELpan, OUTPUT);
    pinMode(relais_ELpan, OUTPUT);
    pinMode(relais_secu,OUTPUT);   
    pinMode(relais_servo,OUTPUT);   

    attachInterrupt(digitalPinToInterrupt(2), secu, FALLING);
    
}
 
unsigned int analogReadReference(void) // Mesure la référence interne à 1.1 volts
{
  
// Elimine toutes charges résiduelles
#if defined(__AVR_ATmega328P__)
    ADMUX = 0x4F;
#elif defined(__AVR_ATmega2560__)
    ADCSRB &= ~(1 << MUX5);
    ADMUX = 0x5F;
#elif defined(__AVR_ATmega32U4__)
    ADCSRB &= ~(1 << MUX5);
    ADMUX = 0x5F;
#endif
    delayMicroseconds(5);
  
// Sélectionne la référence interne à 1.1 volts comme point de mesure, avec comme limite haute VCC
#if defined(__AVR_ATmega328P__)
    ADMUX = 0x4E;
#elif defined(__AVR_ATmega2560__)
    ADCSRB &= ~(1 << MUX5);
    ADMUX = 0x5E;
#elif defined(__AVR_ATmega32U4__)
    ADCSRB &= ~(1 << MUX5);
    ADMUX = 0x5E;
#endif
    delayMicroseconds(200);

  
  ADCSRA |= (1 << ADEN); // Active le convertisseur analogique -> numérique
  
  ADCSRA |= (1 << ADSC); // Lance une conversion analogique -> numérique
  
  while(ADCSRA & (1 << ADSC)); // Attend la fin de la conversion
  
  return ADCL | (ADCH << 8); // Récupère le résultat de la conversion
}

void loop() 
{           
if (digitalRead(ctc_capot_ouvert) == HIGH)
    {
    coverStatus = OPEN; 
    }
    
if (digitalRead(ctc_capot_ferme) == HIGH)
    {
    coverStatus = CLOSED; 
    }

handleSerial();

// Ouverture Fermeture capot  en local 
if((digitalRead(btn_capot) == HIGH) && (digitalRead(ctc_capot_ouvert) == HIGH) && (digitalRead(btn_park) == LOW))
    {
    fermeture(); 
    }
    
if((digitalRead(btn_capot) == HIGH) && (digitalRead(ctc_capot_ferme) == HIGH) && (digitalRead(btn_park) == LOW))
    {    
    ouverture();
    }
    
if((digitalRead(btn_park) == HIGH) && (digitalRead(ctc_capot_ferme) == HIGH))
    {      
    ouverture();
    }

 // Fermeture automatique en cas de coupure de courant 
if (digitalRead(relais_secu)==(HIGH))
    {  
     if (digitalRead(ctc_capot_ouvert) == HIGH)
        {
        fermeture();
        }
        
     if(digitalRead(ctc_capot_ferme) == HIGH)
        {    
        delay(1000);    
        digitalWrite(relais_secu,LOW);
        }    
    }
  
 

// ELpan : control local du panneau EL
etat_btn_ELpan = digitalRead(btn_ELpan);

if (etat_btn_ELpan != etatprecedent_btn_ELpan) // si l'état du bouton a changé
    {
    if (etat_btn_ELpan == HIGH) // et qu'il est haut (= on appuie dessus)
        {
        compte_btn_ELpan++; // on incrémente le compteur
        if (compte_btn_ELpan > 5) // sauf s'il a dépassé 5...
            {
            compte_btn_ELpan = 0; // ...auquel cas on le réinitialise
            }
        }
    }
    
progELpan(); // on execute progELpan
etatprecedent_btn_ELpan = etat_btn_ELpan; // et on stocke l'atat du bouton pour le prochain tour 
         

 
// Voltmetre : control local du niveau des piles 9v
if (digitalRead(btn_voltmetre) == HIGH)
    {
     delay(100);
     voltmetre(); // On execute volmetre
    }
    
else
    {
     analogWrite(led_1,0);
     analogWrite(led_2,0);
     analogWrite(led_3,0);
     analogWrite(led_4,0);
    }
} 

void ouverture() // Routine ouverture capot
{ 
if (compte_btn_ELpan >= 1)// Si le panneau EL est allumé
    {
    compte_btn_ELpan = 0; // On l'éteind          
    analogWrite(led_1,0);
    analogWrite(led_2,0);
    analogWrite(led_3,0);
    analogWrite(led_4,0);
    analogWrite(ELpan,0);
    digitalWrite(relais_ELpan,LOW);
    Serial.println("EL panel éteind");  
    }
  
digitalWrite(relais_servo,HIGH);
delay(500); 
  
while(!(((AngleServoTranslation)==(137))))
    {
    ServoTranslation.write((AngleServoTranslation) + (1)); 
    AngleServoTranslation += 1;
    delay(20);//_delay(0.02);//Réglage de la vitesse du servo
    }
       
delay(1000);//_delay(1);
        
while(!(((AngleServoCapot)==(180))))
    {
    ServoCapot.write((AngleServoCapot) + (1)); 
    AngleServoCapot += 1;
    delay(20);//_delay(0.02);//Réglage de la vitesse du servo
    }
        
delay(1000);//_delay(1);

while(!(((AngleServoRotation)==(47))))
    {
    ServoRotation.write((AngleServoRotation) - (1)); 
    AngleServoRotation += -1;
    delay(20);//_delay(0.02);//Réglage de la vitesse du servo
    }
    
delay(500); 
  
if (digitalRead(ctc_capot_ouvert) == HIGH)
    {
    digitalWrite(relais_servo,LOW);
    Serial.println("Capot ouvert");
    } 
}
 
 void fermeture() // Routine fermeture capot 
{ 
digitalWrite(relais_servo,HIGH);
delay(500); 
  
while(!(((AngleServoRotation)==(137))))
    {
    ServoRotation.write((AngleServoRotation) + (1)); 
    AngleServoRotation += 1;
    delay(20);// _delay(0.02);//Réglage de la vitesse du servo
    }

delay(1000);//_delay(1);

while(!(((AngleServoCapot)==(0))))
    {
    ServoCapot.write((AngleServoCapot) - (1));
    AngleServoCapot += -1;
    delay(20);// _delay(0.02);//Réglage de la vitesse du servo
    }

delay(1000);//_delay(1);

while(!(((AngleServoTranslation)==(47))))
    {
    ServoTranslation.write((AngleServoTranslation) - (1));
    AngleServoTranslation += -1;
    delay(20);// _delay(0.02);//Réglage de la vitesse du servo
    }
    
delay(500); 
  
if (digitalRead(ctc_capot_ferme) == HIGH)
    {
    digitalWrite(relais_servo,LOW);
    Serial.println("Capot fermé");
    }    
}
 
void handleSerial() // Communication serie protocol Alnitak
{
if( Serial.available() >= 5 )  // all incoming communications are fixed length at 6 bytes including the \n
    {
    char* cmd;
    char* data;
    char temp[10];   
    int len = 0;
    char str[20];
    memset(str, 0, 20);
    Serial.readBytesUntil('\n', str, 20);  
    cmd = str + 1;
    data = str + 2;
    
    if( false ) // useful for debugging to make sure your commands came through and are parsed correctly.
       {
       sprintf( temp, "cmd = >%s%s;", cmd, data);
       Serial.println(temp);
       } 

    switch( *cmd )
       {
      case 'P':// Ping device
      sprintf(temp, "*P%d000\n", deviceId);
      Serial.print(temp);
      break;

      case 'O': // Open shutter
      sprintf(temp, "*O%d000\n", deviceId);
      Serial.print(temp);
      coverStatus = OPEN; 
      analogWrite(ELpan,0);
      digitalWrite(relais_ELpan,LOW);
      lightStatus = OFF;
      ouverture();      
      break;

      case 'C':// Close shutter
      sprintf(temp, "*C%d000\n", deviceId);
      Serial.print(temp);
      coverStatus = CLOSED;
      fermeture();     
      compte_btn_ELpan = 0;
      break;

      case 'L':// Turn light on
      sprintf(temp, "*L%d000\n", deviceId);
      Serial.print(temp);
      compte_btn_ELpan = 5;
      digitalWrite(relais_ELpan,HIGH);
      lightStatus = ON; 
      break;

      case 'D':// Turn light off
      sprintf(temp, "*D%d000\n", deviceId);
      Serial.print(temp);
      lightStatus = OFF;
      compte_btn_ELpan = 0;
      break;

      case 'B':// Set brightness
      brightness = atoi(data);    
      if( lightStatus == ON )  
      sprintf( temp, "*B%d%03d\n", deviceId, brightness );
      Serial.print(temp);
      analogWrite(ELpan,brightness);
      break;

      case 'J':// Get brightness
      sprintf( temp, "*J%d%03d\n", deviceId, brightness);
      Serial.print(temp);
      break;
      
      case 'S':// Get device status
      sprintf( temp, "*S%d%d%d%d\n",deviceId, motorStatus, lightStatus, coverStatus);
      Serial.print(temp);
      break;

      case 'V': // get firmware version
      sprintf(temp, "*V%d001\n", deviceId);
      Serial.print(temp);
      break;
        }    

    while( Serial.available() > 0 )
    Serial.read();

     }
}

void progELpan() // Routine éclairage EL panel
{
if ((compte_btn_ELpan >= 1) && (digitalRead(ctc_capot_ferme) == HIGH))
     {
     digitalWrite(relais_ELpan,HIGH); // on allume le relai
     }
     
else 
     {
     digitalWrite(relais_ELpan,LOW); // on eteind le relai
     } 
     
if (compte_btn_ELpan == 0)
     {
     analogWrite(led_1,0);
     analogWrite(led_2,0);
     analogWrite(led_3,0);
     analogWrite(led_4,0);
     analogWrite(ELpan,0);
     digitalWrite(relais_ELpan,LOW); // on eteind le relai  
     } 

if ((compte_btn_ELpan == 1) && (digitalRead(ctc_capot_ferme) == HIGH))
     {
     analogWrite(led_1,255);
     analogWrite(led_2,0);
     analogWrite(led_3,0);
     analogWrite(led_4,0);
     analogWrite(ELpan,27);
     }
     
if ((compte_btn_ELpan == 2) && (digitalRead(ctc_capot_ferme) == HIGH))
     {
     analogWrite(led_1,255);
     analogWrite(led_2,255);
     analogWrite(led_3,0);
     analogWrite(led_4,0);
     analogWrite(ELpan,50);
     }
     
if ((compte_btn_ELpan == 3) && (digitalRead(ctc_capot_ferme) == HIGH))
     {
     analogWrite(led_1,255);
     analogWrite(led_2,255);
     analogWrite(led_3,255);
     analogWrite(led_4,0);
     analogWrite(ELpan,90);
     }
     
if ((compte_btn_ELpan == 4) && (digitalRead(ctc_capot_ferme) == HIGH))
     {
     analogWrite(led_1,255);
     analogWrite(led_2,255);
     analogWrite(led_3,255);
     analogWrite(led_4,255);
     analogWrite(ELpan,255);
     }
     
if (compte_btn_ELpan == 5)
     {
     analogWrite(ELpan,brightness);//
     }   
}

void voltmetre() // Routine voltmetre
{
// Mesure la tension en VIN et la référence interne à 1.1 volts
unsigned int raw_vin = analogRead(BROCHE_CAPTEUR_VIN);
unsigned int raw_ref = analogReadReference();
  
// Calcul de la tension réel avec un produit en croix
float real_vin = ((raw_vin * 1.1) / raw_ref) * COEFF_PONT_DIVISEUR_VIN;
  
if (real_vin >= 6)
     {
     analogWrite(led_1,255);
     analogWrite(led_2,0);
     analogWrite(led_3,0);
     analogWrite(led_4,0);
     }
     
if (real_vin >= 7)
     {
     analogWrite(led_1,255);
     analogWrite(led_2,255);
     analogWrite(led_3,0);
     analogWrite(led_4,0);
     }
     
if (real_vin >= 8)
     {
     analogWrite(led_1,255);
     analogWrite(led_2,255);
     analogWrite(led_3,255);
     analogWrite(led_4,0);
     }
     
if (real_vin >= 9)
     {
     analogWrite(led_1,255);
     analogWrite(led_2,255);
     analogWrite(led_3,255);
     analogWrite(led_4,255);
     }
  
/* Affichage */
Serial.println(real_vin, 3);
delay(1000);
}

void secu() // Secu fermeture automatique si coupure de courant 
{  
if (digitalRead(btn_park) == LOW)
     {
     digitalWrite(relais_secu,HIGH);
     }
}

17 juin 2019

Merci !

En fait, je regardais le programme avec un logiciel de notes qui ne différentie pas le code des annotations.

Maintenant, en utilisant directement l'éditeur de l'arduino, c'est beaucoup plus clair.

En me documentant sur le web, j'ai pu comprendre un peu mieux le programme. Je butais sur des fonctions tels que enum, switch et case.

J'ai donc copié la partie nécessaire à la communication série en prenant en compte les nouvelles variables, je l'ai adapté à mon programme et fait des essais avec le soft Mac proposé sur le site d'Optec pour piloter le Flip flat en USB directement à partir du Mac.

https://rti-zone.org/macosx_flatmancontrol.php

Et là... Bonne surprise, ça marche presque bien. Je récupère les status du Flip flat, j'arrive à ouvrir et fermer le capot mais en revanche, je n'arrive pas à allumer ou éteindre le panneau EL et encore moins à régler l'intensité lumineuse.

J'ai essayer de placer ma commande du relais et celle du panneau à différentes positions dans les parties du code correspondant aux commande d'éclairage mais sans succès.

J'ai aussi essayé de passé outre mon système de panneau lumineux en essayant simplement d'allumer une des quatre led branchées à l'arduino mais ça ne marche pas non plus.

Si quelqu'un a une idée, voilà mon code :

Révélation


 

#include <Arduino.h>
#include <Servo.h>
 
 
Servo ServoCapot;
Servo ServoRotation;
Servo ServoTranslation;

const int btn_capot = A0;
const int btn_voltmetre = A2;
const int btn_ELpan = A1;
const int btn_park = A5;
const int ctc_capot_ouvert = A3;
const int ctc_capot_ferme = A4;

const int led_1 = 4;
const int led_2 = 5;
const int led_3 = 6;
const int led_4 = 7;
const int ELpan = 3;

const int relais_ELpan = 13;
const int relais_secu = 8;
const int relais_servo = 12;


int AngleServoCapot= 0;
int AngleServoRotation= 137;
int AngleServoTranslation= 47;
int reception;
int compte_btn_ELpan = 0; // le nombre qui sera incrémenté et décrémenté
int etat_btn_ELpan = LOW; // lecture de l'état des boutons (un seul à la fois donc une variable suffit)
int etatprecedent_btn_ELpan = LOW; // état relâché par défaut
int real_vin(); // Variable de la tension mesuré par le voltmetre

const byte BROCHE_CAPTEUR_VIN = A7; // Le numéro de broche analogique pour la mesure de la tension en VIN
const float COEFF_PONT_DIVISEUR_VIN = 1.95; // Coefficient diviseur du pont de résistance
String commande;

 //Alnitak
 
 int brightness = 0;

enum devices
{
  FLAT_MAN_L = 10,
  FLAT_MAN_XL = 15,
  FLAT_MAN = 19,
  FLIP_FLAT = 99
};

enum motorStatuses
{
  STOPPED = 0,
  RUNNING
};

enum lightStatuses
{
  OFF = 0,
  ON
};

enum coverStatuses
{
  UNKNOWN = 0, // ie not open or closed...could be moving
  CLOSED,
  OPEN
};


int deviceId = FLIP_FLAT;
int motorStatus = STOPPED;
int lightStatus = OFF;
int coverStatus = UNKNOWN;

    
void setup()
{
    Serial.begin(9600);
    
    ServoCapot.attach(9, 500, 2475); // init pin
    ServoRotation.attach(10, 500, 2475); // init pin
    ServoTranslation.attach(11, 500, 2475); // init pin

    ServoCapot.write(AngleServoCapot);
    ServoRotation.write(AngleServoRotation);
    ServoTranslation.write(AngleServoTranslation);
    
    pinMode(btn_capot,INPUT);     
    pinMode(btn_voltmetre,INPUT);
    pinMode(btn_ELpan, INPUT);
    pinMode(btn_park, INPUT);
    pinMode(ctc_capot_ouvert, INPUT);
    pinMode(ctc_capot_ferme, INPUT);    
    pinMode(led_1, OUTPUT);
    pinMode(led_2, OUTPUT);
    pinMode(led_3, OUTPUT);
    pinMode(led_4, OUTPUT);
    pinMode(ELpan, OUTPUT);
    pinMode(relais_ELpan, OUTPUT);
    pinMode(relais_secu,OUTPUT);   
    pinMode(relais_servo,OUTPUT);   

    attachInterrupt(digitalPinToInterrupt(2), secu, FALLING);
    
}
 
unsigned int analogReadReference(void) // Mesure la référence interne à 1.1 volts
{
  
// Elimine toutes charges résiduelles
#if defined(__AVR_ATmega328P__)
  ADMUX = 0x4F;
#elif defined(__AVR_ATmega2560__)
  ADCSRB &= ~(1 << MUX5);
  ADMUX = 0x5F;
#elif defined(__AVR_ATmega32U4__)
  ADCSRB &= ~(1 << MUX5);
  ADMUX = 0x5F;
#endif
  delayMicroseconds(5);
  
// Sélectionne la référence interne à 1.1 volts comme point de mesure, avec comme limite haute VCC
#if defined(__AVR_ATmega328P__)
  ADMUX = 0x4E;
#elif defined(__AVR_ATmega2560__)
  ADCSRB &= ~(1 << MUX5);
  ADMUX = 0x5E;
#elif defined(__AVR_ATmega32U4__)
  ADCSRB &= ~(1 << MUX5);
  ADMUX = 0x5E;
#endif
  delayMicroseconds(200);

  
  ADCSRA |= (1 << ADEN); // Active le convertisseur analogique -> numérique
  
  ADCSRA |= (1 << ADSC); // Lance une conversion analogique -> numérique
  
  while(ADCSRA & (1 << ADSC)); // Attend la fin de la conversion
  
  return ADCL | (ADCH << 8); // Récupère le résultat de la conversion
}

void loop() 
{           
  if (digitalRead(ctc_capot_ouvert) == HIGH)
  {
    coverStatus = OPEN; 
    }
     if (digitalRead(ctc_capot_ferme) == HIGH)
  {
    coverStatus = CLOSED; 
    }

    handleSerial();

// Ouverture Fermeture capot    
   if((digitalRead(btn_capot) == HIGH) && (digitalRead(ctc_capot_ouvert) == HIGH) && (digitalRead(btn_park) == LOW))
    {
    fermeture(); 
    }
   if((digitalRead(btn_capot) == HIGH) && (digitalRead(ctc_capot_ferme) == HIGH) && (digitalRead(btn_park) == LOW))
    {
      
    ouverture();
    }
    if((digitalRead(btn_park) == HIGH) && (digitalRead(ctc_capot_ferme) == HIGH))
    {
      
    ouverture();
    }
  
    if (digitalRead(relais_secu)==(HIGH))
      {  
        if (digitalRead(ctc_capot_ouvert) == HIGH)
        {
      fermeture();
      }
      if(digitalRead(ctc_capot_ferme) == HIGH)
    {
      
    delay(1000);    
    digitalWrite(relais_secu,LOW);
    }
      
      }
  
 

// ELpan
    etat_btn_ELpan = digitalRead(btn_ELpan);
   if (etat_btn_ELpan != etatprecedent_btn_ELpan) // si l'état du bouton a changé
      {
      if (etat_btn_ELpan == HIGH) // et qu'il est haut (= on appuie dessus)
        {
        compte_btn_ELpan++; // on incrémente le compteur
        if (compte_btn_ELpan > 4) // sauf s'il a dépassé 4...
          {
           compte_btn_ELpan = 0; // ...auquel cas on le réinitialise
          }
       }
    
      }
       
     progELpan(); // on execute progELpan
    etatprecedent_btn_ELpan = etat_btn_ELpan; // et on stocke l'atat du bouton pour le prochain tour
   
     
// Voltmetre
    if (digitalRead(btn_voltmetre) == HIGH)
      {
        delay(100);
      voltmetre(); // On execute volmetre
      }
    else
      {
      analogWrite(led_1,0);
      analogWrite(led_2,0);
      analogWrite(led_3,0);
      analogWrite(led_4,0);
      }
} 

void ouverture() // Routine ouverture capot
{ 
 
 
  if (compte_btn_ELpan >= 1)
          {
           
  analogWrite(led_1,0);
  analogWrite(led_2,0);
  analogWrite(led_3,0);
  analogWrite(led_4,0);
  analogWrite(ELpan,0);
  digitalWrite(relais_ELpan,LOW);
  Serial.println("EL panel éteind");  
  }
    digitalWrite(relais_servo,HIGH);
       delay(500); 
  while(!(((AngleServoTranslation)==(137))))
      {
      ServoTranslation.write((AngleServoTranslation) + (1)); 
      AngleServoTranslation += 1;
      delay(20);//_delay(0.02);
      }
       
   delay(1000);//_delay(1);
        
   while(!(((AngleServoCapot)==(180))))
      {
      ServoCapot.write((AngleServoCapot) + (1)); 
      AngleServoCapot += 1;
      delay(20);//_delay(0.02);
      }
        
   delay(1000);//_delay(1);

   while(!(((AngleServoRotation)==(47))))
      {
       ServoRotation.write((AngleServoRotation) - (1)); 
       AngleServoRotation += -1;
       delay(20);//_delay(0.02);
      }
        delay(500); 
         if (digitalRead(ctc_capot_ouvert) == HIGH)
          {
            digitalWrite(relais_servo,LOW);
      Serial.println("Capot ouvert");
          }
     
}
 
 void fermeture() // Routine fermeture capot 
  { 
  // compte_btn_ELpan = 0; 
     digitalWrite(relais_servo,HIGH);
       delay(500); 
   while(!(((AngleServoRotation)==(137))))
        {

            ServoRotation.write((AngleServoRotation) + (1)); 
            AngleServoRotation += 1;
            delay(20);// _delay(0.02);

        }

        delay(1000);//_delay(1);

        while(!(((AngleServoCapot)==(0))))
        {

            ServoCapot.write((AngleServoCapot) - (1));
            AngleServoCapot += -1;
            delay(20);// _delay(0.02);

        }

        delay(1000);//_delay(1);

        while(!(((AngleServoTranslation)==(47))))
        {

            ServoTranslation.write((AngleServoTranslation) - (1));
            AngleServoTranslation += -1;
            delay(20);// _delay(0.02);

        }
          delay(500); 
           if (digitalRead(ctc_capot_ferme) == HIGH)
          {
            digitalWrite(relais_servo,LOW);
      Serial.println("Capot fermé");
          }
      
    }
 
void handleSerial()
{
  if( Serial.available() >= 5 )  // all incoming communications are fixed length at 6 bytes including the \n
  {
    char* cmd;
  char* data;
    char temp[10];
    
    int len = 0;

    char str[20];
    memset(str, 0, 20);
    
  // I don't personally like using the \n as a command character for reading.  
  // but that's how the command set is.
    Serial.readBytesUntil('\n', str, 20);

  cmd = str + 1;
  data = str + 2;
  
  // useful for debugging to make sure your commands came through and are parsed correctly.
    if( false )
    {
      sprintf( temp, "cmd = >%s%s;", cmd, data);
      Serial.println(temp);
    } 
    


    switch( *cmd )
    {
    /*
    Ping device
      Request: >P000\n
      Return : *Pii000\n
        id = deviceId
    */
      case 'P':
      sprintf(temp, "*P%d000\n", deviceId);
      Serial.print(temp);
      break;

      /*
    Open shutter
      Request: >O000\n
      Return : *Oii000\n
        id = deviceId
      This command is only supported on the Flip-Flat!
    */
      case 'O':
      sprintf(temp, "*O%d000\n", deviceId);
      ouverture();
      Serial.print(temp);
      break;


      /*
    Close shutter
      Request: >C000\n
      Return : *Cii000\n
        id = deviceId
      This command is only supported on the Flip-Flat!
    */
      case 'C':
      sprintf(temp, "*C%d000\n", deviceId);
      fermeture();
      Serial.print(temp);
      break;

    /*
    Turn light on
      Request: >L000\n
      Return : *Lii000\n
        id = deviceId
    */
      case 'L':
      sprintf(temp, "*L%d000\n", deviceId);
      Serial.print(temp);
      analogWrite(led_4, brightness);
      lightStatus = ON;
     
      
      break;

    /*
    Turn light off
      Request: >D000\n
      Return : *Dii000\n
        id = deviceId
    */
      case 'D':
      sprintf(temp, "*D%d000\n", deviceId);
      Serial.print(temp);
      lightStatus = OFF;
      analogWrite(led_4, 0);
      break;

    /*
    Set brightness
      Request: >Bxxx\n
        xxx = brightness value from 000-255
      Return : *Biiyyy\n
        id = deviceId
        yyy = value that brightness was set from 000-255
    */
      case 'B':
      brightness = atoi(data);    
      if( lightStatus == ON )  
      sprintf( temp, "*B%d%03d\n", deviceId, brightness );
      Serial.print(temp);
      analogWrite(led_4, brightness);  
        break;

    /*
    Get brightness
      Request: >J000\n
      Return : *Jiiyyy\n
        id = deviceId
        yyy = current brightness value from 000-255
    */
      case 'J':
        sprintf( temp, "*J%d%03d\n", deviceId, brightness);
        Serial.print(temp);
        break;
      
    /*
    Get device status:
      Request: >S000\n
      Return : *SidMLC\n
        id = deviceId
        M  = motor status( 0 stopped, 1 running)
        L  = light status( 0 off, 1 on)
        C  = Cover Status( 0 moving, 1 closed, 2 open)
    */
      case 'S': 
        sprintf( temp, "*S%d%d%d%d\n",deviceId, motorStatus, lightStatus, coverStatus);
        Serial.print(temp);
        break;

    /*
    Get firmware version
      Request: >V000\n
      Return : *Vii001\n
        id = deviceId
    */
      case 'V': // get firmware version
      sprintf(temp, "*V%d001\n", deviceId);
      Serial.print(temp);
      break;
    }    

  while( Serial.available() > 0 )
    Serial.read();

  }
}

void progELpan() // Routine éclairage EL panel
{
   if ((compte_btn_ELpan >= 1) && (AngleServoTranslation == 47))
        {
        digitalWrite(relais_ELpan,HIGH); // on allume le relai
        }
      else 
        {
        digitalWrite(relais_ELpan,LOW); // on eteind le relai
        } 
      if (compte_btn_ELpan == 0)
  {
    analogWrite(led_1,0);
    analogWrite(led_2,0);
    analogWrite(led_3,0);
    analogWrite(led_4,0);
    analogWrite(ELpan,0);
  }
      if ((compte_btn_ELpan == 1) && (digitalRead(ctc_capot_ferme) == HIGH))
  {
    analogWrite(led_1,255);
    analogWrite(led_2,0);
    analogWrite(led_3,0);
    analogWrite(led_4,0);
    analogWrite(ELpan,27);
  }
     if ((compte_btn_ELpan == 2) && (digitalRead(ctc_capot_ferme) == HIGH))
  {
    analogWrite(led_1,255);
    analogWrite(led_2,255);
    analogWrite(led_3,0);
    analogWrite(led_4,0);
    analogWrite(ELpan,50);
  }
     if ((compte_btn_ELpan == 3) && (digitalRead(ctc_capot_ferme) == HIGH))
  {
    analogWrite(led_1,255);
    analogWrite(led_2,255);
    analogWrite(led_3,255);
    analogWrite(led_4,0);
    analogWrite(ELpan,90);
  }
    if ((compte_btn_ELpan == 4) && (digitalRead(ctc_capot_ferme) == HIGH))
  {
    analogWrite(led_1,255);
    analogWrite(led_2,255);
    analogWrite(led_3,255);
    analogWrite(led_4,255);
    analogWrite(ELpan,255);
  }
 
}

void voltmetre() // Routine voltmetre
{
 
  // Mesure la tension en VIN et la référence interne à 1.1 volts
  unsigned int raw_vin = analogRead(BROCHE_CAPTEUR_VIN);
  unsigned int raw_ref = analogReadReference();
  
  // Calcul de la tension réel avec un produit en croix
  float real_vin = ((raw_vin * 1.1) / raw_ref) * COEFF_PONT_DIVISEUR_VIN;
  
         if (real_vin >= 6)
  {
    analogWrite(led_1,255);
    analogWrite(led_2,0);
    analogWrite(led_3,0);
    analogWrite(led_4,0);
  }
       if (real_vin >= 7)
  {
    analogWrite(led_1,255);
    analogWrite(led_2,255);
    analogWrite(led_3,0);
    analogWrite(led_4,0);
   }
    if (real_vin >= 8)
  {
    analogWrite(led_1,255);
    analogWrite(led_2,255);
    analogWrite(led_3,255);
    analogWrite(led_4,0);
   }
   if (real_vin >= 9)
  {
    analogWrite(led_1,255);
    analogWrite(led_2,255);
    analogWrite(led_3,255);
    analogWrite(led_4,255);
   }
  
 
  /* Affichage */
  Serial.println(real_vin, 3);
  delay(1000);
}

void secu() // Secu fermeture automatique si coupure de courant
  
    {  
       if (digitalRead(btn_park) == LOW)
  {
    digitalWrite(relais_secu,HIGH);
  }
    
 
    }

Par ailleurs, j'ai trouvé des trucs bizarres dans le code original concernant trois variables qui ne sont pas écrites de la même manière dans la partie setup et dans loop :

Dans la partie enum, il y a motorStatuses, lightStatuses et coverStatuses.

Et dans le programme, elles sont écrites : motorStatus, lightStatus et coverStatus.

Est-ce normal ?

Merci pour votre aide...

16 juin 2019

@gehelem Bah... Toute la partie "void handleSerial()"

Par exemple :

 /*
        Set brightness
            Request: >Bxxx\n
                xxx = brightness value from 000-255
            Return : *Biiyyy\n
                id = deviceId
                yyy = value that brightness was set from 000-255
      */
      case 'B':
          brightness = atoi(data);    
          if( lightStatus == ON )
          analogWrite(ledPin, brightness);
          sprintf( temp, "*B%d%03d\n", deviceId, brightness );
          Serial.print(temp);
        break;
      /*
        Get brightness
            Request: >J000\n
            Return : *Jiiyyy\n
                id = deviceId
                yyy = current brightness value from 000-255
      */

Je ne comprends pas bien la façon de programmer.

/* c'est quoi ?

Il y a du texte derrière qui ne semble pas être du programme comme : "Set brightness" ou "xxx = brightness value from 000-255"

Et puis le Request: >Bxxx\n ou Return : *Biiyyy\n et id = deviceId

Ou encore : sprintf( temp, "*B%d%03d\n", deviceId, brightness );

Cela me fait beaucoup d'inconnus pour si peu de lignes 😥

16 juin 2019

Oui, c'est bien celui-ci

16 juin 2019

Bonjour Yves !

Merci pour les tuyaux ! Mon poste est bien plus sexy maintenant 🙂

Concernant le code, c'est toute la partie communication série avec INDI. Je voudrais rendre mon code compatible avec le driver INDI déjà existant du flip flat Alnitak. Mais là... Mes compétences sont vraiment légères. Je ne comprends pas bien comment communique ce driver avec l'arduino. Je ne comprends pas tout le code du driver 😰

Du genre :

Révélation


Typical usage on the command prompt:
Send     : >S000\n      //request state
Recieve  : *S19000\n    //returned state
Send     : >B128\n      //set brightness 128
Recieve  : *B19128\n    //confirming brightness set to 128
Send     : >J000\n      //get brightness
Recieve  : *B19128\n    //brightness value of 128 (assuming as set from above)
Send     : >L000\n      //turn light on (uses set brightness value)
Recieve  : *L19000\n    //confirms light turned on
Send     : >D000\n      //turn light off (brightness value should not be changed)
Recieve  : *D19000\n    //confirms light turned off.

ou :

Révélation


enum devices
{
    FLAT_MAN_L = 10,
    FLAT_MAN_XL = 15,
    FLAT_MAN = 19,
    FLIP_FLAT = 99
};
enum motorStatuses
{
    STOPPED = 0,
    RUNNING
};
enum lightStatuses
{
    OFF = 0,
    ON
};
enum shutterStatuses
{
    UNKNOWN = 0, // ie not open or closed...could be moving
    CLOSED,
    OPEN
};

Et la partie serial 😱 :

Révélation


void handleSerial()
{
  delay(100);
  if( Serial.available() >= 5 )  // all incoming communications are fixed length at 6 bytes including the \n
  {
    char* cmd;
    char* data;
    char temp[10];
    
    int len = 0;
    char str[20];
    memset(str, 0, 20);
    
    // I don't personally like using the \n as a command character for reading.  
    // but that's how the command set is.
  //  Serial.readBytesUntil('\n', str, 20);
  Serial.readBytes( str, 5);
    cmd = str + 1;
    data = str + 2;
    
    // useful for debugging to make sure your commands came through and are parsed correctly.
    if( false )
    {
      sprintf( temp, "cmd = >%s%s;", cmd, data);
      Serial.println(temp);
    }
    

    switch( *cmd )
    {
      /*
        Ping device
            Request: >P000\n
            Return : *Pii000\n
                id = deviceId
      */
      case 'P':
          sprintf(temp, "*P%d000\n", deviceId);
          Serial.print(temp);
          break;
      /*
        Open shutter
            Request: >O000\n
            Return : *Oii000\n
                id = deviceId
            This command is only supported on the Flip-Flat!
      */
      case 'O':
          sprintf(temp, "*O%d000\n", deviceId);
          SetShutter(OPEN);
          EEPROM.put(position_cap,OPEN);
          Serial.print(temp);
          break;

      /*
        Close shutter
            Request: >C000\n
            Return : *Cii000\n
                id = deviceId
            This command is only supported on the Flip-Flat!
      */
      case 'C':
          sprintf(temp, "*C%d000\n", deviceId);
          SetShutter(CLOSED);
          EEPROM.put(position_cap,CLOSED);
          Serial.print(temp);
          break;
      /*
        Turn light on
            Request: >L000\n
            Return : *Lii000\n
                id = deviceId
      */
      case 'L':
          sprintf(temp, "*L%d000\n", deviceId);
          Serial.print(temp);
          lightStatus = ON;
          break;
      /*
        Turn light off
            Request: >D000\n
            Return : *Dii000\n
                id = deviceId
      */
      case 'D':
          sprintf(temp, "*D%d000\n", deviceId);
          Serial.print(temp);
          lightStatus = OFF;
          analogWrite(ledPin, 0);
          break;
      /*
        Set brightness
            Request: >Bxxx\n
                xxx = brightness value from 000-255
            Return : *Biiyyy\n
                id = deviceId
                yyy = value that brightness was set from 000-255
      */
      case 'B':
          brightness = atoi(data);    
          if( lightStatus == ON )
          analogWrite(ledPin, brightness);
          sprintf( temp, "*B%d%03d\n", deviceId, brightness );
          Serial.print(temp);
        break;
      /*
        Get brightness
            Request: >J000\n
            Return : *Jiiyyy\n
                id = deviceId
                yyy = current brightness value from 000-255
      */
      case 'J':
        sprintf( temp, "*J%d%03d\n", deviceId, brightness);
        Serial.print(temp);
        break;
      
      /*
        Get device status:
            Request: >S000\n
            Return : *SidMLC\n
                id = deviceId
                M  = motor status( 0 stopped, 1 running)
                L  = light status( 0 off, 1 on)
                C  = Cover Status( 0 moving, 1 closed, 2 open)
      */
      case 'S':
        sprintf( temp, "*S%d%d%d%d\n",deviceId, motorStatus, lightStatus, EEPROM.get(position_cap,coverStatus));
        Serial.print(temp);
        break;
      /*
        Get firmware version
            Request: >V000\n
            Return : *Vii001\n
                id = deviceId
      */
      case 'V': // get firmware version
          sprintf(temp, "*V%d001\n", deviceId);
          Serial.print(temp);
          break;
    }    
    while( Serial.available() > 0 )
        Serial.read();
            
  }
}

Connexion

Profils

Forums

Téléchargements

Blogs

Boutique

Calendrier

Noctua

Messages posté(e)s par Fabrice Teissier

Information importante