Merge pull request 'update' (#3) from update into main

Reviewed-on: #3

avanceret/binær_tæller/binær_tæller.py

@@ -0,0 +1,52 @@
+from microbit import *
+
+# Binære tal tælles altid fra 0
+# Binære tal representeres med 0-ere og 1-ere - Derfor også kaldet 2-talssystem
+# Binære tal læses altid fra højre mod venstre i følgende orden:
+# 16-ere, 8-ere, 4-ere, 2-ere og 1-ere
+# Et eksempel for værdien 13 oversat til binær
+# 0 16-ere, 1 8-er, 1 4-er, 0 2-ere, 1 1-er
+# |         |       |       |        |
+# 0         1       1       0        1 = 01101 = 1 + 4 + 8 = 13
+
+def get_binær(n):
+    bin_nummer = "00000:00000:00000:00000:00000"
+    # Vi starter med at formatere vores binære streng til 5 karakterer (5 led), hvilket giver n = max 31
+    # f.eks. hvis n er 10, bliver den binære værdi til "0b01010"
+    bin_num = bin(n).format(n, '25b')
+
+    # Vi fjerner "0b" fra strengen
+    # Herved bliver strengen til "01010"
+    # bin_nummer = "".join(reversed(bin_num[2:]))
+    bin_nummer = bin_num[2:]
+
+    for idx, n in enumerate(bin_nummer):
+        if idx % 5 == 0:
+            if idx == len(bin_nummer):
+                break
+            bin_nummer = bin_nummer[idx:] + ":" + bin_nummer[:idx]
+    # Vi erstatter "1" med "9", og tilføjer ":" og returnerer den nye streng
+    # Den returnerede streng bliver "09090:"
+    return bin_nummer.replace("1", "9")
+
+def bin_taeller_v2():
+    for bb in range(100):
+        display.show(Image(get_binær(bb)))
+        sleep(100) #sov 0.1 sekund
+
+BINÆR_DATA = {
+    0: "00000:", 1: "00009:", 2: "00090:", 3: "00099:", 4: "00900:", 5: "00909:",
+    6: "00990:", 7: "00999:", 8: "09000:", 9: "09009:", 10: "09090:", 11: "09099:",
+    12: "09900:", 13: "09909", 14: "09990:", 15: "09999:", 16: "90000:", 17: "90009:",
+    18: "90090:", 19: "90099:", 20: "90900:", 21: "90909:", 22: "90990:", 23: "90999:",
+    24: "99000:", 25: "99009:", 26: "99090:", 27: "99099:", 28: "99900:", 29: "99909:",
+    30: "99990:", 31: "99999:"
+    }
+
+def binaer(n):
+    return BINÆR_DATA[n]+"00000:00000:00000:00000"
+
+def bin_taeller_v1():
+    for b in range(32):
+        display.show(Image(binaer(b)))
+        sleep(100) #sov 0.1 sekund

avanceret/binær_tæller/main.py

@@ -0,0 +1,8 @@
+from .binær_tæller import bin_taeller_v1
+from .binær_tæller import bin_taeller_v2
+
+running = True
+
+while running:
+    bin_taeller_v1()
+    #bin_taeller_v2()

avanceret/binær_tæller_v1.py

@@ -1,19 +0,0 @@
-from microbit import *
-
-BINÆR_DATA = {
-    0: "00000:", 1: "00009:", 2: "00090:", 3: "00099:", 4: "00900:", 5: "00909:",
-    6: "00990:", 7: "00999:", 8: "09000:", 9: "09009:", 10: "09090:", 11: "09099:",
-    12: "09900:", 13: "09909", 14: "09990:", 15: "09999:", 16: "90000:", 17: "90009:",
-    18: "90090:", 19: "90099:", 20: "90900:", 21: "90909:", 22: "90990:", 23: "90999:",
-    24: "99000:", 25: "99009:", 26: "99090:", 27: "99099:", 28: "99900:", 29: "99909:",
-    30: "99990:", 31: "99999:"
-    }
-
-while True:
-    for b in range(32):
-        display.show(BINÆR_DATA[b],
-                     "00000:"
-                     "00000:"
-                     "00000:"
-                     "00000")
-        sleep(100) #sov 0.1 sekund

avanceret/binær_tæller_v2.py

@@ -1,15 +0,0 @@
-from microbit import *
-
-def get_binær(n):
-    bin_format = format(n, '05b') # Vi starter med at sætte vores binær streng til 5 karakterer (n = max 31)
-    bin_nummer = bin_format[2:] # Vi fjerner "0b" fra strengen
-    return bin_nummer.replace("1", "9") + ":" # Vi erstatter "1" med "9", og tilføjer ":" og returnerer den nye streng
-
-while True:
-    for b in range(32):
-        display.show(get_binær(b),
-                     "00000:"
-                     "00000:"
-                     "00000:"
-                     "00000")
-        sleep(100) #sov 0.1 sekund

avanceret/matrix/main.py

@@ -0,0 +1,6 @@
+from .matrix_v1 import *
+
+running = True
+
+while running:
+    pass

avanceret/matrix/matrix_v1.py

@@ -0,0 +1,62 @@
+"""
+Vi vil her lave en Matrix lignende animation, med de 25 LED.
+Hvad skal vi bruge?
+Random kollonne valg (0 til 4)
+Random lysstyrke (1 til 9)
+Random faldhastighed (1 til 10)
+
+Hvergang der faldes, skal de eksisterende LED rykkes ned på næste linie, og en ny sættes i toppen.
+Når en hel kollonne har været fyldt ud, skal der ikke længere sættes en ny LED, i toppen.
+Når alle LED, i en kollonne er faldet ned, startes forfra.
+
+Der skal holdes styr, på hver eneste LED, deres lysstyrke, faldhastighed, og om de er faldet ud.
+"""
+from microbit import *
+from collections import deque
+
+kol_1 = [0, 0, 0, 0, 0]
+kol_2 = [0, 0, 0, 0, 0]
+kol_3 = [0, 0, 0, 0, 0]
+kol_4 = [0, 0, 0, 0, 0]
+kol_5 = [0, 0, 0, 0, 0]
+
+d_kol_1 = deque(kol_1)
+d_kol_2 = deque(kol_2)
+d_kol_3 = deque(kol_3)
+d_kol_4 = deque(kol_4)
+d_kol_5 = deque(kol_5)
+
+matrix = {1: d_kol_1, 2: d_kol_2, 3: d_kol_3, 4: d_kol_4, 5: d_kol_5}
+
+
+# Hver LED representation, skal kun holde styr på sig selv.
+class LED:
+    def __init__(self, kol, lys, hast):
+        self.kol = []
+        self.i_live = True # Vi starter med at være i live.
+        self.række = 0 # Vi starter på øverste række.
+        self.kollonne = kol # Vi ved hvilken kollonne vi er i.
+        self.lys = lys # Vi sætter vores lysstyrke.
+        self.hastighed = hast # Vi falder med en konstant hastighed.
+        self.vis_led() # Tænd led
+    
+    def fald(self):
+        self.række += 1 # Ryk til næste række
+        self.lys -= 1
+        if self.række > 4:
+            self.i_live = False
+        else:
+            self.vis_led()
+            self.matrix.ny_led(self.kol, self.lys, self.hastighed)
+
+    def vis_led(self):
+        display.set_pixel(self.kollonne, self.række, self.lys)
+
+while True:
+    kol = random(1, 5)
+    lys = random(5, 9)
+    hast = random(1, 10)
+
+    for k in matrix:
+        matrix[k].pop()
+        matrix[k].appendleft(0)

begynder/billede.py

@@ -1,6 +1,6 @@
 from microbit import *
 
-while True:
+def billede():
     display.show(Image.HEART)
     sleep(1000)
     display.scroll('Hello')

begynder/main.py

@@ -0,0 +1,6 @@
+from .billede import billede
+
+running = True
+
+while running:
+    billede()

main.py

@@ -0,0 +1,10 @@
+from microbit import *
+from begynder.billede import billede
+from avanceret.binær_tæller.binær_tæller import bin_taeller_v1
+from avanceret.binær_tæller.binær_tæller import bin_taeller_v2
+
+running = True
+
+while running:
+    #billede()
+    bin_taeller_v2()

terning.py

@@ -0,0 +1,22 @@
+from microbit import *
+import random
+
+# Define dice faces
+dice_faces = {
+    1: "00000:00000:00900:00000:00000",
+    2: "90000:00000:00000:00000:00009",
+    3: "90000:00000:00900:00000:00009",
+    4: "90009:00000:00000:00000:90009",
+    5: "90009:00000:00900:00000:90009",
+    6: "90009:00000:90009:00000:90009"
+}
+
+def show_dice(number):
+    display.show(Image(dice_faces[number]))
+
+while True:
+    if accelerometer.was_gesture('shake'):
+        num = random.randint(1, 6)
+        show_dice(num)
+        sleep(1000)
+        display.clear()

test.py

@@ -0,0 +1,16 @@
+from collections import deque
+from time import sleep
+
+kol = [0] * 5
+d_kol = deque(kol)
+test = True
+
+while test == True:
+    d_kol.pop()
+    d_kol.appendleft(1)
+    print(d_kol)
+    sleep(0.5)
+    for i in range(5):
+        test = False
+        if d_kol[i] == 0:
+            test = True