Module RF 433 MHz Arduino : émetteur, récepteur, antenne, code

Un module RF 433 MHz est le moyen le moins cher d'ajouter une liaison sans fil à un projet Arduino : un kit composé d'un émetteur (FS1000A) et d'un récepteur (XY-MK-5V) coûte très peu, se branche avec un seul fil de données et, avec une antenne filaire de 17 cm, transporte un signal sur des dizaines de mètres. Les prises télécommandées, les sonnettes sans fil, les télécommandes de volets roulants, les détecteurs d'ouverture de porte et de fenêtre et les sondes extérieures des stations météo utilisent aussi le plus souvent la même fréquence. Avec ces modules, tu peux donc envoyer des données entre deux Arduino, mais aussi lire les codes des télécommandes de ta maison et les renvoyer depuis un Arduino.

Dans ce guide, tu vas découvrir comment les modules fonctionnent avec la modulation ASK (OOK), pourquoi l'antenne doit mesurer 17,3 cm et comment les brancher sur un Arduino Uno, un ESP32 et un Raspberry Pi Pico. Ensuite, tu enverras du texte et des données de capteurs entre deux Arduino avec la bibliothèque RadioHead, tu liras et copieras le code de la télécommande d'une prise avec la bibliothèque RCSwitch, tu verras comment augmenter la portée et tu compareras le module au nRF24L01.

Qu'est-ce qu'un module RF 433 MHz et comment fonctionne-t-il ?

Le kit se compose de deux cartes séparées. Le petit émetteur carré FS1000A (vendu aussi sous le nom XY-FST) allume et éteint une onde porteuse de 433,92 MHz selon le signal reçu sur sa broche DATA. Le récepteur XY-MK-5V, plus long, capte ce signal dans l'air et le restitue sous forme de 0 et de 1 sur sa broche DATA. Autrement dit, les modules eux-mêmes n'ont ni protocole, ni adresse, ni contrôle d'erreurs ; leur seul rôle est de transporter un signal numérique sans fil jusqu'à l'autre côté. Mettre les données en paquets, les vérifier et les décoder, c'est le travail de la bibliothèque sur l'Arduino. La communication est unidirectionnelle : l'émetteur ne fait qu'envoyer, le récepteur ne fait qu'écouter.

Les deux broches DATA du récepteur sont reliées sur la carte : peu importe celle que tu utilises. Le XY-MK-5V est un récepteur à super-réaction bon marché mais peu sélectif : sa fréquence est fixée par une bobine réglable sur la carte et il est facilement perturbé par les parasites proches. Ne tourne pas la vis de cette bobine ; si le réglage d'usine est perdu, le récepteur n'entend plus l'émetteur. Pour des résultats plus stables, les récepteurs superhétérodynes comme le RXB6 sont plus sensibles et fonctionnent aussi en 3,3 V. Le kit existe aussi en version 315 MHz ; l'émetteur et le récepteur doivent être sur la même fréquence, et le résonateur métallique de l'émetteur porte généralement la fréquence imprimée.

Modulation ASK (OOK) : pourquoi as-tu besoin d'une bibliothèque ?

En OOK (On-Off Keying), la forme la plus simple de l'ASK (Amplitude Shift Keying, modulation par déplacement d'amplitude), la porteuse est allumée pour un bit 1 et éteinte pour un bit 0. Ça paraît simple, mais le récepteur a une particularité : son contrôle automatique de gain (CAG) pousse le gain au maximum en l'absence de signal, prend le bruit ambiant pour des données et sort en permanence des impulsions aléatoires sur la broche DATA. C'est pourquoi brancher l'émetteur directement sur la broche TX de l'Arduino et le récepteur sur RX pour communiquer avec Serial.print donne presque toujours des caractères incompréhensibles.

Le pilote RH_ASK de la bibliothèque RadioHead règle ce problème ainsi : avant chaque paquet, il envoie un préambule de 36 bits et un symbole de départ de 12 bits pour que le gain du récepteur se stabilise. Il convertit ensuite chaque octet en deux symboles de 6 bits équilibrés en continu (codage 4 vers 6) et ajoute un CRC de 16 bits à la fin du paquet. Le récepteur rejette en silence les paquets dont le CRC est faux : seules les données intactes te parviennent. RCSwitch, lui, décode le codage par largeur d'impulsion utilisé par les puces des télécommandes : chaque bit est représenté par des impulsions qui restent à HIGH et à LOW pendant des durées précises.

