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 :

Timers sur Nano


Sujet :

Arduino

  1. #1
    Membre actif
    Inscrit en
    Juillet 2004
    Messages
    762
    Détails du profil
    Informations forums :
    Inscription : Juillet 2004
    Messages : 762
    Points : 230
    Points
    230
    Par défaut Timers sur Nano
    Bonjour à tous,

    Je teste actuellement un couple émetteur (UNO+LoRa RA01 ) récepteur(Nano+LoRa RA01)
    l'ensemble fonctionne correctement mais si je remplace l'UNO par unNANO pour l'émetteur
    celui-ci se bloque et je ne parviens pas à en connaître la raison

    Voici le croquis de l'émetteur :
    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
    123
    124
    125
    126
    127
    128
    129
    130
    131
     
    #include <LoRa.h> 
     
    const int SW1 = 3;
    const int SW2 = 4;
     
    int SyncWord = 0x22;
     
    void setup() {
      Serial.begin(115200);
      pinMode(SW1,INPUT_PULLUP);
      pinMode(SW2,INPUT_PULLUP);
     
      cli();                                    //stop interrupts
                                                //set timer1 interrupt at 1Hz = 1sec
      TCCR1A = 0;                               // set entire TCCR1A register to 0
      TCCR1B = 0;                               // same for TCCR1B
      TCNT1  = 0;                               // initialize counter value to 0
                                                // set compare match register for 1hz increments
      OCR1A = 15624;                            // = (16*10^6) / (1*1024) - 1 (must be <65536)
     
      TCCR1B |= (1 << WGM12);                   // turn on CTC mode                                      
      TCCR1B |= (1 << CS12) | (1 << CS10);      // Set CS10 and CS12 bits for 1024 prescaler                                          
      TIMSK1 |= (1 << OCIE1A);                  // enable timer compare interrupt
     
      sei();                                    //allow interrupts
     
      while (!Serial);  
      Serial.println("LoRa Sender");
      if (!LoRa.begin(433E6)) { // or 915E6, the MHz speed of yout module
        Serial.println("Starting LoRa failed!");
        while (1);
      }
      LoRa.setSpreadingFactor(12);           // ranges from 6-12,default 7 see API docs
      LoRa.setSignalBandwidth(62.5E3 );           // for -139dB (page - 112)
      LoRa.setCodingRate4(8);                   // for -139dB (page - 112)
      LoRa.setSyncWord(SyncWord);
      /*
      Serial.print("current spreading factor : ");
      Serial.println(LoRa.getSpreadingFactor());
      Serial.print("current bandwidth : ");
      Serial.println(LoRa.getSignalBandwidth());
      Serial.println("LoRa init succeeded.");
      */
    }
     
    int priviousSwitchValue1 = 1;
    int priviousSwitchValue2 = 1;
    int liveSwitchValue1 = 0;
    int liveSwitchValue2 = 0;
    bool switchPressFlag1 = false;
    bool switchPressFlag2 = false;
    bool gLedPin = 0;
     
    int data = 1;
     
    void loop() {
      //static int data = 1;
     
      liveSwitchValue1 = digitalRead(SW1);
      if( (liveSwitchValue1 == 0) and (switchPressFlag1 == false) )
      {
        delay(50);
        data = 11;
        Serial.println("11");
        switchPressFlag1 = true;
        priviousSwitchValue1 = !priviousSwitchValue1;
     
        LoRa.beginPacket();  
        LoRa.print(data);
        LoRa.endPacket();
      }
      if( (liveSwitchValue1 == 1) and (switchPressFlag1 == true) )
      {
        delay(50);
        data = 22;
        Serial.println("22");
        switchPressFlag1 = false;
        LoRa.beginPacket();  
        LoRa.print(data);
        LoRa.endPacket();
      }
     
      liveSwitchValue2 = digitalRead(SW2);
      if( (liveSwitchValue2 == 0) and (switchPressFlag2 == false))
      {
        delay(50);
        data = 33;
        Serial.println("33");
        switchPressFlag2 = true;
        priviousSwitchValue2 = !priviousSwitchValue2;
        LoRa.beginPacket();  
        LoRa.print(data);
        LoRa.endPacket();
      }
      if( (liveSwitchValue2 == 1) and (switchPressFlag2 == true) )
      {
        delay(50);
        data = 44;
        Serial.println("44");
        switchPressFlag2 = false;
        LoRa.beginPacket();  
        LoRa.print(data);
        LoRa.endPacket();
      }
     
     
      if(gLedPin == 1)
      {
        data = 55;
        Serial.println("55");
        gLedPin = 0;
        LoRa.beginPacket();  
        LoRa.print(data);
        LoRa.endPacket();
      }
     
      // LoRa.beginPacket();  
      // LoRa.print(data);
      // LoRa.endPacket();
    }
     
    ISR(TIMER1_COMPA_vect){//timer1 interrupt 1Hz toggles pin 13 (LED)
    //generates pulse wave of frequency 1Hz/2 = 0.5kHz (takes two cycles for full wave- toggle high then toggle low)
      static volatile int ledFlag = 0;
      if(++ledFlag >= 1)
      {
        gLedPin = 1;
        ledFlag = 0;
      }
    }
    Je précise que j'ai fait l'essai plusieurs fois avec 2 Nano différents où j'ai constaté le même problème
    le traitement des timers est différent sur NANO et UNO ?

  2. #2
    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
    gLedPin devrait être volatile (et quitte à utiliser un type bool, mettez true et false dedans plutôt que 1 et 0). ça peut suffire à conduire à une différence de comportement

    Je n'ai pas compris à quoi sert ledFlag dans l'interruption.

    il vaut 0
    vous l'incrémentez donc il vaut 1
    vous comparez si c'est >= 1 donc c'est vrai
    vous passez gLedPin à true et remettez ledFlag à 0

    donc votre ISR pourrait se résumer à
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    ISR(TIMER1_COMPA_vect) { //timer1 interrupt 1Hz toggles pin 13 (LED)
        gLedPin = true;
    }

    pour émettre toutes les secondes, surtout depuis la loop, vous n'avez pas besoin de timer... juste une comparaison avec millis() suffit




    PS: en anglais on écrit previous pas privious

  3. #3
    Membre actif
    Inscrit en
    Juillet 2004
    Messages
    762
    Détails du profil
    Informations forums :
    Inscription : Juillet 2004
    Messages : 762
    Points : 230
    Points
    230
    Par défaut
    merci Jay M

    Pour précision je teste le projet suivant :
    https://create.arduino.cc/projecthub...lora&offset=23

    Je n'ai pas compris à quoi sert ledFlag dans l'interruption.
    il ne sert qu'à changer la période de la Led
    régler sur 1 permet juste d'avoir un clignotement d'1 seconde
    mais on peut sans passer c'est vrai


    Par ailleurs , je continue mes investigations
    J'ai fait plusieurs tests en changeant de µC avec le même croquis : UNO ou Nano ou Pro Mini pour l'émetteur
    avec UNO + LoRa RA01 çà fonctionne avec la même fréquence de clignotement sur l'émetteur et le récepteur
    dès que je change par un Nano ou Pro Mini le programme se plante dans l'attente de la synchronisation

    Mais j'avoue ne pas en comprendre la raison (?)

    Edit : j'ai refait l'essai avec un UNO et tout fonctionne sans problème
    tandis qu'avec le Nano avec le même croquis => blocage avec l'INT

    il doit donc bien avoir une différence de traitement de l'interruption entre un UNO et un Nano

  4. #4
    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
    alimentez vous le module LoRa avec le 3.3V de l'arduino?
    le module LoRa RA01 consomme jusqu'à 140mA en émission
    la pin 3.3V d'un UNO peut fournir 150mA donc ça doit fonctionner
    la pin 3.3V d'un Nano peut fournir que 50mA car son courant vient de l'adaptateur FT232RL et non d'un régulateur de tension LP2985-33DBVR que vous trouvez sur la UNO.

    ==> sur la Nano il serait alors sous alimenté pour émettre

    pour vérifier cette hypothèse, alimentez le module LoRa avec une alimentation 3.3V dédiée assez puissante.

  5. #5
    Membre actif
    Inscrit en
    Juillet 2004
    Messages
    762
    Détails du profil
    Informations forums :
    Inscription : Juillet 2004
    Messages : 762
    Points : 230
    Points
    230
    Par défaut
    Effectivement , c'est bien vu
    Je vais faire l'essai
    je ne savais pas que l'alimentation était différente entre UNO et Nano

    merci Jay M

  6. #6
    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
    n'oubliez pas de joindre les GND des deux alimentations!

  7. #7
    Membre actif
    Inscrit en
    Juillet 2004
    Messages
    762
    Détails du profil
    Informations forums :
    Inscription : Juillet 2004
    Messages : 762
    Points : 230
    Points
    230
    Par défaut
    Bonjour Jay M

    Tu avais raison , j'ai séparé les alimentations 5v et 3.3v sur l'émetteur uniquement
    et fait l'essai avec un Nano puis un Pro-Mini
    çà fonctionne mais les réponses sont moins rapides
    le "feedback" est, semble-t-il plus lent, qu'avec le UNO
    ( il faut que je fasse de même je pense sur le récepteur)

    merci encore

  8. #8
    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
    Merci d’avoir fait le test et de partager les résultats

  9. #9
    Membre actif
    Inscrit en
    Juillet 2004
    Messages
    762
    Détails du profil
    Informations forums :
    Inscription : Juillet 2004
    Messages : 762
    Points : 230
    Points
    230
    Par défaut
    mon prochain défi :

    Si je veux mettre un Wemos en lieu et place du Nano en tant que récepteur pour pouvoir par la suite exploiter le IOT
    est-ce que je peux utiliser le même croquis que celui du récepteur actuel tout en adaptant un autre cablage ?
    est-ce possible ?

    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
     
     
    #include <LoRa.h> 
     
    /*
    const int LED1 = D1;   // indicator LED
    const int RLY1 = D5;   // relay 1
    const int RLY2 = D6;   // relay 2
    */
    String inString = "";    // string to hold input
    int val = 0;
    int SyncWord = 0x22;
     
    void setup() {
      Serial.begin(9600);
      /*
      pinMode(LED1,OUTPUT);
      pinMode(RLY1,OUTPUT);
      pinMode(RLY2,OUTPUT);
      
      digitalWrite(LED1 , LOW);
      digitalWrite(RLY1 , HIGH);
      digitalWrite(RLY2 , HIGH);
      */
      while (!Serial);
      Serial.println("LoRa Receiver");
      if (!LoRa.begin(433E6)) { // or 915E6
        Serial.println("Starting LoRa failed!");
        while (1);
      }
       LoRa.setSpreadingFactor(12);           // ranges from 6-12,default 7 see API docs
       LoRa.setSignalBandwidth(62.5E3);           // for -139dB (page - 112)
       LoRa.setCodingRate4(8);                   // for -139dB (page - 112)
       LoRa.setSyncWord(SyncWord);           // ranges from 0-0xFF, default 0x12, see API docs
    /*
      Serial.print("current spreading factor : ");
      Serial.println(LoRa.getSpreadingFactor());
      Serial.print("current bandwidth : ");
      Serial.println(LoRa.getSignalBandwidth());
      Serial.println("LoRa init succeeded.");
      */
    }
    bool i=0;
    int priviousValue = 0;
    int liveValue = 0;
     
    void loop() { 
      // try to parse packet
      int packetSize = LoRa.parsePacket();
      if (packetSize) { 
        // read packet    
        while (LoRa.available())
        {
          int inChar = LoRa.read();
          inString += (char)inChar;
          val = inString.toInt();  
         // digitalWrite(LED1 , HIGH);
          delay(10);
         // digitalWrite(LED1 , LOW);
          delay(10);     
        }
        inString = "";     
        LoRa.packetRssi();    
      }
     
      Serial.println(val);  
      liveValue = val;
     
      if(priviousValue != liveValue)
      {
        priviousValue = liveValue;
     
        if(val == 11)
        {
         // digitalWrite(RLY1 , LOW);
     
        }
     
        if(val == 22)
        {
         // digitalWrite(RLY1 , HIGH);
     
        }
     
        if(val == 33)
        {
        //  digitalWrite(RLY2 , LOW);
     
        }
     
        if(val == 44)
        {
         // digitalWrite(RLY2 , HIGH);
     
        }
      }
      delay(50);
    }

  10. #10
    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
    Il faudrait vérifier que le LoRa.h que vous utilisez est compatible avec cette architecture. Ce devrait être possible

  11. #11
    Membre actif
    Inscrit en
    Juillet 2004
    Messages
    762
    Détails du profil
    Informations forums :
    Inscription : Juillet 2004
    Messages : 762
    Points : 230
    Points
    230
    Par défaut
    Bonjour Jay M

    merci encore pour vos réponses ..

    J'ai repris le croquis suivant pour l'adapter au Wemos

    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
     
    #include <LoRa.h> 
    #include <SPI.h>
     
    const int LED1 = D1;   // indicator LED
    const int RLY1 = D3;   // relay 1
    const int RLY2 = D4;   // relay 2
     
    /*
    Wemos Pins  **************************SX1278 Pins
    GND                                       GND
    3.3V**************************************VCC
    D8**GIO15*********************************NSS
    D7**GIO13*********************************MOSI
    D6**GIO12*********************************MISO
    D5**GIO14*********************************SCK
    D0**GIO16*********************************RST
    D2**GIO4**********************************DIO0
    */
     
    #define nss 15
    #define rst 16
    #define dio0 4
     
    String inString = "";    // string to hold input
    int val = 0;
    int SyncWord = 0x22;
     
    void setup() {
      Serial.begin(9600);
      LoRa.setPins(nss, rst, dio0);
     
     
      pinMode(LED1,OUTPUT);
      pinMode(RLY1,OUTPUT);
      pinMode(RLY2,OUTPUT);
     
      digitalWrite(LED1 , LOW);
      digitalWrite(RLY1 , HIGH);
      digitalWrite(RLY2 , HIGH);
     
      while (!Serial);
      Serial.println("LoRa Receiver");
      if (!LoRa.begin(433E6)) { // or 915E6
        Serial.println("Starting LoRa failed!");
        while (1);
      }
     
       LoRa.setSpreadingFactor(12);           // ranges from 6-12,default 7 see API docs
       LoRa.setSignalBandwidth(62.5E3);           // for -139dB (page - 112)
       LoRa.setCodingRate4(8);                   // for -139dB (page - 112)
       LoRa.setSyncWord(SyncWord);           // ranges from 0-0xFF, default 0x12, see API docs
    /*
      Serial.print("current spreading factor : ");
      Serial.println(LoRa.getSpreadingFactor());
      Serial.print("current bandwidth : ");
      Serial.println(LoRa.getSignalBandwidth());
      Serial.println("LoRa init succeeded.");
      */
    }
    bool i=0;
    int pValue = 0;
    int lValue = 0;
     
    void loop() { 
      // try to parse packet
      int packetSize = LoRa.parsePacket();
      if (packetSize) { 
        // read packet    
        while (LoRa.available())
        {
          int inChar = LoRa.read();
          inString += (char)inChar;
          val = inString.toInt();  
          digitalWrite(LED1 , HIGH);
          delay(10);
          digitalWrite(LED1 , LOW);
          delay(10);     
        }
        inString = "";     
        //LoRa.packetRssi();    
      }
     
      Serial.println(val);  
      lValue = val;
     
      if(pValue != lValue)
      {
        pValue = lValue;
     
        if(val == 11)
        {
          digitalWrite(RLY1 , LOW);
          delay(10);
        }
        if(val == 22)
        {
          digitalWrite(RLY1 , HIGH);
          delay(10);
        }
        if(val == 33)
        {
          digitalWrite(RLY2 , LOW);
          delay(10);
        }
        if(val == 44)
        {
          digitalWrite(RLY2 , HIGH);
          delay(10);
        }
      }
      delay(50);
    }
    çà fonctionnait à peu près mais avec un temps de réponse énorme
    après de nombreuses recherches , je me suis aperçu que ce temps de réponses n'était pas dû au récepteur mais bien à l'émetteur
    et surtout à l'alimentation ( pour mémoire , l'émetteur est composé d'un Pro-Mini 5v+ LoRa) j'ai donc alimenté le tout en 3.3v
    le temps de réponse s'est amélioré mais alimenter le µC en 3.3v n'est peut-être pas la bonne solution

  12. #12
    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 cobra38 Voir le message
    j'ai donc alimenté le tout en 3.3v
    le temps de réponse s'est amélioré mais alimenter le µC en 3.3v n'est peut-être pas la bonne solution
    Par principe il faut alimenter les composants avec ce qu'ils attendent / peuvent consommer. s'ils sont sous alimentés tout peut se produire

  13. #13
    Membre actif
    Inscrit en
    Juillet 2004
    Messages
    762
    Détails du profil
    Informations forums :
    Inscription : Juillet 2004
    Messages : 762
    Points : 230
    Points
    230
    Par défaut
    la solution serait alors de supprimer le régulateur et d'alimenter via VCC en 3.3v
    parce que je suppose que l'on alimente sous 5v cela passe par le régulateur

  14. #14
    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
    Pour quelle carte?

  15. #15
    Membre actif
    Inscrit en
    Juillet 2004
    Messages
    762
    Détails du profil
    Informations forums :
    Inscription : Juillet 2004
    Messages : 762
    Points : 230
    Points
    230
    Par défaut
    Pour la carte PRO-MINI ( j'ai une 5v actuellement)

  16. #16
    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
    l'ATmega328 de votre PRO-MINI peut effectivement fonctionner à 3.3V mais dans ce cas il faudrait changer aussi l'oscillateur car vous ne pourrez pas tourner à 16Mhz (c'est pour cela que le PRO-MINI3.3V est livré avec une horloge à 8Mhz)

    pour moi il faut une alimentation performante de 5V qui alimente d'un côté l'Arduino et vous mettez un step-down de 3.3V capable de 200mA minimum derrière l'alimentation pour alimenter le module LoRa (par exemple un Régulateur à découpage 3.3V 1A, D24V10F3)

  17. #17
    Membre actif
    Inscrit en
    Juillet 2004
    Messages
    762
    Détails du profil
    Informations forums :
    Inscription : Juillet 2004
    Messages : 762
    Points : 230
    Points
    230
    Par défaut
    Bonjour Jay M

    Il semblerait donc que le module "émetteur" devienne un peu compliqué à gérer
    il faut :
    1) une batterie conséquente de type 18460
    2) TP4056 pour permettre de recharger
    3) un module pour alimenter le PRO-MINI en 5v
    4) un autre module Boost pour réguler le 3.3v

    je demandais donc s'il n'était pas plus judicieux d'utiliser ce type de module à minima pour l'emetteur à savoir :
    https://fr.aliexpress.com/item/32824...yAdapt=glo2fra

    il cumule beaucoup d'atouts
    - l'usage du chargeur
    - l'usage du LoRa intégré
    - et ESP32

    c'est un peu surdimensionné pour mon besoin mais de loin plus pratique à gérer (et je l'ai )

    Je n'ai pas encore essayé de téléverser le croquis actuel mais j'aurai une question :
    il y a, semble-t-il, 2 librairies distinctes utilisées dans les exemples sous GiHub
    https://github.com/Xinyuan-LilyGO/Li...7e761bcb2XydQk

    l'une => Lora.h
    l'autre => RadioLib.h
    quelle en est la différence svp ?

  18. #18
    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
    vous pourriez passer sur un pro mini en 3.3V et 8Mhz pour n'avoir qu'une seule tension d'alimentation

    Après effectivement j'ai ce genre de module tout en un avec écran en prime et prise pour une batterie (Heltec Lora V32), c'est super pratique - tout est intégré et il n'y a pas trop à se soucier de la mémoire . J'ai aussi des modules LILYGO, généralement ils sont de bonne facture



    RadioLib.h est une sorte de couteau suisse de la communication radio plus d'info ici ==> https://github.com/jgromes/RadioLib/wiki

  19. #19
    Membre actif
    Inscrit en
    Juillet 2004
    Messages
    762
    Détails du profil
    Informations forums :
    Inscription : Juillet 2004
    Messages : 762
    Points : 230
    Points
    230
    Par défaut
    Re...

    J'ai suivi votre conseil et j'ai reporté le croquis "émetteur" sous un autre support à savoir :
    LILYGO® LoRa V1.0 ESP32 SX1278 433Mhz, 0.96 OLED

    si j'ai pu faire tourner le croquis "émetteur" (voir ci-dessous) sur ce support

    principe :
    envoi de "55" si pas btn enfoncé
    envoi de "11" pour appui sur SW1 puis envoi de "22" au relâchement
    envoi de "33" pour appui sur SW2 puis envoi de "44" au relâchement

    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
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
     
    #include <SPI.h>
    #include <LoRa.h>
    #include <Wire.h>  
    #include "SSD1306.h" 
    //#include "images.h"
     
    #define SCK     5    // GPIO5  -- SX1278's SCK
    #define MISO    19   // GPIO19 -- SX1278's MISO
    #define MOSI    27   // GPIO27 -- SX1278's MOSI
    #define SS      18   // GPIO18 -- SX1278's CS
    #define RST     14   // GPIO14 -- SX1278's RESET
    #define DI0     26   // GPIO26 -- SX1278's IRQ(Interrupt Request)
    #define BAND    433E6
     
    unsigned int counter = 0;
     
    const int SW1 = 32;
    const int SW2 = 33;
     
    int SyncWord = 0x22;
     
    int pValue1 = 1;
    int pValue2 = 1;
    int lValue1 = 0;
    int lValue2 = 0;
    bool Flag1 = false;
    bool Flag2 = false;
     
    int data = 1;
     
    SSD1306 display(0x3c, 4, 15);
    String rssi = "RSSI --";
    String packSize = "--";
    String packet ;
     
    /*
    void logo(){
      display.clear();
      display.drawXbm(0,5,logo_width,logo_height,logo_bits);
      display.display();
    }
    */
     
    void setup() {
      pinMode(16,OUTPUT);
      pinMode(2,OUTPUT);
      pinMode(SW1,INPUT_PULLUP);
      pinMode(SW2,INPUT_PULLUP);
     
     
      digitalWrite(16, LOW);    // set GPIO16 low to reset OLED
      delay(50); 
      digitalWrite(16, HIGH); // while OLED is running, must set GPIO16 in high
     
      Serial.begin(9600);
      while (!Serial);
      Serial.println();
      Serial.println("LoRa Sender Test");
     
      SPI.begin(SCK,MISO,MOSI,SS);
      LoRa.setPins(SS,RST,DI0);
      if (!LoRa.begin(433E6)) {
        Serial.println("Starting LoRa failed!");
        while (1);
      }
     
      LoRa.setSpreadingFactor(12);           // ranges from 6-12,default 7 see API docs
      LoRa.setSignalBandwidth(62.5E3 );      // for -139dB (page - 112)
      LoRa.setCodingRate4(8);                // for -139dB (page - 112)
      LoRa.setSyncWord(SyncWord);
     
      //LoRa.onReceive(cbk);
       //  LoRa.receive();
      Serial.println("init ok");
      display.init();
      display.flipScreenVertically();  
      display.setFont(ArialMT_Plain_10);
      //logo();
      delay(50);
      digitalWrite(2, LOW);    // turn the LED off by making the voltage LOW
    }
     
    void loop() {
      display.clear();
      /*
      display.setTextAlignment(TEXT_ALIGN_LEFT);
      display.setFont(ArialMT_Plain_10);
      */
     
      lValue1 = digitalRead(SW1);
      lValue2 = digitalRead(SW2);
     
      /*
      display.drawString(0, 0, "Sending packet: ");
      display.drawString(90, 0, String(counter));
      display.display();
      */
     
      if( (lValue1 == 0) and (Flag1 == false) )
        {
        delay(50);
        data = 11;
        Serial.println("11");
        Flag1 = true;
        pValue1 = !pValue1;
     
        LoRa.beginPacket();  
        LoRa.print(data);
        LoRa.endPacket();
        }
      if( (lValue1 == 1) and (Flag1 == true) )
      {
        delay(50);
        data = 22;
        Serial.println("22");
        Flag1 = false;
        LoRa.beginPacket();  
        LoRa.print(data);
        LoRa.endPacket();
      }
     
      if( (lValue2 == 0) and (Flag2 == false))
      {
        delay(50);
        data = 33;
        Serial.println("33");
        Flag2 = true;
        pValue2 = !pValue2;
        LoRa.beginPacket();  
        LoRa.print(data);
        LoRa.endPacket();
      }
      if( (lValue2 == 1) and (Flag2 == true) )
      {
        delay(50);
        data = 44;
        Serial.println("44");
        Flag2 = false;
        LoRa.beginPacket();  
        LoRa.print(data);
        LoRa.endPacket();
      } 
     
      if( (lValue1 == 1) and (lValue2 == 1) )
      {
        data = 55;
        Serial.println("55");
        LoRa.beginPacket();  
        LoRa.print(data);
        LoRa.endPacket();
      }
     
      /*
      counter++;
      digitalWrite(2, HIGH);   // turn the LED on (HIGH is the voltage level)
      delay(500);                       // wait for a 1/2 second
      digitalWrite(2, LOW);    // turn the LED off by making the voltage LOW
      delay(500);                       // wait for a 1/2 second
      */
    }
    j'avoue ne pas expliquer la certaine "lenteur" de la boucle "loop" (env 1.3s) que j'ai pu constater en ayant pourtant supprimer tout appel à l'affichage
    ne faudrait-il pas que j'y insère des interruptions pour les boutons ?
    comme par ex :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    attachInterrupt(GPIOPin, fonction_ISR, Mode)

  20. #20
    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
    Il reste le display.clear(); dans la loop

    Pas la peine de passer par des interruptions pour le traitement de boutons - le polling dans votre cas va très bien

+ Répondre à la discussion
Cette discussion est résolue.
Page 1 sur 2 12 DernièreDernière

Discussions similaires

  1. Interruption timer 1 sur nano v3
    Par niconol dans le forum Arduino
    Réponses: 4
    Dernier message: 06/07/2018, 09h37
  2. Timer sur une fenetre "info"
    Par momobulle dans le forum WinDev
    Réponses: 2
    Dernier message: 11/07/2007, 13h26
  3. Waitable timers sur linux
    Par wajihwajih dans le forum Linux
    Réponses: 3
    Dernier message: 23/05/2007, 15h36
  4. [FLASH] Problème de timer sur FLV
    Par BnA dans le forum Flash
    Réponses: 1
    Dernier message: 03/11/2006, 11h52
  5. [C#] Timer sur les évènements des messages Windows
    Par Nullos Oracle dans le forum Windows Forms
    Réponses: 1
    Dernier message: 19/09/2006, 11h33

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