Richten Sie das WLAN des Raspberry Pi über Bluetooth ein, um dann Daten an Ubidots zu senden

Ammar Chauhan
· 9 Minuten Lesezeit
Per E-Mail versenden

Mindestens einmal in Ihrem Leben hatten Sie Schwierigkeiten, die WLAN-Zugangsdaten eines Raspberry Pi einzurichten, nur weil Sie gerade keinen Monitor zur Hand hatten.

In dieser Anleitung beschreibe ich, wie Sie einen Raspberry Pi mit einem Access Point (AP) konfigurieren, der über eine mobile Android-App gesteuert wird. Sie können gerade kein Ethernet-Kabel anschließen, weil Sie sich an einem neuen Ort befinden? Keine Sorge – nach dieser Anleitung können Sie Ihren Pi überall nutzen. Sie müssen lediglich das Netzwerk scannen, das gewünschte Netzwerk auswählen, die Zugangsdaten eingeben und schon sind Sie verbunden!

Ich habe ein einfaches Tool entwickelt, mit dem sich SSID und PSK des Raspberry Pi-WLANs per Bluetooth einstellen lassen. Aktuell ist es noch sehr simpel – man muss lediglich sein Android-Smartphone zuvor mit dem Raspberry Pi gekoppelt haben, und ich habe eine einfache Android-App geschrieben.

Ich persönlich finde das wirklich nützlich für alle, die viel mit ihrem Raspberry Pi unterwegs sind, ihn von einer Werkstatt zur anderen transportieren, ihn von zu Hause zur Schule mitnehmen, und für alle möglichen Anwendungsfälle, die Ihnen jetzt einfallen... Nun, ohne weitere Umschweife, fangen wir an, coole Dinge zu bauen, angefangen mit der Installation des Python-Skripts, das auf unserem Raspberry Pi laufen wird.

Anforderungen

Schritt für Schritt

  1. Bluetooth auf dem Raspberry Pi einrichten
  2. Kopplung von Raspberry Pi und Android-Telefon
  3. DHT22-Sensor einstellen – Hardware
  4. DHT22-Sensor einstellen – Software
  5. Senden/Visualisieren von Daten an Ubidots

1. Bluetooth auf dem Raspberry Pi einrichten

Zu Beginn benötigen Sie einen angeschlossenen Monitor und eine Tastatur. Alternativ können Sie über SSH auf den Raspberry Pi zugreifen, um alle erforderlichen Konfigurationen über das Raspbian Terminal vornehmen zu können.

Führen Sie die folgenden Befehle sorgfältig aus, um die korrekten Konfigurationen herzustellen:

  1. Installieren Sie bluez (Python-Bluetooth-Bibliothek):
$ sudo apt-get install python-bluez

2. Starten Sie den Bluetooth-Daemon im Kompatibilitätsmodus. Bearbeiten Sie dazu die Datei /etc/systemd/system/dbus-org.bluez.service , indem Sie den folgenden Befehl ausführen:

$ sudo nano /etc/systemd/system/dbus-org.bluez.service

3. Ändern Sie anschließend den ExecStart- Parameter:

ExecStart=/usr/lib/bluetooth/bluetoothd –C

4. Laden Sie nun das serielle Portprofil mit dem folgenden Befehl:

$ sudo sdptool add SP

5. Um die Änderungen ordnungsgemäß zu speichern, starten Sie Ihren Pi neu:

$ sudo reboot

Nach dem Neustart koppeln wir nun die Bluetooth-Verbindung mit unserem Android-Telefon

2. Koppeln von Raspberry Pi und Android-Telefon.

1. Koppeln Sie Ihr Android-Smartphone mit Ihrem Raspberry Pi. Schalten Sie dazu Bluetooth auf Ihrem Smartphone ein und führen Sie den folgenden Befehl auf Ihrem Pi aus:

$ bluetoothctl

Sobald der Kopplungsprozess startet, werden die folgenden Parameter eingefügt. (Die Abbildung veranschaulicht den Ablauf.)

Einschalten, Auffindbar beim Scannen

Nun erscheint Ihr Telefon in der Liste der verfügbaren Geräte. Notieren Sie sich die Adresse Ihres Telefons.

Vertrauen<PHONE_ADDRESS> Paar<PHONE_ADDRESS>

2. Um die Bluetooth-Steuerung zu beenden, geben Sie den Befehl „quit“ ein:

$ quit

