Publié le 27 juin 2015 - par

Faire dialoguer un Raspberry et un Arduino via nRF24L01

nrf24l01_250pxDominique (Domi sur le forum de framboise314) a réalisé une liaison 2,4 GHz entre un Raspberry Pi et un Arduino Nano.
Il a publié son tutoriel sur le forum et vous pouvez le lire directement. Dominique m’a gentiment proposé de reprendre son tutoriel sur le blog pour le mettre à disposition de tous les lecteurs. Voilà qui est chose faite. Merci à Dominique pour ce partage ! Attention, ce tutoriel nécessite d’avoir quelques connaissances en ligne commande et en compilation de programme… 😉 Si vous êtes un « vrai » débutant mettez l’adresse dans vos favoris et revenez un peu plus tard.

NRF24L01_FB

Différentes déclinaisons du circuit nRF24L01

Liaison 2,4 GHz entre Raspberry Pi et Arduino

Je laisse la parole à Dominique :

Recherchant un moyen de relier des capteurs autonomes à un Raspberry Pi. Mon choix s’est orienté sur l’utilisation d’un Arduino Nano. Petit mais suffisamment puissant pour être autonome, effectuer différents relevés, mais également effectuer des actions comme par exemple piloter un relais.

Pour communiquer avec le Raspberry Pi, j’ai choisi d’utiliser des modules nRF24L01, module de liaison Hertzienne à 2,4 Ghz.

NRF24L01

Le circuit nRF24L01

But recherché

Le but de ce tutoriel est de faire dialoguer un Raspberry Pi et un Arduino Nano.
Nous allons voir comment réaliser l’installation de la bibliothèque RF24, le câblage, ainsi que la configuration du Raspberry et de l’Arduino Nano.
Les programmes en C++ sont une adaptation de programmes trouvés en exemple sur Internet, je les ai adaptés à mon besoin.

Principe de fonctionnement souhaité

Le principe de fonctionnement de ce tutoriel est de piloter depuis un Raspberry Pi, une LED pilotée par l’Arduino Nano, ce dernier retourne au Raspberry Pi un état de la commande pour indiquer sa bonne exécution, ou pas.

  • Allumage de la LED
    • On envoie dans une commande une chaine JSON au Raspberry Pi, celui ci l’interprète, puis envoie à l’Arduino Nano via le nRF24L01 la commande d’allumage de la led (envoi du N° d’ID attribué au nRF24L01 du Nano + commande « ON » ).
    • L’Arduino Nano reçoit la commande, allume la LED, et retourne sont état au RasPi.
    • Le RasPi reçoit l’état de la LED, le programme reconstruit une chaine JSON de retour avec la valeur de retour pour l’utilisateur (« TRUE » ou « FALSE« ), ainsi que l’état de la LED (« ON » ou « OFF« )
  • Extinction de la LED
    • Idem ci dessus, mais envoi d’une commande « OFF« 
  • Demander l’état de la LED
    • Le Raspberry Pi envoie une demande à l’Arduino Nano pour connaitre l’état de la LED (envoi du N° d’ID attribué au nRF24L01 du Nano + commande « GET« ).
    • L’Arduino Nano lit l’état de la LED qu’il a en mémoire, et le retourne au RasPi.
    • Le RasPi reçoit l’état de la LED, le programme reconstruit une chaine JSON de retour avec la valeur de retour (« TRUE » ou « FALSE ») ainsi que l’état de la LED (« ON » ou « OFF »)

Passons maintenant à la partie technique, installation et configuration du matériel.

NRF24L01-circuits

Schéma d’une carte nRF24L01

Mise à jour du système

Avant toute installation, on commence par mettre à jour le système :

$ sudo apt-get update
$ sudo apt-get upgrade
$ sudo apt-get dist-upgrade

Préparation du système

Installation de SPI

Afin d’assurer une bonne stabilité de l’interface SPI, il est préférable d’annuler l’overcloking si vous l’avez activé sur votre système… Il sera possible une fois que l’ensemble sera fonctionnel, de tenter une réactivation de l’overclock. Mais par sécurité, il vaut mieux d’abord installer l’ensemble, et le faire fonctionner dans des conditions normales et sur un système sain, et seulement après retenter un overclockage.

