AI lesopdrachten toevoegen

Les opdrachten/AI opdrachten/FA2/practicum_2_algoritmiek_student.py

@@ -0,0 +1,244 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Oriëntatie op AI
+
+Practicum 2: algoritmiek
+
+(c) 2019 Hogeschool Utrecht
+Tijmen Muller (tijmen.muller@hu.nl)
+
+
+Opdracht: beantwoord onderstaande vragen en werk onderstaande functies uit.
+
+Je kunt je functies testen met het gegeven raamwerk door het bestand
+uit te voeren (of met behulp van pytest, als je weet hoe dat werkt).
+Lever je werk in op Canvas als alle tests slagen.
+
+Let op! Het is niet toegestaan om bestaande modules te importeren en te
+        gebruiken, zoals `math` en `statistics`.
+"""
+
+# Vul hier je naam, klas en studentnummer in
+naam = "Taha Genc"
+klas = "TICT-PV-SG5-20"
+studentnummer = 1788230
+
+"""
+1.  Sorteeralgoritme
+
+    Hieronder staat de pseudocode van een sorteeralgoritme:
+    1. Startend vanaf het begin van een lijst,
+       vergelijk elk element met zijn volgende buur.
+    2. Als het element groter is dan zijn volgende buur,
+       verwissel ze van plaats.
+    3. Doorloop zo de lijst tot het eind.
+    4. Als er verwisselingen zijn geweest bij stap 2., ga naar stap 1.
+
+    1a. Handmatig toepassen
+        Gegeven is de lijst l = [ 4, 3, 1, 2 ]. Geef de waardes die deze
+        lijst aanneemt bij álle tussenstappen bij toepassing van
+        bovenstaand sorteeralgoritme.
+
+        0 = [ 4, 3, 1, 2 ]
+        1 = [ 3, 4, 1, 2 ]
+        2 = [ 3, 1, 4, 2 ]
+        3 = [ 1, 3, 4, 2 ]
+        4 = [ 1, 3, 2, 4 ]
+        5 = [ 1, 2, 3, 4 ]
+
+    1b. Implementatie
+        Implementeer het sorteeralgoritme in Python in een functie
+        hieronder genaamd my_sort(lst).
+
+    1c. Best en worst case
+        -   Stel je hebt een lijst met de waarden 1, 2 en 3. Bij welke
+            volgorde van de waarden in de lijst is het sorteeralgoritme
+            het snelste klaar (best-case scenario)?
+            Hoeveel vergelijkingen (zoals beschreven in stap 1. van de
+            pseudocode) zijn nodig geweest?
+
+            bij een array van [1,2,3] zijn er minimaal 2 vergelijkingen nodig
+
+
+        -   Bij welke volgorde van de waarden in de lijst is het
+            sorteeralgoritme het minst snel klaar (worst-case scenario)?
+            Hoeveel vergelijkingen zijn nodig geweest?
+
+            bij een array van [3,2,1] zijn er maximaal 3 vergelijkingen nodig
+
+
+        -   Stel je hebt een lijst met de waarden 1 tot en met 4.
+            Wat is nu het best-case scenario?      [1,2,3,4]
+            Hoeveel vergelijkingen zijn er nodig?  3 vergelijkingen
+            En wat is nu het worst-case scenario?  [4,3,2,1]
+            Hoeveel vergelijkingen zijn er nodig?  7 vergelijkingen
+
+
+
+        -   Stel je hebt een lijst met de waarden 1 tot en met n
+            (je weet nu dus niet precies hoeveel waarden er in de lijst
+            zitten, het zijn er 'n').
+            Wat is nu het best-case scenario?      een gesorteerde lijst of n=1
+            Hoeveel vergelijkingen zijn er nodig?  n-1
+            En wat is nu het worst-case scenario?  gesorteerd in de verkeerde richting
+            Hoeveel vergelijkingen zijn er nodig?  1/2 * n + 1
+
+
+2.  Recursie
+
+    2a. Lineair zoeken
+        Implementeer het lineair zoekalgoritme in Python op een
+        *recursieve* manier. Gebruik hiervoor de functie genaamd
+        linear_search_recursive(lst, target).
+
+    2b. Binair zoeken
+        Implementeer het binair zoekalgoritme in Python op een
+        *recursieve* manier. Gebruik hiervoor de functie genaamd
+        binary_search_recursive(lst, target).
+"""
+
+
+def my_sort(lst):
+    """
+    Sorteer gegeven lijst lst volgens het algoritme zoals beschreven in de pseudocode bij 1. hierboven.
+    Zorg dat de gegeven lijst niet verandert, maar geef een nieuwe, gesorteerde variant van de lijst terug.
+    """
+    lst_sorted = lst.copy()  # kopie maken van ingegeven list
+
+    for _ in range(len(lst) - 1):
+        for x in range(len(lst)-1):
+            if lst_sorted[x] > lst_sorted[x+1]:
+                lst_sorted[x], lst_sorted[x+1] = lst_sorted[x+1], lst_sorted[x]
+
+
+
+
+    return lst_sorted
+
+
+def linear_search_recursive(lst, target):
+    """
+    Zoek een element target in gegeven lijst lst door middel van recursief lineair zoeken.
+    De inhoud van de gegeven lijst verandert niet.
+
+    Args:
+        lst    -- de lijst waarin gezocht wordt (list)
+        target -- het element dat gezocht wordt
+
+    Returns:
+        of het element in de lijst voorkomt (bool)
+    """
+    if len(lst) == 0:  # als lijst geen entries meer bevat false returnen
+        return False
+    elif lst[0] == target:  # als positie 0 de target bevat true returnen
+        return True
+    else:
+        return linear_search_recursive(lst[1:], target)  # zichzelf starten min de eerste entry in de list
+
+
+
+
+def binary_search_recursive(lst, target):
+    """
+    Zoek een element target in gegeven lijst door middel van recursief binair zoeken.
+    De inhoud van de gegeven lijst verandert niet.
+
+    Args:
+        lst    -- de (reeds gesorteerde) lijst waarin gezocht wordt (list)
+        target -- het element dat gezocht wordt
+
+    Returns:
+        of het element in de lijst voorkomt (bool)
+    """
+
+    laag = 0  # laagste positie
+    hoog = len(lst) - 1 # hoogste positie
+    cur = (len(lst) - 1) // 2  # middenste index berekenen afrondend naar beneden
+
+    if target == lst[cur]:  # als cursor positie al de target is true returnen
+        return True
+
+    if hoog > laag:  # als de lijst meer dan 1 item bevat, anders bevat de lijst 1 item die niet de target is
+        if lst[cur] > target:  # als target lager ligt dan de cursor
+            return binary_search_recursive(lst[0:cur+1], target)  # functie oproepen met de lijst lager dan de cursor
+        elif lst[cur] < target:  # als de target hoger ligt dan de cursor
+            return binary_search_recursive(lst[cur+1:hoog+1], target)  # functie oproepen met de lijst hoger dan de cursor
+
+    return False
+
+
+
+
+
+"""
+==========================[ HU TESTRAAMWERK ]================================
+Onderstaand staan de tests voor je code -- hieronder mag je niets wijzigen!
+Je kunt je code testen door deze file te runnen of met behulp van pytest.
+"""
+import random
+
+
+def test_id():
+    assert naam != "", "Je moet je naam nog invullen!"
+    assert studentnummer != -1, "Je moet je studentnummer nog invullen!"
+    assert klas != "", "Je moet je klas nog invullen!"
+
+
+def test_my_sort():
+    lst_test = random.choices(range(-99, 100), k=6)
+    lst_copy = lst_test.copy()
+    lst_output = my_sort(lst_test)
+
+    assert lst_copy == lst_test, "Fout: my_sort(lst) verandert de inhoud van lijst lst"
+    assert lst_output == sorted(lst_test), \
+        f"Fout: my_sort({lst_test}) geeft {lst_output} in plaats van {sorted(lst_test)}"
+
+
+def test_linear_search_recursive():
+    for _ in range(99):  # ik heb deze waarde van 10 naar 99 aangepast zodat ik iteratie bugs kan vinden
+        lst_test = random.sample(range(20), 6)
+        target = random.randrange(20)
+        found = target in lst_test
+        lst_copy = lst_test.copy()
+
+        outcome = linear_search_recursive(lst_test, target)
+        assert lst_copy == lst_test, "Fout: linear_search_recursive(lst, target) verandert de inhoud van lijst lst"
+        assert outcome == found, \
+            f"Fout: linear_search_recursive({lst_test}, {target}) geeft {outcome} in plaats van {found}"
+
+
+def test_binary_search_recursive():
+    for _ in range(99):  # ik heb deze waarde van 10 naar 99 aangepast zodat ik iteratie bugs kan vinden
+        lst_test = sorted(random.sample(range(20), 6))
+        target = random.randrange(20)
+        found = target in lst_test
+        lst_copy = lst_test.copy()
+
+        outcome = binary_search_recursive(lst_test, target)
+        assert outcome == found, \
+            f"Fout: binary_search_recursive({lst_test}, {target}) geeft {outcome} in plaats van {found}"
+        assert lst_copy == lst_test, "Fout: binary_search_recursive(lst, target) verandert de inhoud van lijst lst"
+
+
+if __name__ == '__main__':
+    try:
+        print("\x1b[0;32m")
+        test_id()
+
+        test_my_sort()
+        print("Je functie my_sort() werkt goed!")
+
+        test_linear_search_recursive()
+        print("Je functie linear_search_recursive() werkt goed!")
+
+        test_binary_search_recursive()
+        print("Je functie binary_search_recursive() werkt goed!")
+
+        print("\nGefeliciteerd, alles lijkt te werken!")
+        print("Lever je werk nu in op Canvas...")
+
+    except AssertionError as ae:
+        print("\x1b[0;31m")
+        print(ae)

README.md

@@ -25,17 +25,26 @@ Deze applicatie maakt gebruik van de volgende python libraries, zorg ervoor dat
 - [~~steam~~](https://github.com/ValvePython/steam)
   - ~~gevent~~
   - ~~eventemitter~~
-- [matplotlib](https://pypi.org/project/matplotlib/)
+- [~~matplotlib~~](https://pypi.org/project/matplotlib/)
 - [requests](https://pypi.org/project/requests/)
+- [apa102-pi](https://github.com/tinue/apa102-pi)
 
 Om de dependencies te installeren voer het onderste commando uit.
 
-    pip install flask matplotlib requests
+    pip install flask requests apa102-pi
+    
+Als je op een RaspberryPI draait en de hardware wil aansturen moet je in run.py aangeven dat de software draait op een
+RaspberryPI, en in hardware.py kan je de default pinnen aanpassen. De APA102 library gebruikt SPI, dus zorg ervoor dat
+je via ```sudo raspi-config``` spi aan hebt gezet.
+
+In run.py kan je aangeven dat je op een RaspberryPI draait zodat de hardware
+pagina werkt. Default werkt de hardware **niet** omdat de software libraries oproept die alleen op een RaspberryPI
+werken.
 
 De applicatie is simpel uit te voeren door de python script uit te voeren. En via de browser naar de gegeven 
-url te gaan.
+url te gaan. Let op! Gebruik python 3!
 
-    python run.py
+    python3 run.py   of   python run.py
 
 ## Data formaat geheugen tabel
 Om het sorteren makkelijker te maken gaan we de json in een tuple/list opslaan in het geheugen. Het formaat is een tabel
@@ -94,13 +103,34 @@ meegegeven wordt {1: 1, 4: 2, 6: 1} terug gegeven
 #### ```gmld(lst)```
 Geeft de gemiddelde van een lijst terug in een float
 
+### steam_api.py
+#### ```getappdata(appid)```
+Deze functie vraagt de gegeven appid op via de http steam api en retourneert het als json. Een voorbeeld van de json is
+te vinden in steam_api.py
+
+### hardware.py
+#### ```set_strip(value)```
+Deze functie stuurt de ledstrip met 8 APA102 led's aan zodat de hele strip in 1 kleur oplicht. Value moet in HEX RGB
+gegeven worden. Bijvoorbeeld set_strip('FFAABB')
+#### ```set_register(value)```
+Deze functie accepteerd waardes in machten van 2 tot 128. Waarde 1 zet de eerste pinout van het register op ON. Waarde 2
+zet de 2e pinout op ON en de rest op OFF. Waarde 4 zet de 3e pin op ON enz... Tot waarde 128(pin 8). Accepteerd ook
+waarde 0 dat alles op OFF zet.
+#### ```poll_sensor()```
+Een simpele functie die de afstandsensor aanstuurt. Wanneer de functie wordt aangeroepen retourneert het een tuple met 
+als eerste waarde de afstand gemeten in cm van de sensor tot object. En waarde 2 weergeeft de afstand in tijd.
+
+**LET OP** als de sensor niet is aangesloten, en de functie wordt opgeroepen, blokkeert de functie. Zorg ervoor dat de
+sensor is aangesloten voordat de functie wordt opgeroepen. Dit wordt niet aangepast anders wordt de nauwkeurigheid van
+de sensor substantieel negatief beinvloed, vooral op langzame computers.
+#### ```set_servo(degree)```
+Deze functie accepteert waardes van 0 tot en met 180. Deze waardes corresponderen met de gradens vanaf het meest linkse
+positie van de servo([voorbeeld](https://files.ventilaar.net/files/2021-01/servo.jpg)).
+#### ````poll_button()````
+Dit is de meest simpele functie geschreven in dit programme. Wanneer de knop is ingedrukt returnt de functie True,
+anders False
+
 ### graphs.py
 De functie van dit bestand is om grafieken te maken van lijsten met waardes, deze grafieken worden als svg terug gegeven
 om door flask geserveerd te worden.
-
 #### WIP verdere uitleg komt nog
-
-### steam_abstraction.py
-De functie van dit bestand is om makkelijker te kunnen communiceren met de steam api door middel van een python library.
-
-#### verdere uitleg komt nog, als we het uberhoupt gaan gebruiken

hw_funcs.py

@@ -0,0 +1,125 @@
+# imports all necessary libraries and sets predetermined values
+import RPi.GPIO as GPIO
+import time
+from apa102_pi.driver import apa102
+
+GPIO.setmode(GPIO.BCM)
+GPIO.setwarnings(0)
+
+# de onderstaande pin waardes mogen aangepast worden
+register_shift_clock_pin = 17
+register_latch_clock_pin = 27
+register_data_pin = 22
+sensor_trigger_pin = 23
+sensor_echo_pin = 24
+servo_pin = 14
+button_pin = 25
+# led clock = 11 apa102_pi default
+# led data = 10 apa102_pi default
+
+
+GPIO.setup(register_shift_clock_pin, GPIO.OUT)
+GPIO.setup(register_latch_clock_pin, GPIO.OUT)
+GPIO.setup(register_data_pin, GPIO.OUT)
+GPIO.setup(sensor_trigger_pin, GPIO.OUT)
+GPIO.setup(sensor_echo_pin, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
+GPIO.setup(servo_pin, GPIO.OUT)
+GPIO.setup(button_pin, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
+
+
+################################
+
+
+def set_strip(value):
+    strip = apa102.APA102(num_led=8, order='rgb')
+    strip.set_global_brightness(31)
+    for x in range(8):
+        strip.set_pixel_rgb(x, value)
+        strip.show()
+
+
+######################################
+
+
+def set_register(value):
+    """waardes die worden geaccepteerd: 1, 2 ,4, 8, 16, 32, 64, 128"""
+    for k in range(0, 8):  # 8 keer loopen
+        if value % 2 == 1:  # als waarde oneven is
+            GPIO.output(register_data_pin, GPIO.HIGH)  # data pin hoog zetten
+        else:  # waarde is even
+            GPIO.output(register_data_pin, GPIO.LOW)  # data pin laag houden
+        value = value // 2  # waarde halveren
+
+        GPIO.output(register_shift_clock_pin, GPIO.HIGH)  # klok hoog, om de waarde pin te laten aflezen
+        GPIO.output(register_shift_clock_pin, GPIO.LOW)  # klok laag, default positie
+
+    GPIO.output(register_latch_clock_pin, GPIO.HIGH)  # geen idee, waarschijnlijk om de waardes op te laten slaan in de chip
+    GPIO.output(register_latch_clock_pin, GPIO.LOW)  # default positie
+    return True
+
+
+###############################################
+
+
+def poll_sensor():
+    """
+    Return the distance in cm as measured by an SR04
+    that is connected to the trig_pin and the echo_pin.
+    These pins must have been configured as output and input.s
+    """
+
+    GPIO.output(sensor_trigger_pin, False)  # altijd met false starten
+    time.sleep(0.5)
+    GPIO.output(sensor_trigger_pin, True)
+    time.sleep(0.00001)  # pulse trigger
+    GPIO.output(sensor_trigger_pin, False)
+
+    # hmmm, als de sensor niet is aangesloten zal deze functie blokkeren. heb geen zin om dit aan te passen
+
+    while not GPIO.input(sensor_echo_pin):
+        start_time = time.time()  # tijd opslaan wanneer de echo false is
+
+    while GPIO.input(sensor_echo_pin):
+        end_time = time.time()  # tijd opslaan wanneer de echo true is
+
+    total_time = end_time - start_time  # totaal aantal afstand in seconden
+    return (
+        round(total_time * 34300 / 2, 2), total_time)  # tuple terug geven met afstand in cm en totaal aantal seconden
+    # sensor is niet helemaal naukeurig(~1-2cm variatie), kan ook aan de rpi timing liggen
+
+
+###########################################
+
+
+# geef het aantal graden in tussen 0 en 180 (dit is niet hoeveelheid verplaatsing maar naar welke positie)
+def set_servo(degrees):
+    if degrees > 180:
+        return False
+    elif degrees < 0:
+        return False
+
+    left_span = 180 - 0
+    right_span = 12 - 2.5
+
+    value_scaled = float(degrees - 0) / float(left_span)
+
+    integer = 2.5 + (value_scaled * right_span)
+
+    p = GPIO.PWM(servo_pin, 50)
+
+    p.start(integer)
+    time.sleep(0.05)
+    p.stop()
+
+    return True
+
+
+###########################################
+
+
+# Function to check if Switch is pressed, will return a True or False Boolean
+def poll_button():
+    if GPIO.input(button_pin):
+        return True
+    else:
+        return False

run.py

@@ -1,12 +1,22 @@
 import json
-from flask import Flask, render_template, request, url_for, Response
+from flask import Flask, render_template, request, Response
 import ss
 import stats
 import steam_api
-import graphs
 
 
-app = Flask(__name__)
+RPI = False  # ZET NAAR TRUE ALS JE OP EEN RPI DRAAIT MET DE JUISTE LIBRARIES, ZODAT DE HARDWARE TAB WERKT
+
+
+if RPI:
+    import hw_funcs
+
+
+app = Flask(__name__)  # flask app initialiseren
+state_schuifregister = 0  # deze 3 waardes slaan de status op van de hardware onderdelen
+state_ledstrip = '000000'
+state_servo = 0
+
 
 # lees json bestand en maak de tabel structuur aan, data_tpl
 with open('steam.json') as file:
@@ -45,11 +55,14 @@ def root():
 
     genre = stats.popgenre(data_tpl)
 
+    prijsmed = stats.median_prijs(data_tpl)
+
     # limiteer tabel tot en met 15 entries
     for x in range(0, 15):
         entries.append(data_lst[x])
 
-    return render_template('index.html', first_entry=data_tpl[0], sizedb=len(data_tpl), entries=entries, genre=genre)
+    return render_template('index.html', first_entry=data_tpl[0], sizedb=len(data_tpl), entries=entries, genre=genre,
+                           prijsmed=prijsmed)
 
 
 @app.route('/fulltable')
@@ -83,57 +96,126 @@ def fulltable():
     return render_template('fulltable.html', first_entry=data_tpl[0], entries=entries, reverse=not reverse)
 
 
-@app.route('/statistics')
-def statistics():
-    return render_template('statistics.html')
-
-
 @app.route('/hardware')
 def hardware():
-    return render_template('statistics.html')
+    return render_template('hardware.html', RPI=RPI)
 
 
 @app.route('/search')
 def search():
-    query = request.args.get('q')
+    query = request.args.get('q')  # de request argument q opslaan in variabele query
 
-    entries = ss.nest_search(data_tpl, query)
+    entries = ss.nest_search(data_tpl, query)  # de data_tpl doorzoeken voor de waarde query, entries wordt een list
 
     return render_template('search.html', entries=entries)
 
 
 @app.route('/app/<appid>')
 def app_appid(appid):
-    data = steam_api.getappdata(appid)
+    data = steam_api.getappdata(appid)  # applicatie data van steam opvragen en opslaan in variabele data
-    print(data[appid])
     return render_template('app.html', data=data[appid])
 
 
-@app.route('/svgplot/randomplot.svg')
+@app.route('/api/afstandsensor')
-def randomplot():
+def api_afstandsensor():
-    svg = graphs.random_plot()
+    """Dit pad geeft een json array met de key 'afstand' met waarde van de afstandsensor in cm """
-    return Response(svg, mimetype='image/svg+xml')
+    if not RPI:
+        return Response('Hardware kan niet aangestuurt worden omdat het niet op een RPI draait!', status=418)
+
+    return {'afstand': hw_funcs.poll_sensor()[0]}
 
 
-@app.route('/svgplot/releasemean.svg')
+@app.route('/api/schuifregister', methods=['POST', 'GET'])
-def releasemean():
+def api_schuifregister():
-    lst = []
+    """
-    dates = []
+    Door het opvragen van dit pad met de GET functie is het mogelijk om de status van het schuifregister uit te lezen.
-    times = []
+    Door te POST'en naar dit pad met de waarde 'setstate' is het mogelijk om de status aan te passen.
+    """
+    if not RPI:
+        return Response('Hardware kan niet aangestuurt worden omdat het niet op een RPI draait!', status=418)
 
-    for x in data_tpl:
+    global state_schuifregister
-        lst.append(x[2])
 
-    lst = ss.qsort(lst)
+    if request.method == 'POST':
+        desired_state = request.form['setstate']
 
-    freqs = stats.freq(lst)
+        try:
+            hw_funcs.set_register(int(desired_state))
+        except:
+            return {'request': 'False'}
 
-    for x in freqs:
+        print(f'Set value for schuifregister {desired_state}')
-        dates.append(x)
+        state_schuifregister = desired_state
-        times.append(freqs.get(x))
+        return {'request': 'True'}
+    else:
+        return {'state': state_schuifregister}
 
-    svg = graphs.plot_xy(dates, times)
+
-    return Response(svg, mimetype='image/png')
+@app.route('/api/servo', methods=['POST', 'GET'])
+def api_servo():
+    """
+    Door het opvragen van dit pad met de GET functie is het mogelijk om de status van de servo uit te lezen.
+    Door te POST'en naar dit pad met de waarde 'setstate' is het mogelijk om de status aan te passen.
+    """
+    if not RPI:
+        return Response('Hardware kan niet aangestuurt worden omdat het niet op een RPI draait!', status=418)
+
+    global state_servo
+
+    if request.method == 'POST':
+        desired_state = request.form['setstate']
+
+        try:
+            hw_funcs.set_servo(int(desired_state))
+        except:
+            return {'request': 'False'}
+
+        print(f'Set value for servo {desired_state}')
+        state_servo = desired_state
+        return {'request': 'True'}
+    else:
+        return {'state': state_servo}
+
+
+@app.route('/api/pushbutton')
+def api_pushbutton():
+    """Dit pad geeft de status van de pushbuttons af in True en False, de keys alsvolgd genoemd: button0, button1"""
+    if not RPI:
+        return Response('Hardware kan niet aangestuurt worden omdat het niet op een RPI draait!', status=418)
+
+    if hw_funcs.poll_button():
+        return {'button0': True}
+    else:
+        return {'button0': False}
+
+
+@app.route('/api/ledstrip', methods=['POST', 'GET'])
+def api_ledstrip_set():
+    """
+    Door het opvragen van dit pad met de GET functie is het mogelijk om de status van de ledstrip uit te lezen.
+    Door te POST'en naar dit pad met de waarde 'setstate' is het mogelijk om de status aan te passen.
+    """
+    if not RPI:
+        return Response('Hardware kan niet aangestuurt worden omdat het niet op een RPI draait!', status=418)
+
+    global state_ledstrip
+
+    if request.method == 'POST':
+        string_state = request.form['setstate']
+
+        try:
+            # we ontvangen de volgenende waarde '#XXXXXX' maar de driver ondersteunt alleen hex in integer
+            desired_state = int(string_state[1:], 16)
+            hw_funcs.set_strip(desired_state)
+        except:
+
+            return {'request': 'False'}
+
+        print(f'Set value for ledstrip {string_state}')
+        state_ledstrip = string_state
+        return {'request': 'True'}
+    else:
+        return {'state': state_ledstrip}
 
 
 if __name__ == "__main__":

ss.py

@@ -1,5 +1,8 @@
 def nest_qsort(tpl, colnum, reverse=False):
-    """deze functie sorteert de geneste tuple zoals beschreven in de README.md"""
+    """
+    Deze functie sorteert de geneste tuple zoals beschreven in de README.md
+    Het algoritme wat we gebruiken is quicksort, als we lineair gaan sorteren is het met een grote dataset niet te doen
+    """
 
     small = []
     same = []
@@ -29,7 +32,10 @@ def nest_qsort(tpl, colnum, reverse=False):
 
 
 def qsort(tpl, reverse=False):
-    """Deze functie kan een lijst of tuple met waardes sorteren"""
+    """
+    Deze functie kan een lijst of tuple met waardes sorteren
+    Het algoritme wat we gebruiken is quicksort, als we lineair gaan sorteren is het met een grote dataset niet te doen
+    """
 
     small = []
     same = []
@@ -59,10 +65,10 @@ def qsort(tpl, reverse=False):
 
 
 def nest_search(lst, word):
-    found = []
+    found = []  # lege lijst
 
-    for x in lst:
+    for x in lst:  # voor elke nest in de lijst
-        if word.lower() in x[1].lower():
+        if word.lower() in x[1].lower():  # als de keywordt overkomt met de naam van de app
-            found.append(x)
+            found.append(x)  # app nest opslaan in found
 
-    return found
+    return found  # return de lijst

stats.py

@@ -85,3 +85,12 @@ def popgenre(data_tpl):
 
     return modes(genres)[0]  # eerst populairste genre terug geven op basis van gegevens van modes(), wat is de kans
     # dat er meerdere genres tegelijk populair zijn, toch?
+
+
+def median_prijs(data_tpl):
+    prijzen = []
+
+    for x in data_tpl:
+        prijzen.append(x[17])
+
+    return float(median(prijzen))

steam_api.py

@@ -401,14 +401,15 @@ def getappdata(appid):
         }
     }
     """
