import network
import time
import urequests

print("Connecting to WiFi", end="")
sta_if = network.WLAN(network.STA_IF)
sta_if.active(True)
sta_if.connect('Wokwi-GUEST', '')
while not sta_if.isconnected():
  print(".", end="")
  time.sleep(0.1)
print(" Connected!")

resp = urequests.get("https://v2.jokeapi.dev/joke/Programming")
joke_dict = resp.json()
print("Here's a joke!")
if 'joke' in joke_dict:
  print(joke_dict['joke'])
else:
  print(joke_dict['setup'])
  print(joke_dict['delivery'])

print()

#HTML + CSS for webpage
html = """<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>MicroPython Web Server</title>
  <style>
    html {
      font-family: Arial;
      display: inline-block;
      margin: 0px auto;
      text-align: center;
    }
    
    h1 {
      font-family: Arial;
      color: #2551cc;
    }
    
    .button1,
    .button2 {
      -webkit-border-radius: 10;
      -moz-border-radius: 10;
      border-radius: 10px;
      font-family: Arial;
      color: #ffffff;
      font-size: 30px;
      padding: 10px 20px 10px 20px;
      text-decoration: none;
      display: inline-block;
      margin: 5px;
    }
    
    .button1 {
      background: #339966;
    }
    
    .button2 {
      background: #993300;
    }
  </style>
</head>

<body>
  <h1>MicroPython Web Server</h1>
  <p>%s</p>
  <p>
    <a href="/GPIO1/on"><button class="button1">GPIO 1 ON</button></a>
    <a href="/GPIO1/off"><button class="button2">GPIO 1 OFF</button></a>
  </p>
  <p>%s</p>
  <p>
    <a href="/GPIO2/on"><button class="button1">GPIO 2 ON</button></a>
    <a href="/GPIO2/off"><button class="button2">GPIO 2 OFF</button></a>
  </p>
</body>
</html>
"""
# Connect to Wi-Fi
cnctWifi()
    
# Set up socket for web server
addr = socket.getaddrinfo('0.0.0.0', 80)[0][-1]
s = socket.socket()
s.setblocking(0)
s.bind(addr)
s.listen(1)

print('listening on', addr)

# Main loop for handling client requests
while True:
    if not wlan.isconnected():
        print("Connection failed. Trying to reconnect")
        wlan.disconnect()
        cnctWifi()
    if wlan.isconnected():
        try:
            cl, addr = s.accept()
            print('client connected from', addr)
            request = cl.recv(1024)
            print(request)

            request = str(request)
            GPIO1_on = request.find('/GPIO1/on')
            GPIO1_off = request.find('/GPIO1/off')
            GPIO2_on = request.find('/GPIO2/on')
            GPIO2_off = request.find('/GPIO2/off')

            if GPIO1_on == 6:
                print("GPIO 1 is on")
                GPIO1.value(1)
                GPIO1_state = "GPIO 1 is ON"

            if GPIO1_off == 6:
                print("GPIO 1 is off")
                GPIO1.value(0)
                GPIO1_state = "GPIO 1 is OFF"

            if GPIO2_on == 6:
                print("GPIO 2 is on")
                GPIO2.value(1)
                GPIO2_state = "GPIO 2 is ON"

            if GPIO2_off == 6:
                print("GPIO 2 is off")
                GPIO2.value(0)
                GPIO2_state = "GPIO 2 is OFF"

            response = html % (GPIO1_state, GPIO2_state)
            cl.send('HTTP/1.0 200 OK\r\nContent-type: text/html\r\n\r\n')
            cl.send(response)
            cl.close()

        except:
            pass
    time.sleep(0.1)

main.py

diagram.json

# using asyncio for non blocking web server

import utime
from RequestParser import RequestParser
import uasyncio
from ResponseBuilder import ResponseBuilder
from WiFiConnection import WiFiConnection
from IoHandler import IoHandler
import random

# connect to WiFi
if not WiFiConnection.start_station_mode(True):
    raise RuntimeError('network connection failed')

# coroutine to handle HTTP request
async def handle_request(reader, writer):
    try:
        # allow other tasks to run while waiting for data
        raw_request = await reader.read(2048)

        request = RequestParser(raw_request)

        response_builder = ResponseBuilder()

        # filter out api request
        if request.url_match("/api"):
            action = request.get_action()
            if action == 'readData':
                # ajax request for data
                pot_value = IoHandler.get_pot_reading()
                temp_value = IoHandler.get_temp_reading()
                cled_states = {
                    'blue': IoHandler.get_blue_led(),
                    'yellow': IoHandler.get_yellow_led(),
                    'green': IoHandler.get_green_led()
                }
                response_obj = {
                    'status': 0,
                    'pot_value': pot_value,
                    'temp_value': temp_value,
                    'cled_states': cled_states,
                    'rgb_leds': IoHandler.rgb_led_colours
                }
                response_builder.set_body_from_dict(response_obj)
            elif action == 'setLedColour':
                # turn on requested coloured led
                # returns json object with led states
                led_colour = request.data()['colour']

                status = 'OK'
                cled_states = {
                    'blue': 0,
                    'yellow': 0,
                    'green': 0
                }
                if led_colour == 'blue':
                    cled_states['blue'] = 1
                elif led_colour == 'yellow':
                    cled_states['yellow'] = 1
                elif led_colour == 'green':
                    cled_states['green'] = 1
                elif led_colour == 'off':
                    # leave leds off
                    pass
                else:
                    status = 'Error'
                IoHandler.set_coloured_leds([cled_states['blue'], cled_states['yellow'], cled_states['green']])
                response_obj = {
                    'status': status,
                    'cled_states': cled_states
                }
                response_builder.set_body_from_dict(response_obj)
            elif action == 'setRgbColour':
                # set RGB colour of first 4 neopixels
                # returns json object with rgb colour
                rgb_red = int(request.data()['red'])
                rgb_green = int(request.data()['green'])
                rgb_blue = int(request.data()['blue'])

                status = 'OK'
                rgb_colours = {
                    'red': rgb_red,
                    'green': rgb_green,
                    'blue': rgb_blue
                }
                IoHandler.set_rgb_leds(rgb_red, rgb_green, rgb_blue)
                response_obj = {
                    'status': status,
                    'rgb_colours': rgb_colours
                }
                response_builder.set_body_from_dict(response_obj)
            else:
                # unknown action
                response_builder.set_status(404)

        # try to serve static file
        else:
            response_builder.serve_static_file(request.url, "/api_index.html")

        # build response message
        response_builder.build_response()
        # send reponse back to client
        writer.write(response_builder.response)
        # allow other tasks to run while data being sent
        await writer.drain()
        await writer.wait_closed()

    except OSError as e:
        print('connection error ' + str(e.errno) + " " + str(e))