Pour activer l’interface SPI, il faut lancer la commande :

$ sudo raspi-config

Aller dans le menu des options avancées (menu « Advanced Options »), puis dans le sous-menu, sélectionner « SPI« , et cliquer sur « Oui » pour activer le SPI.

Il est ensuite demandé si l’on souhaite charger le module SPI avec le Noyau, répondre « OUI »

Quitter l’utilitaire « Raspi-config ». Rebooter le système.

image9

nRF24L01 : Implantation des composants

Après le redémarrage, on va autoriser l’accès à SPI. Pour cela, éditer le fichier « raspi-blacklist.conf » :

$ sudo nano /etc/modprobe.d/raspi-blacklist.conf

Attention, dans les dernières versions de Raspbian, j’ai remarqué que ce fichier n’existe plus, ou qu’il est vide, il n’y a donc plus rien à modifier dedans. Passer directement à la suite du prochain reboot sans suivre les modifications du fichier.

Si le fichier n’est pas vide, vérifier si la ligne ci-dessous existe :

blacklist spi-bcm2708

Dans ce cas, il faut la commenter en ajoutant un « # » devant :

#blacklist spi-bcm2708

On enregistre, on quitte l’éditeur, et on reboot le Raspberry.

Au redémarrage, on vérifie que le SPI est bien activé :

pi@raspberrypi ~ $ ls -la /dev/spi*
crw-rw---T 1 root spi 153, 0 janv. 1 1970 /dev/spidev0.0
crw-rw---T 1 root spi 153, 1 janv. 1 1970 /dev/spidev0.1

Si on voit apparaître les « /dev/spi* » , c’est que la configuration est correcte.

NRF24L01_02

Installation de la bibliothèque

Créer un dossier que l’on nommera « nrf24l01 » dans le « home directory » de l’utilisateur « pi« . Importer la bibliothèque RF24, et la compiler de la façon suivante.

$ cd
$ mkdir nrf24l01
$ cd nrf24l01
$ git clone https://github.com/TMRh20/RF24.git
$ cd RF24
$ make
$ sudo make install

On installe la librairie « JSON » que l’on va utiliser dans notre script de communication :

$ sudo apt-get install libjson0-dev

Revenir dans le dossier nrf24l01

$ cd ~/nrf24l01

Copier les fichiers « Makefile » et « sender.cpp » que vous trouverez dans le ZIP « nRF24L01_Raspberry » en bas de ce tutoriel.
Compiler le fichier à l’aide de la commande « make »

$ make
NRF24L01_01

nRF24L01 équipé d’une antenne

Installation matérielle

Le Raspberry Pi

Rpi_nrf24l01.png

Connexions entre le  Raspberry Pi et le nRF24L01

Éteignez le Raspberry Pi avant de lui connecter physiquement le module nRF24L01. Ceci évitera d’éventuelles destructions de ports…
L’exemple est ici avec un Raspberry Type B, mais les connexions sont identiques avec un A, A+, B+ ou Pi2

Connexion sur le Raspberry, les connexions aux broches ci-dessous ne peuvent être changées :

  • Pin 19 = MOSI du Raspberry vers MOSI (pin 6) du nRF24L01.
  • Pin 21 = MISO du Raspberry vers MISO (pin 7) du nRF24L01.
  • Pin 23 = SCLK du Raspberry vers SCK (pin 5) du nRF24L01.
  • Pin 24 = CE0 du Raspberry vers CSN (pin 4) du nRF24L01. (Peut éventuellement être connecté sur pin 26 du Raspberry, mais les scripts devront être adaptés).

La connexion du +3,3v, pin 2 du nRF24L01 est prise dans ce schéma sur le pin 1 du Raspberry. Cette alimentation peut être prise sur tout autre pin du Raspberry fournissant du 3,3v (pin 1 ou 17).

La connexion GND, pin 1 du nRF24L01 peut être prise partout ou il y a une pin GND sur le Raspberry.

  • Reste la pin 22 du Raspberry, il s’agit d’un port GPIO. Si celui ci est déjà utilisé, on peut prendre n’importe quel port GPIO. Il faudra pour cela adapter le script « sender.cpp » puis le recompiler.