-    try:
+    try:  # proberen appid geforceerd in een integer om te zetten
         appid = int(appid)
-    except ValueError:
+    except ValueError:  # als het niet mogelijk is False returnen
         return False
 
+    # Steam api opvragen voor appid
     r = requests.get('http://store.steampowered.com/api/appdetails', params={'appids': appid})
 
-    if r.status_code != 200:
+    if r.status_code != 200:  # als de request niet is gelukt
-        return False
+        return False  # False returnen
 
-    return r.json()
+    return r.json()  # return de gekregen json zonder check

templates/app.html

@@ -9,25 +9,22 @@
             <div class="row">
                 <div class="col-md-12">
                     <h1>{{ data['data']['name'] }}</h1>
-                    <p>fffff</p>
                 </div>
             </div>
             <div class="row">
                 <div class="col-md-6">
-                    <div id="carousel" class="carousel slide" data-ride="carousel">
+                    <div id="pictures" class="carousel slide" data-ride="carousel">
                         <div class="carousel-inner">
-                            {% set firstpic = True %}
                             {% for x in data['data']['screenshots'] %}
-                            <div class="carousel-item {% if firstpic == True %}active{% endif %}">
+                            <div class="carousel-item{% if x['id'] == 0 %} active{% endif %}">
-                                <img class="d-block w-100" src="{{ x['path_full'] }}">
+                                <img class="d-block w-100" src="{{ x['path_full'] }}" />
                             </div>