3. [OPTIONAL – PROFI-TIPP] Sie können die obige Einrichtung überspringen, indem Sie Bluetooth über die Benutzeroberfläche von Raspbian konfigurieren. Tippen Sie einfach auf das Bluetooth-Symbol und wählen Sie das Bluetooth-Gerät Ihres Telefons aus.

4. Nach dem Koppeln der Bluetooth-Geräte fügen Sie das Python-Skript direkt in Raspbian ein, indem Sie den Befehl nano den Quellcode kopieren und einfügen 

$ sudo nano run.py

Quellcode (Kopieren/Einfügen):

#!/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): # write wifi config to file 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) # WLAN neu konfigurieren 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 = 'Gefundene SSID : \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) : # SSID abrufen client_sock.send(ssid_discovered()) print "Warte auf SSID..." ssid = client_sock.recv(1024) if ssid == '' : return print "SSID empfangen" print ssid # PSK abrufen client_sock.send("waiting-psk!") print "Warte auf PSK..." psk = client_sock.recv(1024) if psk == '' : return print "PSK empfangen" print psk ip_address = wifi_connect(ssid, psk) print "ip address: " + ip_address client_sock.send("ip-address:" + 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, "RPi Wifi config", service_id = uuid, service_classes = [ uuid, SERIAL_PORT_CLASS ], profiles = [ SERIAL_PORT_PROFILE ]) print "Waiting for connection on RFCOMM channel %d" % port client_sock, client_info = server_sock.accept() print "Verbindung von akzeptiert", client_info handle_client(client_sock) client_sock.close() server_sock.close() # Konfiguration abgeschlossen print 'Konfiguration abgeschlossen\n' except (KeyboardInterrupt, SystemExit): print '\nBeenden\n'

5. Nach dem obigen Schritt muss das Skript ausführbar gemacht werden, indem die erforderlichen Berechtigungen erteilt werden:

$ chmod +x run.py

Zum Ausführen:

$ sudo ./run.py

6. Öffnen Sie nun die Android-App und wählen Sie den Raspberry Pi in den gekoppelten Bluetooth-Geräten aus. Geben Sie die SSID und den PSK und tippen Sie auf „ Konfiguration starten “. Innerhalb weniger Sekunden sollte die WLAN-Verbindung des Raspberry Pi hergestellt sein, wie in den Abbildungen unten dargestellt.

7. Um das Skript während des Bootvorgangs des Raspberry Pi auszuführen, bearbeiten Sie die Datei /etc/rc.local und fügen Sie die folgende Codezeile hinzu:

(sleep 10;/path/to/script/./run.py)&

3. Einrichtung des DHT22-Sensors – Hardware

1. Stellen Sie die korrekten Verbindungen her, wie im folgenden Diagramm dargestellt:

4. Einrichtung des DHT22-Sensors – Software

1. Installieren Sie die benötigten Pakete, indem Sie die folgenden Befehle ausführen:

$ sudo apt-get update

$ sudo apt-get install build-essential python-dev python-openssl git

2. Laden Sie die Sensorbibliothek. In meinem Fall verwende ich eine vorkompilierte Adafruit-Bibliothek, die eine Vielzahl von Sensoren unterstützt:

$ git clone https://github.com/adafruit/Adafruit_Python_DHT.git && cd Adafruit_Python_DHT

3. Nachdem die Bibliothek geladen wurde, führen Sie den unten stehenden Befehl aus, um eine Python-Bibliothek zu erstellen, mit der Sie die Integration für dieses und weitere Projekte einfach durchführen können.

$sudo python setup.py install

4. Wenn alles ordnungsgemäß funktioniert, sollten wir Temperatur und Luftfeuchtigkeit ablesen können. Am einfachsten geht das, indem wir zunächst die bereits auf unserem Raspberry Pi vorhandenen Demodateien verwenden:

$ cd Beispiele

5. Führen Sie den folgenden Beispielcode aus. Der erste Parameter (11) gibt an, welcher Sensor verwendet wurde (22 für den DHT22), und der zweite, an welchen GPIO-Pin er angeschlossen ist (nicht die Pin-Nummer, sondern die GPIO-Nummer). Dies erzeugt eine Ausgabe wie die folgende:

$ sudo ./AdafruitDHT.py 11 4

Erwartetes Ergebnis:

$ sudo ./AdafruitDHT.py 11 4 Temp=24.0* Humidity=41.0%

5. Datenübertragung an Ubidots

