Domotique Raspberry Pi 433MHz super simple : 7 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:08

Ce tutoriel est l'un parmi tant d'autres lorsqu'il s'agit d'utiliser un Raspberry Pi pour contrôler des appareils sans fil dans la maison. Comme beaucoup d'autres, il vous montrera comment utiliser une paire émetteur/récepteur bon marché connectée à votre Pi pour interagir avec des appareils fonctionnant sur la bande de fréquence radio 433 MHz couramment utilisée. Il vous montrera spécifiquement comment allumer ou éteindre n'importe quel appareil électrique à l'aide de votre Pi en transmettant des commandes à un ensemble de prises de courant télécommandées à 433 MHz.

Pourquoi ai-je créé ce tutoriel s'il en existe déjà autant ? Principalement parce que presque tous les autres tutoriels que j'ai rencontrés semblaient trop compliquer les choses, en particulier du côté du logiciel. J'ai remarqué qu'ils s'appuyaient fortement sur des bibliothèques, des scripts ou des extraits de code tiers pour faire tout le travail. Beaucoup n'expliqueraient même pas ce que faisait le code sous-jacent - ils vous demanderaient simplement d'insérer deux ou trois logiciels sur votre Pi et d'exécuter un tas de commandes, sans poser de questions. Je voulais vraiment essayer d'utiliser mon Pi pour allumer et éteindre des appareils électriques dans ma maison à l'aide d'un ensemble de prises télécommandées à 433 MHz, mais je voulais créer ma propre version du système que je pouvais comprendre, en éliminant, espérons-le, le besoin de utiliser les bibliothèques ou les scripts de quelqu'un d'autre.

C'est le sujet de ce tutoriel. Le côté logiciel de ce système se compose de deux scripts Python très simples - un pour recevoir et enregistrer des signaux, et un pour transmettre ces signaux aux prises de courant sans fil. La réception/transmission réelle du signal ne repose que sur la bibliothèque RPi. GPIO facile à utiliser qui, du moins pour moi, est pré-installée avec Raspbian. Cette bibliothèque peut également être importée directement dans Python.

Pour ce projet, vous aurez besoin de:

Un Raspberry Pi. N'importe quel modèle devrait fonctionner, j'ai utilisé un kit de démarrage tout-en-un, mais vous n'avez peut-être besoin que de l'unité centrale

Une paire émetteur/récepteur 433MHz. Les plus couramment utilisés dans ce type de projet semblent être ceux-ci. L'achat d'un pack de cinq comme celui lié garantit que vous avez quelques pièces de rechange

Un ensemble de prises de courant télécommandées 433MHz. J'ai utilisé ceux-ci que je recommande fortement, mais il existe d'innombrables modèles disponibles. Assurez-vous simplement qu'ils fonctionnent sur cette fréquence

Quelques accessoires de construction de circuits. Je recommanderais d'utiliser une planche à pain et des câbles de démarrage pour rendre le processus de construction du circuit aussi simple que possible.