# coroutine that will run as the neopixel update task
async def neopixels():

    counter = 0
    while True:
        if counter % 1000 == 0:
            new_colour = (random.randint(0, 1) * 128, random.randint(0, 1) * 128, random.randint(0, 1) * 128)
            for pixel in range(7, 4, -1):
                IoHandler.set_rgb_pixel(pixel, IoHandler.get_rgb_pixel(pixel - 1))
            IoHandler.set_rgb_pixel(4, new_colour)
            IoHandler.show_rgb_leds()
        counter += 1
        # 0 second pause to allow other tasks to run
        await uasyncio.sleep(0)


# main coroutine to boot async tasks
async def main():
    # start web server task
    print('Setting up webserver...')
    server = uasyncio.start_server(handle_request, "0.0.0.0", 80)
    uasyncio.create_task(server)

    # start top 4 neopixel updating task
    uasyncio.create_task(neopixels())

    # main task control loop pulses red led
    counter = 0
    while True:
        if counter % 1000 == 0:
            IoHandler.toggle_red_led()
        counter += 1
        # 0 second pause to allow other tasks to run
        await uasyncio.sleep(0)


# start asyncio task and loop
try:
    # start the main async tasks
    uasyncio.run(main())
finally:
    # reset and start a new event loop for the task scheduler
    uasyncio.new_event_loop()


api_async.py

# full demo with web control panel
# combines multi core and multi tasking

import utime
from RequestParser import RequestParser
import json
import uasyncio
import _thread
from ResponseBuilder import ResponseBuilder
from WiFiConnection import WiFiConnection
from IoHandler import IoHandler
import random

# connect to WiFi
if not WiFiConnection.start_station_mode(True):
    raise RuntimeError('network connection failed')


async def handle_request(reader, writer):
    try:
        raw_request = await reader.read(2048)

        request = RequestParser(raw_request)

        response_builder = ResponseBuilder()

        # filter out api request
        if request.url_match("/api"):
            action = request.get_action()
            if action == 'readPot':
                # ajax request for potentiometer data
                # used in simple test
                pot_value = IoHandler.get_pot_reading()
                # send back reading as simple text
                response_builder.set_body(pot_value)
            elif action == 'readData':
                # ajax request for data
                pot_value = IoHandler.get_pot_reading()
                temp_value = IoHandler.get_temp_reading()
                cled_states = {
                    'blue': IoHandler.get_blue_led(),
                    'yellow': IoHandler.get_yellow_led(),
                    'green': IoHandler.get_green_led()
                }
                response_obj = {
                    'status': 0,
                    'pot_value': pot_value,
                    'temp_value': temp_value,
                    'cled_states': cled_states,
                    'rgb_leds': IoHandler.rgb_led_colours
                }
                response_builder.set_body_from_dict(response_obj)
            elif action == 'setLedColour':
                # turn on requested coloured led
                # returns json object with led states
                led_colour = request.data()['colour']

                status = 'OK'
                cled_states = {
                    'blue': 0,
                    'yellow': 0,
                    'green': 0
                }
                if led_colour == 'blue':
                    cled_states['blue'] = 1
                elif led_colour == 'yellow':
                    cled_states['yellow'] = 1
                elif led_colour == 'green':
                    cled_states['green'] = 1
                elif led_colour == 'off':
                    # leave leds off
                    pass
                else:
                    status = 'Error'
                IoHandler.set_coloured_leds([cled_states['blue'], cled_states['yellow'], cled_states['green']])
                response_obj = {
                    'status': status,
                    'cled_states': cled_states
                }
                response_builder.set_body_from_dict(response_obj)
            elif action == 'setRgbColour':
                # set RGB colour of first 4 neopixels
                # returns json object with led states
                rgb_red = int(request.data()['red'])
                rgb_green = int(request.data()['green'])
                rgb_blue = int(request.data()['blue'])

                status = 'OK'
                rgb_colours = {
                    'red': rgb_red,
                    'green': rgb_green,
                    'blue': rgb_blue
                }
                IoHandler.set_rgb_leds(rgb_red, rgb_green, rgb_blue)
                response_obj = {
                    'status': status,
                    'rgb_colours': rgb_colours
                }
                response_builder.set_body_from_dict(response_obj)
            else:
                # unknown action
                response_builder.set_status(404)

        # try to serve static file
        else:
            response_builder.serve_static_file(request.url, "/api_index.html")

        response_builder.build_response()
        writer.write(response_builder.response)
        await writer.drain()
        await writer.wait_closed()

    except OSError as e:
        print('connection error ' + str(e.errno) + " " + str(e))


async def main():
    print('Setting up webserver...')
    server = uasyncio.start_server(handle_request, "0.0.0.0", 80)
    uasyncio.create_task(server)

    # main async loop on first core
    # just pulse the red led
    counter = 0
    while True:
        if counter % 500 == 0:
            IoHandler.toggle_red_led()
        counter += 1
        await uasyncio.sleep(0)

# run the top 4 neopixel scrolling loop
def neopixels():
    while True:
        new_colour = (random.randint(0, 1) * 128, random.randint(0, 1) * 128, random.randint(0, 1) * 128)
        for pixel in range(7, 4, -1):
            IoHandler.set_rgb_pixel(pixel, IoHandler.get_rgb_pixel(pixel - 1))
        IoHandler.set_rgb_pixel(4, new_colour)
        IoHandler.show_rgb_leds()
        utime.sleep(1)