-                            {% set firstpic = False %}
                             {% endfor %}
                         </div>
-                        <a class="carousel-control-prev" href="#carousel" role="button" data-slide="prev">
+                        <a class="carousel-control-prev" href="#pictures" role="button" data-slide="prev">
                             <span class="carousel-control-prev-icon" aria-hidden="true"></span>
                         </a>
-                        <a class="carousel-control-next" href="#carousel" role="button" data-slide="next">
+                        <a class="carousel-control-next" href="#pictures" role="button" data-slide="next">
                             <span class="carousel-control-next-icon" aria-hidden="true"></span>
                         </a>
                     </div>
@@ -77,6 +74,8 @@
                 </div>
             </div>
         </div>
+        <script src="{{ url_for('static', filename='js/jquery.min.js') }}"></script>
+        <script src="{{ url_for('static', filename='js/bootstrap.bundle.min.js') }}"></script>
     </body>
 
 </html>

templates/hardware.html

@@ -3,28 +3,138 @@
         <title>Hardware</title>
         <link href="{{ url_for('static', filename='css/bootstrap.min.css') }}" rel="stylesheet">
     </head>
-    <body>
+    <body class="text-center">
         {% include "t-navbar.html" %}
         <div class="container">
+            {% if RPI == False %}
+            <div class="alert alert-danger mt-4" role="alert">
+                Volgens de webserver is de hardware niet aangesloten en kan dus niet worden bestuurd. (Is de variabele aangepast in run.py?)
+            </div>
+            {% endif %}
             <div class="row row-cols-2">
                 <div class="col">