1. Erstellen Sie ein Python-Skript mit dem Nano-Editor und fügen Sie den unten stehenden Code in das Terminal ein. Geben Sie dazu folgenden Befehl ein:

$ sudo nano ubidots3.py

Quellcode:

import time import requests import math import random import sys import Adafruit_DHT sensor = 22 # Wählen Sie Ihre DHT-Version pin = 18 # Geben Sie Ihre DHT22-PIN ein TOKEN = "…" # Fügen Sie hier Ihr TOKEN ein DEVICE_LABEL = "Raspberrypi" # Fügen Sie hier Ihre Gerätebezeichnung ein VARIABLE_LABEL_1 = "temperature" # Fügen Sie hier Ihre erste Variablenbezeichnung ein VARIABLE_LABEL_2 = "humidity" # Fügen Sie hier Ihre zweite Variablenbezeichnung ein # Versuchen Sie, einen Sensorwert zu erfassen. Verwenden Sie die Methode read_retry, die bis zu 15 Mal versucht, einen Sensorwert zu erhalten (mit jeweils 2 Sekunden Wartezeit). humidity, temperature = Adafruit_DHT.read_retry(sensor, pin) # Entfernen Sie die Kommentarzeichen in der folgenden Zeile, um die Temperatur in Fahrenheit umzurechnen. # Temperatur = Temperatur * 9/5,0 + 32 # Beachten Sie, dass manchmal kein Messwert angezeigt wird und die Ergebnisse null sind (da Linux die # korrekte Ausführung der Sensorabfragen nicht garantieren kann). # Versuchen Sie es in diesem Fall erneut! def build_payload(variable_1, variable_2): # Erzeugt zwei Zufallswerte zum Senden von Daten value_1 = temperature value_2 = humidity payload = {variable_1: value_1, variable_2: value_2, } return payload def post_request(payload): # Erzeugt die Header für die HTTP-Anfragen url = "ubidots" url = "{}/api/v1.6/devices/{}".format(url, DEVICE_LABEL) headers = {"X-Auth-Token": TOKEN, "Content-Type": "application/json"} # Sendet die HTTP-Anfragen 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) # Ergebnisse verarbeiten, falls Status >= 400: print("[FEHLER] Daten konnten nach 5 Versuchen nicht gesendet werden. Bitte überprüfen Sie Ihre Token-Zugangsdaten und Ihre Internetverbindung.") return False print("[INFO] Anfrage erfolgreich, Ihr Gerät wurde aktualisiert.") return True def main(): payload = build_payload( VARIABLE_LABEL_1, VARIABLE_LABEL_2) print("[INFO] Versuche, Daten zu senden.") post_request(payload) print("[INFO] Fertig.") if __name__ == '__main__': while (True): print('Temp={0:0.1f}* Humidity={1:0.1f}%'.format(temperature, humidity)) humidity, temperature = Adafruit_DHT.read_retry(sensor, pin) main() time.sleep(1) ```

Nach dem Einfügen des Quellcodes müssen Sie das Ubidots Token an der im Python-Skript angegebenen Stelle zuweisen:

$ sudo nano ubidots3.py

2. Nachdem nun alles konfiguriert ist, können Sie den Beispielcode ausführen, um mit der Datenübertragung an Ihr Ubidots -Konto zu beginnen:

$ sudo python ubidots3.py

Wenn Sie nun in Ihrem Ubidots -Konto den Bereich „Geräte“ aufrufen, sehen Sie dort ein neu erstelltes Gerät mit dem Namen „RaspberryPi“.

3. Um Ihre Daten effizient zu visualisieren, richten wir ein Ubidots - Dashboard . Gehen Sie dazu im Dashboard Bereich auf (Daten > Dashboard ).

4. Klicken Sie anschließend auf „ Neues Widget hinzufügen “ und wählen Sie Ihr Widget aus:

5. Wählen Sie die Variable aus, die angezeigt werden soll:

6. Geben Sie dem Widget einen individuellen Namen und drücken Sie das grüne Symbol, um die Widget-Erstellung abzuschließen.

Ubidots IoT -Anwendungsentwicklungsplattform können Sie nun Variablen von jedem beliebigen Ort aus fernüberwachen :

Empfohlene Artikel:

Verfasst von Ammar Chauhan

Chauhan ist Informatiker mit über 2 Jahren Erfahrung in der Arbeit mit DIY-Elektronik und IoT basierten Computersystemen und begeistert sich außerdem für KI-, DIP- und ML-Projekte.