# start neopixel scrolling loop on second processor
second_thread = _thread.start_new_thread(neopixels, ())

try:
    # start asyncio tasks on first core
    uasyncio.run(main())
finally:
    print("running finally block")
    uasyncio.new_event_loop()


api_full_demo.py

# use web interface to display HTTP Request message

import utime
import network
import socket
import urequests
from NetworkCredentials import NetworkCredentials
from WiFiConnection import WiFiConnection

# connect to WiFi
if not WiFiConnection.start_station_mode(True):
    raise RuntimeError('network connection failed')

# Open socket
addr = socket.getaddrinfo('0.0.0.0', 80)[0][-1]
s = socket.socket()
s.bind(addr)
s.listen(1)
print('listening on', addr)

# main loop
while True:
    client, client_addr = s.accept()
    raw_request = client.recv(1024)
    print("*** byte string ***")
    print()
    print(raw_request)
    print()
    # translate byte string to normal string variable
    decoded_request = raw_request.decode("utf-8")
    print("*** Decoded string ***")
    print()
    print(decoded_request)
    print()

    client.send("HTTP/1.1 200 OK\r\n\r\nRequest Received\r\n")
    client.close()


api_rec_request.py

# use web interface to control an LED

import utime
import network
import socket
import urequests
from NetworkCredentials import NetworkCredentials
from RequestParser import RequestParser
from WiFiConnection import WiFiConnection

# connect to WiFi
if not WiFiConnection.start_station_mode(True):
    raise RuntimeError('network connection failed')

# Open socket
addr = socket.getaddrinfo('0.0.0.0', 80)[0][-1]
s = socket.socket()
s.bind(addr)
s.listen(1)
print('listening on', addr)

# main loop
while True:
    client, client_addr = s.accept()
    raw_request = client.recv(1024)

    print("Request received")
    request = RequestParser(raw_request)
    print(request.method, request.url, request.get_action())
    for key in request.data():
        print(key, request.data()[key])

    client.send("HTTP/1.1 200 OK\r\n\r\nRequest Received\r\n")
    client.close()
    print("Request closed")
    print()


api_request_parser_test.py

# use web interface to control an LED

import utime
import network
import socket
import urequests
from NetworkCredentials import NetworkCredentials
from RequestParser import RequestParser
from WiFiConnection import WiFiConnection

# connect to WiFi
if not WiFiConnection.start_station_mode(True):
    raise RuntimeError('network connection failed')

# Open socket
addr = socket.getaddrinfo('0.0.0.0', 80)[0][-1]
s = socket.socket()
s.bind(addr)
s.listen(1)
print('listening on', addr)

# main loop
while True:
    client, client_addr = s.accept()
    raw_request = client.recv(1024)

    print("Request received")
    request = RequestParser(raw_request)
    print(request.method, request.url, request.get_action())
    for key in request.data():
        print(key, request.data()[key])

    client.send("HTTP/1.1 200 OK\r\n")
    client.send("Content-Type: application/json\r\n")
    client.send("\r\n")
    client.send("{ \"sensor\": 12345, \"reading2\": 98765, \"input\": \"hello\" }\r\n")
    client.close()
    print("Request closed")
    print()


api_request_return.py

# use web interface to control an LED

import utime
import network
import socket
import urequests
from NetworkCredentials import NetworkCredentials
from RequestParser import RequestParser
from ResponseBuilder import ResponseBuilder
from WiFiConnection import WiFiConnection

# connect to WiFi
if not WiFiConnection.start_station_mode(True):
    raise RuntimeError('network connection failed')

# Open socket
addr = socket.getaddrinfo('0.0.0.0', 80)[0][-1]
s = socket.socket()
s.bind(addr)
s.listen(1)
print('listening on', addr)

# main loop
while True:
    client, client_addr = s.accept()
    raw_request = client.recv(1024)

    print("Request received")
    request = RequestParser(raw_request)
    print(request.method, request.url, request.get_action())
    print()

    response_builder = ResponseBuilder()
    # filter out api request
    if request.url_match("/api"):
        action = request.get_action()
        if action == 'readData':
            response_obj = {
                'status': 0,
                'pot_value': 100,
                'temp_value': 25
            }
            response_builder.set_body_from_dict(response_obj)
        else:
            # unknown action
            response_builder.set_status(404)

    # try to serve static file
    else:
        response_builder.serve_static_file(request.url, "/api_index.html")

    response_builder.build_response()
    print(response_builder.response)

    client.send(response_builder.response)
    client.close()
    print("Request closed")
    print()


api_response_builder_test.py

# non blocking web server using second core

import utime
import socket
from RequestParser import RequestParser
import _thread
from ResponseBuilder import ResponseBuilder
from WiFiConnection import WiFiConnection
from IoHandler import IoHandler
import random

# connect to WiFi
if not WiFiConnection.start_station_mode(True):
    raise RuntimeError('network connection failed')