Longueur d'antenne 433 MHz : pourquoi 17,3 cm ?

Les modules n'ont pas d'antenne, seulement une pastille à souder marquée ANT. Sans antenne, un kit ne fonctionne qu'à 1–3 mètres. L'antenne simple la plus efficace est un fil droit d'un quart de longueur d'onde : λ = c / f = 300 000 000 / 433 920 000 ≈ 0,69 m, dont le quart vaut environ 17,3 cm. Pour les modules 315 MHz, le même calcul donne 23,8 cm. Soude l'extrémité d'un fil rigide monobrin sur la pastille ANT et garde le fil droit et vertical ; soude aussi un fil de même longueur sur le récepteur et oriente les deux antennes dans le même sens.

Branchement du module RF 433 MHz : Arduino Uno, ESP32 et Pico

L'émetteur fonctionne sans problème avec un signal de 3,3 V sur sa broche DATA : sur l'ESP32 et le Pico, tu peux donc l'alimenter en 5 V et relier DATA directement à un GPIO. C'est la tension de l'émetteur qui influence le plus la portée : en 3,3 V elle diminue nettement, en 9–12 V elle est multipliée. Placer un condensateur céramique de 100 nF et un électrolytique de 10 µF juste à côté des broches VCC et GND du récepteur réduit le bruit d'alimentation et améliore visiblement la réception.

Envoyer des messages entre deux Arduino avec RadioHead

1. Ouvre le gestionnaire de bibliothèques de l'IDE Arduino, cherche RadioHead et installe la bibliothèque de Mike McCauley. Pour plus de détails, consulte ajouter une bibliothèque Arduino.
2. Branche l'émetteur sur le premier Arduino : DATA → D12, VCC → 5V, GND → GND.
3. Branche le récepteur sur le second Arduino : DATA → D11, VCC → 5V, GND → GND.
4. Soude un fil de 17,3 cm sur la pastille ANT de chaque module.
5. Téléverse le code de l'émetteur sur la première carte et celui du récepteur sur la seconde, puis ouvre le moniteur série côté récepteur à 9600 bauds.

1#include <RH_ASK.h>
2#include <SPI.h>                  // RadioHead derlemesi için / needed for RadioHead to compile
3
4RH_ASK rf(2000, 11, 12);          // hız (bps), RX pini, TX pini / speed (bps), RX pin, TX pin
5unsigned int sayac = 0;
6
7void setup() {
8  Serial.begin(9600);
9  if (!rf.init()) Serial.println("RF init hatasi / failed");
10}
11
12void loop() {
13  char mesaj[24];
14  snprintf(mesaj, sizeof(mesaj), "Merhaba %u", sayac++);
15  rf.send((uint8_t *)mesaj, strlen(mesaj));
16  rf.waitPacketSent();            // paket bitene kadar bekle / wait until the packet is sent
17  Serial.print("Gonderildi / sent: ");
18  Serial.println(mesaj);
19  delay(1000);
20}

1#include <RH_ASK.h>
2#include <SPI.h>                  // RadioHead derlemesi için / needed for RadioHead to compile
3
4RH_ASK rf(2000, 11, 12);          // vericiyle aynı hız / same speed as the transmitter
5
6void setup() {
7  Serial.begin(9600);
8  if (!rf.init()) Serial.println("RF init hatasi / failed");
9}
10
11void loop() {
12  uint8_t buf[RH_ASK_MAX_MESSAGE_LEN + 1];   // +1: metin sonu için / +1 for the string terminator
13  uint8_t len = RH_ASK_MAX_MESSAGE_LEN;      // her turda yeniden ayarla / reset on every pass
14  if (rf.recv(buf, &len)) {                  // yalnız CRC doğruysa true / true only if the CRC is valid
15    buf[len] = '\0';
16    Serial.print("Alindi / received: ");
17    Serial.println((char *)buf);
18  }
19}

Dans le code du récepteur, il est important de réinitialiser la variable len à chaque tour : recv() y écrit la taille du paquet reçu et, à l'appel suivant, cette valeur est prise pour la taille du tampon ; sans réinitialisation, les messages plus longs sont tronqués. Si tout va bien, tu verras chaque seconde les lignes "Merhaba 0", "Merhaba 1" dans le moniteur série. Si des numéros manquent, des paquets se sont perdus en route ; vérifie alors l'antenne et l'alimentation.