Dans le script, changer la ligne :

RF24 radio(RPI_V2_GPIO_P1_22, RPI_V2_GPIO_P1_24, BCM2835_SPI_SPEED_16MHZ);

en adaptant « RPI_V2_GPIO_P1_22″ en fonction du pin GPIO connecté.
Exemple : « RPI_V2_GPIO_P1_11″ pour le GPIO 0.

Avant de remettre le Raspberry Pi sous tension, faites une nouvelle vérification de vos connexions…

L’Arduino Nano

Nous allons installer le module nRF24L01 sur un Arduino Nano. C’est ce dernier qui recevra l’ordre du Raspberry Pi  lui demandant d’allumer ou d’éteindre la LED.
Le tutoriel est ici donné avec un Arduino Nano, mais toute autre carte Arduino fera l’affaire, en respectant les connexions ci-dessous.

Voici le schéma du câblage entre l’Arduino Nano et le nRF24L01

Nano_nrf24l01.png

Connexions entre l’Arduino Nano et le nRF24L01

Connexion sur l’Arduino Nano, les connexions aux broches ci-dessous ne peuvent être changées :

  • Pin D11 du Nano vers MOSI (pin 6) du nRF24L01.
  • Pin D12 du Nano vers MISO (pin 7) du nRF24L01.
  • Pin D13 du Nano vers SCK (pin 5) du nRF24L01.

Connexions pouvant être effectuées sur d’autre pin, mais qui devront être adaptées dans le code du Croquis exporté vers l’Arduino Nano.

  • Pin D10 du Nano vers CSN (pin 4) du nRF24L01.
  • Pin D9 du Nano vers CE (pin 3) du nRF24L01.
  • Pin D6 du Nano vers l’anode de la LED.
  • L’alimentation du +3,3v, pin 2 du nRF24L01 est prise dans ce schéma sur le pin +3,3v du Nano.

Pour effectuer les connexions D10, D9 ou D6 à un autre pin, il faut ouvrir le croquis Arduino (.ino) et adapter les lignes suivantes :

#define RF_CE    9
#define RF_CSN   10
#define LED_PIN  6

Les Programmes

Programme Raspberry Pi

Le programme du Raspberry Pi permet d’envoyer via le nRF24L01, un ordre d’allumage ou d’extinction d’une LED. Cette dernière est commandée par notre Arduino Nano, l’ordre d’allumage et d’extinction est donc envoyé par le Raspberry Pi, vers Arduino Nano.

Le programme est écrit en C++, il utilise la bibliothèque RF24, que nous avons installée plus haut dans ce tutoriel.

Le principe est d’envoyer une chaine JSON via la ligne de commande du Raspberry Pi. Cette chaîne est composée de :

{
"to":"1",              // id di nRF24L01 vers lequel on envoi la commande.
"message":"get", // commande envoyée au Arduino Nano.
"TTL":"3000"      // (paramètre optionnel) "Time out" (si non précisé il sera de 1000 ms).
}

Les messages peuvent être :

set=on     // Commande l'allumage de la LED
set=off    // Commande l'extinction de la LED
get         // Demande au Nano quel est l'état de la LED

Exemple de commande envoyée pour commander l’allumage de la LED :

$ sudo ./sender '{"to":"1","message":"set=on"}'

Nous envoyons bien en paramètre une chaîne au format JSON. Le programme du Raspberry Pi s’occupe de transcrire cette chaine afin d’envoyer les commandes à l’Arduino, via le nRF24L01.

Télécharger ci-dessous le ZIP, puis copier les deux fichiers contenus dans l’archive « nRF24L01_Raspberry » vers le dossier « ~/nrf24l01/« 

nrf24-raspberry.zip    Script pour Raspberry  (1.58 Kio)

Se placer dans le dossier puis compiler le programme.

$ cd ~/nrf24l01
$ make</code>

Le programme sur le Raspberry Pi est maintenant fonctionnel.

Programme Aduino Nano

Le programme de l’Arduino Nano permet de recevoir les commandes envoyées, les interpréter, puis de répondre au Raspberry Pi si la commande est OK ou pas.