# main function to run web server using blocking code
def web_server():

    # Open socket
    addr = socket.getaddrinfo('0.0.0.0', 80)[0][-1]
    s = socket.socket()
    s.bind(addr)
    s.listen(1)

    print('listening on', addr)

    # main web server loop
    while True:
        cl = False
        try:
            # wait for HTTP request
            cl, addr = s.accept()
            # print('client connected from', addr)
            raw_request = cl.recv(1024)

            # parse HTTP request
            request = RequestParser(raw_request)
            #print(request.method, request.url, request.get_action())

            # Prepare to build HTTP response
            response_builder = ResponseBuilder()

            # filter out api request
            if request.url_match("/api"):
                # read api action requested
                action = request.get_action()
                if action == 'readData':
                    # api request for sensor and data values
                    pot_value = IoHandler.get_pot_reading()
                    temp_value = IoHandler.get_temp_reading()
                    cled_states = {
                        'blue': IoHandler.get_blue_led(),
                        'yellow': IoHandler.get_yellow_led(),
                        'green': IoHandler.get_green_led()
                    }
                    # build the response data package
                    response_obj = {
                        'status': 0,
                        'pot_value': pot_value,
                        'temp_value': temp_value,
                        'cled_states': cled_states,
                        'rgb_leds': IoHandler.rgb_led_colours
                    }
                    response_builder.set_body_from_dict(response_obj)
                elif action == 'setLedColour':
                    # turn on requested coloured led
                    # returns json object with led states

                    # get requested colour
                    led_colour = request.data()['colour']

                    # set default states of leds
                    status = 'OK'
                    cled_states = {
                        'blue': 0,
                        'yellow': 0,
                        'green': 0
                    }
                    # turn on requested led
                    if led_colour == 'blue':
                        cled_states['blue'] = 1
                    elif led_colour == 'yellow':
                        cled_states['yellow'] = 1
                    elif led_colour == 'green':
                        cled_states['green'] = 1
                    elif led_colour == 'off':
                        # leave leds off
                        pass
                    else:
                        status = 'Error'
                    # set led outputs
                    IoHandler.set_coloured_leds([cled_states['blue'], cled_states['yellow'], cled_states['green']])
                    # build the response data package
                    response_obj = {
                        'status': status,
                        'cled_states': cled_states
                    }
                    response_builder.set_body_from_dict(response_obj)
                elif action == 'setRgbColour':
                    # sets the RGB colour of the first 4 neopixels
                    rgb_red = int(request.data()['red'])
                    rgb_green = int(request.data()['green'])
                    rgb_blue = int(request.data()['blue'])

                    # build data for RGB leds
                    status = 'OK'
                    rgb_colours = {
                        'red': rgb_red,
                        'green': rgb_green,
                        'blue': rgb_blue
                    }
                    # set colour of neopixels in output handler
                    IoHandler.set_rgb_leds(rgb_red, rgb_green, rgb_blue)
                    # build the response data package
                    response_obj = {
                        'status': status,
                        'rgb_colours': rgb_colours
                    }
                    response_builder.set_body_from_dict(response_obj)
                else:
                    # unknown action - send back not found error status
                    response_builder.set_status(404)

            # try to serve static file
            else:
                # return file if valid
                response_builder.serve_static_file(request.url, "/api_index.html")

            # build the HTTP response
            response_builder.build_response()
            # return response to client
            sent = cl.write(response_builder.response)
            cl.close()

        except OSError as e:
            cl.close()
            print('connection closed')

# main control loop
def main_loop():
    counter = 0
    while True:
        # use simple loop with counter to get idea of speed of operation
        # 70000 loops per change of state in led
        if counter % 70000 == 0:
            # toggle state of red led
            IoHandler.toggle_red_led()
            # generate new RGB colour
            new_colour = (random.randint(0, 1) * 128, random.randint(0, 1) * 128, random.randint(0, 1) * 128)
            # shift bottom 3 neopixels along one slot
            for pixel in range(7, 4, -1):
                IoHandler.set_rgb_pixel(pixel, IoHandler.get_rgb_pixel(pixel - 1))
            # set bottom neopixel to new colour
            IoHandler.set_rgb_pixel(4, new_colour)
            # send colour data to neopixels
            IoHandler.show_rgb_leds()
            # reset counter
            counter = 0
        counter += 1

# run main control loop on second processor
second_thread = _thread.start_new_thread(main_loop, ())

# main loop on first processor
# NOTE : webs server doesn't seem to run on second core (???)
web_server()


api_threaded.py

# simple web control panel
# combines multi core and multi tasking

import utime
from RequestParser import RequestParser
import json
import uasyncio
import _thread
from ResponseBuilder import ResponseBuilder
from WiFiConnection import WiFiConnection
from IoHandler import IoHandler
import random

# connect to WiFi
if not WiFiConnection.start_station_mode(True):
    raise RuntimeError('network connection failed')


async def handle_request(reader, writer):
    try:
        raw_request = await reader.read(2048)

        request = RequestParser(raw_request)

        response_builder = ResponseBuilder()

        # filter out api request
        if request.url_match("/api"):
            action = request.get_action()
            if action == 'readPot':
                # ajax request for potentiometer data
                # used in simple test
                pot_value = IoHandler.get_pot_reading()
                # send back reading as simple text
                response_builder.set_body(str(pot_value))
            elif action == 'setLedColour':
                # turn on requested coloured led
                # returns json object with led states
                led_colour = request.data()['colour']

                status = 'OK'
                cled_states = {
                    'blue': 0,
                    'yellow': 0,
                    'green': 0
                }
                if led_colour == 'blue':
                    cled_states['blue'] = 1
                elif led_colour == 'yellow':
                    cled_states['yellow'] = 1
                elif led_colour == 'green':
                    cled_states['green'] = 1
                elif led_colour == 'off':
                    # leave leds off
                    pass
                else:
                    status = 'Error'
                IoHandler.set_coloured_leds([cled_states['blue'], cled_states['yellow'], cled_states['green']])
                response_obj = {
                    'status': status,
                    'cled_states': cled_states
                }
                response_builder.set_body_from_dict(response_obj)

            else:
                # unknown action
                response_builder.set_status(404)

        # try to serve static file
        else:
            response_builder.serve_static_file(request.url, "/cp_simple.html")

        response_builder.build_response()
        writer.write(response_builder.response)
        await writer.drain()
        await writer.wait_closed()

    except OSError as e:
        print('connection error ' + str(e.errno) + " " + str(e))


async def main():
    print('Setting up webserver...')
    server = uasyncio.start_server(handle_request, "0.0.0.0", 80)
    uasyncio.create_task(server)

    # main async loop on first core
    # just pulse the red led
    counter = 0
    while True:
        if counter % 500 == 0:
            IoHandler.toggle_red_led()
        counter += 1
        await uasyncio.sleep(0)