-                    <h1>container</h1>
+                    <h1>Afstand sensor</h1>
-                    {{ lipsum() }}
+                    <h2>Gemeten afstand is <span class="badge badge-secondary" id="afstand-badge">x cm</span></h2>
                 </div>
                 <div class="col">
-                    <h1>container</h1>
+                    <h1>Push buttons</h1>
-                    {{ lipsum() }}
+                    <h2>Button0 is <span class="badge badge-danger" id="button-badge">Nog niet opgevraagd</span></h2>
                 </div>
-                <div class="col col-lg">
+            </div>
-                    <h1>container</h1>
+            <br>
-                    {{ lipsum() }}
+            <div class="row row-cols-3">
+                <div class="col">
+                    <h1>Ledstrip</h1>
+                    <p>Kies een kleur uit in de colorpicker en klik op set value</p>
+                    <input type="color" id="ledstrip-input" />
+                    <button type="button" id="ledstrip-set" class="btn btn-primary" onclick="setval()">Set value</button>
                 </div>
-                <div class="col col-lg">
+                <div class="col">
-                    <h1>container</h1>
+                    <h1>Schuifregister</h1>
-                    {{ lipsum() }}
+                    <p>Kies de bit uit die je positief wil aansluiten</p>
+                    <select name="Bit volgorde" id="register-input" onchange="set_register(this.value)">
+                        <option value="0">Uit</option>
+                        <option value="1">Bit 1</option>
+                        <option value="2">Bit 2</option>
+                        <option value="4">Bit 3</option>
+                        <option value="8">Bit 4</option>
+                        <option value="16">Bit 5</option>
+                        <option value="32">Bit 6</option>
+                        <option value="64">Bit 7</option>
+                        <option value="128">Bit 8</option>
+                    </select>
+                </div>
+                <div class="col">
+                    <h1>Servo</h1>
+                    <p>Stel waarde in tussen 0 en 180 graden</p>
+                    <input id="servo-range" type="range" min="0" max="180" step="10" value="90" oninput="this.nextElementSibling.value = this.value" onchange="set_servo(this.value)">
+                    <output id="servo-span">90</output>
                 </div>
             </div>
         </div>
