niot-helfer 0.0.2__tar.gz

niot_helfer-0.0.2/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: niot_helfer
+Version: 0.0.2
+Summary: Ein Helfermodul für NIT-Unterricht mit IoT Projekten
+Author-email: dickschaedel <dickschaedel@example.org>
+License-Expression: Unlicense
+Project-URL: Homepage, https://codeberg.org/dickschaedel/niot_helfer
+Project-URL: Source, https://codeberg.org/dickschaedel/niot_helfer
+Keywords: education,learning
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Education
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Development Status :: 3 - Alpha
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown

niot_helfer-0.0.2/pre-push

@@ -0,0 +1,42 @@
+#!/usr/bin/env sh
+set -e
+
+GREEN="\033[32m"
+YELLOW="\033[33m"
+RED="\033[31m"
+RESET="\033[0m"
+
+log() { printf "%b\n" "${GREEN}$1${RESET}"; }
+warn() { printf "%b\n" "${YELLOW}$1${RESET}"; }
+err() { printf "%b\n" "${RED}$1${RESET}" >&2; }
+
+while read local_ref local_sha remote_ref remote_sha
+do
+  case "$local_ref" in
+    refs/tags/v*)
+      # neuer Tag? (remote_sha = 40x0)
+      if [ "$remote_sha" != "0000000000000000000000000000000000000000" ]; then
+        warn "🔁 Tag existiert bereits auf dem Remote – überspringe"
+        continue
+      fi
+
+      TAG_NAME="${local_ref#refs/tags/}"
+
+      log "🔖 Neuer Versionstag erkannt: ${TAG_NAME}"
+      log "🧹 Alte Build-Artefakte entfernen"
+      rm -rf dist build *.egg-info
+
+      log "📦 Baue Paket"
+      python -m pip install --upgrade build twine
+      python -m build
+
+      log "🚀 Upload nach PyPI"
+      twine upload dist/*
+
+      log "✅ Release ${TAG_NAME} erfolgreich veröffentlicht"
+      ;;
+    *)
+      # kein Tag → nichts tun
+      ;;
+  esac
+done

niot_helfer-0.0.2/pyproject.toml

@@ -0,0 +1,41 @@
+
+[build-system]
+requires = [
+  "setuptools>=68",
+  "wheel",
+  "setuptools_scm[toml]>=8"
+]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "niot_helfer"
+dynamic = ["version"]
+description = "Ein Helfermodul für NIT-Unterricht mit IoT Projekten"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "Unlicense"
+authors = [
+  { name = "dickschaedel", email = "dickschaedel@example.org" }
+]
+keywords = [
+  "education",
+  "learning",
+]
+
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Topic :: Education",
+  "Intended Audience :: Education",
+  "Intended Audience :: Developers",
+  "Intended Audience :: End Users/Desktop",
+  "Development Status :: 3 - Alpha",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://codeberg.org/dickschaedel/niot_helfer"
+Source = "https://codeberg.org/dickschaedel/niot_helfer"
+
+[tool.setuptools_scm]
+# akzeptiert Tags wie v1.2.3
+tag_regex = "^v(?P<version>\\d+\\.\\d+\\.\\d+)$"

niot_helfer-0.0.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

niot_helfer-0.0.2/src/examples/example_schalter_per_wlan_als_ap.py

@@ -0,0 +1,19 @@
+from niot_helfer import *
+import machine
+
+def handle_default(client):
+    return wifi.get_file("examples/schalter.html")
+                 
+def handle_schalter(client):
+    led.value(not led.value())
+    
+# MAIN
+led = machine.Pin(LED_BUILTIN, machine.Pin.OUT)
+
+wifi = NIoTHelper(verbose=True)		# wifi/Webserver Vorbereitungen
+wifi.register_handler_default(handle_default)
+wifi.register_handler("/", handle_default)
+wifi.register_handler("/schalter", handle_schalter)
+wifi.start_ap()						# eigens AP aufspannen
+wifi.start_webserver()				# Webserver starten
+wifi.run()							# Kümmert sich um alle Anfragen

niot_helfer-0.0.2/src/examples/example_schalter_per_wlan_als_client.py

@@ -0,0 +1,19 @@
+from niot_helfer import *
+from machine import Pin
+
+def handle_default(client):
+    return wifi.get_file("examples/schalter.html")
+                 
+def handle_schalter(client):
+    led.value(not led.value())    
+    
+# MAIN
+led = Pin(LED_BUILTIN, Pin.OUT)
+
+wifi = NIoTHelper(verbose=True)		# wifi/Webserver Vorbereitungen
+wifi.register_handler_default(handle_default)
+wifi.register_handler("/", handle_default)
+wifi.register_handler("/schalter", handle_schalter)
+wifi.connect("ssid","pw")	# mit WLAN verbinden
+wifi.start_webserver()				# Webserver starten
+wifi.run()							# Kümmert sich um alle Anfragen

niot_helfer-0.0.2/src/examples/schalter.html

@@ -0,0 +1 @@
+<html><head><style>.switch {  position: relative;  display: inline-block;  width:60px;height: 34px;}.switch input {   opacity: 0;  width: 0;  height: 0;}.slider {position: absolute;  cursor: pointer;  top: 0;  left: 0;  right: 0;  bottom: 0;  background-color: ccc;  -webkit-transition: .4s;  transition:.4s;}.slider:before {  position: absolute;  content: '';  height: 26px;  width: 26px;  left: 4px;  bottom: 4px;  background-color: white;  -webkit-transition: .4s;  transition: .4s;}input:checked + .slider {  background-color: 2196F3;}input:focus + .slider {  box-shadow: 0 0 1px 2196F3;}input:checked + .slider:before {  -webkit-transform: translateX(26px);  -ms-transform: translateX(26px);  transform: translateX(26px);}/* Rounded sliders */.slider.round {  border-radius: 34px;}.slider.round:before {  border-radius: 50%;}</style></head><body><h2>Umschalten</h2><label class='switch' >  <input type='checkbox' id='switch'>  <span class='slider round'></span></label></body><script>function click() {fetch('/schalter');return true;}document.getElementById('switch').addEventListener('change',click);</script></html>