[Si vous décidez d'acheter l'un de ces produits, j'apprécierais grandement que vous accédiez aux listes en utilisant les liens ci-dessus - de cette façon, je reçois une infime part des bénéfices sans frais supplémentaires pour vous !]

Étape 1: Configuration du récepteur

Avant de pouvoir utiliser votre Pi pour envoyer des commandes aux prises télécommandées, vous devez savoir à quels signaux spécifiques elles répondent. La plupart des prises télécommandées sont livrées avec un combiné qui peut être utilisé pour allumer ou éteindre des unités spécifiques. Dans le cas de ceux que j'ai achetés, le combiné dispose de quatre rangées de boutons ON/OFF appairés, dont chacun envoie un signal ON ou OFF à une prise particulière.

Cela soulève une question: comment savoir quels boutons correspondent à quelle prise ? Cela dépend en fait du modèle que vous avez. L'une des principales raisons pour lesquelles j'ai choisi mon style particulier de prise (liée dans l'introduction) est que les unités peuvent être configurées avec un interrupteur physique pour qu'une prise particulière réponde à un ensemble particulier de boutons ON/OFF sur le combiné. Cela signifie également que vous pouvez débrancher et déplacer les prises dans la maison en sachant que chaque unité répondra toujours aux mêmes signaux ON/OFF.

Une fois que vous avez compris comment vos prises interagissent avec le combiné, vous devrez utiliser votre récepteur 433 MHz (illustré ci-dessus) pour « renifler » les codes envoyés par le combiné. Une fois que vous avez enregistré les formes d'onde de ces codes, vous pouvez les répliquer à l'aide de Python et les envoyer à l'aide de l'unité émettrice.

La première chose à faire ici est de câbler les broches de votre récepteur aux bonnes broches GPIO du Pi. L'unité de réception a quatre broches, mais seulement trois d'entre elles sont nécessaires. Je pense que les deux broches centrales donnent la même sortie, vous n'avez donc besoin de vous connecter qu'à l'une d'entre elles (à moins que vous ne souhaitiez diffuser les signaux reçus sur deux broches GPIO distinctes).

L'image ci-dessus résume assez bien le câblage. Chaque broche du récepteur peut être câblée directement à la broche correspondante du Pi. J'utilise une maquette et des câbles de démarrage pour rendre le processus un peu plus élégant. Notez que vous pouvez choisir n'importe quelle broche de données GPIO pour vous connecter à l'une des broches du récepteur central. J'ai utilisé la broche marquée "23" sur mon en-tête Pi.

IMPORTANT: si vous connectez la broche marquée « 3v3 » dans l'image ci-dessus à une broche de tension plus élevée sur le Pi (par exemple 5v), vous endommagerez probablement le Pi car les broches GPIO ne peuvent pas tolérer des tensions supérieures à 3v3. Alternativement, vous pouvez l'alimenter avec 5v et configurer un diviseur de tension pour envoyer une tension de sécurité à la broche DATA.

La portée du récepteur ne sera pas très large à cette tension, surtout si aucune antenne n'est connectée. Cependant, vous n'avez pas besoin d'une longue portée ici - tant que le récepteur peut capter les signaux du combiné lorsqu'ils sont tenus côte à côte, c'est tout ce dont nous avons besoin.

Étape 2: renifler les codes du combiné

Maintenant que votre récepteur est connecté au Pi, vous pouvez commencer la première étape passionnante de ce projet - le reniflement. Cela implique l'utilisation du script Python joint pour enregistrer le signal transmis par le combiné lorsque chaque bouton est enfoncé. Le script est très simple, et je vous recommande fortement de le consulter avant de l'exécuter - après tout, le but de ce projet est que vous n'exécuterez pas aveuglément le code de quelqu'un d'autre !

Avant de commencer ce processus, vous devrez vous assurer que vous disposez des bibliothèques Python nécessaires pour exécuter le script de renifleur. Ils sont répertoriés en haut du script:

à partir de datetime importer datetime

importer matplotlib.pyplot en tant que pyplot importer RPi. GPIO en tant que GPIO

Les bibliothèques RPi. GPIO et datetime étaient incluses dans ma distribution Raspbian, mais j'ai dû installer la bibliothèque matplotlib comme suit:

sudo apt-get install python-matplotlib

Cette bibliothèque est une bibliothèque de traçage de graphiques couramment utilisée qui est très utile même en dehors de ce projet, donc l'installer ne peut certainement pas faire de mal ! Une fois que vos bibliothèques sont à jour, vous êtes prêt à commencer à enregistrer des données. Voici comment fonctionne le script:

Lorsqu'il est exécuté (à l'aide de la commande 'python ReceiveRF.py'), il configure la broche GPIO définie en tant qu'entrée de données (broche 23 par défaut). Il échantillonnera ensuite continuellement la broche et enregistrera s'il reçoit un 1 ou un 0 numérique. Cela continue pendant une durée définie (5 secondes par défaut). Lorsque cette limite de temps est atteinte, le script arrêtera d'enregistrer les données et fermera l'entrée GPIO. Il effectue ensuite un petit post-traitement et trace la valeur d'entrée reçue en fonction du temps. Encore une fois, si vous avez des questions sur ce que fait le script, vous pouvez probablement y répondre vous-même après avoir examiné son fonctionnement. J'ai essayé de rendre le code aussi lisible et simple que possible.

Ce que vous devez faire est de rechercher lorsque le script indique qu'il a **L'enregistrement commencé**. Une fois que ce message apparaît, vous devez appuyer sur l'un des boutons du combiné et le maintenir enfoncé pendant environ une seconde. Assurez-vous de le tenir près du récepteur. Une fois que le script a terminé l'enregistrement, il utilisera matplotlib pour tracer une forme d'onde graphique du signal qu'il a reçu pendant l'intervalle d'enregistrement. Veuillez noter que si vous êtes connecté à votre Pi à l'aide d'un client SSH tel que PuTTY, vous devrez également ouvrir une application X11 pour permettre à la forme d'onde de s'afficher. J'utilise xMing pour cela (et pour d'autres choses telles que le bureau à distance dans mon Pi). Pour permettre au tracé d'être affiché, démarrez simplement xMing avant d'exécuter le script et attendez que les résultats apparaissent.