-    </body>
+        <script src="{{ url_for('static', filename='js/jquery.min.js') }}"></script>
+        <script>
+            // dit script blok geldt alleen voor de ledstrip
+            $(document).ready(function() {
+				$.getJSON('/api/ledstrip', function(data) {
+					document.getElementById('ledstrip-input').value = data.state
+			    });
+		    });
 
+            function setval() {
+                let valinbox = document.getElementById('ledstrip-input').value
+
+                $.post("/api/ledstrip", {setstate:valinbox})
+            }
+        </script>
+        <script>
+            // dit script blok geldt alleen voor de pushknoppen
+
+            // functie om de badge groen te maken en text 'ingedrukt'
+            function set_true() {
+                document.getElementById('button-badge').className = "badge badge-success";
+                document.getElementById('button-badge').textContent = 'Ingedrukt';
+            };
+
+            // functie om de badge rood te maken en text 'niet ingedrukt'
+            function set_false() {
+                document.getElementById('button-badge').className = "badge badge-danger";
+                document.getElementById('button-badge').textContent = 'Niet ingedrukt';
+            };
+
+            function button_poll() {
+                $.getJSON('/api/pushbutton', function(data) {
+					if (data.button0 == true) {
+					    set_true();
+					} else {
+					    set_false();
+					};
+			    });
+            };
+
+            {% if RPI == False %}// {% endif %}setInterval(function(){ button_poll(); }, 500);
+        </script>
+        <script>
+            // dit script blok geldt alleen voor de afstandsensor
+
+            // functie om de waarde aan te passen in html
+            function set_afstand(waarde) {
+                document.getElementById('afstand-badge').textContent = waarde + ' cm';
+            };
+
+            // waarde opvragen en dan set_afstand() uitvoeren
+            function afstand_poll() {
+                $.getJSON('/api/afstandsensor', function(data) {
+                    set_afstand(data.afstand);
+			    });
+            };
+
+            {% if RPI == False %}// {% endif %}setInterval(function(){ afstand_poll(); }, 1500);
+        </script>
+        <script>
+            // dit script blok geldt alleen voor de servo
+            $(document).ready(function() {
+				$.getJSON('/api/servo', function(data) {
+					document.getElementById('servo-range').value = data.state
+					document.getElementById('servo-span').value = data.state
+			    });
+		    });
+
+            function set_servo(deg) {
+                $.post("/api/servo", {setstate:deg})
+            };
+        </script>
+        <script>
+            // dit script blok geldt alleen voor het schuifregister
+            $(document).ready(function() {
+				$.getJSON('/api/schuifregister', function(data) {
+					document.getElementById('register-input').value = data.state
+			    });
+		    });
+
+            function set_register(bit) {
+                $.post("/api/schuifregister", {setstate:bit})
+            };
+        </script>
+    </body>
 </html>

templates/index.html

@@ -12,6 +12,7 @@
                     <p>Eerste game in memory is <b>{{ first_entry[1] }}</b> met de game id <b>{{ first_entry[0] }}</b></p>
                     <p>Totaal aantal games in memory is <b>{{ sizedb }}</b></p>
                     <p>Meest populaire genre is <b>{{ genre }}</b></p>
+                    <p>Het mediaan van alle geindexeerde prijzen is <b>{{ prijsmed }}</b>,-</p>
                 </div>
                 <div class="col mt-3">
                     <!--

templates/t-navbar.html

@@ -7,9 +7,6 @@
       <li class="nav-item">
         <a class="nav-link" href="/fulltable">Volledig tabel</a>
       </li>
-      <li class="nav-item">
-        <a class="nav-link" href="/statistics">Statistieken</a>
-      </li>
       <li class="nav-item">
         <a class="nav-link" href="/hardware">Hardware</a>
       </li>