Envoyer des données de capteur : un paquet avec un struct

Dans les vrais projets, envoyer des nombres est plus efficace que du texte. Tu peux regrouper tes mesures dans un struct et envoyer ses octets tels quels. L'émetteur ci-dessous envoie cinq fois par seconde la valeur d'une LDR ou d'un potentiomètre branché sur A0 et l'état du bouton sur D2. Le récepteur allume la LED de D13 quand on appuie sur le bouton distant et repère les paquets perdus.

1#include <RH_ASK.h>
2#include <SPI.h>
3
4struct __attribute__((packed)) Paket {   // iki tarafta birebir aynı olmalı / must be identical on both sides
5  uint16_t no;                           // paket numarası / packet number
6  int16_t deger;                         // analog değer / analog value
7  uint8_t buton;                         // 1 = basılı / 1 = pressed
8};
9
10RH_ASK rf;                               // varsayılan: 2000 bps, RX 11, TX 12 / defaults
11Paket p = {0, 0, 0};
12
13void setup() {
14  pinMode(2, INPUT_PULLUP);              // buton D2-GND / button D2-GND
15  rf.init();
16}
17
18void loop() {
19  p.no++;
20  p.deger = analogRead(A0);              // örneğin LDR ya da potansiyometre / e.g. LDR or potentiometer
21  p.buton = (digitalRead(2) == LOW);
22  rf.send((uint8_t *)&p, sizeof(p));
23  rf.waitPacketSent();
24  delay(200);
25}

1#include <RH_ASK.h>
2#include <SPI.h>
3
4struct __attribute__((packed)) Paket {
5  uint16_t no;
6  int16_t deger;
7  uint8_t buton;
8};
9
10RH_ASK rf;
11const int LED = 13;
12uint16_t sonNo = 0;
13
14void setup() {
15  Serial.begin(9600);
16  pinMode(LED, OUTPUT);
17  rf.init();
18}
19
20void loop() {
21  Paket p;
22  uint8_t len = sizeof(p);
23  if (rf.recv((uint8_t *)&p, &len) && len == sizeof(p)) {
24    digitalWrite(LED, p.buton ? HIGH : LOW);   // uzaktaki buton LED'i yakar / remote button lights the LED
25    if (sonNo != 0 && p.no != (uint16_t)(sonNo + 1)) {
26      Serial.println("Paket kaybi / packet lost");
27    }
28    sonNo = p.no;
29    Serial.print(p.no);
30    Serial.print("  A0 = ");
31    Serial.println(p.deger);
32  }
33}

L'attribut __attribute__((packed)) empêche le compilateur d'ajouter des octets de remplissage entre les champs. C'est important : le même struct peut occuper 5 octets sur un Arduino Uno et 6 sur un ESP32, et les données se décalent quand deux cartes différentes communiquent. Grâce au numéro de paquet, le récepteur peut compter les pertes. Comme les modules 433 MHz n'ont pas d'accusé de réception, c'est une bonne habitude de répéter plusieurs fois les commandes importantes. Si tu mets un émetteur et un récepteur de chaque côté, tu peux aussi créer une communication avec accusés de réception et réémissions grâce à la classe RHReliableDatagram de RadioHead.

Lire les codes des télécommandes du commerce avec RCSwitch

Beaucoup de prises télécommandées, de sonnettes sans fil, de télécommandes de volets et de portails ainsi que de détecteurs d'ouverture et de mouvement (PIR) utilisent des puces de codage comme l'EV1527 ou le PT2262. À chaque appui, ces puces envoient plusieurs fois de suite le même code de 12 à 24 bits, séparé par des pauses de synchronisation. La bibliothèque RCSwitch (rc-switch dans le gestionnaire de bibliothèques) décode ces codes. Sur l'Uno, relie la broche DATA du récepteur à une broche d'interruption, c'est-à-dire D2 ou D3, et téléverse le code suivant :

1#include <RCSwitch.h>
2
3RCSwitch rf = RCSwitch();
4
5void setup() {
6  Serial.begin(9600);
7  rf.enableReceive(digitalPinToInterrupt(2));   // alıcı DATA -> D2 (kesme pini) / receiver DATA -> D2 (interrupt pin)
8  Serial.println(F("Kumandanin tusuna bas / press a remote button"));
9}
10
11void loop() {
12  if (rf.available()) {
13    Serial.print(F("Kod / code: "));
14    Serial.print(rf.getReceivedValue());
15    Serial.print(F("  Bit: "));
16    Serial.print(rf.getReceivedBitlength());
17    Serial.print(F("  Protokol / protocol: "));
18    Serial.print(rf.getReceivedProtocol());
19    Serial.print(F("  Darbe / pulse: "));
20    Serial.print(rf.getReceivedDelay());
21    Serial.println(F(" us"));
22    rf.resetAvailable();                         // bir sonraki koda hazırlan / get ready for the next code
23  }
24}