# run the top 4 neopixel scrolling loop
def neopixels():
    while True:
        new_colour = (random.randint(0, 1) * 128, random.randint(0, 1) * 128, random.randint(0, 1) * 128)
        for pixel in range(7, 4, -1):
            IoHandler.set_rgb_pixel(pixel, IoHandler.get_rgb_pixel(pixel - 1))
        IoHandler.set_rgb_pixel(4, new_colour)
        IoHandler.show_rgb_leds()
        utime.sleep(1)


# start neopixel scrolling loop on second processor
second_thread = _thread.start_new_thread(neopixels, ())

try:
    # start asyncio tasks on first core
    uasyncio.run(main())
finally:
    print("running finally block")
    uasyncio.new_event_loop()


cp_simple.py

# use web service to get date and time information

import utime
import network
import urequests
from NetworkCredentials import NetworkCredentials

ssid = NetworkCredentials.ssid
password = NetworkCredentials.password

# set WiFi to station interface
wlan = network.WLAN(network.STA_IF)
# activate the network interface
wlan.active(True)
# connect to wifi network
wlan.connect(ssid, password)

max_wait = 10
# wait for connection
while max_wait > 0:
    """
        0   STAT_IDLE -- no connection and no activity,
        1   STAT_CONNECTING -- connecting in progress,
        -3  STAT_WRONG_PASSWORD -- failed due to incorrect password,
        -2  STAT_NO_AP_FOUND -- failed because no access point replied,
        -1  STAT_CONNECT_FAIL -- failed due to other problems,
        3   STAT_GOT_IP -- connection successful.
    """
    if wlan.status() < 0 or wlan.status() >= 3:
        # connection successful
        break
    max_wait -= 1
    print('waiting for connection... ' + str(max_wait))
    utime.sleep(1)

# check connection
if wlan.status() != 3:
    # No connection
    raise RuntimeError('network connection failed')
else:
    # connection successful
    print('wlan connected')
    status = wlan.ifconfig()
    print('ip = ' + status[0])

# main loop
while True:
    start = utime.ticks_ms()
    response = urequests.get('https://timeapi.io/api/Time/current/zone?timeZone=Europe/London')
    print('request took ' + str(utime.ticks_ms() - start) + "ms")
    print(response.content)
    print(response.json()['dateTime'])
    utime.sleep(5)


gettime.py

GET /page.html?action=setled&colour=blue HTTP/1.1\r\nUser-Agent: PostmanRuntime/7.30.0\r\nAccep
t: */*\r\nCache-Control: no-cache\r\nPostman-Token: ecce0bea-5bf6-4cbc-9218-7c2c
d25b9da3\r\nHost: 192.168.1.246\r\nAccept-Encoding: gzip, deflate, br\r\nConnect
ion: keep-alive\r\n\r\n


GET /page.html?action=setled&colour=blue HTTP/1.1
User-Agent: PostmanRuntime/7.30.0
Accept: */*
Cache-Control: no-cache
Postman-Token: ecce0bea-5bf6-4cbc-9218-7c2cd25b9da3
Host: 192.168.1.246
Accept-Encoding: gzip, deflate, br
Connection: keep-alive



http get query string.txt

POST /api HTTP/1.1\r\nUser-Agent: PostmanRuntime/7.30.0\r\nAccept: */*\r\nCach
e-Control: no-cache\r\nPostman-Token: 42f8113f-acec-46db-abb1-a2840e5011d3\r\nHo
st: 192.168.1.246\r\nAccept-Encoding: gzip, deflate, br\r\nConnection: keep-aliv
e\r\nContent-Type: multipart/form-data; boundary=--------------------------83399
4107218074559113347\r\nContent-Length: 429\r\n\r\n----------------------------83
3994107218074559113347\r\nContent-Disposition: form-data; name="action"\r\n\r\ns
etLedColour\r\n----------------------------833994107218074559113347\r\nContent-D
isposition: form-data; name="colour"\r\n\r\ngreen\r\n---------------------------
-833994107218074559113347\r\nContent-Disposition: form-data; name="text"\r\n\r\n
this is line1\nthis is line 2\nthis is line 3\r\n----------------------------833
994107218074559113347--\r\n


POST /api HTTP/1.1
User-Agent: PostmanRuntime/7.30.0
Accept: */*
Cache-Control: no-cache
Postman-Token: 42f8113f-acec-46db-abb1-a2840e5011d3
Host: 192.168.1.246
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Content-Type: multipart/form-data; boundary=--------------------------8339941072
18074559113347
Content-Length: 429

----------------------------833994107218074559113347
Content-Disposition: form-data; name="action"

setLedColour
----------------------------833994107218074559113347
Content-Disposition: form-data; name="colour"

green
----------------------------833994107218074559113347
Content-Disposition: form-data; name="text"

this is line1
this is line 2
this is line 3
----------------------------833994107218074559113347--


http post form data.txt

POST /api HTTP/1.1\r\nUser-Agent: PostmanRuntime/7.30.0\r\nAccept: */*\r\nCach
e-Control: no-cache\r\nPostman-Token: 1afeaab6-220f-4539-84af-227c9960006d\r\nHo
st: 192.168.1.246\r\nAccept-Encoding: gzip, deflate, br\r\nConnection: keep-aliv
e\r\nContent-Type: application/x-www-form-urlencoded\r\nContent-Length: 102\r\n\
r\naction=setLedColour&colour=yellow&text=this%20is%20line1%0Athis%20is%20line%2
02%0Athis%20is%20line%203

POST /api HTTP/1.1
User-Agent: PostmanRuntime/7.30.0
Accept: */*
Cache-Control: no-cache
Postman-Token: 1afeaab6-220f-4539-84af-227c9960006d
Host: 192.168.1.246
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Content-Type: application/x-www-form-urlencoded
Content-Length: 102

action=setLedColour&colour=yellow&text=this%20is%20line1%0Athis%20is%20line%202%
0Athis%20is%20line%203


http post form urlencoded.txt

