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

@@ -119,6 +119,10 @@ 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)).

hw_funcs.py

@@ -24,7 +24,7 @@ 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)
+GPIO.setup(button_pin, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
 
 
 ################################
@@ -32,6 +32,7 @@ GPIO.setup(button_pin, GPIO.IN)
 
 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()
@@ -73,6 +74,8 @@ def poll_sensor():
     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
 
@@ -90,9 +93,6 @@ def poll_sensor():
 
 # geef het aantal graden in tussen 0 en 180 (dit is niet hoeveelheid verplaatsing maar naar welke positie)
 def set_servo(degrees):
-    p = GPIO.PWM(servo_pin, 50)
-    p.start(2.5)
-
     if degrees > 180:
         return False
     elif degrees < 0:
@@ -105,7 +105,11 @@ def set_servo(degrees):
 
     integer = 2.5 + (value_scaled * right_span)
 
-    p.ChangeDutyCycle(integer)
+    p = GPIO.PWM(servo_pin, 50)
+
+    p.start(integer)
+    time.sleep(0.05)
+    p.stop()
 
     return True
 

run.py

@@ -97,7 +97,7 @@ def fulltable():
 
 
 @app.route('/hardware')
-def hw_funcs():
+def hardware():
     return render_template('hardware.html', RPI=RPI)
 
 
@@ -140,7 +140,7 @@ def api_schuifregister():
         desired_state = request.form['setstate']
 
         try:
-            hw_funcs.set_register(desired_state)
+            hw_funcs.set_register(int(desired_state))
         except:
             return {'request': 'False'}
 
@@ -166,7 +166,7 @@ def api_servo():
         desired_state = request.form['setstate']
 
         try:
-            hw_funcs.set_servo(desired_state)
+            hw_funcs.set_servo(int(desired_state))
         except:
             return {'request': 'False'}
 
@@ -201,17 +201,17 @@ def api_ledstrip_set():
     global state_ledstrip
 
     if request.method == 'POST':
-        # we ontvangen de volgenende waarde '#XXXXXX' maar de driver ondersteunt allen '0xFFFFFF'
         string_state = request.form['setstate']
 
         try:
-            desired_state = hex(int(string_state[1:], 16))
+            # 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 {desired_state}')
+        print(f'Set value for ledstrip {string_state}')
         state_ledstrip = string_state
         return {'request': 'True'}
     else:

templates/index.html

@@ -12,7 +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 prijsen is <b>{{ prijsmed }}</b>,-</p>
+                    <p>Het mediaan van alle geindexeerde prijzen is <b>{{ prijsmed }}</b>,-</p>
                 </div>
                 <div class="col mt-3">
                     <!--