Ci-dessous le programme « ino » à charger depuis votre atelier Arduino (IDE).
nrf24-arduino.ino.zip     Script pour Arduino  (1.28 Kio)

Conclusion

Notre montage est maintenant fonctionnel.
Les prochaines étapes seront de remplacer la LED par une sonde de température DS18B20, et donc d’adapter les programmes à ce nouveau périphérique.
Au menu également une sonde DHT 11 ou DHT 22, un détecteur ultrasons de type HC-SR04 (pour remplacer le RasPi dans ma cuve à eau), …. et tout autre détecteur ou sonde dont je pourrais avoir besoin.

Note de framboise314 : Merci Domi pour cette description détaillée qui pourra servir de point de départ à de nombreuses réalisations domotiques !

Sources

Voici quelques liens vers des articles sur la mise en œuvre du nRF24L01. Ce sont des articles de montages ou de programmes, auxquels je me suis inspirés afin d’arriver à ce résultat.

L’article d’origine se trouve ici :

Share Button

À propos François MOCQ

Électronicien d'origine, devenu informaticien, et passionné de nouvelles technologies, formateur en maintenance informatique puis en Réseau et Télécommunications. Dès son arrivée sur le marché, le potentiel offert par Raspberry Pi m’a enthousiasmé j'ai rapidement créé un blog dédié à ce nano-ordinateur (www.framboise314.fr) pour partager cette passion. .