POST /api HTTP/1.1\r\nContent-Type: application/javascript\r\nUser-Agent: Post
manRuntime/7.30.0\r\nAccept: */*\r\nCache-Control: no-cache\r\nPostman-Token: 91
2ebdcc-bac5-4b2f-b913-b4706e509cd0\r\nHost: 192.168.1.246\r\nAccept-Encoding: gz
ip, deflate, br\r\nConnection: keep-alive\r\nContent-Length: 123\r\n\r\n{\r\n
 "action" : "setLedColour",\r\n    "colour" : "blue",\r\n    "text" : "this is l
ine 1\\nthis is line 2\\nthis is line 3"\r\n}


POST /api HTTP/1.1
Content-Type: application/javascript
User-Agent: PostmanRuntime/7.30.0
Accept: */*
Cache-Control: no-cache
Postman-Token: 912ebdcc-bac5-4b2f-b913-b4706e509cd0
Host: 192.168.1.246
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Content-Length: 123

{
    "action" : "setLedColour",
    "colour" : "blue",
    "text" : "this is line 1\nthis is line 2\nthis is line 3"
}


http post json.txt

HTTP/1.1 200 OK
Server: nginx/1.18.0 (Ubuntu)
Date: Fri, 03 Feb 2023 15:42:46 GMT
Content-Type: application/json; charset=utf-8
Transfer-Encoding: chunked
Connection: keep-alive
Content-Encoding: br
Vary: Accept-Encoding

{"year":2023,"month":2,"day":3,"hour":15,"minute":42,"seconds":46,
"milliSeconds":73,"dateTime":"2023-02-03T15:42:46.073709",
"date":"02/03/2023","time":"15:42","timeZone":"Europe/London",
"dayOfWeek":"Friday","dstActive":false}

http response.txt

# class to handle the IO for the demo setup
from machine import Pin, ADC
import neopixel
import time


class IoHandler:
    # create array of neopixels
    rgb_leds = neopixel.NeoPixel(Pin(15), 8)
    # create list of RGB tuples to control led states
    rgb_led_colours = [(0, 0, 0)] * 8

    # red led
    led = Pin(28, Pin.OUT)
    led_state = 0

    # potentiometer
    pot = ADC(26)
    pot_value = 0

    # temp sensor
    temp = ADC(4)
    temp_value = 0

    # coloured leds
    blue_led = Pin(16, Pin.OUT)
    yellow_led = Pin(17, Pin.OUT)
    green_led = Pin(18, Pin.OUT)
    coloured_states = [0, 0, 0]

    def __init__(self):
        # get everything into a starting state
        self.__class__.show_red_led()
        self.__class__.get_pot_reading()
        self.__class__.show_coloured_leds()
        self.__class__.clear_rgb_leds()

    # output, setters and getters for coloured leds
    @classmethod
    def show_coloured_leds(cls):
        cls.blue_led.value(cls.coloured_states[0])
        cls.yellow_led.value(cls.coloured_states[1])
        cls.green_led.value(cls.coloured_states[2])

    @classmethod
    def set_coloured_leds(cls, states):
        try:
            cls.set_blue_led(states[0])
            cls.set_yellow_led(states[1])
            cls.set_green_led(states[2])
        except:
            pass
        cls.show_coloured_leds()

    @classmethod
    def set_blue_led(cls, state):
        cls.coloured_states[0] = 0 if state == 0 else 1

    @classmethod
    def set_yellow_led(cls, state):
        cls.coloured_states[1] = 0 if state == 0 else 1

    @classmethod
    def set_green_led(cls, state):
        cls.coloured_states[2] = 0 if state == 0 else 1

    @classmethod
    def get_blue_led(cls):
        return 0 if cls.coloured_states[0] == 0 else 1

    @classmethod
    def get_yellow_led(cls):
        return 0 if cls.coloured_states[1] == 0 else 1

    @classmethod
    def get_green_led(cls):
        return 0 if cls.coloured_states[2] == 0 else 1

    # red led handlers
    @classmethod
    def show_red_led(cls):
        cls.led.value(cls.led_state)

    @classmethod
    def toggle_red_led(cls):
        cls.led_state = 0 if cls.led_state == 1 else 1
        cls.show_red_led()

    @classmethod
    def get_red_led(cls):
        return 0 if cls.led_state == 0 else 1

    @classmethod
    def set_red_led(cls, state):
        cls.led_state = 0 if state == 0 else 1
        cls.show_red_led()

    # potentiometer handler
    @classmethod
    def get_pot_reading(cls):
        cls.pot_value = cls.pot.read_u16()
        return cls.pot_value

    # temp handler
    @classmethod
    def get_temp_reading(cls):
        temp_voltage = cls.temp.read_u16() * (3.3 / 65535)
        cls.temp_value = 27 - (temp_voltage - 0.706) / 0.001721
        return cls.temp_value

    # rgb leds
    @classmethod
    def set_rgb_pixel(cls, pixel, colour):
        cls.rgb_leds[pixel] = colour
        cls.rgb_led_colours[pixel] = colour

    @classmethod
    def get_rgb_pixel(cls, pixel):
        return cls.rgb_led_colours[pixel]

    @classmethod
    def set_rgb_leds(cls, rgb_red, rgb_green, rgb_blue):
        for n in range(4):
            cls.set_rgb_pixel(n, (rgb_red, rgb_green, rgb_blue))
        cls.show_rgb_leds()

    @classmethod
    def show_rgb_leds(cls):
        cls.rgb_leds.write()

    @classmethod
    def clear_rgb_leds(cls):
        for n in range(8):
            cls.set_rgb_pixel(n, (0, 0, 0))
        cls.show_rgb_leds()


IoHandler.py

class NetworkCredentials:
    ssid = 'xxx'
    password = 'xxx'


NetworkCredentials.py

# micropython-web-control-panel
Create a web based control panel for your Micropython project. Web server, parallel processing and web API.
Please have a look at the video tutorials on my YouTube channel.
https://www.youtube.com/playlist?list=PLvOT6zBnJyYGLmvrJeYzRYwBFa44SVnLZ


README.md

# Request object to handle http requests
import re
import json

