Skyduino:~#
Articles
arduino, programmation, tutoriel

[Tutoriel] Arduino + Mirf v2 (nRF24L01+)

Le contenu de cet article a été entièrement réécrit et mis à jour sur le site Carnet du Maker.

Liens vers les nouveaux articles :

N.B. Les commentaires de l’article ont été pris en compte lors de la rédaction des nouveaux articles😉

Discussion

70 réflexions sur “[Tutoriel] Arduino + Mirf v2 (nRF24L01+)

  1. Cool! Merci
    j’ai hâte de recevoir les miens…
    c’est quoi la portée dans une maison environ?

    Publié par nicolas | 21 janvier 2012, 0 h 00 min
    • Moi avec deux mur en placo sur le passage du signal je fait du 40-50m environ.

      Publié par skywodd | 21 janvier 2012, 0 h 48 min
    • Merci pour ce tuto de qualité…

      J’ai un problème à la compilation avec une Arduino Due

      sketch\MirfHardwareSpiDriver.cpp: In member function ‘virtual void MirfHardwareSpiDriver::begin()’:

      MirfHardwareSpiDriver.cpp:17: error: ‘SPI_2XCLOCK_MASK’ was not declared in this scope

      SPI.setClockDivider(SPI_2XCLOCK_MASK);

      apparemment SPI_2XCLOCK_MASK serait inconnu pour le SPI de la due

      Existe t-il une solution sans revoir la structure du code… ?

      Merci d’avance

      Publié par Mauribilis | 1 décembre 2015, 20 h 34 min
      • En fait l’arduino due n’utilise pas les même paramètre pour la fonction ‘setClockDivider’. Alors que pour une carte AVR il faut mettre en paramètre une des constantes de préprocesseur du type ‘SPI_xXCLOCKMASK’, les cartes ARM (donc l’arduino due) demande un intiger qui servira de diviseur.
        Pour remédier à ce problème tu peux tout simplement ajouter au début de ton code « #define DUE » et remplacer dans le fichier MirfHardwareSPIDriver.cpp :
        « SPI.setClockDivider(SPI_2XCLOCK_MASK) »
        par :

        #ifndef DUE
        SPI.setClockDivider(10);
        #else
        SPI.setClockDivider(SPI_2XCLOCK_MASK);
        #endif

        Publié par Prométhée | 30 avril 2016, 12 h 25 min
  2. Super sympa ce tuto!

    Quelle serait la meilleure méthode pour envoyer plusieurs données de type différents, par exemple envoyer un int puis un un tableau de char et les récupérer de l autre coté?

    Merci d avance

    Publié par fly | 24 janvier 2012, 12 h 56 min
    • La meilleur solution serait de tout envoyer en byte[], que ce soit les int ou les char avec un octet « balise » avant pour faire la différence à la réception.
      Exemple :

      Publié par skywodd | 24 janvier 2012, 13 h 27 min
      • Merci pour ta réponse, c’est ce que j avais en tete, envoyer une « trame » de byte avec une entête (ou « etiquette ») pour déterminer de quelle valeur il s agit et pouvoir la stocker au bon endroit.

        Publié par fly | 24 janvier 2012, 23 h 41 min
  3. Re-Bonjour,

    J’ai pas mal étudier cette page, qui est celle de l auteur de la librairie à priori : http://www.mrroot.net/tag/arduino/

    Il me reste quelques questions :

    Pour configurer mon NRF, j utilise ce code

    Mirf.configRegister(RF_SETUP, 0x07);
    Mirf.channel=120;
    Mirf.config();

    Ce qui est sensé paramétrer un débit de 1Mo et une puissance d’émission maximum, est ce correct?

    Je pose cette question car ma portée ne dépasse pas les 10m ce qui m’étonne un peu.

    Voici le type de module que j utilise avec une amplification de la partie HF : http://2fly.free.fr/arduino/nrf24l01.jpg
    (Je n’ai pas mis les résistance pour passer à 3.3v sauf pour la partie alimentation car d après la doc technique, c’est toléré)

    Merci encore de votre aide

    Publié par fly | 25 janvier 2012, 0 h 18 min
    • Ça ressemble à un module nRF « made in china » (ebay ?) …
      Mon module nRF à une antenne céramique et un ci nRF24L01+ (version +), je sait pas si cela peut affecter la distance d’émission mais j’arrive aux 40m sans trop de probléme.

      Ps: plus la vitesse est élevé plus la porté est réduite, à 1Mbs (Mbs pas Mo ;)) tu perd pas mal de porté, moi je suis en 250Kbs.

      Publié par skywodd | 25 janvier 2012, 11 h 27 min
  4. Oui c’est du module made in China mais j ai également testé des modules Nordic qui ne me donnent pas plus de résultat.

    Peux tu me donner la configuration de ton registre stp? moi j’utilise : Mirf.configRegister(RF_SETUP, 0×07);

    Que me conseilles tu?

    Publié par fly | 25 janvier 2012, 19 h 53 min
    • Moi: RF_SETUP, 0x26 -> sortie 0dBm @ 250Kbs, c’est avec cette config que je fait du 40m sur zone « dégagé ».

      Après recherche il semblerai que l’antenne, son orientation, et le type de matériaux sur lequel ce réfléchi le signal joue beaucoup aussi apparemment.
      (cf test des modules nRF2401 de sparkfun : http://www.sparkfun.com/tutorials/48)

      Publié par skywodd | 25 janvier 2012, 20 h 10 min
  5. Merci pour ta réponse, je vais essayer avec cette config et je te tiendrai au courant.

    Je bosse dans le modèle réduit et pas mal d’émetteurs récepteurs 2.4Ghz utilisent le nrf24L01 et bien souvent les platines ne sont pas plus belles à voir mais fonctionnent tout de même.

    @+

    Publié par Fly | 25 janvier 2012, 23 h 20 min
    • C’est vrai qu’en modélisme les kit RC 2.4GHz sont courant, mais ils ont l’avantage d’avoir une antenne amplifié externe.
      Chez sparkfun ils ont un kit nRF avec connecteur à vis pour antenne externe qui porte sur +100m, donc quelque pars le design de l’antenne doit jouer énormément.

      Publié par skywodd | 26 janvier 2012, 13 h 59 min
  6. Bonjour, j’ai tenté d’utiliser ces modules pour faire des transferts de données et ils ne tiennent pas en endurance.
    Je m’explique, j’ai utilisé un module pour transférer des trames teleinfo de mon compteur EDF vers un autre module relié à mon PC : les modules tiennent 30 secondes puis se bloquent. J’envoie chaque trame de teleinfo (après récupération par Arduino Nano) dans des payload de 32bytes en 1Mbps. L’Arduino relié au PC retransmet directement ces trames sur le terminal dés qu’il les reçoit.
    J’ai essayé des tonnes de configurations pour résoudre le problème mais rien n’y fait.

    Pareil, j’ai tenté de monter des sondes de températures avec. Même sur quelques caractères avec des sollicitations toutes les 10 minutes, il y a au moins 1 sonde sur 2 qui bloque.

    Pour moi, ces petits modules ne sont pas du tout fiable. Tous les test que l’on voit sur internet ne font que du ping, ou n’envoient pas de données à manipuler derrière donc personne ne mets ceci en évidence.

    De plus et pour info, pour envoyer des données et les recevoir pour les manipuler se fait de cette manière :
    Pour envoyer :
    char message[Mirf.payload];
    Mirf.send((byte *)&message); // avec le &

    Pour recevoir :
    char message[Mirf.payload];
    Mirf.getData((byte *)message); // sans le &

    Si des personnes ont déjà rencontré ce problème, je suis preneur de la solution ! En attendant, je migre vers une solution plus chère, mais plus FIABLE.

    Publié par Tibrol | 1 février 2012, 10 h 53 min
    • Je suis pas du tout d’accord !

      J’utilise des nRF24L01+ pour tout mes projets sans fil « simple ».
      Pour mon derniers bricolage j’envoyai 9 octets en provenance d’un capteur capacitif. J’ai fait tourner mon prog pendant bien 3h et rien n’as planté !

      Les nRF24L01 sont utilisé pour faire des télécommandes, de la communication en robotique, etc … ils sont reconnu partout pour leur fiabilité à toute épreuve !

      Je pense qu’il s’agit plutôt d’un bug au niveau du code ou quelque chose dans le genre …

      Publié par skywodd | 1 février 2012, 21 h 58 min
      • Dans ce cas je voudrais bien voir ton sketch pour comprendre d’où vient l’erreur dans mon algorithme. Je suis dessus depuis plusieurs semaines et je ne trouve pas d’où vient l’erreur (si elle existe…).

        Montre moi ta routine d’échange entre tes différentes platines, stp.

        Publié par Tibrol | 1 février 2012, 22 h 17 min
  7. Je te propose d’essayer ceci :
    2 platines arduino chacune munies d’un NRF24L01+

    la premiere platine :

    #include “SPI.h”
    #include “Mirf.h”
    #include “nRF24L01.h”
    #include “MirfHardwareSpiDriver.h”
    
    #define PAYLOAD 20
    
    void setup(){
      
      Mirf.spi = &MirfHardwareSpi;
      Mirf.cePin = 10;
      Mirf.csnPin = 9;
      Mirf.init();
      
      Mirf.setRADDR((byte *)"tele1");
      Mirf.setTADDR((byte *)"serv1");
      Mirf.payload = PAYLOAD;
      Mirf.channel = 12;
      Mirf.config();
    }
    
    void loop(){
       char reponse[PAYLOAD];
      
       String("ADCO:123456789012").toCharArray(reponse,String("ADCO:123456789012").length()+1);
       Mirf.send((byte *)&reponse); while(Mirf.isSending()){}
       delay(100);
    }
    

    Et la seconde platine :

    #include “SPI.h”
    #include “Mirf.h”
    #include “nRF24L01.h”
    #include “MirfHardwareSpiDriver.h”
    
    const int waiter = 100;
    long compteur;
    
    void setup(){
      
      Serial.begin(115200); 
      
      Mirf.spi = &MirfHardwareSpi;
      Mirf.cePin = 10;
      Mirf.csnPin = 9;
      Mirf.init();
      
      Mirf.setRADDR((byte *)"serv1");
      Mirf.setTADDR((byte *)"tele1");
      Mirf.payload = 20;
      Mirf.channel = 12;
    
      Mirf.config();
      
      attachInterrupt(1,teleinfo,LOW);
    }
    
    void loop(){  
    }
    
    void teleinfo(){
    
      if(!Mirf.isSending() && Mirf.dataReady()){
        
        char inData[Mirf.payload];  
        Mirf.getData((byte *)inData);
        Serial.println(inData);
      
      }
    }
    

    Tu vas voir les temps de réponses se dégrader au fur et à mesure….

    Essaies et dis moi comment ça réagit chez toi…

    Publié par Tibrol | 1 février 2012, 22 h 57 min
    • Tu envois une String de 18 octets avec un payload de 20 octets donc à tout les coup tu dégage 2 octets de la ram …
      De plus je suis pas sure que la librairie Mirf2 est était pensé pour marcher en interruption donc coté récepteur aussi ça doit posé probléme je pense.

      PS: Je me suis permis d’éditer ton commentaire pour activer la coloration syntaxique😉

      Publié par skywodd | 1 février 2012, 23 h 25 min
  8. @TIBROL J’ai mis tout le code source émetteur & récepteur dans un nouvelle article😉

    Publié par skywodd | 1 février 2012, 23 h 07 min
  9. mea-culpa,

    j’étais en tort, je l’avoue, après avoir repris mon sketch ça fonctionne à merveille. Pardon à toi oh grand Dieu Nordic Semiconductor pour avoir blasphémé. Tes créations sont bonnes et fonctionnent à merveille. Merci à toi SKYWODD pour m’avoir mis sur la voie.

    Publié par Tibrol | 11 février 2012, 17 h 02 min
    • No problém ^^

      Bonne chance pour ton projet ^^

      Publié par skywodd | 11 février 2012, 17 h 13 min
    • Hello blog ..
      Tibrol, peux tu stp expliquer quel etait ton probleme de « fiabilité » ?..
      je fais moi meme mumuse avec ces modules et un PIC (donc pas un carte ARDUINO et pas la librairie correspondante) .. et je tombe sur le meme probleme !

      ca semble fonctionner sans probleme sur un reset, pendant 30 secondes (ping/pong avec une payload de 1 byte) et ensuite ca se plante ..
      mon TX me génère tout d’un coup une IRQ MAX_RT … je la reset, mais elle revient aussi tot !

      merci de tes suggestions
      phil

      Publié par phil | 15 mai 2012, 16 h 35 min
  10. Ma petite contribution:

    Pour rendre la librairie compatible avec IDE Arduino 1.0, il faut remplacer Wprogram.h par Arduino.h dans le fichier Mirf.h de la librairie. En effet WProgram.h a été remplacé par Arduino.h, il faut donc mettre à jour tous vos programmes.

    Il est possible de faire un test pour rendre vos programmes compatibles avec les différentes versions :

    #if defined(ARDUINO) && ARDUINO >= 100
    #include « Arduino.h »
    #else
    #include « WProgram.h »
    #endif

    @+
    FLY

    Publié par FLY | 11 mars 2012, 23 h 06 min
  11. Bonjours,

    J’ai suivi ce tuto mais mon montage ne fonctionne pas. J’ai utilisé deux cartes arduino mega 2560 sur lesquel j’ai connecté le module nrf24L01+ comme suit:
    MISO -> 50
    MOSI -> 51
    SCK -> 52
    CE -> 48
    CSN -> 53
    IRQ -> pas connecté
    Donc j’ai juste adapter les lignes de déclaration des pin CE et CSN comme suit:
    Mirf.cePin = 48; // CE sur 48
    Mirf.csnPin = 53; // CSN sur 53

    Je n’avais pas vu tout de suite que le Vcc doit être connecté au 3v3 et j’ai fait quelques essais en ayant mis le Vcc sur le 5V alors j’espère ne pas avoir endomagé le module nrf24L01+.

    Si quelqu’un a une solution ce serais super sympas, je ne sais plus quoi faire. Dans le sérial je vois juste le message « go! » pour chacun des deux mega. Je pense que le client est bloqué sur le while(Mirf.isSending()).

    Merci pour l’aide

    Publié par Manuc | 16 novembre 2012, 12 h 33 min
    • Si ce sont des modules nRF24L01 chinois & co, je ne sait pas si ils auront survécu au +5v à la place de +3v3 …
      Les modules sparkfun eux ont un régulateur 3v3 intégré donc pas de problème.

      Pour le problème de communication je vois pas trop de solution …
      Regarde ces deux liens, ils pourraient peut être t’aider :
      http://arduino.cc/forum/index.php/topic,82906.0.html
      http://www.bajdi.com/playing-with-nrf24l01-modules/

      Publié par skywodd | 16 novembre 2012, 18 h 10 min
      • Tu répond rappidement Skywodd. Sympas.
        C’est un module qui vient de chez Nordic semiconductor, sur le datasheet il est indiqué que le module tolère des signaux d’entrées à 5V, donc je suppose alors qu’il a résisté au +5V.
        Le premier lien indiqué je l’ai épluché a fond, J’ai tester les librairies « RF24Network » et « RF24 » et j’ai placé un condensateur électrolitique de 4,5µF entre le 3v3 et le Gnd.
        Ca reste toujours sans effet.

        Peut-être que si je met un petit régulateur de tension alimenté par l’extérieur, je vais tester.

        Publié par Manuc | 16 novembre 2012, 19 h 59 min
  12. Salut tout le monde et merci Skywodd pour ce blog qui m’a déjà beaucoup appris.
    Juste pour info, et pour éviter à d’autre de se prendre la tête pendant des heures : j’ai acheté des modules chinois sur ebay (les moins chers), ils ne marchent que si je ne mets pas les résistances de 10K.

    Publié par sebuntu | 10 décembre 2012, 23 h 17 min
  13. Bonjour à tous,

    Tout d’abord, je tiens à remercier l’auteur de cet article super détailler qui met le NRF à portée de tous y compris les débutant comme moi.
    Malheureusement, malgré toutes ces explications je n’arrive pas à faire fonctionner mon montage.
    Le montage est à base de deux arduino micro (ATmega 32U4 idem leonardo). Les modules NRF sont alimentés par le +3.3 de l’arduino. Les broches SCK, MOSI, CE et CSN sont reliées au µc à travers des resistances de 10k.
    Le CE est relié à la broche 8 et le CSN à la 10 (J’ai modifié le code en conséquence). Les autres broches sont reliées au port SPI de l’arduino micro.

    Lorsque je lance l’exemple de ping, j’obtiens un ping/pong infini sur le serveur et « =( » sur le client. C’est assez frustrant car je sens qu’il ne doit pas manquer grand chose…

    J’ai tenté de vérifier le lien SPI en utilisant le code suivant afin de lire un registre, le modifier et le lire à nouveau… (Attention ce code va surement piquer les yeux des maitres de la programmation que vous êtes…)

    #include
    #include
    #include
    #include

    void setup() {
    byte rf_setup = 0;
    byte newval=0;

    Serial.begin(9600);
    while(!Serial);
    Serial.println( « Init… » );

    Mirf.cePin = 8; // CE sur D8
    Serial.println(« CEpin ok »);
    Mirf.csnPin = 10; // CSN sur D10
    Serial.println(« CSNpin ok »);
    Mirf.spi = &MirfHardwareSpi; // On veut utiliser le port SPI hardware
    Serial.println(« mirfhardware ok »);
    Mirf.init(); // Tout est bon ? Ok let’s go !
    Serial.println(« init ok »);

    Mirf.readRegister( RF_SETUP, &rf_setup, sizeof(rf_setup) );
    Serial.print( « rf_setup =  » );
    Serial.println( rf_setup, BIN );
    Serial.println(« Enter a new Rf register value: « );
    while(Serial.available()==0);
    newval=Serial.read();
    Serial.print(« Nouvelle valeur renseignee : »);
    Serial.println(newval, BIN);

    Mirf.writeRegister( RF_SETUP, &newval, sizeof(rf_setup));

    Mirf.readRegister( RF_SETUP, &rf_setup, sizeof(rf_setup) );
    Serial.print(« Nouvelle valeur lue: »);
    Serial.println( rf_setup, BIN );

    }

    void loop() {
    }

    En exécutant ce code, j’arrive bien, à modifier et lire la nouvelle valeur du registre RF_SETUP. J’en déduit que le SPI fonctionne. Ce code s’exécute de la même façon sur mes deux montages.

    Si quelqu’un a une idée à me proposer, je suis preneur.

    Merci d’avance

    Publié par Drainbow | 9 septembre 2013, 19 h 58 min
    • Les cartes Leonardo sont très spéciales.
      Le port SPI ce trouve sur le connecteur 6 broches au centre-droite de la carte.
      Tu est sûr de ton montage ?

      Publié par skywodd | 9 septembre 2013, 20 h 46 min
      • Bonjour et merci de cette réponse,

        Effectivement, la carte micro est un peu spéciale et dispose du port SPI à deux endroits : au centre de la carte ainsi que sur des contacts dédiés à l’opposé du port USB. (voir schéma http://arduino.cc/en/uploads/Main/arduino-micro-schematic.pdf).
        Je pense donc que mon montage est correct, d’autant plus que a priori j’arrive à dialoguer en SPI puisque je lis et j’écris dans des registres du NRF.
        Ce que je n’arrive pas à faire fonctionner c’est la transmission/récupération d’info entre deux Micro/NRF.

        Publié par Drainbow | 10 septembre 2013, 19 h 24 min
  14. Bonjour à tous,

    J’ai réglé mon problème… Après avoir vérifier 50 fois mon montage, je l’ai prêter à un collègue qui a tout de suite remarqué que les deux micro n’étaient pas câblés pareil… en effet, sur l’un des deux montage le +3.3v était câblé sur le Vref. Les repère de contact sont inscrits sur le coté des trous, et sur l’un des deux micro un repère est effacé. J’ai donc décalé ma broche d’un trou.
    C’est rectifié et maintenant tout fonctionne.

    Merci encore pour ce tuto!!!

    @+
    Drainbow

    Publié par Drainbow | 13 septembre 2013, 18 h 38 min
  15. je ne comprends pas, je mets n’importe quoi à la place de Mirf.setRADDR((byte *) »nrf01″); et l’arduino nrf01 reçoit quand même les données😦

    Publié par laul | 21 octobre 2013, 15 h 33 min
  16. Salut,
    Serait-il possible de savoir comment tu es arrivé a avoir des résistances d’une valeur de 10KOhms ?

    Publié par vincent | 18 janvier 2014, 21 h 22 min
    • Suffit d’aller sur n’importe quel site / boutique de vente d’électronique.
      Selectronic, Lextronic, Go Tronic, Farnell, …

      Publié par skywodd | 19 janvier 2014, 16 h 03 min
      • x) enfaite la question c’est as-tu fait des calcul ? parce que sur d’autre site présentant ce module ils le font sans résistance…
        Merci

        Publié par vincent | 19 janvier 2014, 16 h 19 min
      • Le nRF24L01+ a des broches tolérants le 5v mais de base c’est censé être du 3v3.
        En ajoutant une résistance (10K c’est classique comme valeur) tu limites le courant et tu allonges un peu la durée de vie du circuit. La diode zener dans la broche du circuit n’as ainsi pas à dissiper trop de courant.

        Ça marche aussi bien sans résistances, mais sur le long terme c’est mieux avec les résistances en série.
        Et ce serait encore mieux avec un montage de type « level shifter » à mosfet, mais là c’est pas le même niveau de câblage:)

        Publié par skywodd | 19 janvier 2014, 16 h 25 min
      • D’accord merci pour cette explication

        Publié par vincent | 19 janvier 2014, 16 h 37 min
  17. Salut,

    J’utilise ces modules pour la transmission d’un drone et je voulais savoir si il est possible ce connaître la force du signal de réception (en % par exemple) pour éviter de le perdre si ça ne capte plus.

    Je me demandais aussi quel est l’utilité de la librairie “nRF24L01.h” et si elle est vraiment nécessaire car chez moi ça fonctionne très bien sans.

    Merci

    Publié par Nicobas | 18 mars 2014, 20 h 26 min
    • Les modules nRF24L01+ n’ont pas de registre RSSI, il est donc impossible de quantifier la qualité du signal.

      Au mieux tu as le bit « RPD » du registre 0x09 (bit 0) qui passe à « 1 » quand le signal reçu est inférieur à -64Dbm, mais pas plus.

      Publié par skywodd | 24 mars 2014, 14 h 17 min
  18. Tout d’abord merci pour tout tes tuto, je m’en suis beaucoup inspiré pour mes projet domotique. Je laisse un petit commentaire pour ceux qui comme moi n’arrive pas à faire fonctionner. Pour ma part j’ai du mettre un condensateur entre la borne + et – comme cité un peu plus au ( 10µ est suffisent). Par contre il faut impérativement 2 sources de 3.3v différente ( deux arduino comme dans ce tuto par exemple). Voila si ça peut aidé les prochains:)

    Publié par Ravin | 17 janvier 2015, 20 h 14 min
  19. Il doit y avoir une solution pour que des commandes comme celle si fonctionne avec Mirf ?

    const uint8_t SOFT_SPI_MISO_PIN = A2;
    const uint8_t SOFT_SPI_MOSI_PIN = A3;
    const uint8_t SOFT_SPI_SCK_PIN = A0;

    Non ??

    Publié par WlanFr | 20 mars 2015, 19 h 46 min
    • Mon copier-coller a comme un petit peut dérapé.

      Donc je disais merci pour ce superbe tuto. Mais comme j’utilise un sheild ethernet les pin de 10 à 13 sont occupés. Il doit y avoir une solution pour que des commandes comme celle si fonctionne avec Mirf ?

      const uint8_t SOFT_SPI_MISO_PIN = A2;
      const uint8_t SOFT_SPI_MOSI_PIN = A3;
      const uint8_t SOFT_SPI_SCK_PIN = A0;

      Non ??

      Publié par WlanFr | 20 mars 2015, 19 h 51 min
      • Je continue a me répondre a moi même:) Le port ISCP est il utilisé par le sheild ethernet ???

        Publié par WlanFr | 20 mars 2015, 20 h 06 min
    • Bon je suis désolé. Mais il est inutile de vouloir faire cela, en effet les PINS SPI ce partage.

      Publié par WlanFr | 23 mars 2015, 10 h 15 min
  20. help me j’ai un gros bug re reçois un ping même quant je débranche l’autre module

    Publié par vinpwey | 28 mars 2015, 6 h 09 min
    • Mauvais câblage du module en réception ou alors un problème de code (c’est le même que celui fourni en exemple ou il y a eu des modifications ?).

      Publié par Skywodd | 9 avril 2015, 13 h 49 min
      • j’utilise le même et j’ai vérifier je ne sait combien de foi les branchement
        mais je ne sait pourquoi même quant l’arduino na rien de connecter je reçois les ping
        bon j’ai seulement remarquer maintenant que mes module ne sont pas exactement les même mais se sont aussi des module nRF24L01+

        Publié par vinpwey | 9 avril 2015, 17 h 19 min
  21. bonjour

    deja bravo pour vos realisation et l’usage infini que ce type de montage ouvre.

    une petite question peut etre hors sujet mais je recherche un montage qui sappuie sur les nrf24l01 pour commander deux sortie S1 et S2 avec deux boutons distant BP1 et BP2

    par exemple la sortie 4 qui s’active a la reception du BP1 et la sortie 5 a la reception du BP2 avec une temporisation de 4secondes(si possible l’une ou l’autre mais pas les deux en meme temps) en gros c’est une telecommande 2 voies

    j’ai deja fabriqué ce type montage avec un pic et du 433mhz mais ca reste peut fiable d’ou mon interet pour du 2.4ghz

    y aurait-il quelqu’un qui saurait programmer ca sans trop abuser de votre gentillesse😀

    DD91

    Publié par DD91 | 26 mai 2015, 19 h 21 min
  22. Bonjour !

    Je deviens un peu fou avec ces modules.

    J’ai un serveur et plusieurs clients.

    Voici en très gros ce que j’ai setté :

    Server :

    Mirf.setRADDR((byte *) « serv1 »);

    Client 1:

    Mirf.setTADDR((byte *) « serv1 »);

    Mirf.setRADDR((byte *) « btn01 »);

    Client 2:

    Mirf.setTADDR((byte *) « serv1 »);

    Mirf.setRADDR((byte *) « btn02 »);

    Si depuis le serveur je fais :

    Mirf.setTADDR((byte *) « btn01 »);
    Mirf.send((byte *) 1);

    Il n’y a que le btn01 qui reçoit la commande, ce qui est pour moi normal.

    Maintenant, quand le client répond :

    Mirf.setTADDR((byte *) « serv1 »);

    Mirf.setRADDR((byte *) « btn01 »);

    Mirf.send((byte *) 2);

    Et bien le serveur et le btn02 reçoivent les deux le message… ce qui me pose un gros soucis.

    Ou est le bug ?

    Quelle est la combine pour que cela fonctionne ?

    D’avance merci
    A+

    Publié par Iggy | 7 août 2015, 23 h 18 min
    • Fait un test tout simple, au lieu des adresses du style btn0X, utilise des adresses du style btnX (une lettre en moins). Si ça marche c’est que la lib Mirf utilise des adresses sur 4 octets au lieu de 5 (ce qui serait un bug inconnu).

      Publié par Skywodd | 12 août 2015, 16 h 08 min
      • Bonjour,
        En fait quand le serveur envoie il n’y a pas de soucis, le bouton voulu est bien le seul à reçevoir les données.
        Il n’y a que quand les bouton répondent que ça coince.

        En modifiant le nom du serveur en btn00 il n’a a plus aucun soucis.

        En remettant serv1 ça bug😦

        Probablement un bug de la librairie sinon je comprend pas bien d’où ça peut venir.

        Publié par Iggy | 12 août 2015, 20 h 08 min
  23. Bonjour,

    tout d’abord merci pour ce tutoriel, très concis et complet!

    Je débute sous arduino et la gestion du type de variable donc je sollicite votre aide.

    Mon problème est le suivant: j’ai 32 modules, chacun équipé d’une pro-mini et de l’antenne 24rfL01 et j’aimerais pouvoir indexer l’adresse de réception automatiquement dans mon code sans avoir à écrire textuellement le numéro de l’adresse (i.e. « mod01 » pour le module 1 etc… ) mais plutôt passer par une variable intermédiaire nommée ‘index_mod’ et définir l’adresse avec: string(« mod »,index_mod);

    Je pense que cela est possible. Pouvez vous m’expliquer, quelle(s) fonction(s) je dois utiliser pour créer une nouvelle chaine de caractère à partir d’une chaine de caractère et d’un entier?

    Merci à vous!

    Publié par Quidzila | 22 janvier 2016, 13 h 20 min
    • Salut!

      Ou vas-tu trouver l’index, ta variable intermédiaire ?

      Si tu as le même code pour chaque module du devra lire ton index en externe, genre avec un DIP switch.

      Sinon essaye ça:

      int modNr = 10;
      char num[2];
      sprintf(num, « %d », modNr);
      char modName[] = « mod00 »;
      modName[3] = num[0];
      modName[4] = num[1];

      Mirf.setRADDR((byte *)modName);

      Publié par Iggy | 22 janvier 2016, 21 h 44 min
      • Merci bien.

        Je vais essayer et je reviendrai pour vous dire ce que ça donne.

        L’index est tout simplement tiré aléatoirement avec la fonction random entre 1 et 32.

        Publié par Quidzila | 24 janvier 2016, 23 h 34 min
  24. Salut!

    OK, mais…

    Comment t’assures-tu que tes modules ne vont pas s’attribuer un n° identique ???

    Et comment ton serveur va communiquer avec le module désiré ?

    Perso j’ai opté pour une solution avec un DIP switch, facile à mettre en oeuvre et peu coûteuse, et toujours juste.

    Publié par Iggy | 25 janvier 2016, 8 h 53 min
  25. Bonjour, j’ai un petit problème lors de l’utilisation de la librairie Mirf… En effet au tout début quand il s’agit d’appeler la commande elle n’apparaît pas en surbrillance et ne semble pas être reconnu par mon programme. J’ai essayé plusieurs méthodes pour appeler les commandes, notamment Mirf.h mais rien n’y fait.. Quelqu’un aurait-il une idée?
    Merci d’avance

    Publié par Quemar | 8 mars 2016, 15 h 55 min
    • Salut!

      Au début de ton programme il faut que tu inclues tes librairies :

      #include
      #include

      Il te faut évidement les installer dans ton IDE.

      En fonction de ton IDE cherche sur le net comment les installer.

      Par exemple:
      http://www.visualmicro.com/page/Arduino-Library-Manager.aspx

      Ensuite tu configure ton Mirf, par exemple :

      // Setup MIRF board
      Mirf.csnPin = A0;
      Mirf.cePin = A1;
      Mirf.spi = &MirfHardwareSpi;
      Mirf.init();
      // Setup packet data
      Mirf.setRADDR((byte *)btnName); //Set name of this button
      Mirf.setTADDR((byte *) »btn00″); //Name of the server
      Mirf.payload = 5; // Set the payload length to sizeof(byte)
      Mirf.channel = 90;// we use channel 90 as it is outside of WLAN bands or channels used by wireless surveillance cameras
      Mirf.configRegister(RF_SETUP, 0x22); //256Kbpsbps

      Mirf.config();

      A+

      Publié par Iggy | 8 mars 2016, 19 h 31 min
  26. bonsoir,
    j’utilise en ce moment le nfr24l01, mais quand j’envoie des données dans les 2 sens, il m’arrive d’avoir des paquets tronqués,
    y a il un problème ?
    ou dois-je coder un protocole en couche 7 afin de vérifier que le message a bien été reçu et n’est pas tronqué ?
    merci

    Publié par nemesis | 30 mai 2016, 23 h 30 min

Rétroliens/Pings

  1. Pingback: Outils, services, sites à (re)découvrir 2012 S03 | La Mare du Gof - 22 janvier 2012

  2. Pingback: [Tutorial] Le Nrf24L01, l’Arduino et le MSP 430. | B@ttoMicro - Microcontrôleurs et compagnie ! - 27 mars 2013

  3. Pingback: arduino + modules NRF24L01+ avec LCD | blog de laurent - 8 octobre 2013

  4. Pingback: arduino + ethernet +modules NRF24L01 | blog de laurent - 9 octobre 2013

  5. Pingback: Sonnerie Portail arduino sans fil | Alnoa.fr - 12 mars 2014

  6. Pingback: Coms and ports | Pearltrees - 22 octobre 2014

Skyduino devient Carnet du Maker

Le site Carnet du Maker remplace désormais le blog Skyduino pour tout ce qui touche à l'Arduino, l'informatique et au DIY.

Suivre

Recevez les nouvelles publications par mail.

Rejoignez 1 008 autres abonnés