Ouvre le moniteur série et appuie sur une touche de la télécommande ; tu verras une ligne comme "Kod / code: 5393 Bit: 24 Protokol / protocol: 1 Darbe / pulse: 350 us". Note pour chaque touche le code, le nombre de bits, le protocole et la durée d'impulsion : il te faudra les quatre pour la copie. Sur les télécommandes à EV1527, les 20 premiers des 24 bits sont l'identifiant de la télécommande et les 4 derniers la touche pressée ; c'est pourquoi les codes des touches d'une même télécommande sont très proches. En protocole 1, une unité dure environ 350 µs : un bit 0 vaut 1 unité à HIGH et 3 à LOW, un bit 1 vaut 3 unités à HIGH et 1 à LOW, et la synchronisation 1 unité à HIGH et 31 à LOW.

Envoyer le code de la télécommande depuis l'Arduino

Pour envoyer le code lu, relie la broche DATA de l'émetteur à D10 et deux boutons entre D4 et D5 et GND. À chaque appui, l'Arduino répète le code 10 fois, exactement comme la télécommande ; les touches marche et arrêt de la prise sont désormais sur ton Arduino :

1#include <RCSwitch.h>
2
3RCSwitch rf = RCSwitch();
4const int BTN_AC = 4;            // "aç" butonu D4-GND / "on" button D4-GND
5const int BTN_KAPAT = 5;         // "kapat" butonu D5-GND / "off" button D5-GND
6
7void setup() {
8  pinMode(BTN_AC, INPUT_PULLUP);
9  pinMode(BTN_KAPAT, INPUT_PULLUP);
10  rf.enableTransmit(10);         // verici DATA -> D10 / transmitter DATA -> D10
11  rf.setProtocol(1);             // önce protokol... / protocol first...
12  rf.setPulseLength(350);        // ...sonra okuduğun darbe süresi / ...then the pulse length you read
13  rf.setRepeatTransmit(10);      // her gönderim 10 kez tekrarlanır / each send is repeated 10 times
14}
15
16void loop() {
17  if (digitalRead(BTN_AC) == LOW) {
18    rf.send(5393, 24);           // okuduğun "aç" kodu ve bit sayısı / the "on" code and bit length you read
19    delay(300);
20  }
21  if (digitalRead(BTN_KAPAT) == LOW) {
22    rf.send(5396, 24);           // okuduğun "kapat" kodu / the "off" code you read
23    delay(300);
24  }
25}

Comme setProtocol() remet la durée d'impulsion à la valeur par défaut du protocole, appelle toujours setPulseLength() après. Si la prise ne réagit pas, indique d'abord exactement la durée d'impulsion lue (par exemple 320 ou 420 µs), puis augmente le nombre de répétitions à 15. Les prises à code d'apprentissage offrent un autre raccourci : si tu mets la prise en mode apprentissage et que tu envoies n'importe quel code de 24 bits depuis l'Arduino, la prise l'enregistre dans sa mémoire. Tu peux ainsi créer tes propres codes sans copier aucune télécommande.

Récepteur 433 MHz avec l'ESP32 : piloter un relais avec une télécommande

L'ESP32 est un pont idéal pour relier les télécommandes 433 MHz au monde du Wi-Fi. RCSwitch fonctionne aussi sur l'ESP32 et, comme tous ses GPIO acceptent les interruptions, tu peux brancher le récepteur sur la broche sûre de ton choix. Le code ci-dessous lit les codes d'un récepteur relié au GPIO 27 (via un pont diviseur) ; quand le code de ta propre télécommande arrive, il bascule la LED du GPIO 2 ou un module relais. Comme une télécommande envoie son code de nombreuses fois pour un seul appui, le programme ne rebascule pas tant que le code n'a pas cessé pendant 600 ms :

