[TUTORIEL] Shield RFM22

Forum de support et échanges autour des Shields RFM22 et RFM Master

[TUTORIEL] Shield RFM22

Message non lude Florian » Mar 27 Oct 2015 10:02

Bonjour,

Aujourd'hui nous allons faire connaissance avec le Shield RFM22.
shield-rfm22-fr.jpg
shield-rfm22-fr.jpg (34.72 Kio) Vu 714 fois


Ce produit embarque un module bidirectionnel RFM22 comme son nom l'indique. Ce shield s'inscrit dans la lignée du breakout RFM22.
Le RFM22 est un module bidirectionnel, c'est à dire qu'il peut à la fois émettre et recevoir une donnée. Ainsi avec plusieurs de ces modules, on peut les faire interagir et communiquer entre eux.

Datasheet du RFM22 disponible ici.

La librairie utilisée pour faire fonctionner ce produit a été développée par RadioHead, disponible ici.

Voir tutoriels breakout RFM22:

Petit Rappel:
Le module RFM22 fonctionne en 0-3,3V. L'arduino Uno fonctionne en 0-5V. Les deux communiquent ensemble grâce à la liaison SPI. Il y aura donc un problème de communication entre les deux à cause des niveaux de tensions différents. Pour y remédier avec le breakout RFM22, il a fallu faire un montage à base de résistance pour adapter la tension entre les deux modules. Le shield RFM22, nous simplifie la vie car il est déjà équipé d'un composant qui réalise l'adaptation de tension entre le module RFM22 et la carte arduino Uno. Il s'agit du NXP-NVT2010.

De plus le shield RFM22 nous évite également de devoir réaliser le câblage de communication SPI entre le module et la Uno. Il suffit simplement de mettre le shield RFM22 sur la carte arduino Uno et d'uploader le sketch dans cette dernière et le tour est joué. Ainsi les tutoriels pour le breakout RFM22 fonctionnent sans aucune modification avec le shield RFM22 et en s'évitant toute les parties câblage et adaptation des niveaux de tensions.

Comme ce produit fonctionne exactement de la même façon que le breakout RFM22, il nous suffit juste de reprendre les tutoriels de ce dernier pour le faire fonctionner.

Premier tutoriel: Shield RFM22. Jouons au PING-PONG!

Dans ce tutoriel, nous allons réaliser deux programmes. Le premier enverra la data suivante, PING. Le deuxième, à la réception de la précédente data l'affichera sur le moniteur série et enverra à son tour une data qui sera PONG. Cette dernière sera à son tour affiché par le premier programme sur son moniteur série. Ainsi avec le rebouclage des programmes nous aurons un effet PING-PONG!

- MATÉRIEL:

- BRANCHEMENTS:
Rien de plus simple, il suffit simplement de placer le shield RFM22 en mezzanine sur la carte Arduino Uno. Absolument aucun câblage à effectuer.
Il faut tout de même penser à connecter l'antenne!

- CODE:
Pour réaliser ce tutoriel, il faut deux sketchs. Le premier qui envoie une donnée en continue et peut afficher une donnée sur le moniteur série dès qu'il en reçoit une. Et le deuxième qui affiche la donnée qu'il reçoit sur le moniteur série puis qui envoie une nouvelle donnée à son tour, seulement et seulement si il en a reçu une avant.

Premier Sketch:
Code: Tout sélectionner
/* Skecth Ping-Pong */

#include <SPI.h>
#include <RH_RF22.h>

RH_RF22 rf22;    // Définition de la commande.

uint8_t data[] = "PING";    // Donnée qui va être émise.

uint8_t buf[RH_RF22_MAX_MESSAGE_LEN];    // Variables qui vont permettre de
uint8_t len = sizeof(buf);               // décrypter les données reçues.

void setup()
{
  Serial.begin(9600);
  Serial.println("Sketch PING.");
 
  if (!rf22.init())    // Vérification que le modem soit correctement initialisé.
  {
    Serial.println("Echec de l'initialisation modem!");
  }
  else
  {
    Serial.println("Succes de l'initialisation modem!");
  }
}

