Contrôleur d'éclairage à leds basé sur LoRa: pas besoin de visibilité directe

À une époque où l'efficacité énergétique et la personnalisation des maisons deviennent de plus en plus importantes, la gestion traditionnelle de l'éclairage par des systèmes infrarouges présente des faiblesses évidentes, notamment la nécessité d'une visibilité directe et la vulnérabilité aux interférences. Cet article aborde ces défis, en présentant un système innovant de contrôle de l'intensité lumineuse avec LoRa, pour les lampes à leds de puissance moyenne.

La technologie des leds a un rendement plus élevé que n'importe quelle lampe conventionnelle. Et nous avons donc mis au point une installation qui permet de faire varier l'intensité lumineuse des diodes sans affecter leur rendement, tout en respectant les spécifications communiquées par le fabricant. Cette variation de luminosité pourrait également être contrôlée linéairement à l'aide d'un potentiomètre, mais nous avons préféré opter pour une commande à distance (qui est plus pratique et plus commode). Il était possible d'utiliser une télécommande IR, mais comme indiqué dans l'introduction, elle ne fonctionnerait que dans des conditions où le faisceau IR est visé en ligne directe. Compte tenu de ce qui précède, nous avons préféré opter pour LoRa (Il s'agit d'une technologie à longue portée, tant pour l'émission que pour la réception, qui surmonte cette limitation dans la mesure où elle peut fonctionner dans toutes les conditions environnementales (à proximité, à distance et avec des obstacles physiques).

Il s'agit d'une technologie de communication sans fil point à point, qui exploite la bande libre de 868 MHz utilisée en Europe. Il existe sur le marché un certain nombre de modules émetteurs-récepteurs LoRa 868 MHz qui peuvent faire l'affaire, mais pour des raisons de prix, de facilité de contrôle et de petite taille, nous avons opté pour une carte d'interface appelée RFM95W (par la suite, pour des raisons de commodité, nous l'appellerons module LoRa).

Une fois que nous avons décidé ce que nous allions utiliser pour contrôler la source lumineuse à leds, il restait à déterminer comment conserver ses caractéristiques intactes, même s'il était nécessaire de faire varier l'intensité lumineuse. À cet effet, nous avons pensé que la modulation de largeur d'impulsion (PWM) était la meilleure technique.

Le schéma fonctionnel du RTX

La Figure 1 montre le schéma fonctionnel des sections TX et RX du projet. L'émetteur étant utilisé comme une télécommande (donc portable), il faut nécessairement l'alimenter avec une batterie (BT1). Dans notre cas, nous avons choisi une cellule au lithium rechargeable (ICR14500). Sachant que la tension délivrée par une cellule au lithium peut varier de 3 V (épuisée) à 4,2 V (complètement chargée), pour respecter les caractéristiques d'alimentation du module LoRa (U3), qui vont d'un minimum de 1,8 V à un maximum de 3,7 V, nous avons introduit un régulateur de tension de 3,3 V (U2). Ceci afin d'avoir une tension stable qui nous permettrait de contrôler l'alimentation, à la fois lors de la charge de la cellule et lorsqu'elle est alimentée directement par la cellule elle-même.

Le module LoRa est contrôlé par le microcontrôleur ATmega328 (U1), tandis que l'écran LCD permet d'afficher la valeur numérique, exprimée en pourcentage de l'intensité lumineuse des leds. L'augmentation ou la diminution de ce chiffre se fait en appuyant individuellement sur les deux petits boutons-poussoirs S1 et S2. Le schéma fonctionnel du récepteur se compose d'une entrée d'alimentation (J2), dont la plage est de 9 à 12 V CC (il est important de rester dans cette plage de puissance).

Les régulateurs de tension U3 (5 V) et U4 (3,3 V), respectivement, alimentent le module PWM et le module LoRa (U2), qui ne doit pas être alimenté avec plus de 3,7 V, comme expliqué précédemment. De plus, le régulateur 3,3 V alimente le microcontrôleur ATmega328, qui est dédié au contrôle du module LoRa, et à la génération de la forme d'onde pour la modulation PWM.

Nous avons inclus une mémoire EEPROM (IC1), pour garder en mémoire les données numériques reçues de l'émetteur (qui définissent l'intensité lumineuse des leds), même lorsque nous éteignons le récepteur. Etant donné la consommation d'énergie des leds, qui peut être d'environ 80 mA chacune comme nous le verront un peu plus loin, il n'a pas été possible de connecter la sortie de la modulation PWM, générée par le microcontrôleur, directement aux leds. Pour cela, nous avons inséré une interface dénommée PWM et IC2.

L'émetteur

La télécommande, dont le prototype est illustré à la Figure 2 est alimenté par une batterie de 3,6 V, 800 mAh (BT1) qui peut être chargée via le port micro-USB (J1) connecté à une prise USB commune de 5 V ( voir le schéma de la Figure 3). La led LD1, combinée à l'allumage de la led LD3, indique que l'émetteur est alimenté et que la batterie est en cours de charge. Lorsque la led LD3 s'éteint, cela signifie que la charge de la batterie BT1 est terminée.

Le courant de charge est contrôlé par U2 et déterminé par la valeur de R2. En appliquant la formule donnée dans la fiche technique du fabricant (IREG = 1000V/RPROG), on peut définir sa valeur, qui est normalement de l'ordre d'un dixième de la capacité de la batterie. Bien que l'émetteur soit alimenté par une pile, nous avons dû introduire un stabilisateur de tension, constitué par IC1 (3,3 V). De cette façon, nous aurons une tension d'alimentation stable qui est utilisée pour alimenter le microcontrôleur (U1), l'écran LCD et le module RFM95W.

L'écran OLED 128 × 32 de 0,91" nous permet de visualiser les données transmises au récepteur pour augmenter ou diminuer la modulation PWM. Nous avons divisé l'écran en deux lignes, avec sur la ligne supérieure, l'affichage d'un bargraphe, dont la longueur est proportionnelle à la valeur des données transmises au récepteur via le module LoRa.

La deuxième ligne affiche les données, transmises au récepteur, sous forme de pourcentage avec Power écrit à côté, de sorte que 0% correspond à l'intensité lumineuse minimale et 100% à l'intensité maximale (Figure 4).

En utilisant un microcontrôleur ATmega328 (U1) pour contrôler l'écran LCD et le module LoRa, la programmation du microcontrôleur peut être effectuée dans l'environnement de développement Arduino (IDE), en profitant des bibliothèques nécessaires pour contrôler la communication LoRa et l'écran OLED de 0,91".

Pour ce projet, nous avons préféré utiliser l'IDE Microchip Studio, en utilisant le programmateur MPLAB PICkit 4 de Microchip pour charger le programme. Nous verrons dans la section appropriée comment effectuer la programmation. Le module LoRa, une carte RFM95W (U3), est utilisée pour transmettre les données qui permettent de varier le taux de modulation PWM.

Le Dip-switch SW2 est connecté entre le bus de communication SPI du microcontrôleur et le module LoRa. En plus de la communication entre le microcontrôleur U1 et le module LoRa U3, le port SPI est utilisé pour le programmateur PICKit 4 connecté à J2,  et donc pour programmer le microcontrôleur il faudra s'assurer que le bus de communication SPI est bien isolé du module LoRa. Il suffit pour cela de mettre les quatre Dip-switchs de SW2 en position OFF. Cela nous permet de programmer correctement le microcontrôleur, sans risquer d'erreurs dans le chargement du programme. Il est évident que cette opération n'est nécessaire que pendant la phase de téléchargement du programme.

Les deux boutons S1 et S2 permettent de commander l'augmentation (S1) ou la diminution (S2) de la modulation PWM, que nous appellerons simplement Power. Cela se traduit par la transmission des données qui permettront au récepteur de gérer l'intensité lumineuse des leds.

L'antenne AE1 peut même être très sommaire, si l'on travaille à l'intérieur, il n'est pas nécessaire d'avoir une antenne très performante. Elle doit être réglée sur la longueur d'onde de 868 MHz, mais un simple fil de cuivre d'environ 8,6 cm de long (soit ¼ de la longueur d'onde, 34,56 cm/4) sera suffisant. La led LD2 indique que la pile est faible (3,35 V). Nous mesurons sa tension grâce aux résistances R4 et R5 connectées à l'entrée PC2 du microcontrôleur.