1#include <RCSwitch.h>
2
3RCSwitch rf = RCSwitch();
4const int RX_PIN = 27;              // alıcı DATA, gerilim bölücüyle / receiver DATA, through a divider
5const int ROLE_PIN = 2;             // dahili LED ya da röle girişi / onboard LED or relay input
6const unsigned long KOD = 5393;     // kendi kumandanın kodu / your own remote's code
7bool durum = false;
8unsigned long sonGorulme = 0;
9
10void setup() {
11  Serial.begin(115200);
12  pinMode(ROLE_PIN, OUTPUT);
13  rf.enableReceive(digitalPinToInterrupt(RX_PIN));   // ESP32'de her GPIO kesme alır / every GPIO takes interrupts on the ESP32
14}
15
16void loop() {
17  if (rf.available()) {
18    unsigned long kod = rf.getReceivedValue();
19    Serial.printf("Kod / code: %lu  %u bit  protokol %u\n", kod, rf.getReceivedBitlength(), rf.getReceivedProtocol());
20    if (kod == KOD) {
21      // kumanda kodu art arda tekrarlar; yalnız yeni basışta değiştir / the remote repeats the code; toggle only on a new press
22      if (millis() - sonGorulme > 600) {
23        durum = !durum;
24        digitalWrite(ROLE_PIN, durum ? HIGH : LOW);
25      }
26      sonGorulme = millis();
27    }
28    rf.resetAvailable();
29  }
30}

Tu peux construire beaucoup de choses sur cette base : transmets les codes reçus à Home Assistant via MQTT pour intégrer des détecteurs d'ouverture 433 MHz bon marché à ta domotique, ou commande des prises depuis ton téléphone avec un émetteur sur le GPIO 26. RadioHead prend aussi en charge l'ESP32 ; la seule différence est d'écrire explicitement les broches dans le constructeur : RH_ASK rf(2000, 27, 26, 25); (récepteur 27, émetteur 26 et 25 comme broche libre pour PTT). Si tu découvres l'ESP32, jette un œil à Qu'est-ce que l'ESP32 ?.

Émetteur 433 MHz avec le Raspberry Pi Pico et MicroPython

MicroPython n'a pas d'équivalent tout prêt de RCSwitch, mais la temporisation du protocole 1 est si simple que tu peux l'écrire toi-même en quelques lignes. Relie le VCC du FS1000A à la broche VBUS (5 V) du Pico, DATA au GP15 et un bouton entre GP16 et GND. Quand tu appuies sur le bouton, le Pico envoie les 24 bits en commençant par le bit de poids fort, comme RCSwitch, ajoute l'impulsion de synchronisation à la fin et répète tout le paquet 10 fois. Si tu ne sais pas encore installer MicroPython sur le Pico, commence par Qu'est-ce que le Raspberry Pi Pico ?.

1from machine import Pin
2import time
3
4tx = Pin(15, Pin.OUT, value=0)        # FS1000A DATA -> GP15
5buton = Pin(16, Pin.IN, Pin.PULL_UP)  # buton GP16-GND / button GP16-GND
6T = 350                               # darbe süresi µs (RCSwitch protokol 1) / pulse length µs (RCSwitch protocol 1)
7
8def darbe(yuksek, dusuk):             # süreler T cinsinden / durations in units of T
9    tx.value(1)
10    time.sleep_us(yuksek * T)
11    tx.value(0)
12    time.sleep_us(dusuk * T)
13
14def gonder(kod, bit=24, tekrar=10):
15    for _ in range(tekrar):
16        for i in range(bit - 1, -1, -1):   # en anlamlı bitten başla / start from the most significant bit
17            if (kod >> i) & 1:
18                darbe(3, 1)                # "1" biti: 3T HIGH, 1T LOW / bit "1"
19            else:
20                darbe(1, 3)                # "0" biti: 1T HIGH, 3T LOW / bit "0"
21        darbe(1, 31)                       # senkron: 1T HIGH, 31T LOW / sync
22
23while True:
24    if buton.value() == 0:                 # butona basıldı / button pressed
25        gonder(5393)                       # okuduğun kodu yaz / put the code you read here
26        time.sleep_ms(300)

Pour le processeur à 125 MHz du Pico, des impulsions de 350 µs sont un rythme confortable ; les petits retards de Python restent bien en dessous de la tolérance de 60 % des récepteurs RCSwitch. Tu peux tester le code tout de suite en posant à côté un Arduino équipé du code lecteur RCSwitch : le nombre envoyé doit s'afficher dans le moniteur série. Pour la réception, il faudrait mesurer et décoder les durées d'impulsion avec des horodatages ; pour cela, un Arduino ou un ESP32 avec RCSwitch est plus pratique.