class RequestParser:

    def __init__(self, raw_request):
        # make sure raw_request is a str
        if isinstance(raw_request, bytes):
            raw_request = raw_request.decode("utf-8")
        self.method = ""
        self.full_url = ""
        self.url = ""
        self.query_string = ""
        self.protocol = ""
        self.headers = {}
        self.query_params = {}
        self.post_data = {}
        self.boundary = False
        self.content = []

        self.parse_request(raw_request)

    def parse_request(self, raw_request):

        if len(raw_request) > 0:
            # some data supplied
            # check end of line chars
            eol_char = '\r\n'  # default as per HTTP protocol
            if raw_request.find('\r\n') == -1:
                # some systems may use single char newline
                eol_char = '\n'
            # split request into individual lines
            request_lines = raw_request.split(eol_char)

            # first line holds request verb, url and protocol
            self.parse_first_line(request_lines[0])

            if len(request_lines) > 1:
                # next section holds header information - section ends with blank line
                # parse header lines
                line_num = 1  # skip first line
                while line_num < len(request_lines) and len(request_lines[line_num]) != 0:
                    header, value = self.parse_header_line(request_lines[line_num])
                    if header:
                        self.headers[header] = value
                    line_num += 1

                # check if any lines left for content
                # headers must be followed by blank line, then content lines
                line_num += 1  # skip blank line (if there)
                if line_num > (len(request_lines) - 1):
                    # no lines left
                    return

                # content is any remaining lines
                self.content = request_lines[line_num:]

                # handle content depending on Content-Type header
                content_type = self.get_header_value('Content-Type')
                if content_type:
                    # filter out form submissions
                    if content_type.find('multipart/form-data') != -1:
                        # data is in multipart/form-data format
                        # get boundary string
                        content_type_parts = content_type.split('boundary=')
                        if len(content_type_parts) == 2:
                            # found boundary
                            self.boundary = content_type_parts[1]
                        else:
                            # boundary not found - error
                            self.boundary = False
                            return
                        self.parse_content_form_data()

                    elif content_type.find('application/x-www-form-urlencoded') != -1:
                        # data is in application/x-www-form-urlencoded format
                        self.parse_content_form_url_encoded()

                    elif content_type.find('application/json') != -1 \
                            or content_type.find('application/javascript') != -1:
                        # data is in application/json format
                        self.parse_json_body()

                    else:
                        # treat as text
                        # leave content lines as list
                        pass
                else:
                    # no content type - ignore
                    pass

        else:
            return

    def get_header_value(self, header_name):
        if header_name in self.headers:
            return self.headers[header_name]
        else:
            return False

    def parse_first_line(self, first_line):
        # split line on spaces to get words
        line_parts = first_line.split()
        # should be three parts
        if len(line_parts) == 3:
            self.method = line_parts[0]
            self.full_url = line_parts[1]
            # try to split the full_url
            url_parts = line_parts[1].split('?', 1)
            self.url = url_parts[0]
            # is there a query string?
            if len(url_parts) > 1:
                self.query_string = url_parts[1]
            self.protocol = line_parts[2]
            # decode query string if it's there
            if len(self.query_string) > 0:
                self.query_params = self.decode_query_string(self.query_string)
        else:
            # something is wrong - flag it
            self.method = "ERROR"

    def parse_header_line(self, header_line):
        # split header line on : to get name and value
        line_parts = header_line.split(':')
        # should be two parts
        if len(line_parts) != 2:
            return (False, False)
        else:
            # strip leading and trailing spaces
            header_name = line_parts[0].strip()
            header_value = line_parts[1].strip()
            # return as tuple
            return (header_name, header_value)

    def decode_query_string(self, query_string):
        # split query string on &
        # this gives key=value list
        param_strings = query_string.split('&')
        params = {}
        for param_string in param_strings:
            try:
                # correctly formatted value
                # splits into 2 on =
                key, value = param_string.split('=')
                # values may be url encoded
                # unquote decodes special characters (well just a couple!)
                value = self.unquote(value)
            except:
                # no value specified
                key = param_string
                value = False

            # save param in dictionary
            params[key] = value
        return params

    def parse_content_form_data(self):
        # check if boundary found
        if not self.boundary:
            return
        line_num = 0  # first line in content
        while line_num < len(self.content):
            # find next section
            # will start with line --boundary
            while line_num < len(self.content) and self.content[line_num].find(self.boundary) == -1:
                line_num += 1
            # check end of lines
            if line_num >= len(self.content) - 1:
                # past end
                return
            # found boundary line
            # skip boundary line
            line_num += 1
            # section headers - find Content-Disposition or end of headers
            while line_num < len(self.content) and self.content[line_num].find("Content-Disposition:") == -1 \
                    and len(self.content[line_num]) != 0:
                line_num += 1
            # check end of lines
            if line_num >= len(self.content) - 1:
                # past end
                return
            # line num points at content-disposition line
            # extract name of variable - note does not handle arrays!
            # uses regular expression - learn how to use these!!
            match = re.search(r'name=\"([^\"]+)', self.content[line_num])
            # move pointer to next line
            line_num += 1
            try:
                # check if regular expression caught a variable
                var_name = match.group(1)
            except:
                continue  # skip this section
            # skip rest of section headers to find blank line
            while line_num < len(self.content) and len(self.content[line_num]) != 0:
                line_num += 1
            # skip blank line
            line_num += 1
            # check end of lines
            if line_num > len(self.content) - 1:
                # past last line
                return
            # line_num points at first line of data
            # read lines until we find start of next section
            # will start with line --boundary
            var_value = ""
            while line_num < len(self.content) and self.content[line_num].find(self.boundary) == -1:
                # build value from data lines
                if len(var_value) > 0:
                    var_value += "\n"
                var_value += self.content[line_num]
                line_num += 1
            # save data value
            self.post_data[var_name] = var_value
            # process next section

    def parse_content_form_url_encoded(self):
        # first line of content will contain data
        self.post_data = self.decode_query_string(self.content[0])

    def parse_json_body(self):
        # content contains json string
        line_num = 0  # first line in content
        json_string = ""
        # build json string from content lines
        while line_num < len(self.content):
            if len(json_string) > 0:
                json_string += "\n"
            json_string += self.content[line_num]
            line_num += 1
        # parse json string to dictionary
        self.post_data = json.loads(json_string)

    def url_match(self, test_url):
        # make sure string is cleaned and has leading /
        test_url = '/' + str(test_url).strip().strip('/')
        # check for / route
        if test_url == '/':
            if self.url == '/':
                return True
            else:
                return False
        if self.url == test_url:
            return True
        else:
            return False

    def unquote(self, url_string):
        # replaces %20 with space
        # %0A with newline
        url_string = re.sub(r'%20', ' ', url_string)
        url_string = re.sub(r'%0A', '\n', url_string)
        return url_string

    # return relevant data set depending on request method
    def data(self):
        if self.method == 'POST':
            return self.post_data
        elif self.method == 'GET':
            return self.query_params
        else:
            return False

    # return the request action
    # gets the value from the request method data section
    def get_action(self):
        if self.method == 'POST':
            if 'action' in self.post_data:
                return self.post_data['action']
            else:
                return False
        elif self.method == 'GET':
            if 'action' in self.query_params:
                return self.query_params['action']
            else:
                return False
        else:
            return False


