Configurez le Wi-Fi du Raspberry Pi via Bluetooth pour ensuite envoyer des données à Ubidots
Vous avez sûrement déjà eu du mal, au moins une fois dans votre vie, à configurer les identifiants Wi-Fi d'un Raspberry Pi simplement parce que vous n'aviez pas d'écran sous la main.
Dans ce guide, je vais vous expliquer comment configurer un Raspberry Pi avec un point d'accès (AP) via une application Android portable. Impossible de brancher un câble Ethernet simplement parce que vous êtes dans un nouvel endroit ? Pas de souci ! Après avoir suivi ce guide, vous pourrez utiliser votre Pi où que vous soyez. Il vous suffira de scanner le réseau, de choisir le réseau auquel vous souhaitez vous connecter, de saisir vos identifiants, et le tour est joué !
J'ai déployé un outil simple permettant de configurer le SSID et la clé pré-partagée (PSK) du Wi-Fi du Raspberry Pi via Bluetooth. Pour l'instant, il est très basique : il suffit d'avoir préalablement appairé votre téléphone Android avec votre Raspberry Pi, et j'ai développé une application Android simple.
Personnellement, je pense que c'est vraiment utile pour ceux qui se baladent avec leur Raspberry Pi, le déplaçant d'un atelier à l'autre, de la maison à l'école, et dans tous les cas possibles auxquels vous pensez en ce moment... Maintenant, sans plus tarder, commençons à créer des choses intéressantes, en commençant par l'installation du script Python qui va s'exécuter sur notre Raspberry Pi.
Exigences
- Raspberry Pi (Tout Raspberry Pi avec Wi-Fi)
- Carte microSD avec système d'exploitation Raspbian intégré
- Téléphone Android avec système d'exploitation Jelly Bean 4.2
- Fichier APK et script d'exécution Python
Étape par étape
- Configuration du Bluetooth du Raspberry Pi
- Associer un Raspberry Pi et un téléphone Android
- Configuration du capteur DHT22 – Matériel
- Configuration du capteur DHT22 – Logiciel
- Envoi/Visualisation de données vers Ubidots
1. Configuration du Bluetooth du Raspberry Pi
Au début, vous aurez besoin d'un moniteur et d'un clavier connectés ; vous pouvez également accéder au Raspberry Pi via SSH afin de pouvoir effectuer toutes les configurations nécessaires via le terminal Raspbian.
Exécutez attentivement les commandes ci-dessous pour établir les configurations appropriées :
- Installez bluez (bibliothèque Bluetooth Python) :
$ sudo apt-get install python-bluez
2. Démarrez le démon Bluetooth en mode de compatibilité. Pour ce faire, modifiez le fichier /etc/systemd/system/dbus-org.bluez.service en exécutant la commande ci-dessous :
$ sudo nano /etc/systemd/system/dbus-org.bluez.service
3. Ensuite, modifiez le ExecStart :
ExecStart=/usr/lib/bluetooth/bluetoothd –C
4. Chargez maintenant le profil du port série à l'aide de la commande ci-dessous :
$ sudo sdptool ajouter SP
5. Pour enregistrer correctement les modifications, redémarrez votre Pi :
$ reboot
Après le redémarrage, connectons le Bluetooth à notre téléphone Android
2. Appairage d'un Raspberry Pi et d'un téléphone Android.
1. Associez votre téléphone Android à votre Raspberry Pi. Pour ce faire, activez le Bluetooth de votre téléphone et exécutez la commande ci-dessous sur votre Pi :
$ bluetoothctl
Ensuite, une fois le processus d'appariement lancé, insérez les paramètres suivants. (Reportez-vous à l'image pour mieux comprendre le déroulement du processus.)
mise sous tension détectable lors de la numérisation
À ce stade, votre téléphone apparaîtra dans la liste des appareils disponibles. Notez l'adresse de votre téléphone.
confiance<PHONE_ADDRESS> paire<PHONE_ADDRESS>
2. Pour simplement quitter le contrôle Bluetooth, saisissez la commande quit :
$ quitter
3. [FACULTATIF – ASTUCE] Vous pouvez ignorer la configuration ci-dessus en configurant le Bluetooth via l'interface utilisateur de Raspbian. Il vous suffit d'appuyer sur l'icône Bluetooth et de sélectionner le périphérique Bluetooth de votre téléphone.
4. Après avoir jumelé le Bluetooth, ajoutez le script Python directement dans Raspbian en tapant la commande nano en copiant/collant le code source, ou vous pouvez copier directement le fichier run.py.
$ sudo nano run.py
Code source (Copier/Coller) :
#!/usr/bin/env python #Run.py import os from bluetooth import * from wifi import Cell, Scheme import subprocess import time wpa_supplicant_conf = "/etc/wpa_supplicant/wpa_supplicant.conf" sudo_mode = "sudo " def wifi_connect(ssid, psk): # écrire la configuration wifi dans un fichier cmd = 'wpa_passphrase {ssid} {psk} | sudo tee -a {conf} > /dev/null'.format( ssid=str(ssid).replace('!', '\!'), psk=str(psk).replace('!', '\!'), conf=wpa_supplicant_conf ) cmd_result = "" cmd_result = os.system(cmd) print cmd + " - " + str(cmd_result) # reconfigurer le wifi cmd = sudo_mode + 'wpa_cli -i wlan0 reconfigure' cmd_result = os.system(cmd) print cmd + " - " + str(cmd_result) time.sleep(10) cmd = 'iwconfig wlan0' cmd_result = os.system(cmd) print cmd + " - " + str(cmd_result) cmd = 'ifconfig wlan0' cmd_result = os.system(cmd) print cmd + " - " + str(cmd_result) p = subprocess.Popen(['hostname', '-I'], stdout=subprocess.PIPE, stderr=subprocess.PIPE) out, err = p.communicate() if out: ip_address = out else: ip_address = "<Not Set> " return ip_address def ssid_discovered(): Cells = Cell.all('wlan0') wifi_info = 'SSID trouvé : \n' for current in range(len(Cells)): wifi_info += Cells[current].ssid + "\n" wifi_info+="!" print wifi_info return wifi_info def handle_client(client_sock) : # obtenir le SSID client_sock.send(ssid_discovered()) print "En attente du SSID..." ssid = client_sock.recv(1024) if ssid == '' : return print "SSID reçu" print ssid # obtenir le PSK client_sock.send("waiting-psk!") print "En attente du PSK..." psk = client_sock.recv(1024) if psk == '' : return print "PSK reçu" print psk ip_address = wifi_connect(ssid, psk) print "Adresse IP : " + ip_address client_sock.send("Adresse IP : " + ip_address + "!") return try: while True: server_sock=BluetoothSocket( RFCOMM ) server_sock.bind(("",PORT_ANY)) server_sock.listen(1) port = server_sock.getsockname()[1] uuid = "815425a5-bfac-47bf-9321-c5ff980b5e11" advertise_service( server_sock, "Configuration Wi-Fi RPi", service_id = uuid, service_classes = [ uuid, SERIAL_PORT_CLASS ], profiles = [ SERIAL_PORT_PROFILE ]) print "En attente de connexion sur le canal RFCOMM %d" % port client_sock, client_info = server_sock.accept() print "Connexion acceptée depuis ", client_info handle_client(client_sock) client_sock.close() server_sock.close() # Configuration terminée print 'Configuration terminée\n' except (KeyboardInterrupt, SystemExit): print '\nSortie\n'
5. Après l'étape précédente, il est temps de rendre le script exécutable en lui accordant les autorisations requises :
$ chmod +x run.py
Pour exécuter :
$ sudo ./run.py
6. Ouvrez ensuite l'application Android et sélectionnez le Raspberry Pi dans la liste des appareils Bluetooth associés. Saisissez le SSID et (PSK) , puis appuyez sur le « Démarrer la configuration » . La connexion Wi-Fi du Raspberry Pi devrait s'établir en quelques secondes, comme illustré ci-dessous.
7. Pour exécuter le script pendant le processus de démarrage du Raspberry Pi, modifiez le fichier /etc/rc.local et ajoutez la ligne de code suivante :
(sommeil 10;/chemin/vers/script/./run.py)&
3. Configuration du capteur DHT22 - Matériel
1. Établissez les connexions appropriées, comme indiqué dans le schéma ci-dessous :
4. Configuration du capteur DHT22 - Logiciel
1. Installez les paquets requis en exécutant les commandes suivantes :
$ sudo apt-get mise à jour
$ sudo apt-get install build-essential python-dev python-openssl git
2. Chargez la bibliothèque des capteurs. Dans mon cas, j'utilise une bibliothèque Adafruit précompilée qui prend en charge divers capteurs :
$ git clone https://github.com/adafruit/Adafruit_Python_DHT.git && cd Adafruit_Python_DHT
3. Une fois la bibliothèque chargée, exécutez la commande ci-dessous pour créer une bibliothèque Python qui vous permettra d'effectuer facilement l'intégration pour ce projet et d'autres projets ultérieurs.
$sudo python setup.py install
4. Si tout fonctionne correctement, nous devrions pouvoir lire la température et l'humidité. Le plus simple est d'utiliser d'abord les fichiers de démonstration déjà disponibles sur notre Raspberry Pi :
Exemples de $ cd
5. Exécutez l'exemple de code suivant. Le premier paramètre (11) indique le capteur utilisé (22 pour le DHT22) et le second, le numéro de la broche GPIO à laquelle il est connecté (et non le numéro de broche). Le résultat devrait ressembler à ceci :
$ sudo ./AdafruitDHT.py 11 4
Résultat attendu :
$ sudo ./AdafruitDHT.py 11 4 Temp=24.0* Humidité=41.0%
5. Envoi de données aux Ubidots
1. Créez un script Python à l'aide de l'éditeur nano, puis collez le code ci-dessous dans le terminal. Pour ce faire, saisissez la commande suivante :
$ sudo nano ubidots3.py
Code source :
import time import requests import math import random import sys import Adafruit_DHT sensor = 22 # Sélectionnez votre version DHT pin = 18 # Saisissez votre broche DHT22 TOKEN = "…" # Saisissez votre jeton ici DEVICE_LABEL = "Raspberrypi" # Saisissez le nom de votre appareil ici VARIABLE_LABEL_1 = "temperature" # Saisissez le nom de votre première variable ici VARIABLE_LABEL_2 = "humidity" # Saisissez le nom de votre deuxième variable ici # Tentez de récupérer une mesure du capteur. Utilisez la méthode read_retry qui effectuera jusqu'à 15 tentatives pour obtenir une mesure (avec un intervalle de 2 secondes entre chaque tentative). humidity, temperature = Adafruit_DHT.read_retry(sensor, pin) # Décommentez la ligne ci-dessous pour convertir la température en degrés Fahrenheit. # température = température * 9/5,0 + 32 # Notez que parfois vous n'obtiendrez pas de lecture et # les résultats seront nuls (car Linux ne peut pas # garantir le moment des appels pour lire le capteur). # Si cela se produit, réessayez ! def build_payload(variable_1, variable_2): # Crée deux valeurs aléatoires pour l'envoi des données value_1 = temperature value_2 = humidity payload = {variable_1: value_1, variable_2: value_2, } return payload def post_request(payload): # Crée les en-têtes pour les requêtes HTTP url = "ubidots" url = "{}/api/v1.6/devices/{}".format(url, DEVICE_LABEL) headers = {"X-Auth-Token": TOKEN, "Content-Type": "application/json"} # Effectue les requêtes HTTP status = 400 attempts = 0 while status >= 400 and attempts <= 5: req = requests.post(url=url, headers=headers, json=payload) status = req.status_code attempts += 1 time.sleep(1) # Traite les résultats si le statut est supérieur ou égal à 400 : print("[ERREUR] Impossible d'envoyer les données après 5 tentatives, veuillez vérifier vos identifiants de jeton et votre connexion Internet") return False print("[INFO] Requête effectuée correctement, votre appareil est mis à jour") return True def main(): payload = build_payload( VARIABLE_LABEL_1, VARIABLE_LABEL_2) print("[INFO] Tentative d'envoi des données") post_request(payload) print("[INFO] Terminé") if __name__ == '__main__': while (True): print('Température={0:0.1f}* Humidité={1:0.1f}%'.format(température, humidity)) humidity, temperature = Adafruit_DHT.read_retry(sensor, pin) main() time.sleep(1) ```
Après avoir collé le code source, vous devez attribuer le jeton Ubidots à l'endroit indiqué dans le script Python :
$ sudo nano ubidots3.py
2. Maintenant que tout est configuré, vous pouvez exécuter l'exemple de code pour commencer à transmettre des données à votre compte Ubidots :
$ sudo python ubidots3.py
À ce stade, si vous consultez la section « Appareils » de votre compte Ubidots , vous pourrez voir un nouvel appareil créé, appelé « RaspberryPi ».
3. Pour visualiser efficacement vos données, configurons un Dashboard Ubidots Ubidots Pour le créer, accédez à la Dashboard (Données > Dashboard ).
4. Ensuite, appuyez sur « Ajouter un nouveau widget » et sélectionnez votre widget :
5. Sélectionnez la variable à afficher :
6. Donnez un nom personnalisé au widget, puis appuyez sur l'icône verte pour terminer sa création.
Vous pouvez désormais surveiller des variables à distance depuis n'importe quel endroit grâce à la plateforme de développement d'applications IoT Ubidots :
Articles recommandés :