Pour préserver la charge de la batterie et avoir la plus grande portée possible de l'émetteur, nous essayerons de garder l'écran allumé le moins longtemps possible, mais suffisamment pour afficher efficacement l'augmentation et la diminution de la valeur de Power. Pour y arriver, l'affichage restera actif pendant 26 s (plus de temps qu'il n'en faut pour notre application ici).

Lorsque la durée programmée est atteinte, l'alimentation de l'écran est coupée par l'intermédiaire de Q2. Une autre aide à l'économie d'énergie nous est apportée par une fonction du module LoRa appelée « sleep ». Cette fonction nous permet de minimiser la consommation de courant du module. Grâce aux deux fonctions mentionnées ci-dessus, la consommation à pleine puissance qui est d'environ 15 mA, se réduit ainsi au niveau d'une valeur d'environ 3 mA.

Le mini-bouton S1, en plus d'avoir la fonction d'incrémenter la valeur Power, permet de réactiver l'écran OLED et de sortir le module LoRa du mode veille. Il suffit d'appuyer sur ce bouton et de le relâcher.

Le récepteur

La programmation du microcontrôleur ATmega328 (U1), ainsi que la fonction des Dip-switchs SW1 (voir le schéma de la Figure 5),  se fait de la même manière que pour l'émetteur. Etant donné que la modulation PWM est la meilleure solution pour un contrôle efficace de l'intensité lumineuse des leds, nous allons entrer dans les détails du récepteur en tenant compte des valeurs suivantes, qui sont :

