Es ist ein Klassiker in der IT-Sicherheit:
Man verlässt kurz den Schreibtisch, vergisst den Rechner zu sperren und schon steht das System für jeden offen. Windows bietet dafür zwar die integrierte Funktion „Dynamische Sperre“ an, die den Personal Computer (PC) über Bluetooth an das Smartphone koppelt. Doch diese Lösung hat in der Praxis einen gewaltigen Haken: Wie oft lässt man das Handy einfach neben der Tastatur liegen, wenn man nur mal eben den Raum verlässt?
Die Folge: Das Handy bleibt am Platz und der Bildschirm bleibt ungeschützt entsperrt.
Ein Schlüsselbund hingegen ruht meistens sicher in der eigenen Hosentasche. In diesem Projekt bauen wir daher einen besseren und zuverlässigeren automatischen Näherungsschalter (Proximity Lock) selbst.
Ein kleiner, extrem günstiger NRF51822 iBeacon dient als digitaler Sender an deinem Schlüsselbund. Ein Python-Skript auf dem PC überwacht die Funksignale. Entfernst du dich vom Arbeitsplatz, reißt das Signal ab und der Rechner sperrt sich vollautomatisch. Der Clou: Wir benötigen dafür keine extra Handy-App auf dem PC. Wir nutzen Python, um die einmalige Hardware-Adresse unseres Beacons aus der Luft zu fischen und unseren Rechner so abzusichern, dass er nur auf diesen einen, spezifischen Schlüsselanhänger reagiert.
Das brauchst du für das Projekt
- NRF51822 iBeacon: Ein kleiner, stromsparendener Funksender für Bluetooth Low Energy (BLE). Er läuft monatelang mit einer einfachen Knopfzelle.
- Optional: Bluetooth 5 USB-Adapter: Ein Universal Serial Bus (USB) Dongle, damit dein Computer die modernen, energiesparenden Bluetooth-Signale empfangen kann (falls nicht bereits auf dem Mainboard verbaut).
- Python: Die Programmiersprache muss auf deinem Rechner installiert sein.
- Smartphone-App „BLE360“: Zur einmaligen Hardware-Konfiguration des Senders.
Das Prinzip: Wie funktioniert ein iBeacon eigentlich?
Bevor wir in den Code einsteigen, müssen wir kurz klären, wie so ein iBeacon überhaupt arbeitet. Man kann sich diesen kleinen Sender am besten wie einen digitalen Leuchtturm vorstellen.
Er baut keine dauerhafte Verbindung zu deinem PC auf (wie es beispielsweise ein Bluetooth-Kopfhörer tut). Stattdessen „schläft“ der Chip die meiste Zeit, um extrem viel Strom zu sparen. In einem festen Rhythmus wacht er für den Bruchteil einer Sekunde auf und funkt blind ein kleines Datenpaket in seine Umgebung – wie der Lichtblitz eines Leuchtturms.
Dieses Datenpaket (Werbepaket oder Advertisement genannt) enthält zwei für uns wichtige Informationen:
- Eine UUID (Universally Unique Identifier – universell eindeutige Kennung), die beschreibt, zu welcher Gruppe oder welchem Hersteller der Beacon gehört.
- Die MAC-Adresse (Media Access Control), die absolut einmalige Hardware-Nummer des eingebauten Bluetooth-Chips.
Unser PC muss nun nichts weiter tun, als diese „Lichtblitze“ aufzufangen. Bleiben die Blitze aus oder werden sie zu schwach, wissen wir: Der Schlüssel hat sich entfernt.
Exkurs: Warum wir die MAC-Adresse und keine UUID nutzen
Wer sich schon einmal mit Beacons beschäftigt hat, wird sich jetzt fragen: Warum nutzen wir zum Sperren nicht die UUID? Genau dafür sind Beacons doch gemacht!
Das hat bei diesem Projekt einen ganz praktischen Sicherheitsgrund: Bei vielen günstigen Modellen ist die ab Werk gesendete Service-UUID (oft die Hersteller-Kennung iLogicTech) bei allen baugleichen Geräten absolut identisch.
Würden wir unser Skript auf diese UUID ansetzen, gäbe es ein Problem: Wenn ein Kollege mit exakt dem gleichen iBeacon-Modell an deinem Schreibtisch vorbeiläuft, würde dein Rechner die UUID erkennen und den PC entsperrt lassen! Die MAC-Adresse ist hingegen der unveränderliche Fingerabdruck des Chips. Wir nutzen Python, um diese echte Hardware-Adresse aus der Luft zu fischen. So funktioniert wirklich nur dein persönlicher Schlüssel.
Schritt 1: Vorbereitung – Python-Bibliothek installieren
Damit Python überhaupt auf die Bluetooth-Hardware des PCs zugreifen kann, benötigen wir die moderne Bibliothek Bleak. Öffne deine Kommandozeile (Eingabeaufforderung) und installiere sie mit folgendem Befehl:
pip install bleakSchritt 2: Den Schlüssel finden
Bevor wir den Computer überwachen können, müssen wir die MAC-Adresse unseres Beacons herausfinden. Dafür nutzen wir einen einfachen Scanner. Erstelle mit dem Editor eine scanner.py und lege diesen Code hinein:
import asyncio
from bleak import BleakScanner
async def mac_adressen_finden():
print("Starte Bluetooth-Scan für 5 Sekunden...")
# return_adv=True ist in neueren Bleak-Versionen zwingend nötig, um Signalstärken auszulesen
gefundene_geraete = await BleakScanner.discover(timeout=5.0, return_adv=True)
print("\n--- Scan beendet. Ergebnisse: ---")
for mac_adresse, (geraet, adv_daten) in gefundene_geraete.items():
print(f"MAC-Adresse: {geraet.address} | Name: {geraet.name} | Signal: {adv_daten.rssi} dBm")
if __name__ == "__main__":
asyncio.run(mac_adressen_finden())Leg den eingeschalteten Beacon neben den PC, starte das Skript mit
PS C:\Users\prilchen> python scanner.py
und notiere dir die MAC-Adresse mit dem stärksten Signal (z.B. -40 dBm).
Beispiel: Ergebnis sieht etwa so aus:
Schritt 3: Der erste Testlauf (Die einfache Lösung)
Mit der MAC-Adresse können wir nun unser erstes, simples Überwachungsskript schreiben. Das Prinzip: Das Skript sucht alle paar Sekunden nach dem Beacon. Ist das Signal zu schwach oder ganz weg, wird der Rechner gesperrt.
import asyncio
from bleak import BleakScanner
import os
import time
# Trage hier deine gefundene MAC-Adresse ein
ZIEL_MAC = "AA:BB:CC:DD:EE:FF"
RSSI_SCHWELLENWERT = -80 # Grenzwert für die Signalstärke
async def raum_ueberwachen():
print("Die einfache Überwachung läuft...")
while True:
gefundene_geraete = await BleakScanner.discover(timeout=5.0, return_adv=True)
beacon_gefunden = False
for mac_adresse, (geraet, adv_daten) in gefundene_geraete.items():
if geraet.address.upper() == ZIEL_MAC.upper():
beacon_gefunden = True
if adv_daten.rssi < RSSI_SCHWELLENWERT:
print("Signal zu schwach! PC wird gesperrt.")
os.system("rundll32.exe user32.dll,LockWorkStation")
time.sleep(10)
else:
print(f"Alles okay. Signal: {adv_daten.rssi} dBm")
break
if not beacon_gefunden:
print("Beacon weg! PC wird gesperrt.")
os.system("rundll32.exe user32.dll,LockWorkStation")
time.sleep(10)
if __name__ == "__main__":
asyncio.run(raum_ueberwachen())Probier es aus! Speiche als sperre.py und starte das Skript. Solange der Beacon auf dem Tisch liegt, passiert nichts. Nimmst du ihn mit und verlässt den Raum, sperrt sich der Bildschirm. Perfekt, oder? Nicht ganz!
Schritt 4: Das Problem – Warum Theorie und Praxis kollidieren
Wenn man nun ein simples Skript schreibt, das den PC sperrt, sobald das Signal schwächer wird, kommt es aber auch mal zu einer Überraschung: Der Rechner sperrt sich ständig von selbst, obwohl der Beacon direkt auf dem Schreibtisch liegt!
Melde dich wieder an und stoppe Ausführung mit STRG + C
Woher kommen diese massiven Aussetzer? Um nicht im Blindflug zu raten, müssen wir messen.
Schritt 5: Die Analyse – Dem Fehler auf der Spur
Wir bauen uns einen Echtzeit-Monitor, der ununterbrochen lauscht und jede Millisekunde protokolliert, in der ein Funksignal unseres Beacons eintrifft.
import asyncio
from bleak import BleakScanner
from datetime import datetime
# Trage hier deine gefundene MAC-Adresse ein
ZIEL_MAC = "AA:BB:CC:DD:EE:FF"
def beacon_gesehen(geraet, adv_daten):
if geraet.address.upper() == ZIEL_MAC.upper():
aktuelle_zeit = datetime.now().strftime("%H:%M:%S.%f")[:-3]
print(f"[{aktuelle_zeit}] Beacon empfangen! | Signal: {adv_daten.rssi} dBm")
async def starte_analyse():
print("Der Scanner lauscht jetzt ununterbrochen im Hintergrund...")
scanner = BleakScanner(detection_callback=beacon_gesehen)
await scanner.start()
while True:
await asyncio.sleep(1.0)
if __name__ == "__main__":
try:
asyncio.run(starte_analyse())
except KeyboardInterrupt:
print("\nAnalyse beendet.")Interessantes Messergebnis bei mir:
Ein Blick in die Protokolle (Auszug) dieses Tools deckte bei unseren Tests direkt zwei massive Probleme auf:
- Zu langsamer Takt: Der Beacon sendete ab Werk nur alle 2 Sekunden ein Datenpaket.
- Ignorantes Betriebssystem: Windows und der USB-Treiber schluckten Funksignale teilweise für 10 bis 40 Sekunden komplett (!), vermutlich um Energie zu sparen oder „Spam-Signale“ zu filtern.
Ein Skript, das nur 5 Sekunden lang nach einem Signal sucht, fiel hier unweigerlich auf die Nase.
Schritt 6: Die finale Lösung (Hardware & Software)
Um das System absolut stabil zu bekommen, müssen wir an drei Stellschrauben drehen: Am Beacon, an Windows und an unserem Python-Code.
1. Das Sendeintervall (Hardware) anpassen
Wir müssen den Beacon dazu bringen, öfter zu rufen.
- Lade dir die App BLE360 auf dein Smartphone herunter.
- Verbinde dich mit dem iBeacon (das Standard-Passwort lautet meist
123456). - Suche den Wert Advertising Interval (Sendeintervall) und ändere ihn von z.B. 2000 ms auf 480 ms.
Der kleine Chip sendet jetzt jede halbe Sekunde – ein perfekter Kompromiss aus Reaktionszeit und Batterie-Lebensdauer.
2. Windows Energieverwaltung bändigen
Damit der Bluetooth-Treiber nicht ungefragt in den Schlafmodus geht:
- Öffne in Windows den Geräte-Manager.
- Klicke unter Bluetooth doppelt auf deinen USB-Adapter.
- Entferne im Reiter Energieverwaltung zwingend den Haken bei: „Computer kann das Gerät ausschalten, um Energie zu sparen“.
3. Das finale, fehlertolerante Python-Skript
Zuletzt statten wir unser Überwachungsskript mit einer sogenannten Fehlertoleranz (Entprellen) aus. Wir geben dem System eine „Drei-Strikes-Regel“. Der PC wird nicht beim ersten fehlenden Signal gesperrt, sondern erst, wenn der Beacon dreimal hintereinander (also für insgesamt ca. 15 Sekunden) unauffindbar oder zu schwach ist.
import asyncio
from bleak import BleakScanner
import os
import time
# 1. DEINE MAC-ADRESSE HIER EINTRAGEN
ZIEL_MAC = "AA:BB:CC:DD:EE:FF"
# 2. Der Grenzwert für die Empfangssignalstärke (Received Signal Strength Indicator - RSSI)
RSSI_SCHWELLENWERT = -80
# 3. Wie oft darf der Beacon in Folge fehlen? (Entprellen)
MAX_FEHLVERSUCHE = 3
async def raum_ueberwachen():
print("Die fehlertolerante Bluetooth-Raumüberwachung läuft...")
fehlversuche = 0
while True:
gefundene_geraete = await BleakScanner.discover(timeout=5.0, return_adv=True)
beacon_gefunden = False
for mac_adresse, (geraet, adv_daten) in gefundene_geraete.items():
if geraet.address.upper() == ZIEL_MAC.upper():
beacon_gefunden = True
aktuelle_rssi = adv_daten.rssi
# Signalstärke prüfen
if aktuelle_rssi < RSSI_SCHWELLENWERT:
fehlversuche += 1
print(f"Schlüssel da, aber Signal zu schwach ({aktuelle_rssi} dBm). Warnung {fehlversuche}/{MAX_FEHLVERSUCHE}")
else:
if fehlversuche > 0:
print("Signal wieder stark genug. Fehlerzähler zurückgesetzt.")
fehlversuche = 0 # Alles in Ordnung
break
# Prüfung: Wurde der Beacon gar nicht gesichtet?
if not beacon_gefunden:
fehlversuche += 1
print(f"Schlüssel nicht gefunden! Warnung {fehlversuche}/{MAX_FEHLVERSUCHE}")
# Prüfung: Toleranzgrenze erreicht?
if fehlversuche >= MAX_FEHLVERSUCHE:
print("Toleranzgrenze überschritten! PC wird gesperrt.")
os.system("rundll32.exe user32.dll,LockWorkStation")
fehlversuche = 0
time.sleep(10) # Kurze Pause nach dem Sperren
if __name__ == "__main__":
asyncio.run(raum_ueberwachen())Das Fazit
Mit diesem Setup erhältst du eine durchaus zuverlässigere PC-Sperre.
Die Kombination aus Live-Analyse, Hardware-Tuning und sauberer Fehlerabfang-Routine in der Software zeigt perfekt, worauf es bei solchen IT-Projekten ankommt.
Viel Spaß beim Nachbauen und Experimentieren!
Weitere Anwendungsbeispiele für iBeacon:
Raumbezogene Anwesenheitserkennung im Smart Home
Viele Smart-Home-Systeme tun sich schwer damit, genau zu wissen, in welchem Raum sich eine Person aufhält. Bewegungsmelder reagieren oft nicht, wenn man still am Schreibtisch sitzt.
- Der Aufbau: Man platziert kleine Empfänger (zum Beispiel Mikrocontroller wie den ESP32) in verschiedenen Räumen. Der Nutzer trägt den NRF51822 bei sich.
- Der Effekt: Das System weiß genau, wo das Signal am stärksten ist. So kann das Licht, das Radio oder die Heizung in genau dem Raum gesteuert werden, in dem man sich gerade wirklich aufhält.
Inventar-Ortung für Werkzeuge und Hardware (Asset Tracking)
In Werkstätten oder Serverräumen verschwinden oft teure Messgeräte oder Spezialwerkzeuge.
- Das Prinzip: Man befestigt an jedem wichtigen Werkzeug einen iBeacon. Die Beacons senden dauerhaft ihre eindeutige Kennung aus.
- Der Nutzen: Über ein paar verteilte Empfänger im Gebäude kann man grob orten, in welchem Raum das Werkzeug zuletzt ein Signal gesendet hat. Man baut sich also ein eigenes kleines Radar für Gegenstände.
Digitale Infopunkte (Indoor-Navigation)
Das ist das klassische iBeacon-Szenario, das oft in Museen eingesetzt wird, sich aber auch super für eigene Projekte adaptieren lässt.
- Die Idee: Man klebt Beacons an bestimmte Geräte (zum Beispiel an einen 3D-Drucker oder einen bestimmten Server im Netzwerkschrank).
- Die Umsetzung: Nähert man sich mit dem Smartphone diesem Gerät, taucht auf dem Handy automatisch eine Benachrichtigung auf, die direkt zur passenden Dokumentation, dem Handbuch oder einer Video-Anleitung verlinkt.
Wichtige Fakten für die Umsetzung: - Energieverbrauch: Ein NRF51822 kann mit einer einfachen Knopfzelle (CR2032) bei richtiger Programmierung nachweislich mehrere Monate bis zu über einem Jahr senden.
- Reichweite: Je nach Hindernissen im Raum (Wände, Metallschränke) liegt die realistische Reichweite meist zwischen 10 und 30 Metern.
- Hinweis zu Messdaten: Die RSSI-Signalstärke schwankt physikalisch bedingt stark durch Reflexionen im Raum oder durch den menschlichen Körper (der viel Wasser enthält und das Signal dämpft). Distanzmessungen über Bluetooth sind daher nie auf den Zentimeter genau, sondern dienen immer nur der groben Entfernungsabschätzung.
Welches dieser Szenarien passt am besten zu den Themen, die du als Nächstes genauer vorstellen oder selbst aufbauen möchtest?