void loop()
{
  rf22.send(data, sizeof(data));    // Envoi de la donnée(PING).
 
  if (rf22.waitAvailableTimeout(500))    // Timeout.
  {   
    if (rf22.recv(buf, &len))    // Réception d'une donnée(PONG).
    {
      Serial.println((char*)buf);    // Affichage de la donnée reçue.
    }
  }
  delay(400);
}

Deuxième Sketch:
Code: Tout sélectionner
/* Skecth Ping-Pong */

#include <SPI.h>
#include <RH_RF22.h>

RH_RF22 rf22;    // Définition de la commande.

uint8_t data[] = "PONG";   // Donnée qui va être émise.

uint8_t buf[RH_RF22_MAX_MESSAGE_LEN];    // Variables qui vont permettre de
uint8_t len = sizeof(buf);               // décrypter les données reçues.

void setup()
{
  Serial.begin(9600);
  Serial.println("Sketch PONG.");

  if (!rf22.init())    // Vérification que le modem soit correctement initialisé.
  {
    Serial.println("Echec de l'initialisation modem!");
  }
  else
  {
    Serial.println("Succes de l'initialisation modem!");
  }
}

void loop()

  if (rf22.recv(buf, &len))    // Réception d'une donnée(PING).
  {
    Serial.println((char*)buf);    // Affichage de la donnée reçue.
   
    rf22.send(data, sizeof(data));    // Envoi de la donnée(PONG).
  } 
}

Lorsque vous avez uploadé les sketchs. Le premier sketch devrait faire afficher quelque chose de similaire dans le moniteur série :
Sketch Ping.png
Sketch Ping.png (25.78 Kio) Vu 772 fois

Le deuxième sketch devrait vous fournir quelque chose de semblable à ceci :
Sketch Pong.png
Sketch Pong.png (27.44 Kio) Vu 772 fois


Et voilà, nous avons réalisé une communication simple entre nos deux shield RFM22.

Deuxième tutoriel: Shield RFM22. Envoi Température.

Dans le précédent tuto, nous avons simplement envoyé une donnée fixe (PING ou PONG) qui était pré-enregistrée dans le sketch. Cette fois-ci le tuto que nous allons réaliser va transmettre les données d'un capteur de température. Nous aurons donc une donnée qui change continuellement.
Pour rendre les choses plus interactives, on ajoutera des leds avec le module qui reçoit afin de savoir juste à l'oeil l'ordre de grandeur des températures captées et envoyées par le premier module RFM22.

- MATÉRIEL:

- SCHÉMA DU MONTAGE:
Shield RFM22.PNG
Shield RFM22.PNG (52.82 Kio) Vu 772 fois

==> Du capteur de température LM35DZ à la carte Arduino Uno:
- La pin VCC à la broche +5V.
- La pin GND au GND
- La pin Out(celle du milieu) à la broche A0.

Shield RFM22 LEd.PNG
Shield RFM22 LEd.PNG (58.48 Kio) Vu 772 fois

- CODE:
Sketch Transmission température:
Code: Tout sélectionner
/* Sketch Transmission Température */

//Librairies.
#include <SPI.h>    // Implantantion librairie SPI. Protocole de communication entre Arduino Uno et module RF22.
#include <RH_RF22.h>    // Implantation de la librairie RF22. Intègre les fonctions du modules RF22.

RH_RF22 rf22;    // Définition de la commande.

int Temperature;    // Stockage de la température. Valeur qui sera envoyée par le module RF22.

const char Capteur = A0;    // Affectation de la broche A0 à la variable Capteur.

// Différentes variables nécessaire pour la détermination de la température. Elles concernent le capteur.
float ValeurCapteur;
char PleineEchelle = 5;
int Resolution = 1024;
float Pas = 0.01;

void setup()
{
  pinMode(Capteur, INPUT);    // Configure la broche A0 en entrée.
 
  Serial.begin(9600);    // Initialisation de la vitesse de la liaison série.
  Serial.println("Sketch Temperature");
 
  if (!rf22.init()) // Vérification que le modem soit correctement initialisé.
  {
    Serial.println("Echec de l'initialisation modem!");
  }
  else
  {
    Serial.println("Succes de l'initialisation modem!");
  }
}