30 réflexions au sujet de « Faire dialoguer un Raspberry et un Arduino via nRF24L01 »

    1. Christophe

      Si tu es dans une maison 10 mètres. En champs libre beaucoup plus ( 50 mètres ).
      Tu peux aller sur mon site ou je parle de la mise en oeuvre du module. http://www.caron.ws
      Pour ma part, j’utilise une antenne du coté serveur et il faut être à 250Kbs pour avoir une meilleure distance. Il y un peu de paramétrage à faire.
      Cordialement
      Christophe 🙂

      Répondre
  1. nono056

    Bonjour.
    Juste pour information, il existe aussi mysensrs qui utilise le meme materiel.
    Couple à Jeedom, ca donne un outil tres fonctionnel.

    Répondre
  2. Gustavo del mar

    Merci pour votre article ; j’ai eu quelques difficultées avec le type définissant les pipes, j’ai utilisé la déclaration des exemples de la librairie RF24 et tout fonctionne correctement!

    Répondre
  3. ingfred

    Merci pour le tuto.
    Tout fonctionne hormis une réponse {« status »: »false », »code »: »6″, »message »: »Wrong ACK »}
    Sur la console de l’arduino la répons est ok.
    Une idée ?
    Merci par avance.

    Répondre
  4. Sylvain

    Bonjour,

    tout d’abord merci pour ce tutoriel.
    Je l’ai suivi entièrement, et lorsque j’essaie d’envoyer un message depuis le Rpi vers l’Arduino,
    pi@raspberrypi ~/nrf24l01 $ sudo ./sender ‘{« to »: »1″, »message »: »set=on »}’
    j’ai ce message :
    {« status »: »false », »code »: »5″, »message »: »Timed-out »}
    Les 2 modules MRF24 ne semblent pas arriver à communiquer ensemble.
    Avez-vous un conseil à me donner afin de résoudre ce pb et faire allumer cette fameuse LED ?
    Merci d’avance pour votre aide.
    Sylvain

    Répondre
    1. ingfred

      Bonjour Sylvain.
      J’ai eu le même soucis.
      En fait les pins utilisé pour les schema de montage ne correspondent pas au pins du programme. de mémoire c’est pour la connexion CE sur le raspi.
      Suis désolé de n’être pas plus précis, je n’ai pas le matos sous la main

      Répondre
  5. Tsim79

    Bonjour,
    J’essai d’installé un module NRF24L01 sur mon RPI2 mais j’ai des erreur lors de la compilation. Après quelques recherches sur Google, je crois avoir compris que la librairie du BCM2835 normalement fait pour le PIB n’est pas compatible avec le PI2 qui utilise un BCM2836!!! Ai-je bien compris ou alors mon anglais est trop limité!?
    A cet effet j’ai cherché, trouvé et télécharger un fichier TAR de la librairie pour le PI2 mais comment faire pour le décompresser et le compiler via putty!?
    Merci de votre aide.

    Répondre
    1. Tsim79

      je me réponds à moi même…
      tar xzf fichier.tar.gz
      Donc je vais continuer a bidouiller pour voir si j’arrive à compiler cette librairie sans erreur pour utiliser un NRF24L01 en SPI sur mon RPI2.

      Répondre
  6. Greg

    Bonjour,

    Je vous remercie pour cet article, dont je me suis servi comme point de départ pour mon projet très simpliste. Néanmoins, après l’avoir lu et relu et après avoir lu de nombreux autres articles sur le sujet, je n’arrive toujours pas à envoyer une valeur quelconque de mon Arduino UNO R3 vers mon RPi2. Pas de sonde de je ne sais quoi! Juste transmettre un entier me comblerait de joie!!
    Je pense pourtant avoir bien mis en place:
    – le cablage du tout avec « wire jumpers » sur breadboard (en vérifiant l’absence de faux contacts au multimètre et en vérifiant bien les pins du RPi 2 rev 1.1)
    – les bons « pipes » (en faisant attention à ce que le pipe « write » sur l’Arduino soit de même adresse que le pipe « read » sur le RPi)
    – la bonne déclaration des pins CE et CSN, aussi bien sur le RPi (pin 15 pour GPIO22 et pin 24 pour CE0) que sur l’Arduino (pins 9 et 10)
    – le même « radio.CHANNEL() » sur RPi et sur Arduino, en ayant pris soin de vérifier grâce à l’utilitaire « scanner » que j’utilise un canal « libre ».

    Je pense que mon Arduino envoie bien les paquets (en tout cas, le programme d’envoi s’exécute normalement) mais par contre mon RPi reste en écoute, sans rien entendre… A noter que radio.details() sur mon RPi n’affiche rien de déconnant (les adresses sont bien définies, etc…). En regardant de plus près dans le code, je vois que « radio.available() » ne renvoie jamais « true »… Je pense pourtant que mon module RF24 du RPi fonctionne, puisque j’arrive à lancer l’utilitaire « scanner ».

    J’avoue ne plus savoir quoi tester et me tourne vers vous pour une éventuelle idée.
    Je ne sais tellement plus quoi faire que J’en viens à me questionner sur l’existence de parasites électromagnétiques éventuels (après tout, il y a quand même un paquet de trucs qui émettent à 2.4GHz…)… et ce d’autant que j’ai l’impression que mon module sur Arduino ne veut pas émettre s’il est trop près de mon PC portable (OK, j’ai peut-être des hallucinations…)!!

    J’ai lu ça et là qu’ajouter une capacité entre les broches 3.3V et GND du module RF24 pouvait résoudre des problèmes en cas de pertes de paquets… mais là, mon RPi ne reçoit pas mes paquets! Pareil, il parait que radio.setPALevel ne devrait pas être mis à MAX, mais plutôt à HIGH…

    Bref, je suis perdu… dès la première marche de mon projet! Ca promet…

    Merci beaucoup,
    Gregala

    Répondre
  7. HerveB

    Bonjour,

    Si cela ne fonctionne pas c’est tout simplement parce que le NRF24L01 ne peut supporter des vitesses SPI supérieures à 10MHz (cf datasheet). Le programme pour le Raspberry Pi n’est donc pas bon puisqu’il fixe la vitesse sur le SPI à 16MHz : BCM2835_SPI_SPEED_16MHZ. Si vous la passez à 8MHz : BCM2835_SPI_SPEED_8MHZ tout fonctionnera comme prévu !

    Hervé

    Répondre
  8. jérémie

    Bonjour je cherche à transmettre du signal midi entre des arduino en passant par des RF24 , et je patauge..
    à tout hazard quelqu’un sait faire ça?
    J’ai un clavier midi qui envoie du signal dans un arduino, lequel est branché sur un rf24 « émetteur », de l’autre coté j’ai un rf24  » récepteur » branché sur un arduino qui doit allumer des leds correspondant aux notes du clavier: les leds s’allument bien mais seulement une fraction de seconde…
    j’ai essayé le truc des condensateurs mais ça ne change rien, je pense que c’est dans le code mais caramba!! je ne sais pas quoi..
    jérémie

    Répondre
  9. Damien

    Bonjour à vous, j’ai un soucis rien ne s’affiche dans mon terminal Raspberry… J’ai toujours une erreur « Timed-Out » … Pourtant j’ai suivi ce tutoriel à la lettre. la commande n’arrive pas à se transmettre à la carte arduino…

    Répondre
  10. frinux

    Bonjour
    est-ce que quelqu’un a tenté d’exploiter ce fameux NRF24 avec une application NodeJS ? J’ai trouvé un module qui est censé fonctionner (https://github.com/natevw/node-nrf) mais après pas mal d’essais je n’arrive toujours pas à récupérer les infos (alors que cela passe avec l’application en C++°

    J’ai mis des détails sur Stackoverflow si cela intéresse quelqu’un :
    https://stackoverflow.com/questions/35877346/nrf24l01-between-arduino-and-raspberry-pi-in-nodejs

    Répondre
    1. François MOCQ Auteur de l’article

      merci pour ce retour frinux
      éventuellement postez la question sur le forum, il y a plus de chance d’avoir une réponse que sur cette page qui date un peu et ne doit pas recevoir énormément de visites
      cordialement
      François

      Répondre
  11. Guy

    Bonjour,
    Merci pour tuto,
    Suivi a la lettre tout fonctionne. En 3H! pas mal.
    Par contre il y a une clarification nécessaire le tuto dis:

    en adaptant « RPI_V2_GPIO_P1_22″ en fonction du pin GPIO connecté.
    Exemple : « RPI_V2_GPIO_P1_11″ pour le GPIO 0.

    Mais après téléchargement le script tel-quel c’est RPI_V2_GPIO_P1_15 (et non pas 22)
    changer le 15 pour 22 suivre exactement le schema et le tuto et ca roule
    (c’est un peu confus car PIN15=GPIO22 et PIN22=GPIO25, mais le script parle en numéro de PIN pas de GPIO)

    Aussi sur l’Arduino j’avais une erreur de compilation par manque de lib.
    nrf24-arduino ne suffit pas il faut les *.h et *.cpp Mais en cherchant un peu on comprend que c’est la meme lib que celle chargée sur le raspberry pi, il suffit de les copier et ca roule (le tuto ne le disais pas). Mais bon faut bien un peu de recherche perso sinon c’est pas fun 😉
    Merci

    Répondre
  12. François MOCQ Auteur de l’article

    ==Bonjour je ne suis pas l’auteur du message comme indiqué ci-dessus ==
    == Guy n’a pas pu laisser ce commentaire car le firewall le refuse ==
    == sans doute à cause du code qu’il contient 🙁 ==
    == Je laisse la parole à Guy et je le remercie pour ce complément ==
    == Vous pouvez télécharger le programme ICI ==
    =======================================================================

    Bonsoir,
    Depuis hier: J’ai réussi a augmenter la portée en réduisant la vitesse a 250Kbps (était a 1Mbps). J’ai une portée de 15m a travers plusieurs murs, pas encore essayé en extérieur. C’est setDataRate dans RF24.cpp qu’il faut modifier; il faut ensuite tout recompiler (+ réinstaller les lib [make install] sur le raspberry pi).

    Et surtout j’ai modifié le code de l’arduino pour pouvoir lire des capteurs de temperature 1wire DS1820 (comme plusieurs en parlaient ici). Le code est ci-dessous. Toute les commandes JSON sont conservées (get, set on, set off) et la commande tmp est ajoutée. A chaque requête « tmp » l’arduino répond en envoyant la temperature lu sur le premier capteur (18S20 ou 18B20) qu’il trouve, a la requête suivante c’est le second et ainsi de suite, quand il n’y en a plus il réponds « no more address ». Ainsi avec 1 seul capteur on aura 1 fois la temperature et la fois suivante le message « no more address » ainsi de suite. Testé OK avec 0, 1, 2 et 3 capteurs, mix 18S20 et 18B20. A raccorder sur la pin8 de l’arduino avec la resistance de 4.7k qui va bien. Nécessite la lib OneWire (bien sur) officielle Arduino. De + il faut passer le timeout de 1000 a 2000ms dans le code du Pi car la conversion de temperature met environ 1s et sinon le Pi passe en timeout.

    #include
    #include "nRF24L01.h"
    #include "RF24.h"
    #include "printf.h"

    /* Définition des Pins CE, CSN et connexion de la LED sur ARDUINO */
    #define RF_CE 9
    #define RF_CSN 10
    #define LED_PIN 6

    RF24 radio(RF_CE,RF_CSN);

    /* Définition de l'id de l'Arduino */
    byte myID = 0x01;

    byte pipes[][7] = {"master","slave","idle"};

    struct payload_request_t
    {
    uint8_t number;
    uint8_t destination;
    char message[14];
    };

    struct payload_general_t
    {
    uint8_t number;
    char message[15];
    };

    payload_request_t incoming;
    payload_general_t outgoing;

    // Guy Avril 2016 Temperature 1wire readings sent to radio
    #include
    char buffer[255];
    boolean NoMoreAddress;
    OneWire ds(8); // on pin 8 (a 4.7K resistor is necessary)

    void ReadOneWireTemp(void) {
    byte addr[8];
    byte i;
    byte present = 0;
    byte type_s;
    byte data[12];
    float celsius;

    if ( !ds.search(addr)) {
    Serial.print("No more addresses.\n");
    ds.reset_search();
    NoMoreAddress = true;
    return;
    }

    NoMoreAddress = false;

    Serial.print("ROM =");
    for( i = 0; i < 8; i++) { Serial.write(' '); Serial.print(addr[i], HEX); } if ( OneWire::crc8( addr, 7) != addr[7]) { Serial.print("CRC is not valid!\n"); return; } // the first ROM byte indicates which chip switch (addr[0]) { case 0x10: Serial.println(" Chip = DS18S20"); // or old DS1820 type_s = 1; break; case 0x28: Serial.println(" Chip = DS18B20"); type_s = 0; break; case 0x22: Serial.println(" Chip = DS1822"); type_s = 0; break; default: Serial.println("Device is not a DS18x20 family device."); return; } ds.reset(); ds.select(addr); ds.write(0x44,1); // start conversion, with parasite power on at the end delay(1000); // maybe 750ms is enough, maybe not // we might do a ds.depower() here, but the reset will take care of t. present = ds.reset(); ds.select(addr); ds.write(0xBE); // Read Scratchpad Serial.print(" Data = "); Serial.print(present,HEX); Serial.print(" "); for ( i = 0; i < 9; i++) { // we need 9 bytes data[i] = ds.read(); Serial.print(data[i], HEX); Serial.print(" "); } Serial.print(" CRC="); Serial.print( OneWire::crc8( data, 8), HEX); Serial.println(); // Convert the data to actual temperature // because the result is a 16 bit signed integer, it should // be stored to an "int16_t" type, which is always 16 bits // even when compiled on a 32 bit processor. int16_t raw = (data[1] << 8) | data[0]; if (type_s) { raw = raw << 3; // 9 bit resolution default if (data[7] == 0x10) { // "count remain" gives full 12 bit resolution raw = (raw & 0xFFF0) + 12 - data[6]; } } else { byte cfg = (data[4] & 0x60); // at lower res, the low bits are undefined, so let's zero them if (cfg == 0x00) raw = raw & ~7; // 9 bit resolution, 93.75 ms else if (cfg == 0x20) raw = raw & ~3; // 10 bit res, 187.5 ms else if (cfg == 0x40) raw = raw & ~1; // 11 bit res, 375 ms //// default is 12 bit resolution, 750 ms conversion time } celsius = (float)raw / 16.0; Serial.print(" Temperature = "); Serial.print(celsius); Serial.print(" Celsius, "); dtostrf(celsius, 6, 4, buffer); } /* Envoi de la réponse */ /* ******************* */ void sendReply() { /* Message visible si la console est ouverte */ Serial.print("Message de retour de la commande \""); Serial.print(outgoing.message); Serial.println("\""); /* Retour de la reponse au demandeur */ radio.stopListening(); radio.openWritingPipe(pipes[1]); delay(10); radio.write(&outgoing,sizeof(payload_general_t)+1); delay(10); radio.startListening(); } /* Par défaut, la LED est enregistrée à l'état "off" */ byte last = 0; /* Initialisation du programme */ /* *************************** */ void setup() { Serial.begin(9600); /* Définition de pin de la LED comme SORTIE */ pinMode(LED_PIN, OUTPUT); /* On met le pin à l'état éteind */ digitalWrite(LED_PIN, LOW); printf_begin(); radio.begin(); radio.setAutoAck(1); radio.setRetries(1,3); radio.enableDynamicPayloads(); radio.openWritingPipe(pipes[1]); radio.openReadingPipe(1, pipes[0]); radio.startListening(); radio.printDetails(); } /* Boucle de "travail" */ /* ******************* */ void loop(void) { if(radio.available()) { radio.read(&incoming, sizeof(payload_request_t)); /* Affichage de la commande demandée dans la console */ Serial.print("Commande recu \""); Serial.println(incoming.message); /* Aduino vérifie que c'est bien à son ID que la demande s'adresse / if (incoming.destination==myID) { /* Si le message est "get", on retourne l'état enregistré de la LED / if (strncmp(incoming.message, "get", 3) == 0) { if (last > 0)
    strcpy(outgoing.message, "on");
    else
    strcpy(outgoing.message, "off");

    /* Sinon, la commande est t'elle de type "set" */
    } else if (strncmp(incoming.message, "set", 3) == 0) {
    if (strncmp(&incoming.message[4], "on", 2)==0) {
    /* Si la commande est "on", on allume la LED */
    digitalWrite(LED_PIN, HIGH);
    last = 1;
    strcpy(outgoing.message, "ok");
    } else if (strncmp(&incoming.message[4], "off", 3)==0) {
    /* Si la commande est "off", on éteind la LED */
    digitalWrite(LED_PIN, LOW);
    last = 0;
    strcpy(outgoing.message, "ok");
    } else
    /* Sinon, Commande inconnue, ni"on", ni "off" */
    strcpy(outgoing.message, "?");
    /* Sinon, la commande est t'elle de type "tmp" (temperature) */
    } else if (strncmp(incoming.message, "tmp", 3) == 0) {
    ReadOneWireTemp();
    if (!NoMoreAddress) {
    strcpy(outgoing.message, buffer);
    } else
    strcpy(outgoing.message, "No more address");
    /* Sinon, Commande inconnue, ni "get", ni "set" */
    } else {
    strcpy(outgoing.message, "?");
    }

    /* On retourne le résultat du traitement */
    outgoing.number = incoming.number;
    sendReply();
    }
    }
    delay(100);
    }

    Répondre
  13. Jack

    Bonjour , je n’ai pas copier et extrait les fichier mais je les est crée et édité correctement mais la commande make ne marche marche je ne comprend pas d’ou ça viens j’ai fais exactement le tuto . Je suis sur RPI2 apparemment ça viendrais de la lib mais comment corriger cela ? ..
    Merci

    Répondre
  14. Paolo

    Bonsoir,
    il m’est impossible d’installer proprement la bibliothèque RF24.
    Je bute à chaque fois à la commande make.
    ça me donne ça :

    cc1plus: error: bad value (cortex-a7) for -mtune switch
    Makefile:40: recipe for target ‘RF24.o’ failed
    make: *** [RF24.o] Error 1

    Pourriez vous m’aiguiller ?
    Merci beaucoup

    Répondre
  15. lionel

    Bonjour,

    une petite précision qui pourrait avoir son importance.

    Certaines nano à bas prix n’ont pas de pin 3.3V, la broche existe mais envoie du 5V.

    Cependant, pas de panique, les modules radio utilisés ici supportent parfaitement le 5V en alimentation.

    Concernant la portée, elle peut atteindre une centaine de mètres voire même près d’un kilomètre avec des modules munis d’antenne spécifique et dans des conditions optimales (testé en pleine mer).

    Pour avoir une puissance maximale du signal d’émission, il faut ajouter Mirf.configRegister(RF_SETUP, 0x26); dans le paramétrage du module émetteur. La vitesse de transmission sera faible mais la puissance de sortie passe à 0dBm (soit le maximum)

    Répondre

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Complétez ce captcha SVP * Time limit is exhausted. Please reload CAPTCHA.