• Fréquence PWM de 120 Hz
• Courant de led maximum de 1.3 A
• Tension d’entrée de 9 à 12 V

Comme vous pouvez le voir sur le schéma, l'alimentation se compose de trois étages. Le premier fournit la puissance d'entrée, via J2, qui est utilisée pour alimenter les leds connectées à J3. Sachant que le courant maximum que nous pouvons fournir est de 1,3 A, en fonction du courant de commande des leds utilisées (c'est-à-dire 80 mA), nous pourrons connecter un maximum de seize leds en parallèle. Le deuxième étage concerne l'alimentation de 5 V, fournie par le régulateur de tension U3, il permet d'alimenter l'étage de contrôle de la modulation PWM, composé de Q2, Q3, Q4, etc. (nous abordons cette fonction plus en détail plus tard).

Enfin, le régulateur 3,3 V qui sert à alimenter U1, U2 et IC1,  comme nous l'avons vu plus haut. La présence d'une EEPROM (IC1) nous permet de stocker la dernière valeur de Power reçue, qui est ainsi utilisée pour contrôler la modulation PWM. Pour obtenir la même intensité lumineuse que celle avant la désactivation du récepteur, la donnée Power est chargée lorsque le récepteur est réactivé.

La modulation PWM est générée par le microcontrôleur ATmega328 (U1), en utilisant son timer interne TIMER 0. A la sortie de la broche PD5, vous trouverez une forme d'onde avec une fréquence de 120 Hz à 3,3 V. Comme nous l'avons vu ci-dessus, nous ne pouvons pas contrôler les leds directement via la sortie PD5 du microcontrôleur, mais nous avons besoin d'une interface qui sera en mesure de contrôler le courant élevé fourni aux leds et maintenir la stabilité de la fréquence de modulation PWM. La Figure 6 montre le prototype de ce module de réception terminé.

Pour réaliser cela, nous avons utilisé les composants Q1, Q2, Q3 et Q4. Ce réseau de mise en forme des impulsions nous permet de contrôler les leds tout en maintenant une fréquence stable sans crêtes parasites (voir la Figure 7), qui pourraient endommager le MOSFET (Q4) et le générateur de courant IC2, qui dans ce cas, est utilisé comme un limiteur de courant au lieu d'un limiteur de tension.

Le courant maximum de commande de la LED, qui est de 1,3 A comme nous l'avons déjà écrit, est déterminé par les deux résistances R3 et R4. Nous avons préféré mettre deux résistances en parallèle plutôt qu'une seule, étant donné qu'il est difficile de trouver des résistances SMD d'une puissance supérieure à 2 W de faible valeur.

Une attention particulière doit être portée au limiteur de courant IC2 (un LM338 de Texas Instruments), qui est équipé d'un dissipateur de chaleur pour évacuer la puissance dépassant sa valeur nominale maximale (1 W). Comme la tension d'entrée peut être de 9 à 12 V, dans le pire des cas (12 V) nous aurons une dissipation de puissance de 8.6 W, et donc l'utilisation d'un dissipateur thermique est obligatoire.

Le calcul et le choix du dissipateur thermique n'entrent pas dans le cadre de cet article. Mais il suffit de dire que pour maintenir la température maximale de fonctionnement de la jonction de IC2 (Tj) en dessous de 125°C, il est nécessaire de la fixer sur un dissipateur thermique d'une valeur d'au moins 6°C/W ou moins (plus la valeur est basse, plus la puissance dissipée est élevée).

L’IDE Microchip Studio

Comme nous l'avons déjà mentionné, les programmes des modules émetteur et récepteur (LoRaSender et LoRaReceiver, respectivement) ont été développés grâce à l'IDE Arduino, mais pour la programmation, nous utiliserons l'IDE Microchip Studio. Microchip Studio fonctionne comme si nous étions dans l'environnement de développement Arduino. Pour programmer le microcontrôleur de l'émetteur et du récepteur, nous pourrions utiliser la carte Arduino UNO, en suivant le tutoriel que vous trouverez sur ce lien, mais en ce qui nous concerne, ce n'est pas pratique pour les microcontrôleurs avec un brochage TQFP monté sur la carte.

Il est beaucoup plus pratique d'utiliser un programmateur tel que :

• ATMEL-ICE(AVR) - fonctionnel mais quelque peu onéreux. Il peut être utilisé directement dans l'IDE Arduino et seulement pour les microcontrôleurs avec l'architecture AVR.
• MPLAB PICkit4 - le programmateur de Microchip est nettement moins cher, et surtout plus polyvalent.

En utilisant le programmateur PICkit 4, Microchip Studio nous permet de programmer une large gamme de microcontrôleurs de la famille Microchip et avec une architecture AVR et SAM. Nous allons maintenant installer le logiciel Microchip Studio, que vous pouvez trouver sur le site Internet de Microchip à cette adresse. Ouvrez-le pour charger le sketch que vous avez créé avec l'IDE Arduino.

Au démarrage, vous arriverez sur la page d'accueil (Figure 8), cliquez sur New project et la fenêtre apparaîtra comme dans la Figure 9. Cliquez sur Create project from Arduino sketch, quelques champs apparaissent pour que vous puissiez les remplir :

• Name : entrez le titre du fichier à créer (LoRaSender ou LoRaReceiver). Le champ Solution name sera automatiquement rempli avec le même titre.
• Location : c’est l'adresse où le fichier sera sauvegardé.
• Create new solution : laisser ce champ inchangé, car il s'agit d'un nouveau fichier.

Cliquez sur le bouton OK pour continuer. La fenêtre suivante qui apparaît est illustrée à la Figure 10. Remplissez à nouveau les champs comme ci-dessous :

• Sketch file : cliquez sur l'icône des trois points pour accéder au dossier dans lequel vous avez stocké le fichier sketch que nous avons créé avec l'IDE Arduino. Le fichier sélectionné sera utilisé pour créer notre programme dans l'IDE Microchip Studio.
• Arduino IDE path : c'est l'endroit où se trouve le logiciel Arduino.
• Board : bien que cela soit sans importance, nous avons choisi la carte Arduino UNO.
• Device : évidemment, nous choisirons ATmega328.

En cliquant sur OK, le fichier du programme Arduino sera importé dans l'IDE Microchip Studio. Comme mentionné précédemment, l'environnement Microchip Studio a les mêmes fonctions que l'IDE Arduino, mais avec plus de particularités. Et nous vous invitons à les explorer un peu plus lorsque nous aurons fini de vérifier la fonctionnalité du fichier du programme, sauvegardé dans le nouvel environnement de développement.

Pour que notre programme fonctionne, il manque une dernière étape, qui est de charger les bibliothèques nécessaires. Pour ce faire, cliquez avec le bouton droit de la souris sur la fenêtre surlignée en rouge (voir la Figure 11), et un menu déroulant apparaîtra, dans lequel vous trouverez l'option Add Arduino Library (Ajouter une bibliothèque Arduino). Sélectionnez-la, puis choisissez dans la liste les bibliothèques nécessaires à votre projet.

Pour LoRaSender, les bibliothèques à sélectionner sont :

• Wire.h
• SPI.h
• Adafruit_GFX.h
• Adafruit_Sensor.h
• Adafruit_SSD1306.h
• LoRa.h

Pour LoRaReceiver, il faut sélectionner :

• Wire.h>
• SPI.h>
• LoRa.h>

Remarque : Pour que les bibliothèques apparaissent dans la liste ci-dessus, vous devez les avoir installées via les fonctions de chargement des bibliothèques dans l'IDE Arduino. A ce stade, nous avons réalisé toutes les étapes qui nous permettent de charger le sketch dans notre microcontrôleur ATmega328. Pour charger le firmware, nous utilisons le programmateur MPLAB PICkit 4.

Le chargement du micrologiciel

Sur les deux cartes, il y a un connecteur à 6 broches (J2 pour l'émetteur et J1 pour le récepteur) que nous utiliserons avec notre programmateur MPLAB PICkit 4 pour charger le micrologiciel dans le microcontrôleur, en connectant les broches comme indiqué dans la Figure 12.

Veuillez noter que pour charger le micrologiciel dans le microcontrôleur, nous devons désactiver le Dip-switch SW2 sur la carte de l'émetteur et SW1 sur la carte du récepteur. Après avoir connecté le MPLAB PICkit 4 à la carte, nous sélectionnons le type de microcontrôleur utilisé en cliquant sur l'icône située dans la barre d'outils et représentée par un circuit intégré entouré en rouge (voir la Figure 13). Une page s’ouvre qui nous permettra de choisir le type de microcontrôleur que nous utilisons. 

Si ce n'est pas déjà fait, cliquez sur l'icône change device entourée en vert, et un menu déroulant s'ouvrira avec un certain nombre de microcontrôleurs supportés par Microchip Studio, choisissez alors ATmega328 et cliquez sur OK. Sur la même page se trouve une liste de programmateurs pris en charge (voir la liste encerclée en violet) appelée Supported Tools. Cliquez sur celui qui vous intéresse et vous serez dirigé vers la page web correspondante, où vous trouverez plus de détails et de documentation à son sujet.

Connectez le programmateur via le mini port série USB, et s'il est correctement reconnu, sélectionnez-le en cliquant sur l'icône entourée en jaune (précédemment ouverte via le symbole du marteau). A ce stade, nous avons sélectionné les outils dont nous avons besoin pour charger notre micrologiciel. Il ne reste plus qu'à cliquer sur l'icône représentée par une flèche verte (entourée en bleu). Si vous avez sélectionné correctement tous les outils, le téléchargement du micrologiciel dans le microcontrôleur débutera.

Lorsque le téléchargement est terminé, dans la fenêtre output en bas, vous devez lire Build succeeded : cela signifie que le téléchargement s'est déroulé avec succès.

Le programme LoRaSender

Avant d'analyser le sketch, qui peut être téléchargé sur la page Elektor Labs de cet article, une petite mise au point s'impose. Dans le sketch, vous verrez souvent apparaître une fonction nommée power, qui n'est rien d'autre que les données transmises pour contrôler la modulation de largeur d'impulsion (PWM), qui une fois traduite, détermine l'intensité lumineuse de la led.

La partie configuration du sketch LoRaSender n'est pas couverte puisqu'il y a déjà une brève explication à côté des fonctions. En plus, certaines fonctions font partie de la bibliothèque correspondante comme, par exemple, la gestion de l'écran OLED SSD1306 (Adafruit_GFX.h, Adafruit_Sensor.h et Adafruit_SSD1306.h) et la transmission des paquets LoRa (LoRa.h).

Comme nous l'avons mentionné, nous avons une limitation de temps de 26 s pendant laquelle l'écran reste allumé. Pour atteindre ce temps, nous utilisons le TIMER 1 de 16 bits interne au microcontrôleur Atmega328. Lorsque la valeur de débordement du TIMER est atteinte, la routine ISR TIMER1_OVF_Vector est appelée. Dans cette routine, jusqu'à ce qu'un nombre de 50 incréments (défini par la variable count) soit atteint, l'écran ne s'éteindra pas et le module LoRa ne sera pas mis en mode veille.

La procédure wake_up est appelée au moment où le mini-bouton S1 est pressé et relâché, et comme vous pouvez l'imaginer, elle rallume l'écran et réveille le module LoRa (Listing 1).

La commande qui détermine l'augmentation ou la diminution des données appelées power est donnée par les mini-boutons S1 et S2. Les commandes :

LoRa.beginPacket();

LoRa.print("A");

LoRa.print(power);

LoRa.endPacket();

permettent de transmettre la donnée power, pour la traduire en intensité lumineuse depuis le récepteur. La lettre qui précède la donnée power, dans notre cas la lettre A, nous sert à transmettre une donnée qui peut être interprétée par le récepteur comme un début de réception, ce qui nous permet de filtrer toute interférence radio qui pourrait perturber la réception de la donnée transmise. Le calcul de l'incrémentation ou de la décrémentation du bargraphe, qui indique le pourcentage de la variable power, est le suivant :

power--;

pct = power / 1.28;

v_pct = pct;

Pour augmenter la taille du bargraphe et le pourcentage qui lui est associé, il faut soustraire la variable power au lieu de l'ajouter. C'est une conséquence de la fonction qui contrôle la longueur et la hauteur du bargraphe, appelée : display.fillRect(0, 0, display.width()-counter, display.height()/8, INVERSE).

Sachant que la matrice d'affichage est de 128x32 pixels, la partie concernant la longueur du bargraphe est déterminée par display.width()-counter tandis que l'épaisseur est déterminée par display.height()/8. Et donc la longueur est déterminée en soustrayant la valeur de 128, tandis que la hauteur du bargraphe est déterminée par la valeur de 32 divisée par 8. Dans notre cas, il s'agit donc de 4 pixels.

La dernière remarque concerne la valeur de la variable power exprimée en pourcentage. Car pour que les 128 pixels, correspondants à la largeur de l'écran, soient équivalent à la valeur de 100%, il faut les diviser par 1,28. C'est pourquoi nous devons avoir une valeur flottante initiale (pct, pourcentage), puis l'arrondir en une valeur entière (v_pct, valeur en pourcentage).

La partie concernant la diminution de la valeur du bargraphe est la même que la fonction que nous venons de voir, sauf qu'au lieu d'avoir la variable power soustraite (power--), nous aurons la même variable incrémentée (power++).

Le programme LoRaReceiver

Le code du récepteur est simple et court, mais pour mieux comprendre sa signification, nous l'avons décomposé en quatre grandes zones. Dans la configuration, nous lisons les dernières données de modulation PWM reçues et stockées dans le circuit EEPROM, de sorte que les leds soient allumées avec la même intensité que celle définie lors de la mise hors tension. Là encore, la variable qui détermine les données de modulation PWM est appelée power. La composante essentielle est la partie :

TCCR0A = 0b000000;

TCCR0B = 0b000000;

TCCR0A = 0b10000011;

TCCR0B = 0b00000100;

OCR0A = 0;

car elle détermine comment le TIMER 0, qui est interne au microcontrôleur ATmega328, doit fonctionner pour le contrôle de la modulation PWM. Les données de modulation PWM sont stockées dans la variable OCR0A qui détermine le temps pendant lequel la forme d'onde de modulation de largeur d'impulsion PWM reste activée, et le temps pendant lequel elle reste désactivée. Pour éviter des pics incontrôlables dans l'intensité lumineuse des leds, nous avons introduit une petite routine qui n'est exécutée que lorsque le récepteur est allumé :

if (cnt == 0){

    Wire.beginTransmission(0x50);

    Wire.write(0x00);

    Wire.write(OCR0A = power);

    Wire.endTransmission();

    cnt++;

}

Dans le Listing 2, nous trouvons la partie concernant la réception du paquet LoRa, qui détermine la valeur de la variable power.

Comme la valeur de power est comprise entre 0 et 127, nous avons introduit un facteur multiplicatif de 1,71 (fatt = 1.71 variable) pour que la valeur de la variable OCR0A soit supérieure à 255 (valeur maximale d'une variable de 8 bits), ce qui nous permet d'obtenir une modulation PWM avec une forme d'onde minimale, moyenne et maximale, comme le montre la Figure 14. Comme le module LoRa met continuellement à jour la donnée power, pour minimiser le nombre de fois où nous la stockons dans l'EEPROM, nous avons introduit une boucle while. Dans ce cas, les données variables ne sont stockées que lorsqu'elles diffèrent des données précédentes, ce qui minimise les cycles d'écriture/lecture de la mémoire.

En résumé

Il existe sur le marché une large gamme de leds de moyenne puissance. Dans cet article, nous nous sommes concentrés sur celles qui peuvent être utilisées pour l'éclairage, en vous permettant de comprendre quel est le meilleur choix pour vos besoins. En plus, nous avons ajouté la possibilité de contrôler à distance votre application, en utilisant une technologie qui n'a pas de limites en matière de réception. Tous les matériaux nécessaires pour les unités TX et RX, y compris les fichiers Gerber, les fichiers PDF pour les PCB et les fichiers de projet du logiciel peuvent être téléchargés à cette adresse.

Notes de l'éditeur : Intéressé par les solutions LoRa et sans-fil ? Ce projet a été publié à l'origine dans Elettronica IN.