Portée et parasites : envoyer le signal plus loin

• N'oublie pas l'antenne : soude un fil droit de 17,3 cm des deux côtés ; c'est ce qui influence le plus la portée.
• Augmente la tension de l'émetteur : alimenter le FS1000A en 9–12 V augmente nettement la puissance et la portée. N'oublie pas la masse commune.
• Réduis la vitesse : utiliser 1000 bit/s au lieu de 2000 dans RadioHead allonge chaque bit et permet au récepteur de décoder des signaux plus faibles. Mets la même vitesse des deux côtés.
• Vue dégagée et hauteur : les murs en béton armé, les boîtiers métalliques et un montage près du sol peuvent diviser la portée par deux ; sors les antennes des boîtiers métalliques et place-les le plus haut possible.
• Soigne l'alimentation : les moteurs, les relais et les alimentations à découpage rendent le récepteur sourd. Donne-lui une alimentation filtrée et garde des fils courts.
• Prends un meilleur récepteur : un récepteur superhétérodyne comme le RXB6 à la place du XY-MK-5V va souvent nettement plus loin avec le même émetteur.
• Renvoie : comme il n'y a pas d'accusé de réception, envoie les commandes importantes 3 à 5 fois et élimine les doublons côté récepteur grâce au numéro de paquet.

N'oublie pas que le 433 MHz est une bande partagée : la station météo du voisin, les clés de voiture et les sonnettes émettent sur la même fréquence. En Europe et en Turquie, la plage 433,05–434,79 MHz est ouverte sans licence aux appareils à courte portée, mais la puissance est limitée à 10 mW (PAR) et tu ne dois pas occuper le canal en permanence. Envoyer les données à intervalles réguliers ou seulement quand quelque chose change, plutôt qu'en continu, respecte les règles et prolonge l'autonomie ; pour un émetteur sur pile, tu peux utiliser le calculateur d'autonomie de batterie.

Module RF 433 MHz ou nRF24L01 ?

En bref, si tu dois envoyer dans un seul sens de petites données peu fréquentes (un bouton, une température, l'ouverture d'une porte) ou travailler avec des prises et capteurs du commerce, le module 433 MHz est la solution la plus simple et la moins chère. Pour une voiture radiocommandée, un joystick ou des réseaux de capteurs à plusieurs nœuds qui ont besoin d'une communication rapide, bidirectionnelle et avec accusé de réception, le nRF24L01 est un meilleur choix. Si tu as besoin de plusieurs kilomètres de portée, regarde les modules LoRa ; pour voir toutes les options côte à côte, lis les modules de communication sans fil pour Arduino.

Idées de projets avec le module RF 433 MHz

• Sonnette sans fil : joue une mélodie dans la maison quand le bouton du portail envoie un signal ; un buzzer suffit pour le son.
• Piloter des prises depuis l'Arduino : copie les codes des prises télécommandées et allume ou éteins des lampes selon l'heure ou la luminosité.
• Détecteur d'ouverture sans fil : place sur la porte un interrupteur reed (ILS) et un petit Arduino avec émetteur ; quand la porte s'ouvre, le côté récepteur déclenche l'alarme.
• Système d'alarme maison : construis un système d'alarme Arduino qui regroupe des détecteurs PIR et d'ouverture 433 MHz du commerce dans une centrale.
• Station de capteurs pour le jardin : envoie l'humidité du sol ou la température à la maison toutes les quelques minutes avec un émetteur sur pile.
• Passerelle 433 MHz vers Wi-Fi : pilote avec un ESP32 tous les appareils 433 MHz de la maison depuis ton téléphone et ta domotique.

Erreurs fréquentes et solutions

Les modules RF 433 MHz offrent à tes projets un bras sans fil pour presque rien et font partie des rares modules capables de dialoguer avec les appareils télécommandés déjà présents chez toi. Une fois la logique de la commande sans fil comprise, tu apprendras facilement d'autres méthodes comme les télécommandes IR et le Bluetooth. Dans l'application BlueGrays, tu trouveras des projets comme la communication entre deux Arduino, l'allumage d'une ampoule 220 V avec une télécommande, un détecteur de porte avec interrupteur reed et une alarme de mouvement ESP32, avec schémas de câblage et code pas à pas.