niot_helfer-0.0.2/src/index.html

@@ -0,0 +1,100 @@
+<!DOCTYPE html><html lang='en'><head>
+<meta http-equiv='Content-Type' content='text/html; charset=UTF-8'><meta name='viewport' content='width=device-width, initial-scale=1, user-scalable=no'>
+<title>Einstellungen</title><script>
+function waehleSSID(eintrag) {
+	document.getElementById('ssid').value = eintrag.innerText || eintrag.textContent;
+	document.getElementById('pw').focus();
+}
+function reqListener() {
+  var data = JSON.parse(this.responseText);
+  alert(data);
+}
+function reqError(err) {
+  document.getElementById('test').innerHTML = 'juhu';
+}
+function holeWLANs() {
+	var oReq = new XMLHttpRequest();
+	oReq.onload = reqListener;
+	oReq.onerror = reqError;
+	oReq.open('get', '/wlansearch', true);
+	oReq.send();	
+}
+function testWifiSettings() {
+	fetch('/connection_test',{"method":"get"})
+	.then(response => {
+      if (!response.ok) {
+        throw new Error('Network response was not ok');
+      }
+      return response.json();
+    })	
+    .catch(error => {
+      document.getElementById('msg').innerHTML = 'Fetch error';
+      console.error('Fetch error:', error);
+    });	
+	return false;
+}
+async function speichernWLAN() {
+
+    const ssid = document.getElementById('ssid').value;
+    const pw = document.getElementById('pw').value;
+
+    try {
+
+        const response = await fetch('/speichern', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                ssid: ssid,
+                pw: pw
+            })
+        });
+
+        const text = await response.text();
+
+        document.getElementById('msg').innerHTML = text;
+
+    } catch(error) {
+
+        console.log(error);
+        alert("Fehler beim Speichern");
+
+    }
+
+    return false;
+}
+</script><style type='text/css'>.thinborder {border: 1px solid black;border-radius:.3rem}
+button { border:0;border-radius:.3rem;background-color:#20a0f0;color:#ffffff;line-height:2.6rem;font-size:1.2rem;width:100%}
+input:focus {background-color: yellow}
+div,input {padding:5px;font-size:1em}
+input {width:95%;margin-top:5px;margin-bottom:10px}
+body {text-align:center;font-family:verdana}
+.right {float:right;text-align:right}
+.info {margin:10px;padding:10px;border-radius:10px;background-color:#a0e0ff}
+.halbl{width:48%;float:left;padding:0pt}
+.halbr{width:48%;float:right;padding:0pt}</style></head>
+<body onload='holeWLANs();'>
+<div style='text-align:left;display:inline-block;min-width:260px;'>
+<div class='thinborder'>
+<form onsubmit="return speichernWLAN()">
+<div class='info'>Mit welchem WLAN soll sich der Mikrocontroller normalerweise verbinden?</div>
+<label>WLAN-Name ('SSID'):</label><input id='ssid' name='ssid' length='32' autofocus placeholder='SSID eingeben oder unten ausw&auml;hlen'/>
+<label>Passwort:</label><input id='pw' name='pw' length='64' type='password' placeholder='Passwort'/>
+<div>
+<button class='halbl' type='submit'>Speichern</button>
+</form>
+<div class='halbr'><button type='submit' onclick='return testWifiSettings()'>Testen</button></div>
+</div>
+<br style='clear:both'/>
+<br/>
+Verf&uuml;gbare WLANs:
+<div class='thinborder'>
+<!--{wlans}-->
+</div>
+<br/>
+
+<div class='info' id='test'>MAC-Adresse dieses Mikrocontrollers: $MAC$</div>
+</div>
+</body>
+</html>

niot_helfer-0.0.2/src/niot_helfer.egg-info/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: niot_helfer
+Version: 0.0.2
+Summary: Ein Helfermodul für NIT-Unterricht mit IoT Projekten
+Author-email: dickschaedel <dickschaedel@example.org>
+License-Expression: Unlicense
+Project-URL: Homepage, https://codeberg.org/dickschaedel/niot_helfer
+Project-URL: Source, https://codeberg.org/dickschaedel/niot_helfer
+Keywords: education,learning
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Education
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Development Status :: 3 - Alpha
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown

niot_helfer-0.0.2/src/niot_helfer.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pre-push
+pyproject.toml
+src/index.html
+src/niot_helfer.py
+src/examples/example_schalter_per_wlan_als_ap.py
+src/examples/example_schalter_per_wlan_als_client.py
+src/examples/schalter.html
+src/niot_helfer.egg-info/PKG-INFO
+src/niot_helfer.egg-info/SOURCES.txt
+src/niot_helfer.egg-info/dependency_links.txt
+src/niot_helfer.egg-info/top_level.txt

niot_helfer-0.0.2/src/niot_helfer.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

niot_helfer-0.0.2/src/niot_helfer.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+examples
+niot_helfer

niot_helfer-0.0.2/src/niot_helfer.py

@@ -0,0 +1,474 @@
+import network
+import urequests
+import time
+import socket
+import os
+import machine
+import json
+import gc
+import sys
+import uasyncio as asyncio
+
+# Helper to detect uasyncio v3
+IS_UASYNCIO_V3 = hasattr(asyncio, "__version__") and asyncio.__version__ >= (3,)
+
+'''
+NIoT Helfer - Version 0.1
+==========================
+# sendas main.py
+# token ghsdufjsdtzxcvfgsHSRZTG23jFTDGSdjf
+# ip 192.168.0.73
+'''
+# globals für den ESP8266
+D4 = machine.Pin(2)
+LED_BUILTIN = D4
+LED_BUILDIN = D4
+
+class DNSQuery:
+    def __init__(self, data):
+        self.data = data
+        self.domain = ''
+        tipo = (data[2] >> 3) & 15  # Opcode bits
+        if tipo == 0:  # Standard query
+            ini = 12
+            lon = data[ini]
+            while lon != 0:
+                self.domain += data[ini + 1:ini + lon + 1].decode('utf-8') + '.'
+                ini += lon + 1
+                lon = data[ini]
+        print("DNSQuery domain:" + self.domain)
+
+    def response(self, ip):
+        print("DNSQuery response: {} ==> {}".format(self.domain, ip))
+        if self.domain:
+            packet = self.data[:2] + b'\x81\x80'
+            packet += self.data[4:6] + self.data[4:6] + b'\x00\x00\x00\x00'
+            packet += self.data[12:]  # Original Domain Name Question
+            packet += b'\xC0\x0C'  # Pointer to domain name
+            packet += b'\x00\x01\x00\x01\x00\x00\x00\x3C\x00\x04'
+            packet += bytes(map(int, ip.split('.')))
+        return packet
+
+class NIoTHelper:
+    __URL_SERVER = "http://informatik.fsg-pfullingen.de"
+    __URL_SENSORAPI = "/iot/webapi.php"
+    _hostname = "LittleGreenPanda"
+
+    # Access point constants
+    __AP_SSID = 'NIoT'  # max 32 characters
+    __AP_IP = '192.168.42.1'
+    __AP_SUBNET = '255.255.255.0'
+
+    def __init__(self, verbose=False):
+        self.client = None
+        self.server_socket = None
+        self.handlers = {}
+        self.register_handler("/", self.handle_root)
+        self.handler_default = self.handle_404
+        self.verbose = verbose
+        # get and store the event loop
+        self.tasks = []
+        self.webserver_infos = None
+        self.run_captive_portal = False
+        self.wifis = []
+
+    def register_handler(self, url, fun):
+        self.handlers[url] = fun
+    def register_handler_default(self, fun):
+        self.handler_default = fun
+
+    def logging(self, msg):
+        if self.verbose:
+            print(msg)
+    
+    def getConfig(self):
+        return self.client.ifconfig()
+             
+    def getCredentials(self):
+
+        try:
+
+            with open("wifi.json", "r") as f:
+                daten = json.load(f)
+
+            ssid = daten["ssid"]
+            pw = daten["pw"]
+
+            print("Geladene WLAN-Daten:")
+            print("SSID:", ssid)
+
+            return ssid, pw
+
+        except Exception as e:
+
+            print("Keine gespeicherten WLAN-Daten gefunden")
+            print(e)
+
+            return None, None
+    
+    def getDeviceID(self):
+        return "".join(["%02x" % b for b in self.client.config("mac")])
+    
+    def isConnected(self):
+        return self.client and self.client.isconnected()
+
+    def connect(self, ssid=None, pw=None):
+        self.client = network.WLAN(network.WLAN.IF_STA)
+        network.hostname(self._hostname)
+        if not self.isConnected():
+            if not ssid or not pw:
+                ssid, pw = self.getCredentials()                
+            self.logging(f'connecting to: {ssid} with pw: {pw[:max(1,len(pw)//5)]}...')
+            self.client.active(False)
+            time.sleep(1)
+            self.client.active(True)
+            time.sleep(0.5)
+            try:
+                self.client.connect(ssid,pw)
+                for num in range(20):
+                    if self.isConnected():
+                        break
+                    else:
+                        if self.verbose:
+                            print(".", end="")
+                        if num == 19:
+                            self.logging(f'\nERROR connecting: timed out')
+                            break
+                    time.sleep(0.5)
+                print()
+            except Exception as e:
+                self.logging(f'Error connecting:\n {e}')
+            # FIXME: what about wrong credentials / timeout?
+        else:
+            self.logging(f'Wifi already connected. Nothing to do.')            
+        self.logging(f'IP: {self.client.ipconfig("addr4")} MAC: {self.getDeviceID()}')
+        return self.client.isconnected()
+    
+    def disconnect(self):
+        if self.client:            
+            self.client.disconnect()
+
+    '''
+        The socket does not assure to successfully write all the data.
+        This this function repeats the sending process until
+        everything is transfered.
+    '''
+    def send_verified(self, conn, data):
+        total_sent = 0
+        length = len(data)
+        while total_sent < length:
+            sent = conn.send(data[total_sent:])
+            if sent == 0:
+                raise OSError("Socket connection broken")
+            total_sent += sent
+            
+    def get_file(self, filename):
+        headers = ""
+        content = ""
+        try:
+            headers = "HTTP/1.0 200 OK\r\n"
+            headers += "Content-Type: text/html\r\n"
+            headers += "Connection: close\r\n\r\n"
+            
+            with open(filename, "r") as f:
+                while True:
+                    chunk = f.read()
+                    if not chunk:
+                        break
+                    content += chunk
+        except OSError:
+            headers = "HTTP/1.0 404 Not Found\r\n\r\n"            
+            print("file not found")
+        except Exception as e:
+            headers = "HTTP/1.0 500 Internal Server Error\r\n\r\n" + str(e)
+        return content, headers
+
+    def handle_root(self, client):        
+        return "no handler for /", None
+#        self.send_verified(client, b"no handler for \\")
+    
+    def handle_404(self, client):
+        return "404 - URL not handled", None
+#        self.send_verified(client, b"404 - URL not handled")
+
+    def start_webserver(self, port=80):
+        self.webserver_infos = {"port":port}
+    
+    def stop_webserver(self):
+        if self.server_socket:
+            self.server_socket.close()           
+
+    async def handle_http_connection(self, reader, writer):
+        # Get HTTP request line
+        data = await reader.readline()
+        request_line = data.decode()
+        if not request_line:
+            return
+        addr = writer.get_extra_info('peername')
+        method, url, version = request_line.split()
+        print(f"Received {method} from {addr} for {url}")
+
+        # Header lesen
+        headers_in = {}
+        content_length = 0
+
+        while True:
+            gc.collect()
+            line = await reader.readline()
+
+            if line == b'\r\n':
+                break
+
+            line = line.decode().strip()
+
+            if ":" in line:
+                key, value = line.split(":", 1)
+                headers_in[key.lower()] = value.strip()
+
+        # Content-Length holen
+        if "content-length" in headers_in:
+            content_length = int(headers_in["content-length"])
+
+        # POST-Daten lesen
+        payload = ""
+
+        if content_length > 0:
+            payload = await reader.read(content_length)
+            payload = payload.decode()
+
+        print("POST DATA:", payload)
+
+        # Handle the request
+        if len(request_line) > 0:
+            if "GET" == method or "POST" == method:
+                if url in self.handlers:
+                    try:
+                        if not callable(self.handlers[url]):
+                            print("WARNING: a registered handler is not callable: ", url)
+                        content, headers = self.handlers[url](payload)
+                    except Exception as e:
+                        print(url, e)
+                        content, headers = "", None
+                else:
+                    content, headers = self.handler_default(None)
+                if not headers:
+                    headers = 'HTTP/1.0 200 OK\r\n\r\n'
+                writer.write(headers+content)
+                try:
+                    await writer.drain()
+                except:
+                    None
+
+        # Close the socket
+        await writer.aclose()
+        # print("client socket closed")
+        gc.collect()
+
+    def add_task(self, func):
+        if not callable(func):
+            print("WARNING: function for add_task not callable - no brackets please")
+        self.tasks.append(func)        
+    
+    def run(self):
+        asyncio.run(self._run())
+
+    async def _loop(self):
+        while True:
+            for t in self.tasks:
+                t()
+            await asyncio.sleep(0.1)
+
+    def wifi_table_html(self,networks):
+        html = "<table>"
+        html += "<tr><th>SSID</th><th>Signal [dB]</th></tr>"
+
+        for net in networks:
+            ssid = "<a href='#' onclick='waehleSSID(this)'>"+net["ssid"]+"</a>"
+            rssi = net["rssi"]
+
+            html += "<tr>"
+            html += "<td>{}</td>".format(ssid)
+            html += "<td>{}</td>".format(rssi)
+            html += "</tr>"
+
+        html += "</table>"
+        return html
+
+    async def scan_wifi(self):
+        wlan = network.WLAN(network.STA_IF)
+        wlan.active(True)
+
+        await asyncio.sleep(0)  # Scheduler freigeben
+
+        nets = wlan.scan()  # ⚠️ blockiert kurz
+
+        result = []
+        for ssid, bssid, channel, rssi, authmode, hidden in nets:
+            ssid_str = ssid.decode('utf-8', 'ignore')
+            mac = ':'.join('{:02x}'.format(b) for b in bssid)
+
+            result.append({
+                "ssid": ssid_str,
+                "bssid": mac,
+                "rssi": rssi,
+                "channel": channel,
+                "authmode": authmode,
+                "hidden": hidden
+            })
+        print("wifi scan done")
+        self.wifis = result
+
+    async def _run(self):
+        # create loop task for user code
+        asyncio.create_task(self._loop())
+        
+        # create a wifi scan task
+        asyncio.create_task(self.scan_wifi())
+        
+        # Create the server and add task to event loop
+        if self.webserver_infos:
+            print("start webserver..")
+            await asyncio.start_server(self.handle_http_connection, "0.0.0.0", self.webserver_infos["port"])
+            
+        if self.run_captive_portal:
+            asyncio.create_task(self.start_dns_server())
+        await asyncio.Event().wait()
+        
+    def start_ap_off(self):
+        asyncio.run(self._start_ap())
+
+    def _handle_exception(self, loop, context):
+        """ uasyncio v3 only: global exception handler """
+        print('Global exception handler')
+        sys.print_exception(context["exception"])
+        sys.exit()
+
+    def start_ap(self):
+        # get and prepare event loop
+#        loop = asyncio.get_event_loop()
+        # TODO: Warum den exception handler überschreiben?
+#        loop.set_exception_handler(self._handle_exception)
+
+        # start the wifi AP
+        """ setup the access point """
+        self.ap = network.WLAN(network.AP_IF)
+        self.ap.active(True)
+        self.ap.ifconfig((self.__AP_IP, self.__AP_SUBNET, self.__AP_IP, self.__AP_IP))
+        self.ap.config(essid=self.__AP_SSID, authmode=network.AUTH_OPEN)
+        print('Network config:', self.ap.ifconfig())
+
+        self.run_captive_portal = True
+        # Create the server and add task to event loop
+#        server = await asyncio.start_server(self.handle_http_connection, "0.0.0.0", 80)
+#        loop.create_task(server)
+
+        # Start the DNS server task
+#        loop.create_task(self.run_dns_server())
+
+        # Start looping forever
+#        print('Looping forever...')
+#        loop.run_forever()
+        wifi.register_handler("/wlansearch", handle_wlansearch)
+        
+    def start_captive_portal(self):
+        self.run_captive_portal = True
+        self.start_webserver()
+        self.register_handler("/wlansearch", handle_wlansearch)        
+        self.register_handler("/connection_test", handle_connection_test)        
+        self.register_handler("/speichern", handle_speichern)        
+    
+    async def start_dns_server(self):
+        """ function to handle incoming dns requests """
+        udps = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        udps.setblocking(False)
+        udps.bind(('0.0.0.0', 53))
+
+        while True:
+            try:
+                gc.collect()
+                if IS_UASYNCIO_V3:
+                    yield asyncio.core._io_queue.queue_read(udps)
+                else:
+                    yield asyncio.IORead(udps)
+                data, addr = udps.recvfrom(128)
+                print("Incoming DNS request...")
+
+                DNS = DNSQuery(data)
+                udps.sendto(DNS.response(self.__AP_IP), addr)
+
+                print("Replying: {:s} -> {:s}".format(DNS.domain, self.__AP_IP))
+                print(gc.mem_free())
+
+            except Exception as e:
+                print("DNS server error:", e)
+                await asyncio.sleep_ms(3000)
+        udps.close()
+
+def handle_wlansearch(x):
+    print("wlan_search")
+    asyncio.create_task(wifi.scan_wifi())
+    return wifi.handle_404(None)
+
+def handle_speichern(data):
+
+    print("speichern")
+    print(data)
+
+    try:
+        daten = json.loads(data)
+
+        print("SSID:", daten["ssid"])
+        print("PW:", daten["pw"])
+
+        with open("wifi.json", "w") as f:
+            json.dump(daten, f)
+
+        return "WLAN gespeichert!", \
+            "HTTP/1.0 200 OK\r\nContent-Type: text/plain\r\n\r\n"
+
+    except Exception as e:
+
+        print(e)
+
+        return "Fehler beim Speichern", \
+            "HTTP/1.0 500 ERROR\r\nContent-Type: text/plain\r\n\r\n"
+    return wifi.handle_404(None)
+
+def handle_connection_test(x):
+    print("connection test")
+    wifi.connect()
+    print(wifi.isConnected())
+    return wifi.handle_404(None)
+
+def handle_captiveportal(client):
+    content, headers = wifi.get_file("index.html")
+    mac = wifi.ap.config('mac')
+    mac_str = ':'.join('{:02x}'.format(b) for b in mac)
+    content = content.replace("$MAC$", mac_str)
+    content = content.replace("<!--{wlans}-->", wifi.wifi_table_html(wifi.wifis))
+    return content, headers
+    
+led = machine.Pin(LED_BUILTIN, machine.Pin.OUT)
+
+def loop():
+    led.value(not led.value())
+    
+if __name__ == '__main__':
+    use_case = "ap"
+    if use_case == "client":
+        wifi = NIoTHelper(verbose=True)
+        wifi.connect()
+    if use_case == "ap":
+        wifi = NIoTHelper(verbose=True)
+        wifi.start_ap()
+        wifi.start_captive_portal()
+        wifi.register_handler_default(handle_captiveportal)
+        wifi.register_handler("/", handle_captiveportal)
+    try:
+        wifi.add_task(loop)
+        wifi.run()
+    except Exception as e:
+        print(f"ERROR: Exception occured: {e}")
+    wifi.stop_webserver()
+    wifi.disconnect()
+