Une fois que votre fenêtre matplotlib apparaît, la zone d'intérêt dans l'intrigue devrait être assez évidente. Vous pouvez utiliser les commandes en bas de la fenêtre pour effectuer un zoom avant jusqu'à ce que vous soyez en mesure de sélectionner les hauts et les bas du signal transmis par le combiné pendant que le bouton était maintenu enfoncé. Voir l'image ci-dessus pour un exemple de code complet. Le signal sera probablement composé d'impulsions très courtes séparées par des périodes de temps similaires où aucun signal n'est reçu. Ce bloc d'impulsions courtes sera probablement suivi d'une période plus longue où rien n'est reçu, après quoi le motif se répétera. Une fois que vous avez identifié le modèle appartenant à une seule instance du code, prenez une capture d'écran comme celle-ci en haut de cette page et passez à l'étape suivante pour l'interpréter.

Étape 3: Transcrire le signal résultant

Maintenant que vous avez identifié le bloc de hauts et de bas périodiques correspondant au signal d'un bouton particulier, vous aurez besoin d'un moyen de le stocker et de l'interpréter. Dans l'exemple de signal ci-dessus, vous remarquerez qu'il n'y a que deux modèles uniques qui composent l'ensemble du bloc de signal. Parfois, vous voyez un haut court suivi d'un bas long, et parfois c'est le contraire - un haut long suivi d'un bas court. Lors de la transcription de mes signaux, j'ai décidé d'utiliser la convention de nommage suivante:

1 = short_on + long_off0 = long_on + short_off

Regardez à nouveau la forme d'onde étiquetée et vous verrez ce que je veux dire. Une fois que vous avez identifié les modèles équivalents dans votre signal, tout ce que vous avez à faire est de compter les 1 et les 0 pour construire la séquence. Une fois transcrit, le signal ci-dessus peut s'écrire comme suit:

1111111111111010101011101

Il ne vous reste plus qu'à répéter ce processus pour enregistrer et retranscrire les signaux correspondant aux autres boutons de votre combiné, et vous avez terminé la première partie du processus !

Avant de pouvoir renvoyer les signaux à l'aide de l'émetteur, il reste encore un peu de travail à faire. Le timing entre les hauts et les bas correspondant à un 1 ou à un 0 est très important, et vous devez vous assurer que vous savez combien de temps dure réellement un « short_on » ou un « long_off ». Pour mes codes, il y avait trois informations de synchronisation que je devais extraire afin de reproduire les signaux:

• La durée d'un intervalle « court », c'est-à-dire le début d'un 1 ou la fin d'un 0.
• La durée d'un intervalle « long », c'est-à-dire la fin d'un 1 ou le début d'un 0.
• La durée d'un intervalle « prolongé ». J'ai remarqué que lorsque je maintenais un bouton enfoncé sur le combiné, il y avait une période "extended_off" entre chaque instance répétée du bloc de signal. Ce délai est utilisé pour la synchronisation et a une durée fixe.