RequestParser.py

# Class to build an HTTP response

import json
import os


class ResponseBuilder:
    protocol = "HTTP/1.1"
    server = "Pi Pico Micropython"

    def __init__(self):
        # set default values
        self.status = 200
        self.content_type = "text/html"
        self.body = ""
        self.response = ""

    def set_content_type(self, content_type):
        self.content_type = content_type

    def set_status(self, status):
        self.status = status

    def set_body(self, body):
        self.body = body

    def serve_static_file(self, req_filename, default_file="/index.html"):
        # make sure filename starts with /
        if req_filename.find("/") == -1:
            req_filename = "/" + req_filename
        # remove query string
        if req_filename.find("?") != -1:
            req_filename, qs = req_filename.split("?", 1)
        # remove bookmark
        if req_filename.find("#") != -1:
            req_filename, qs = req_filename.split("#", 1)
        # filter out default file
        if req_filename == "/":
            req_filename = default_file
        # break filename into path and filename
        path, filename = req_filename.rsplit("/", 1)
        # reinstate root path for listdir
        if len(path) == 0:
            path = "/"
        # print(path, filename)
        # make sure working from root directory
        os.chdir("/")
        # get directory listing
        dir_contents = os.listdir(path)
        # check if file exists
        if filename in dir_contents:
            # file found
            # get file type
            name, file_type = filename.rsplit(".", 1)
            if file_type == "htm" or file_type == "html":
                self.content_type = "text/html"
            elif file_type == "js":
                self.content_type = "text/javascript"
            elif file_type == "css":
                self.content_type = "text/css"
            else:
                # let browser work it out
                self.content_type = "text/html"
            # load content
            file = open(path + "/" + filename)
            self.set_body(file.read())
            self.set_status(200)
        else:
            # file not found
            self.set_status(404)

    def set_body_from_dict(self, dictionary):
        self.body = json.dumps(dictionary)
        self.set_content_type("application/json")

    def build_response(self):
        self.response = ""
        # status line
        self.response += self.__class__.protocol \
                         + " " \
                         + str(self.status) \
                         + " " \
                         + self.get_status_message() \
                         + "\r\n"
        # Headers
        self.response += "Server: " + self.server + "\r\n"
        self.response += "Content-Type: " + self.content_type + "\r\n"
        self.response += "Content-Length: " + str(len(self.body)) + "\r\n"
        self.response += "Connection: Closed\r\n"
        self.response += "\r\n"
        # body
        if len(self.body) > 0:
            self.response += self.body

    def get_status_message(self):
        status_messages = {
            200: "OK",
            400: "Bad Request",
            403: "Forbidden",
            404: "Not Found"
        }
        if self.status in status_messages:
            return status_messages[self.status]
        else:
            return "Invalid Status"


ResponseBuilder.py

# class to handle WiFi conenction
import utime
import network
from NetworkCredentials import NetworkCredentials


class WiFiConnection:
    # class level vars accessible to all code
    status = network.STAT_IDLE
    ip = ""
    subnet_mask = ""
    gateway = ""
    dns_server = ""
    wlan = None

    def __init__(self):
        pass

    @classmethod
    def start_station_mode(cls, print_progress=False):
        # set WiFi to station interface
        cls.wlan = network.WLAN(network.STA_IF)
        # activate the network interface
        cls.wlan.active(True)
        # connect to wifi network
        cls.wlan.connect(NetworkCredentials.ssid, NetworkCredentials.password)
        cls.status = network.STAT_CONNECTING
        if print_progress:
            print("Connecting to Wi-Fi - please wait")
        max_wait = 20
        # wait for connection - poll every 0.5 secs
        while max_wait > 0:
            """
                0   STAT_IDLE -- no connection and no activity,
                1   STAT_CONNECTING -- connecting in progress,
                -3  STAT_WRONG_PASSWORD -- failed due to incorrect password,
                -2  STAT_NO_AP_FOUND -- failed because no access point replied,
                -1  STAT_CONNECT_FAIL -- failed due to other problems,
                3   STAT_GOT_IP -- connection successful.
            """
            if cls.wlan.status() < 0 or cls.wlan.status() >= 3:
                # connection attempt finished
                break
            max_wait -= 1
            utime.sleep(0.5)

        # check connection
        cls.status = cls.wlan.status()
        if cls.wlan.status() != 3:
            # No connection
            if print_progress:
                print("Connection Failed")
            return False
        else:
            # connection successful
            config = cls.wlan.ifconfig()
            cls.ip = config[0]
            cls.subnet_mask = config[1]
            cls.gateway = config[2]
            cls.dns_server = config[3]
            if print_progress:
                print('ip = ' + str(cls.ip))
            return True
