IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Arduino Discussion :

Détection de top synchro sur FI sur 162kh (fréquence étalon).


Sujet :

Arduino

  1. #21
    Membre à l'essai
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    Mars 2019
    Messages
    64
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 62
    Localisation : France, Loire (Rhône Alpes)

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Mars 2019
    Messages : 64
    Points : 23
    Points
    23
    Par défaut Décodage code hoaraire 162kh
    Bonjour à vous... Je suis sagement à la maison lol,

    J'essaie en me servant de ton programme, de le réécrire sans interruption, avec des millis() , delay et digitalRead (c'est pour apprendre).
    Il me semble que cela devrait être aussi fiable qu'avec des interruptions...? on mesure des temps de plusieurs dizaines de millisecondes (on est au ralenti).

    Pour l'instant je bute sur les drapeaux et les millis() qui ne se laissent pas facilement manipuler dans des "conditions IF".


    Une aide sera sans doute la bienvenue , sinon, Leclerc vend des horloges pilotées par dcf77 .

    Bonne soirée

    pat42

  2. #22
    Membre émérite
    Avatar de jpbbricole
    Homme Profil pro
    Retraité des réseaux informatiques
    Inscrit en
    Février 2013
    Messages
    1 012
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : Retraité des réseaux informatiques
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Février 2013
    Messages : 1 012
    Points : 2 341
    Points
    2 341
    Par défaut
    Bonsoir Pat
    Citation Envoyé par Pat42 Voir le message
    J'essaie en me servant de ton programme, de le réécrire sans interruption, avec des millis() , delay et digitalRead (c'est pour apprendre).
    Il me semble que cela devrait être aussi fiable qu'avec des interruptions...? on mesure des temps de plusieurs dizaines de millisecondes (on est au ralenti).....
    Bof! Peut-être, mais certainement très ardu à développer, c'est clair qu'avec environ 6 semaines de confinement, tu as le temps . Avec les interrupt, ça se fait "presque tout seul", tu n'as qu'à pêcher le résultat quand l'interrupt te le signale.

    Citation Envoyé par Pat42 Voir le message
    sinon, Leclerc vend des horloges pilotées par dcf77 .
    Il y a aussi ça.

    Cordialement
    jpbbricole
    L'expérience est la seule chose qu'il ne faut acheter que d'occasion!

  3. #23
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 711
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 711
    Points : 5 390
    Points
    5 390
    Par défaut
    Citation Envoyé par Pat42 Voir le message
    J'essaie en me servant de ton programme, de le réécrire sans interruption, avec des millis() , delay et digitalRead (c'est pour apprendre).
    Il me semble que cela devrait être aussi fiable qu'avec des interruptions...? on mesure des temps de plusieurs dizaines de millisecondes (on est au ralenti).
    Pour l'instant je bute sur les drapeaux et les millis() qui ne se laissent pas facilement manipuler dans des "conditions IF".
    Oui c'est tout à fait réalisable étant donné que le code ne fait rien d'autre pour le moment et qu'on s"intéresse à des événements lents. Une petite machine à état va régler cela pour vous.

    Voici un exemple de comment ça pourrait se coder (tapé ici, donc pas sûr à 100% que ça compile) - je vous laisse debuguer si nécessaire

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    // les constantes
    const uint8_t pinImportante = 2;
    const uint8_t ledPin = LED_BUILTIN; // la LED intégrée sur la carte (pin 13 sur un UNO par exemple)
     
    const uint16_t topSyncMinimum = 800U;   // durée min d'attente
    const uint16_t dureeSyncLED = 50U;      // durée d'allumage de la LED
    const uint16_t antiRebond = 15U;        // si le signal n'est pas pur, on évitera les rebonds en attendant un peu
     
    // variable pour la mesure du temps
    uint32_t topChronoDepartMesure, topChronoFinMesure;
     
    // les différentes etapes du processus
    enum : uint8_t {ATTENTE_HIGH, ATTENTE_LOW, MESURE, LED_SYNC_ON} etapeMesure = ATTENTE_HIGH;
     
    void setup()
    {
      pinMode(pinImportante, INPUT_PULLUP);
      pinMode(ledPin, OUTPUT);
      digitalWrite(ledPin, LOW);
      Serial.begin(115200);
    }
     
    void loop()
    {
      uint8_t etatPinImportante = digitalRead(pinImportante);
      switch (etapeMesure) {
     
        case ATTENTE_HIGH: // Lors du premier lancement, il ne faut pas prendre le train en route, on attend un HIGH
          if (etatPinImportante == HIGH) etapeMesure = ATTENTE_LOW; // c'est bon on est prêt à commencer
          break;
     
        case ATTENTE_LOW: // On attend que la pin passe à LOW
          if (etatPinImportante == LOW) {
            topChronoDepartMesure = millis();
            delay(antiRebond);
            etapeMesure = MESURE; // c'est bon on mesure
          }
          break;
     
        case MESURE: // on est LOW, on attend de repasser à HIGH
          if (etatPinImportante == HIGH) { // ok, on vient de repasser HIGH
            topChronoFinMesure = millis();
            if (topChronoFinMesure - topChronoDepartMesure >= topSyncMinimum) { // si plus de topSyncMinimum ms alors led allumée 50 ms
              digitalWrite(ledPin, HIGH);
              etapeMesure = LED_SYNC_ON; // on active la lED
              Serial.print(F("TOP SYNC !"));
            } else {
              etapeMesure = ATTENTE_LOW; // On est prêt à recommencer
              Serial.print(F("Parasite !"));
              delay(antiRebond);
            }
            Serial.print(F("\tTEMPS = "));
            Serial.print(topChronoFinMesure - topChronoDepartMesure);
            Serial.println(F(" ms."));
          }
          break;
     
        case LED_SYNC_ON:
          if (millis() - topChronoFinMesure >= dureeSyncLED) {
            digitalWrite(ledPin, LOW);
            etapeMesure = ATTENTE_LOW; // On est prêt à recommencer
          }
          break;
      }
    }
    L'idée d'une machine à état c'est qu'on définit formellement dans quel état se trouve le programme à un instant T et quels sont les événements qui peuvent survenir pour nous faire changer d'état.
    La structure du code est simple, dans la loop on regarde dans quel état on est par un switch/case et pour chaque cas on traite les événements possibles

    J'ai identifié 4 états que je range pour la bonne forme dans un enum
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    enum : uint8_t {ATTENTE_HIGH, ATTENTE_LOW, MESURE, LED_SYNC_ON} etapeMesure = ATTENTE_HIGH;
    et je vais suivre mon état dans la variable etapeMesure. Au début du programme on veut s'assurer que l'on part avec la pin HIGH pour bien détecter une transition vers LOW. donc l'état initial sera ATTENTE_HIGH et le case associé ne fait qu'attendre un HIGH.

    Une fois qu'on reçoit ce HIGH, on passe à l'étape suivante qui est d'attendre le LOW.

    Quand on reçoit LOW on note l'heure de départ et on passe à l'étape suivante qui est la mesure et on attend le prochain HIGH.

    Quand on reçoit le HIGH, on note l'heure de fin. et on vérifie si c'est un signal qui a bien durée plus de 800ms ou pas. Si c'est un bon signal alors on passe dans un mode ou on allume la LED sinon on retourne à l'attente

    Quand on est dans le mode LED allumée, on attend que les 50ms se soient écoulées puis on retourne au départ.

    ça devrait marcher car les signaux sont lents, mais on voit bien avec cette approche que si par hasard le signal vient à changer pendant que la LED de sync est allumée, on ne le voit pas tout de suite alors qu'avec l'approche par interruption c'est capturé pour vous. (On voit aussi qu'il y a plus de code qu'avec l'interruption !)

    A titre "éducatif" c'est toujours bon de savoir écrire une petite machine à états.

  4. #24
    Membre à l'essai
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    Mars 2019
    Messages
    64
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 62
    Localisation : France, Loire (Rhône Alpes)

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Mars 2019
    Messages : 64
    Points : 23
    Points
    23
    Par défaut Décodage code horaire 162kh
    Bonjour à vous,

    C' est uniquement pour apprendre et bien comprendre que je veux un petit programme sans interruption.
    Il est certain que les interrupts seront nécessaires, car il y aura à gérer, l'afficheur I2c, le décodage des bits ect...

    Je suis allé faire un tour sur le lien, Effectivement, ce sont des modules pour la réception de DCF 77.
    Il y a quelques temps de cela , je m'étais fabriqué un récepteur sur la fréquence de 77.5 khz et la logique qui va bien pour l'heure (avec une tartine de CI).
    La réception n'étant pas terrible, je me retourne sur Allouis qui m'arrive clair et net, et la carte arduino nano qui me donnera souplesse et simplicité pour des modifs
    éventuelles.


    Super le code et les explications, je vais me les garder pour se soir lol.

    Je vous mets en pièce jointe un souvenir..
    Une carte de développement (intégrant le célèbre 68 HC11) utilisée dans le bureau d'étude dans lequel je bossais en 1991. Cette carte se connecte sur un pc ou un Minitel .
    Cela permettait aux collègues programmeurs d'emmener du boulot chez eux lol ...A l'époque les PC n'étaient pas courant chez les particuliers, le minitel SI !

    Je vais prendre un peu de temps pour la remettre en fonctionnement, pour le fun.

    Merci et bonne soirée à vous.

    PAT42
    Images attachées Images attachées  

  5. #25
    Membre à l'essai
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    Mars 2019
    Messages
    64
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 62
    Localisation : France, Loire (Rhône Alpes)

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Mars 2019
    Messages : 64
    Points : 23
    Points
    23
    Par défaut Décodage code hoaraire 162kh
    Bonsoir, j'ai testé le code sans interrupt. et cela fonctionne sans avoir eu besoin de débugger...
    Avec ce que j' ai appris , je vais essayer de greffer le top des secondes sur le programme.

    Bonne soirée à vous et à JP.

    Pat 42

  6. #26
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 711
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 711
    Points : 5 390
    Points
    5 390
    Par défaut
    Citation Envoyé par Pat42 Voir le message
    Bonsoir, j'ai testé le code sans interrupt. et cela fonctionne sans avoir eu besoin de débugger...


    cool

    bonne soirée (et merci pour la jolie photo souvenir !!)

  7. #27
    Membre à l'essai
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    Mars 2019
    Messages
    64
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 62
    Localisation : France, Loire (Rhône Alpes)

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Mars 2019
    Messages : 64
    Points : 23
    Points
    23
    Par défaut Décodage code horaire 162kh
    Bonjour a vous,
    j'ai bossé sur mon horloge pilotée , mais comme n'ayant pas encore beaucoup d'expérience, je bute sur deux pbs...

    J'ai intégré dans le programme qui gère la synchro un timer (timer 2) qui est synchronisé par le top synchro et me génère une interruption toutes les secondes.

    Je me suis aperçu que la seconde est trop longue et qu' à la fin d'une minute , je ne suis plus synchro de 5ms. j'ai diminué le compteur "nbrInterrup" à 248, mais là, c'est l"inverse et il me manque du temps. Puis je rajouter du temps précisément avec "delay" sans que cela crée un soucis dans le fonctionnement des interruptions ou y a t 'il une autre solution ?

    Et ma question principale est la suivante,

    je n'arrive pas à intégrer une fonction tempo de 50ms avec millis(); dans une quelconque routine pour avoir un niveau haut de 50 ms à chaque seconde.
    Comment puis je m'y prendre en sachant que je m'en sors avec delay ( mais que je veux éviter d'utiliser car j'aurais besoin après chaque interruption d' un niveau haut de 50ms indiquant par une led les secondes et "au même instant" le démarrage d'une tempo de 200ms pour lire les bits de données suivant le top.) ?

    je vous mets les deux programmes.

    Je vous remercie.

    Pat

    Programme avec delay.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    #define interruptPin 2
    int16_t nbrInterrupt;
    volatile boolean compteur = 0;                                                                                //volatile boolean mesureEnCours = false;
    volatile boolean mesureNouvelle = false;
    volatile unsigned long tempoDepart = millis();
    volatile unsigned long topSyncMilliSec = millis();
    int ledSeconde = 12;
    int ledMinute = 13;
    const unsigned int topSyncMinimum = 1000;
     
    void setup()
    {
      Serial.begin(115200);
      pinMode (ledSeconde, OUTPUT);
      digitalWrite(ledSeconde, LOW);
      pinMode (ledMinute, OUTPUT);
      digitalWrite(ledMinute, LOW);
     
                                                           // Initialise le Timer 2 pour déclencher les interruptions à intervalle régulier,
      TCCR2A = 0;                                         //on peut aussi écrire bitClear (TCCR2A, WGM21); // WGM21 = 0 -----//bitClear (TCCR2A, WGM20); // WGM20 = 0
      TCCR2B = 0b00000110;                               // clk/256 est incrémenté toutes les 16uS
      TIMSK2 = 0b00000001;                               // TOIE2 Autorise l'interruption quand le compteur déborde
      pinMode(interruptPin, INPUT_PULLUP);
      pinMode(ledMinute, OUTPUT);
     
     
     
      attachInterrupt(digitalPinToInterrupt(interruptPin), impulsionInterruption, CHANGE);
    }
     
    void loop()
    {
      if (mesureNouvelle == true)
      {
        topSyncAction();
        mesureNouvelle = false;
      }
      if (compteur == 1)
      {
        routineSeconde();
        compteur = 0;
      }
     
    } 
     
     
     
     
    void impulsionInterruption()
    {
      if (digitalRead(interruptPin) == LOW)// && !mesureEnCours)
      {
        tempoDepart = millis();
        //mesureEnCours = true;
      }
      if (digitalRead(interruptPin) == HIGH)// && mesureEnCours)
      {
        topSyncMilliSec = millis() - tempoDepart;
        // mesureEnCours = false;
        mesureNouvelle = true;
     
      }
     
    }
     
     
     
     
    void topSyncAction()
    {
      if (topSyncMilliSec >= topSyncMinimum)
      {
        nbrInterrupt = 0;
        digitalWrite (ledMinute,HIGH);
        delay(50);
        digitalWrite (ledMinute, LOW);
        //digitalWrite (ledSeconde,HIGH);
       //routineSeconde();
       //digitalWrite (ledSeconde,HIGH);
      }
     
      else
      {
        digitalWrite(ledMinute, LOW);
      }
     
    }
     
    ISR(TIMER2_OVF_vect)
    {
      TCNT2 = 6;                      //on met TCNT2 a 7 pour avoir un comptage de 249 incrementations 256 -7= 249
     
      if (nbrInterrupt++ >= 249)     //interruption toutes les secondes
      {
        nbrInterrupt = 0;            //on remet nbrIterrupt à 0
        compteur = 1;
     
      }
     
    }
     
     
     
    void routineSeconde()
    {
      digitalWrite ( ledSeconde, HIGH);
      delay(50);
      digitalWrite (ledSeconde, LOW);
     
    }
    programme non fonctionnel avec millis();

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    #define interruptPin 2
    int16_t nbrInterrupt;
    volatile boolean compteur = 0;
    volatile boolean mesureEnCours = false;                                                                              
    volatile boolean mesureNouvelle = false;
    volatile unsigned long tempoDepart = millis();
    volatile unsigned long topSyncMilliSec = millis();
    volatile unsigned long departSeconde = millis();
    int ledSeconde = 12;
    int ledMinute = 13;
    const unsigned int topSyncMinimum = 1000;
     
    void setup()
    {
      Serial.begin(115200);
      pinMode (ledSeconde, OUTPUT);
      digitalWrite(ledSeconde, LOW);
      pinMode (ledMinute, OUTPUT);
      digitalWrite(ledMinute, LOW);
     
      // Initialise le Timer 2 pour déclencher les interruptions à intervalle régulier,
      TCCR2A = 0;                                         //on peut aussi écrire bitClear (TCCR2A, WGM21); // WGM21 = 0 -----//bitClear (TCCR2A, WGM20); // WGM20 = 0
      TCCR2B = 0b00000110;                               // clk/256 est incrémenté toutes les 16uS
      TIMSK2 = 0b00000001;                               // TOIE2 Autorise l'interruption quand le compteur déborde
      pinMode(interruptPin, INPUT_PULLUP);
      pinMode(ledMinute, OUTPUT);
     
     
     
      attachInterrupt(digitalPinToInterrupt(interruptPin), impulsionInterruption, CHANGE);
    }
     
    void loop()
    {
      if (mesureNouvelle == true)
      {
        topSyncAction();
        mesureNouvelle = false;
      }
     
      if (digitalRead (ledSeconde) == HIGH)
      {
       departSeconde = millis();
       routineSeconde();
      }
     
     
    }
     
     
     
     
    void impulsionInterruption()
    {
      if (digitalRead(interruptPin) == LOW && !mesureEnCours)
      {
        tempoDepart = millis();
        mesureEnCours = true;
      }
      if (digitalRead(interruptPin) == HIGH && mesureEnCours)
      {
        topSyncMilliSec = millis() - tempoDepart;
         mesureEnCours = false;
        mesureNouvelle = true;
     
      }
     
    }
     
     
    void topSyncAction()
    {
      if (topSyncMilliSec >= topSyncMinimum)
      {
        nbrInterrupt = 0;
        digitalWrite (ledMinute, HIGH);
        delay(50);
        digitalWrite (ledMinute, LOW);
        //digitalWrite (ledSeconde,HIGH);
        //routineSeconde();
        //digitalWrite (ledSeconde,HIGH);
      }
     
      else
      {
        digitalWrite(ledMinute, LOW);
      }
     
    }
     
    ISR(TIMER2_OVF_vect)
    {
      TCNT2 = 6;                      //on met TCNT2 a 7 pour avoir un comptage de 249 incrementations 256 -7= 249
     
      if (nbrInterrupt++ >= 249)     //interruption toutes les secondes
      {
        nbrInterrupt = 0;            //on remet nbrIterrupt à 0
        compteur = 1;
        digitalWrite(ledSeconde , HIGH);
     
      }
     
    }
     
    void routineSeconde()
    {
     
     
      if (millis() >= departSeconde == 50)
      {
        digitalWrite (ledSeconde, LOW);
      }
     
    }

  8. #28
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 711
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 711
    Points : 5 390
    Points
    5 390
    Par défaut
    dans la version avec interruption il faut que les variables partagées en lecture/écriture entre l'ISR et la loop soient déclarées en volatile
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    volatile uint16_t nbrInterrupt;
    Mais avec des traitements nécessaire à la ms, je pense que vous n'avez pas besoin de timer.

    Ensuite vous aurez toujours une dérive, le résonateur des petits Arduino n'est pas précis dans la durée donc pour faire des mesures sur du long terme la solution est de ne pas utiliser l'oscillateur interne du micro mais de prendre un vrai oscillateur ou s'assurer qu'on ne cumule pas une mesure trop longue

    je n'arrive pas à intégrer une fonction tempo de 50ms avec millis(); dans une quelconque routine pour avoir un niveau haut de 50 ms à chaque seconde.
    il faut le faire avec une machine à état comme dans le code que j'avais proposé avec le ou juste un if sur l'état de cette LED (ce qui revient à avoir plusieurs machines à états en parallèle si on veut gérer des événements disjoints)

  9. #29
    Membre à l'essai
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    Mars 2019
    Messages
    64
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 62
    Localisation : France, Loire (Rhône Alpes)

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Mars 2019
    Messages : 64
    Points : 23
    Points
    23
    Par défaut Décodage code horaire 162kh
    Bonjour, Jay M

    Je vais modifier "nbrInterrupt"
    Je n'aurais pas de pb de dérive étant donné que je réinitialise le compteur une fois par minute avec la synchro. donc pas de soucis . Le pb est que la seconde ne fait pas une seconde et qu'a la fin de la minute, les micros secondes sont devenues des ms.

    Mon souci avec millis(), est que cela ne fonctionne pas dans la fonction interruption et même dans une routine appelée par la fonction interruption.
    Il faut que j'utilise la loop et là je bug.

    j'ai pensé à ne pas utiliser le timer, car oui! cela ne va pas vite...

    Merci pour les conseils

    Cordialement

    Pat

  10. #30
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 711
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 711
    Points : 5 390
    Points
    5 390
    Par défaut
    inspirez vous du code posté en #23 pour faire une machine à état...

    Mon souci avec millis(), est que cela ne fonctionne pas dans la fonction interruption et même dans une routine appelée par la fonction interruption.
    la valeur de millis() est correcte à l'entrée de l'interruption mais oui elle n'évolue plus et si vous avez à passer plus d'une milliseconde dans une interruption c'est qu'il y a un souci de conception de toutes façons.

  11. #31
    Membre à l'essai
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    Mars 2019
    Messages
    64
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 62
    Localisation : France, Loire (Rhône Alpes)

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Mars 2019
    Messages : 64
    Points : 23
    Points
    23
    Par défaut Décodage code horaire 162kh
    Petite avancée sur mon projet, " mon horloge à moi" mais maintenant je suis bloqué.

    J'ai greffé sur le programme de Jp, une routine qui me permet d'avoir un top de 125ms tout les débuts de seconde et qui sont visualisés... par une led.

    Le programme se synchronise impeccablement avec l'interruption générée par le top syncro. du début de la première seconde ( émetteur Allouis sur 162 khz), et pour plus de précision, j'ai utilisé microseconds(); ce qui m'a permis d'ajuster parfaitement mes secondes (qui font 1 seconde).


    Une deuxième routine me permet de ne lire que "l'intérieur" des secondes intéressantes, c'est à dire de la seconde 20 à la seconde 58.
    Ceci n'était pas obligatoire, c'est pour mon... apprentissage.

    Une troisième me permet de mettre les bits en forme pour une lecture et une mémorisation.

    Eh là, je suis bloqué...

    Comme vous pouvez le voir sur la photo, il y a, encadré par des créneaux de 125ms, des données sur deux bits et sur un bit.
    En réalité seul le bit de droite est une donnée , celui de gauche est le top de la seconde en cours, ce qui veut dire qu' un bit = 1 pas de bit = 0.

    1) Pourriez vous me donner un coup de main pour ne faire apparaître ou ne lire que le bit de droite ( Etant donné que se sont les données reçues qui génèrent les interruptions qui elles même génèrent les bits de données , j'ai du mal à trouver la solution).

    2) Comment associer le numéro de la seconde avec la donnée qu'elle contient. Dans le programme , je lis les secondes de 20 à 58 , mais je ne sais pas trop
    écrire par ex: " les secondes 21....27 contiennent chacune un bit à 1 ou à 0, et je vais les mémoriser dans une mémoire nommée "

    Il me faudra bien sur plusieurs emplacements mémoires , heure, mois, année etc... que je lirai à la 59° seconde .

    N'ayant pas encore les connaissances nécessaires et la maîtrise des subtilités "arduiniennes" pour écrire un joli prg, j'écris le mien en avançant chronologiquement et ainsi, éviter de me perdre...

    Merci de m'éclairer.

    Pat42

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
     
    #define interruptPin 2                                      // Pin de l'interrupt
     
    volatile boolean mesureEnCours = false;                     // Volatile pour les variables traitées en interrupt
    volatile boolean mesureNouvelle = false;
    volatile unsigned long tempoDepart = millis();
    volatile unsigned long topSyncMilliSec = millis();
    volatile unsigned long departMesure = millis();
    volatile unsigned long departbit_Importante = millis();
    const unsigned int topSyncMinimum = 800;
     
    #define led_bit 12
    #define ledSeconde 13
     
    int compteurSeconde = 0;
     
    int infoMinute = 0;
    int infoheure =  0;
    int infoJourDuMois = 0;
    int infoJourDeLaSemaine = 0;
    int infoAnnee = 0;
     
    void setup()
    {
      Serial.begin (115200);
      pinMode(interruptPin, INPUT_PULLUP);
      pinMode(ledSeconde, OUTPUT);
      digitalWrite(ledSeconde, LOW);
      pinMode(led_bit, OUTPUT);
      digitalWrite(led_bit, LOW);
      attachInterrupt(digitalPinToInterrupt(interruptPin), impulsion_Interruption, CHANGE); //interruption pour rechercher le top syncrho du debut de la pemière seconde
    }
     
    void loop()
    {
     
      if (mesureNouvelle == true)
      {
        mesureNouvelle = false;
        topSyncAction();
      }
     
      calibrage_Seconde();
      lecture_Seconde_Importante();
      lecture_Bit_Importante();
    }
     
     
    void impulsion_Interruption()
    {
      if (digitalRead(interruptPin) == LOW && !mesureEnCours)
      {
        tempoDepart = millis();
        mesureEnCours = true;
      }
     
      if (digitalRead(interruptPin) == HIGH && mesureEnCours)
      {
     
        topSyncMilliSec = millis() - tempoDepart;
        mesureEnCours = false;
        mesureNouvelle = true;
      }
    }
     
     
    void topSyncAction()
    {
     
      if (topSyncMilliSec >= topSyncMinimum)
      {
        departMesure = micros();
        digitalWrite (ledSeconde, HIGH);
        compteurSeconde = 0;
     
      }
    }
     
     
    void calibrage_Seconde()
    {
     
        if (micros() - departMesure >= 140000 )
      {
        digitalWrite(ledSeconde, LOW);
     
        if (micros() - departMesure >= 999550)
        {
          digitalWrite(ledSeconde, HIGH);
          departMesure = micros();
          departbit_Importante = millis();
          compteurSeconde++;
        }
     
      }
     
    }
     
    void lecture_Seconde_Importante()
    {
        //Serial.println (compteur);
     
        if ( digitalRead (ledSeconde) == HIGH &&  digitalRead (interruptPin) == HIGH &&(compteurSeconde >= 20 && compteurSeconde <= 58))
       {
        digitalWrite (led_bit , HIGH);
        departbit_Importante = millis();
        //Serial.println (compteurSeconde);
       }
     
     
    }
     
    void lecture_Bit_Importante()
    {
       if( millis()- departbit_Importante >= 25) 
       { 
     
        digitalWrite (led_bit, LOW);
     
       }
     
    }
    Images attachées Images attachées  

  12. #32
    Membre émérite
    Avatar de jpbbricole
    Homme Profil pro
    Retraité des réseaux informatiques
    Inscrit en
    Février 2013
    Messages
    1 012
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : Retraité des réseaux informatiques
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Février 2013
    Messages : 1 012
    Points : 2 341
    Points
    2 341
    Par défaut
    Bonjour Pat
    Citation Envoyé par Pat42 Voir le message
    ...une routine qui me permet d'avoir un top de 125ms tout les débuts de seconde et qui sont visualisés... par une led....
    Comme vous pouvez le voir sur la photo, il y a, encadré par des créneaux de 125ms, des données sur deux bits et sur un bit.
    ...
    En réalité seul le bit de droite est une donnée , celui de gauche est le top de la seconde en cours, ce qui veut dire qu' un bit = 1 pas de bit = 0.
    Je n'ai pas cherché d'où provient cette période 125 ms, mais si tu la scinde en 2, une de 100 et une de 25 (en bidouillant pour compenser le temps des opérations), à la fin de celle de 100, tu peux tester l'état du bit.

    Citation Envoyé par Pat42 Voir le message
    2) Comment associer le numéro de la seconde avec la donnée qu'elle contient. Dans le programme , je lis les secondes de 20 à 58 , mais je ne sais pas trop
    En créant un tableau (array) de 60 "cases", qui contiennent l'état du bit.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    int infoMinute[60];                       // Déclaration du tableau Minute avec 60 secondes
    //Pour mémoriser l'état du bit
    infoMinute[numeroSeconde] = etatDuBit;
    Cordialement
    jpbbricole
    L'expérience est la seule chose qu'il ne faut acheter que d'occasion!

  13. #33
    Membre à l'essai
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    Mars 2019
    Messages
    64
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 62
    Localisation : France, Loire (Rhône Alpes)

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Mars 2019
    Messages : 64
    Points : 23
    Points
    23
    Par défaut Décodage code horaire 162kh
    Bonsoir Jp,

    Je crée mon temps de 125 ms dans la routine "calibrage_Seconde". A chaque début de seconde, il faut lire les données et la donnée à lire se termine à 125ms du début de chaque seconde. J'ai donc calibré mon créneau seconde à cette valeur, pour encadrer le top seconde et le bit des données, ce qui me permet en passant de faire clignoter ma led .

    Concernant ta réponse à ma première question, du coup il serait peut être plus facile de lire dans ce créneau, et le top seconde qui est présent à chaque seconde et le bit des données. Ce qui ferait 2 bits à 1 = 1 et 1 bit ( le top seconde ) à 1 = 0. On éviterait ainsi de bidouiller

    j'ai essayé en vain de lire ces bits, mais cela ne marche pas ou ce qui est le plus probable , je ne sais pas faire...

    je vais me pencher sur le tableau array que je ne connais pas...

    Merci et bonne soirée

    Pat42

  14. #34
    Membre émérite
    Avatar de jpbbricole
    Homme Profil pro
    Retraité des réseaux informatiques
    Inscrit en
    Février 2013
    Messages
    1 012
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : Retraité des réseaux informatiques
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Février 2013
    Messages : 1 012
    Points : 2 341
    Points
    2 341
    Par défaut
    Bonjour Pat

    Citation Envoyé par Pat42 Voir le message
    je vais me pencher sur le tableau array que je ne connais pas...
    En résumé ça donne ceci:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    byte bitDonnees[60];                 // Déclaration du tableau
     
    void setup()
    {
    	 for (byte s = 0; s <= 59; s++)   // Initialisation des bits de données
    	 {                                // A faire avant chaque cycle de minute
    		 bitDonnees[s] = 0;          
    	 }
    }
     
    void loop()
    {
     
    }
    Citation Envoyé par Pat42 Voir le message
    ...du coup il serait peut être plus facile de lire dans ce créneau, et le top seconde qui est présent à chaque seconde et le bit des données....
    Si j'ai tout compris, le bit de données déclenche également l'interruption, mais après top debut 1° seconde ?
    Si oui, à cet instant, ledSeconde == HIGH, donc si interruption && ledSeconde == HIGH, bitDonnees[compteurSeconde] = 1
    S'il n'y a pas ce bit de donnée, bitDonnees[compteurSeconde] reste inchangé, donc à 0.
    Ne pas oublier que le tableau bitDonnees[s] doît être remis à 0 avant chaque cycle de minute.
    Je te laisse arranger tout ceci en "Arduino"

    PS: Ne serais-tu pas entrain de décoder un protocole DCF77?

    Cordialement
    jpbbricole
    L'expérience est la seule chose qu'il ne faut acheter que d'occasion!

  15. #35
    Membre à l'essai
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    Mars 2019
    Messages
    64
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 62
    Localisation : France, Loire (Rhône Alpes)

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Mars 2019
    Messages : 64
    Points : 23
    Points
    23
    Par défaut Décodage code horaire 162kh
    Bonjour Jp,

    C'est cela, toutes les données déclenchent une interruption sur leur front montant ou descendant.
    Mais il n'y a que celle du front montant de la première seconde qui synchronise la routine " calibrage_Seconde" par l'intermédiaire de la machine à état et de la routine "topSyncAction" que tu m'avais écrite. Ensuite, la routine tourne seule en attendant le nouveau top synchro qui la recadrera s'il y a besoin (une sorte de PLL)

    Puis il faut lire les données qui arrivent à chaque début de seconde ( durée de 140ms) de la seconde 20 à la seconde 58)

    Je dois sans doute me répéter dans ce fil, mais pas toujours facile d'expliquer ou de comprendre par clavier interposé.

    DCF 77 est modulé en amplitude, France inter en modulation de phase, mais leur codage horaire est quasi identique. Je pourrais avec quelques composants supplémentaires avoir des données de sortie identiques . A savoir, une amplitude moindre sur 100 ms pour un bit à 0 et 200 ms pour un bit à 1, et du coup utiliser
    des bibliothèques DCF77 toutes faites dont je pourrais me servir...

    Mais il me faut" me casser la tête" et avec de l'aide, écrire le prg qui va bien. C'est le meilleur moyen , il me semble pour apprendre et comprendre...Et puis c'est une bonne gymnastique intellectuelle quand on prend de l'âge ...


    Merci pour l'exemple et les explications, je vais inclure un tableau dans le prg, et puis je crierais Help si je ne m'en sors pas.

    Petite photo de l'émetteur d'Allouis et de la carte de réception, dire que les Chinois mettent ça sur une puce... (l'antenne cadre n'est pas sur la photo)

    Bon weekend

    Pat42
    Images attachées Images attachées   

  16. #36
    Membre à l'essai
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    Mars 2019
    Messages
    64
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 62
    Localisation : France, Loire (Rhône Alpes)

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Mars 2019
    Messages : 64
    Points : 23
    Points
    23
    Par défaut Décodage code horaire 162kh
    Bonjour,

    J'ai bien avancé sur mon projet "mon horloge à moi" et j'ai pu résoudre deux problèmes (avec votre aide).

    le premier était, comment faire la différence entre deux tops dans un même créneau de 140ms.
    L'un est le top seconde et l'autre le bit de donnée... et ne lire que le bit de donnée.

    Le deuxième, comment associer le bit de donnée à la seconde concernée et intégrer cette association
    dans un tableau array (merci à Jp).

    j'ai pu ainsi mettre en mémoire dans un tableau au fur et à mesures des secondes les bits de données. Le tableau est lu
    à la 59° seconde et s'affichent sur mon pc par la liaison série (voir photo).

    j'ai aussi mis en oeuvre un afficheur ou j'ai pu après quelques incompréhensions, faire défiler les secondes.

    Il me reste à lire les données par paquet de 7 bits, les convertir en décimal et les envoyer
    sur l'afficheur au prochain top synchro ( début de la première seconde).

    Une petite explication pour la bonne compréhension de ce que je dois encore mettre en oeuvre.

    Par exemple, sur les secondes 20 à 27 qui concernent la minute qui sera affichée au prochain top.

    exp: pour 27 minutes

    le bit de la seconde 21 à 1 = 1 -- 1
    le bit de la seconde 22 à 1 = 2 -- 1
    le bit de la seconde 23 à 1 = 4 -- 1
    le bit de la seconde 24 à 1 = 8 -- 0 écriture pour 27 minutes

    le bit de la seconde 25 à 1 = 10 -- 0
    le bit de la seconde 26 à 1 = 20 -- 1
    le bit de la seconde 27 à 1 = 40 -- 0



    le bit des secondes 21, 22 ,23 sont à 1 ainsi que le bit de la seconde 26 qui vaux 20 .

    il y a comme cela, le paquet des minutes, heures, jour, année...

    Comment dois-je mis prendre pour lire un un paquet de 7 bits dans un tableau (contenant 59 cases), les additionner
    et les convertir en décimales, en sachant que les secondes 25 à 27 dans cette exemple ne sont pas en binaire, mais multiples de 10 ?

    Merci pour votre aide

    Pat


    Le petit bout de pgr qui récupère les données et les affiches...

    ------------------------------------------------------------------------------

    Code C : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    void lecture_Tableau_Info_Donnees()
    {    
      if(compteurSeconde == 59 && top2 == true) 
      { 
     
        for( byte s = 0; s <= nombreDeSeconde ; s++ )
        {
         Serial.print ("Seconde"); Serial.print(s);Serial.print("   "); Serial.print ("info_donnée--->"); Serial.println(infoDonnees[s]); //pour test  
        }
       top2 = false;
      }
    }
     //---------------------------------------------------------------------------------
     
    void affichage_I2c()
    {
      if( top3 == true)
      {
        lcd.backlight();
        // Envoi du message
        lcd.setCursor(0, 0);
        lcd.print("TEST");
        lcd.setCursor(10,1);
        lcd.print( compteurSeconde);
        lcd.setCursor(13,1);
        lcd.print("sec");
        top3 = false;
     
      }
    }
    Images attachées Images attachées  

  17. #37
    Membre émérite
    Avatar de jpbbricole
    Homme Profil pro
    Retraité des réseaux informatiques
    Inscrit en
    Février 2013
    Messages
    1 012
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : Retraité des réseaux informatiques
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Février 2013
    Messages : 1 012
    Points : 2 341
    Points
    2 341
    Par défaut
    Bonjour Pat

    Tu peux résoudre ton problème en créant un tableau d'indices pour chaque cellules "minutes" de ton tableau bitDonnees
    et ça donne ceci:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    /*
    le bit de la seconde 21 à 1 = 1 -- 1
    le bit de la seconde 22 à 1 = 2 -- 1
    le bit de la seconde 23 à 1 = 4 -- 1
    le bit de la seconde 24 à 1 = 8 -- 0 écriture pour 27 minutes
     
    le bit de la seconde 25 à 1 = 10 -- 0
    le bit de la seconde 26 à 1 = 20 -- 1
    le bit de la seconde 27 à 1 = 40 -- 0
    */
    byte bitDonnees[60];                 // Déclaration du tableau
     
    #define bitDonneesMinutesStart 21
    #define bitDonneesMinutesNbr 7
    byte bitDonneesMinutesCoeff[] = {1, 2, 4, 8, 10, 20, 40};            // Coefficient de valeur de chaque bit "minute"
     
    void setup()
    {
    	Serial.begin(115200);
    	delay(500);
     
    	bitDonnees[bitDonneesMinutesStart] = 1;                          // Mettre 27 dans les mininutes
    	bitDonnees[bitDonneesMinutesStart +1] = 1;
    	bitDonnees[bitDonneesMinutesStart +2] = 1;
    	bitDonnees[bitDonneesMinutesStart +3] = 0;
    	bitDonnees[bitDonneesMinutesStart +4] = 0;
    	bitDonnees[bitDonneesMinutesStart +5] = 1;
    	bitDonnees[bitDonneesMinutesStart +6] = 0;
     
    	int min = extraireMinute();
    	Serial.println(min);
    }
     
    void loop()
    {
     
     
    }
    //------------------------------------- Extraction des minutes du tableau bitDonnees
    int extraireMinute()
    {
    	int minute = 0;
     
    	for (int mInd = 0; mInd < bitDonneesMinutesNbr; mInd ++)
    	{
    		minute += bitDonneesMinutesCoeff[mInd] * bitDonnees[bitDonneesMinutesStart + mInd];
    	}
     
    	return minute;
    }
    Cordialement
    jpbbricole
    L'expérience est la seule chose qu'il ne faut acheter que d'occasion!

  18. #38
    Membre à l'essai
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    Mars 2019
    Messages
    64
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 62
    Localisation : France, Loire (Rhône Alpes)

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Mars 2019
    Messages : 64
    Points : 23
    Points
    23
    Par défaut Décodage code horaire 162kh
    Bonjour Jp,

    Réponse ultra rapide! Je vais étudier le code attentivement, puis écrire le bout de code qui va bien
    Comme d'habitude, si j'ai un souci j'appelle à l'aide...

    Cordialement.

    Pat42

  19. #39
    Membre à l'essai
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    Mars 2019
    Messages
    64
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 62
    Localisation : France, Loire (Rhône Alpes)

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Mars 2019
    Messages : 64
    Points : 23
    Points
    23
    Par défaut Décodage code horaire 162kh
    Bonsoir Jp,

    je suis devant mon pc à me casser la tête pour comprendre le code que tu m'as écrit.

    je bute pour commencer, sur ce morceau de code...

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    int min= extraireMinute();
      Serial.println(min);
    j'ai recherché et je ne trouve que l' instruction" min()" qui détermine le plus petit de deux nombres.
    Pourrais je avoir quelques explications.

    Merci

    Pat

  20. #40
    Membre émérite
    Avatar de jpbbricole
    Homme Profil pro
    Retraité des réseaux informatiques
    Inscrit en
    Février 2013
    Messages
    1 012
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : Retraité des réseaux informatiques
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Février 2013
    Messages : 1 012
    Points : 2 341
    Points
    2 341
    Par défaut
    Bonsoir Pat

    Milles excuses, j'ai mal choisi le nom de ma variable, car ça prête à confusion avec la fonction min()
    change:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    int min = extraireMinute();
    Serial.println(min);
    par
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    int nouvelleMinute = extraireMinute();
    Serial.println(nouvelleMinute);
    Ça t'aide ?

    A+
    jpbbricole
    L'expérience est la seule chose qu'il ne faut acheter que d'occasion!

Discussions similaires

  1. TOP 10 sur WeBI
    Par aemag dans le forum Webi
    Réponses: 9
    Dernier message: 21/05/2008, 20h41
  2. Detecter si l'on a toujours la synchro sur son modem
    Par yoghisan dans le forum API, COM et SDKs
    Réponses: 25
    Dernier message: 21/10/2005, 18h09
  3. Top 10 sur plusieurs items
    Par hussard dans le forum Langage SQL
    Réponses: 1
    Dernier message: 03/10/2005, 09h33
  4. Réponses: 3
    Dernier message: 23/08/2005, 09h43
  5. Détection d'un front sur la broche RI d'un port série
    Par G3G3 dans le forum Ordinateurs
    Réponses: 2
    Dernier message: 19/08/2005, 17h14

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo