Le module RF se compose d’un émetteur RF 433 MHz et de modules de réception. Ce sont des modules RF de type ASK (Amplitude shift keying) ou OOK (Of Hook Keying). Lors de la transmission du zéro logique, l’émetteur supprime totalement la fréquence porteuse et ne consomme donc qu’une faible puissance en fonctionnement sur batterie. Lorsque le logique un est transmis, l’émetteur est allumé et la fréquence porteuse est pleine et donc, il y aura une alimentation élevée qui est de l’ordre d’environ 4,5mA avec une alimentation de 3V.
L’émetteur et le récepteur sont nécessaires pour être interfacés avec des microcontrôleurs pour le transfert de données. Les données sont envoyées en série par l’émetteur et sont reçues par un récepteur accordé. L’émetteur RF reçoit des données en série d’un microcontrôleur et les transmet au récepteur par le biais d’une antenne connectée à la 4ème broche de l’émetteur. Le récepteur reçoit les données à travers une antenne et donne les données au microcontrôleur qui lui est connecté.
Ces modules RF fonctionnent à une fréquence spécifique de 433MHz. Les signaux RF peuvent circuler entre l’émetteur et le récepteur même en présence d’un obstacle. Ces modules sont utilisés pour les communications de courte portée, à faible budget, basées sur le simplex. La faible consommation d’énergie les rend idéaux pour les implémentations sur batterie. Elle est utilisée dans divers domaines tels que les commandes d’éclairage à distance, la RFID à longue portée, les systèmes d’alarme et de sécurité sans fil, etc. La communication RF est utilisée dans la communication mobile et peut avoir une communication longue distance, ce qui la rend appropriée pour la construction d’applications IoT. Donc ici nous commençons avec un article d’introduction sur les modules RF et comment les modules RF peuvent être utilisés avec Arduino pour envoyer et recevoir des données.
Module émetteur RF 433 MHz
Ce petit module est l’émetteur RF. Il est très simple. Le résonateur SAW qui est accordé pour un fonctionnement à 433,xx MHz est le cœur du module. Il y a un transistor de commutation et quelques composants passifs dessus.
Lorsqu’une logique HIGH est donnée comme entrée DATA, l’oscillateur est ON et produit une onde porteuse de sortie RF constante à 433,xx MHz et lorsque l’entrée DATA est logique LOW, l’oscillateur est OFF, donc aucune porteuse n’est produite. Cette technique est appelée Amplitude Shift Keying (ASK).
Spécifications
- Tension de fonctionnement : 3V – 12V
- Courant de fonctionnement : max Moins de 40mA, et min 9mA
- Mode de résonance : (SAW)
- Mode de modulation : ASK
- Fréquence de travail : 433,92MHz
- Puissance d’émission : 25mW
- Erreur de fréquence : +150kHz (max)
- Vélocité : moins de 10Kbps
- Portée de transmission : 90m (en espace ouvert)
Module récepteur RF 433 MHz
C’est le module récepteur RF. Même s’il semble complexe, il est aussi simple que le module émetteur. Il se compose d’un circuit de tuner RF, d’amplificateurs OP et d’une PLL. Un couple d’amplificateurs OP est utilisé pour amplifier l’onde porteuse reçue de l’émetteur. Le signal amplifié est ensuite transmis à une PLL (Phase Lock Loop) qui permet au décodeur de se « verrouiller » sur un flux de bits numériques, ce qui donne une meilleure sortie décodée et une meilleure immunité au bruit.
Spécifications
- Tension de fonctionnement : 5,0VDC +0,5V
- Courant de fonctionnement :≤5,5mA max
- Mode de modulation : OOK/ASK
- Fréquence de travail : 433.92MHz
- Largeur de bande : 2MHz
- Sensibilité : dépasse -100dBm (50Ω)
Composants requis
- Arduino Nano (2)
- Module émetteur RF 433MHz
- Module récepteur RF 433MHz
- Potentiomètre
- LED (5)
- Connexion des fils
.
Schéma de circuit
Le schéma de circuit pour l’émetteur RF utilisant Arduino Nano est donné ci-dessous. Ici, un potentiomètre est connecté pour faire varier les valeurs à envoyer au récepteur en utilisant l’émetteur RF.
Voici les détails des connexions des broches entre l’émetteur RF et l’Arduino
- Pince D12 de l’Arduino – Broche DATA de l’émetteur RF
- VCC de l’Arduino – VCC de l’émetteur RF
- GND de l’Arduino – GND de l’émetteur RF
- GND de l’Arduino – première broche du potentiomètre
- Broche A2 de l’Arduino – deuxième broche du potentiomètre
- VCC de l’Arduino – troisième broche du potentiomètre
.
Le schéma de circuit pour le récepteur RF utilisant Arduino Nano est montré ci-dessous. Ici, nous avons une série de diodes électroluminescentes. Les LED sont décalées en fonction des valeurs du potentiomètre reçues par le récepteur.
Ci-après sont les détails des connexions des broches entre le récepteur RF et Arduino
- Pince D11 de Arduino – Broche DATA du récepteur RF.
- VCC de Arduino – VCC du récepteur RF.
- GND de Arduino – GND du récepteur RF.
- Les fils positifs des DEL sont connectés aux broches numériques D2, D3, D4, D5 et D6
- Les fils négatifs des DEL sont mis à la terre.
Explication du code
Le code Arduino complet pour les deux côtés émetteur et récepteur RF sont donnés à la fin de ce tutoriel, ici nous expliquons le programme complet pour comprendre le fonctionnement du projet. Mais avant de commencer avec le code d’abord nous devons installer une bibliothèque dans Arduino IDE.
Ici nous utilisons la bibliothèque de fil virtuel. Téléchargez la bibliothèque virtual wire à partir du lien ci-dessous
https://www.resistorpark.com/content/Arduino_Libraries/Arduino_Wireless_Communication_Libraries/VirtualWire.zip
VirtualWire est une bibliothèque Arduino qui fournit les fonctionnalités pour envoyer des messages courts, sans adressage, accusé de réception ou retransmission. Les messages sont envoyés un peu comme UDP sur le sans fil en utilisant ASK (amplitude shift keying). Cette bibliothèque prend en charge un certain nombre d’émetteurs et de récepteurs radio peu coûteux.
Pour ajouter la bibliothèque dans Arduino IDE, allez dans Sketch>>Inclure la bibliothèque>>Ajouter la bibliothèque .ZIP puis téléchargez la bibliothèque que vous avez téléchargée à partir du lien ci-dessus.
Après avoir téléchargé le programme, ouvrez le moniteur série des deux côtés et vous verrez les sorties comme indiqué ci-dessous.
La sortie à la section de l’émetteur RF montre les valeurs du potentiomètre.
Et la sortie au récepteur montre la valeur du capteur reçu. Les diodes sont décalées en fonction de la plage des valeurs du capteur. Ici, nous avons donné une plage de 200 pour chaque LED.
Voilà donc comment Arduino peut être utilisé dans la communication basée sur la RF, consultez plus de projets IoT basés sur Arduino ici.
Code pour la section de l’émetteur RF
#include <VirtualWire.h>
const int SensorPin = A2 ; // broche de potentiomètre
int SensorData;
char SensorCharMsg ;
void setup()
{
pinMode(SensorPin,INPUT);
// pour le débogage
Serial.begin(9600) ;
// Configuration de VirtualWire
vw_setup(2000) ; // Bits par seconde
}
void loop()
{
// Lire et stocker les données du capteur 1
SensorData = analogRead(SensorPin) ;
// Convertir directement les données entières en tableau Char
itoa(SensorData,SensorCharMsg,10);
// DEBUG
Serial.print(« Sensor Integer : « );
Serial.print(SensorData) ; // imprime les données du capteur
Serial.print( » Sensor CharMsg : « );
Serial.print(SensorCharMsg) ; //imprime le tableau de caractères
Serial.println( » « );
delay(100);
// END DEBUG
vw_send((uint8_t *)SensorCharMsg, strlen(SensorCharMsg)) ; // envoyer le message
vw_wait_tx() ; // Attendre que tout le message soit parti
delay(200) ;
} // FIN void loop
Code pour la section du récepteur RF
#include <VirtualWire.h>
int SensorData ; // Capteurs
char SensorCharMsg ; // Conteneur de transmission RF
const int led1 = 2;
const int led2 = 3;
const int led3 = 4;
const int led4 = 5;
const int led5 = 6;
void setup()
{
Serial.begin(9600);
pinMode(led1, INPUT);
pinMode(led2, INPUT);
pinMode(led3, INPUT);
pinMode(led4, INPUT);
pinMode(led5, INPUT) ;
// VirtualWire
// Initialisation de l’IO et de l’ISR
// Nécessaire pour le DR3100
vw_set_ptt_inverted(true);
// Bits par seconde
vw_setup(2000);
// Lancement de la PLL du récepteur en cours d’exécution
vw_rx_start();
} // FIN void setup
void loop()
{
uint8_t buf;
uint8_t buflen = VW_MAX_MESSAGE_LEN;
/// Non-blocage
if (vw_get_message(buf, &buflen))
{
int i;
/// Message avec une bonne somme de contrôle reçu, le vider.
for (i = 0 ; i < buflen ; i++)
{
// Remplir le tableau SensorCharMsg Char avec les
//carts correspondants du tampon.
SensorCharMsg = char(buf);
}
/// Terminer à zéro le tableau de chars
// Cela doit être fait sinon des problèmes surviendront
// lorsque les messages entrants auront moins de chiffres que le
// précédent.
SensorCharMsg = ‘\0’;
/// Convertir le tableau de Char de Sensor1CharMsg en entier
SensorData = atoi(SensorCharMsg);
// DEBUG
Serial.print(« Sensor « );
Serial.println(SensorData);
// END DEBUG
}
if (SensorData <= 200)
{
digitalWrite(led1, HIGH);
}
else
digitalWrite(led1, LOW) ;
if ( SensorData > 200 && SensorData <= 400)
{
digitalWrite(led2, HIGH) ;
}
else
digitalWrite(led2, LOW);
if ( SensorData > 400 && SensorData <= 600)
{
digitalWrite(led3, HIGH) ;
}
else
digitalWrite(led3, LOW);
if ( SensorData > 600 && SensorData <= 800)
{
digitalWrite(led4, HIGH);
}
else
digitalWrite(led4, LOW) ;
if ( SensorData > 800 && SensorData <= 1023)
{
digitalWrite(led5, HIGH);
}
else
digitalWrite(led5, LOW);
}
.