Pour déterminer ces valeurs de synchronisation, vous pouvez utiliser la fonction zoom de la fenêtre matplotlib pour zoomer complètement et placer le curseur sur les parties pertinentes du signal. La lecture de l'emplacement du curseur au bas de la fenêtre devrait vous permettre de déterminer la largeur de chaque partie du signal qui correspond à un intervalle long, court ou prolongé. Notez que l'axe des x du tracé représente le temps et que la composante x de la lecture du curseur est en unités de secondes. Pour moi, les largeurs étaient les suivantes (en secondes):

• short_delay = 0.00045
• long_delay = 0.00090 (deux fois plus long qu'un 'short')
• délai_étendu = 0,0096

Étape 4: Configuration de l'unité émettrice

Une fois que vous avez collecté vos codes et vos données de synchronisation, vous pouvez déconnecter votre récepteur car vous n'en aurez plus besoin. Vous pouvez ensuite câbler l'émetteur directement aux broches Pi GPIO appropriées, comme indiqué dans l'image ci-dessus. J'ai constaté que les broches des unités émettrices sont étiquetées, ce qui facilite le processus.

Dans ce cas, il est correct d'alimenter l'unité en utilisant l'alimentation 5v du Pi car la broche DATA n'enverra pas de signaux au Pi, mais les recevra seulement. De plus, une alimentation 5v fournira une plus grande portée de transmission que l'utilisation de l'alimentation 3v3. Encore une fois, vous pouvez connecter la broche DATA à n'importe quelle broche appropriée sur le Pi. J'ai utilisé la broche 23 (la même que pour le récepteur).

Une autre chose que je recommanderais de faire est d'ajouter une antenne au petit trou en haut à droite de l'émetteur. J'ai utilisé un morceau de fil droit de 17 cm de long. Certaines sources recommandent un fil enroulé de longueur similaire. Je ne sais pas ce qui est le mieux, mais le fil droit offre une portée suffisante pour que je puisse allumer/éteindre les prises depuis n'importe quel endroit de mon petit appartement. Il est préférable de souder l'antenne, mais j'ai juste retiré une partie du plastique du fil et j'ai enroulé le cuivre à travers le trou.

Une fois l'émetteur câblé, c'est toute la configuration matérielle terminée ! Il ne vous reste plus qu'à installer vos prises de courant dans la maison et à consulter le programme de l'émetteur.

Étape 5: Transmission de signaux à l'aide du Pi

C'est là qu'intervient le deuxième script Python. Il est conçu pour être aussi simple que le premier, sinon plus. Encore une fois, téléchargez-le et examinez le code. Vous devrez éditer le script pour transmettre les signaux corrects en fonction des données que vous avez enregistrées à l'étape 3, c'est donc le bon moment pour y jeter un coup d'œil.

Les bibliothèques nécessaires pour exécuter ce script étaient toutes pré-installées sur mon Pi, donc aucune autre installation n'était nécessaire. Ils sont répertoriés en haut du script:

heure d'importation

importer sys importer RPi. GPIO en tant que GPIO

Sous les importations de la bibliothèque se trouvent les informations que vous devrez modifier. Voici à quoi cela ressemble par défaut (ce sont les informations correspondant à mes sockets telles que déterminées à l'aide de l'étape 3):

a_on = '11111111111111010101011101'

a_off = '1111111111111010101010111' b_on = '1111111111101110101011101' b_off = '111111111110111101010111' c_on = '1111111111101011101011101' c_off = '1111111111101011101010111' d_on = '111111111lay_lay1010111011101' 0,0

Ici, nous avons huit chaînes de codes (deux pour chaque paire de boutons marche/arrêt sur mon combiné - vous pouvez avoir plus ou moins de codes) suivies des trois informations de synchronisation également déterminées à l'étape 3. Prenez le temps de vous assurer d'avoir entré ces informations correctement.

Une fois que vous êtes satisfait des codes/retards que vous avez entrés dans le script (vous pouvez renommer les variables de chaîne de code si vous le souhaitez), vous êtes à peu près prêt à essayer le système ! Avant de le faire, jetez un œil à la fonction transmit_code() dans le script. C'est là que se produit l'interaction réelle avec l'émetteur. Cette fonction s'attend à ce que l'une des chaînes de code soit envoyée en tant qu'argument. Il ouvre ensuite la broche définie en tant que sortie GPIO et parcourt chaque caractère de la chaîne de code. Il allume ou éteint ensuite l'émetteur en fonction des informations de synchronisation que vous avez saisies pour créer une forme d'onde correspondant à la chaîne de code. Il envoie chaque code plusieurs fois (10 par défaut) pour réduire le risque qu'il soit manqué, et laisse un extend_delay entre chaque bloc de code, tout comme le combiné.

Pour exécuter le script, vous pouvez utiliser la syntaxe de commande suivante:

python TransmitRF.py code_1 code_2 …

Vous pouvez transmettre plusieurs chaînes de code avec une seule exécution du script. Par exemple, pour activer les sockets (a) et (b) et désactiver le socket (c), exécutez le script avec la commande suivante:

python TransmitRF.py a_on b_on c_off

Étape 6: Une note sur la précision de la synchronisation

Comme mentionné, la synchronisation entre les impulsions marche/arrêt transmises est assez importante. Le script TransmitRF.py utilise la fonction time.sleep() de python pour créer les formes d'onde avec les intervalles d'impulsion corrects, mais il convient de noter que cette fonction n'est pas tout à fait précise. La durée d'attente du script avant d'exécuter l'opération suivante peut dépendre de la charge du processeur à cet instant donné. C'est une autre raison pour laquelle TransmitRF.py envoie chaque code plusieurs fois - juste au cas où la fonction time.sleep() ne serait pas capable de construire correctement une instance donnée du code.

Personnellement, je n'ai jamais eu de problèmes avec time.sleep() lorsqu'il s'agit d'envoyer les codes. Je sais cependant que mon time.sleep() a tendance à avoir une erreur d'environ 0,1 ms. J'ai déterminé cela à l'aide du script SleepTest.py joint qui peut être utilisé pour donner une estimation de la précision de la fonction time.sleep() de votre Pi. Pour mes prises télécommandées particulières, le délai le plus court que j'avais besoin de mettre en œuvre était de 0,45 ms. Comme je l'ai dit, je n'ai pas eu de problèmes avec les sockets non réactifs, il semble donc que 0,45 ± 0,1 ms soit suffisant.

Il existe d'autres méthodes pour s'assurer que le délai est plus précis; par exemple, vous pouvez utiliser une puce PIC dédiée pour générer les codes, mais ce genre de choses dépasse le cadre de ce didacticiel.

Étape 7: Conclusion

Ce projet a présenté une méthode pour contrôler n'importe quel appareil électrique à l'aide d'un Raspberry Pi et d'un ensemble de prises télécommandées à 433 MHz, dans un souci de simplicité et de transparence. C'est le projet le plus excitant et le plus flexible pour lequel j'ai utilisé mon Pi, et il y a des applications illimitées pour cela. Voici quelques choses que je peux maintenant faire grâce à mon Pi:

• Allumez un radiateur électrique à côté de mon lit une demi-heure avant que mon réveil ne sonne.
• Éteignez le chauffage une heure après que je me sois endormi.
• Allumez ma lampe de chevet lorsque mon réveil sonne pour ne pas me rendormir.
• et beaucoup plus…

Pour la plupart de ces tâches, j'utilise la fonction crontab sous Linux. Cela vous permet de configurer des tâches planifiées automatiques pour exécuter le script TransmitRF.py à des moments précis. Vous pouvez également utiliser la commande Linux at pour exécuter des tâches ponctuelles (qui, pour moi, devaient être installées séparément à l'aide de 'sudo apt-get install at'). Par exemple, pour allumer mon chauffage une demi-heure avant que mon réveil ne sonne le lendemain matin, il me suffit de taper:

à 05:30

python TransmitRF.py c_on

Vous pouvez également utiliser ce projet en conjonction avec mon système de surveillance domestique Dropbox pour contrôler les appareils via Internet ! Merci d'avoir lu, et si vous souhaitez clarifier quelque chose ou partager votre opinion, n'hésitez pas à poster un commentaire !