void loop()
{
  ValeurCapteur = analogRead(Capteur);    // Stockage de la valeur numérique de la broche A0 dans ValeurCapteur.
  Temperature = (((ValeurCapteur*PleineEchelle)/Resolution)/Pas);    // Calcul de la température d'après cette valeur numérique.
  Serial.println(Temperature);    // Affichage de la température dans le moniteur série.
 
  rf22.send((uint8_t*)&Temperature, sizeof(Temperature));    // Envoi de la température.
 
  delay(400);
}

Sketch Réception température:
Code: Tout sélectionner
/* Skecth Réception Température */

//Librairies.
#include <SPI.h>    // Implantation librairie SPI. Protocole de communication entre Arduino Uno et module RF22.
#include <RH_RF22.h>    // Implantation de la librairie RF22. Intègre les fonctions du modules RF22.

RH_RF22 rf22;    // Définition de la commande.

uint8_t buf[RH_RF22_MAX_MESSAGE_LEN];    // Variables qui vont permettre de
uint8_t len = sizeof(buf);               // décrypter les données reçues.

char* Valeur;    // Variable de stockage contenant ce qui est dans le buffer.

int Temperature;    // Variable contenant la température.

// Attribution des pins aux broches.
int LedBleu = 5;
int LedVerte = 6;
int LedRouge = 7;

void setup()
{
  Serial.begin(9600);    // Initialisation de la vitesse de la liaison série.
  Serial.println("Sketch Reception Temperature.");
 
  // Configuration des leds en sortie.
  pinMode(LedBleu, OUTPUT);
  pinMode(LedVerte, OUTPUT);
  pinMode(LedRouge, OUTPUT);

  if (!rf22.init())    // Vérification que le modem soit correctement initialisé.
  {
    Serial.println("Echec de l'initialisation modem!");
  }
  else
  {
    Serial.println("Succes de l'initialisation modem!");
  }
}

void loop()

  if (rf22.recv(buf, &len))    // Réception d'une donnée sous la forme ASCII.
  {
    Valeur = ((char*)buf);    // Stockage de cette donnée dans la variable Valeur.
    sscanf(Valeur, "%s", &Temperature);    // Conversion de la valeur ASCII en décimal.
    Serial.println(Temperature);    // Affichage de la température.
   
    if(Temperature < 25)    // Si température strictement inférieure à 25°C.
    {
      digitalWrite(LedBleu, HIGH);
      digitalWrite(LedVerte, LOW);    // On allume la Led Bleue.
      digitalWrite(LedRouge, LOW);
    }
    else if(Temperature > 35)    // Autrement si température strictement supérieure à 35°C.
    {
      digitalWrite(LedBleu, LOW);
      digitalWrite(LedVerte, LOW);    // On allume la Led Rouge.
      digitalWrite(LedRouge, HIGH);
    }
    else    // Autrement (entre 25 et 35°C).
    {
      digitalWrite(LedBleu, LOW);
      digitalWrite(LedVerte, HIGH);    // On allume la Led Verte.
      digitalWrite(LedRouge, LOW);
    }
  } 
}

Réponse moniteur série Transmission:
MoniteurSérieTransmission.png
MoniteurSérieTransmission.png (31.13 Kio) Vu 772 fois

Réponse moniteur série Réception:
MoniteurSérieRéception.png
MoniteurSérieRéception.png (37.15 Kio) Vu 772 fois

Normalement si tout fonctionne correctement l'arduino avec le module récepteur doit avoir une des trois leds allumées.
La bleue si la température est strictement inférieure à 25°C.
La verte si la température est comprise entre 25 et 35°C.
La rouge si la température est strictement supérieure à 35°C.

Voilà pour ce tutoriel. Vous avez bien compris que le shield RFM22 fonctionne de façon similaire au Breakout RFM22. Nous avons simplement repris les tutoriels du Breakout pour les utiliser avec le shield en évitant l'étape emmêlage des câbles! Rien de sorcier!

A savoir: la LED ("L") du shield RFM22 est reliée à la broche 8.
Florian
 
Messages: 69
Inscription: Mer 24 Juil 2013 17:36

Retourner vers Shield RFM22 et RFM Master

Qui est en ligne

Utilisateurs parcourant ce forum: Aucun utilisateur enregistré et 1 invité