Add scripts

.gitignore

@@ -0,0 +1 @@
+.vscode/

.micropico

@@ -0,0 +1,3 @@
+{
+    "info": "This file is just used to identify a project folder."
+}

01_an.py

@@ -0,0 +1,22 @@
+import neopixel
+from machine import Pin
+import time
+
+ws_pin = 0
+led_zahl = 64
+helligkeit = 0.1
+
+matrix = neopixel.NeoPixel(Pin(ws_pin), led_zahl)
+
+def setze_helligkeit(farbe):
+    r, g, b = farbe
+    r = int(r * helligkeit)
+    g = int(g * helligkeit)
+    b = int(b * helligkeit)
+    return (r, g, b)
+
+# anmachen
+farbe = (255, 255, 255)  # HELL
+farbe = setze_helligkeit(farbe)
+matrix.fill(farbe)
+matrix.write()

02_farben.py

@@ -0,0 +1,42 @@
+import neopixel
+from machine import Pin
+import time
+
+ws_pin = 0
+led_zahl = 64
+helligkeit = 0.1
+
+matrix = neopixel.NeoPixel(Pin(ws_pin), led_zahl)
+
+def setze_helligkeit(farbe):
+    r, g, b = farbe
+    r = int(r * helligkeit)
+    g = int(g * helligkeit)
+    b = int(b * helligkeit)
+    return (r, g, b)
+
+def schleife():
+    # rot anzeigen
+    farbe = (255, 0, 0)  # ROT
+    farbe = setze_helligkeit(farbe)
+    matrix.fill(farbe)
+    matrix.write()
+    time.sleep(2)
+
+    # grün anzeigen
+    farbe = (0, 255, 0)  # GRÜN
+    farbe = setze_helligkeit(farbe)
+    matrix.fill(farbe)
+    matrix.write()
+    time.sleep(2)
+
+    # blau anzeigen
+    farbe = (0, 0, 255)  # BLAU
+    farbe = setze_helligkeit(farbe)
+    matrix.fill(farbe)
+    matrix.write()
+    time.sleep(2)
+
+while True:
+    schleife()
+    

03_pixel.py

@@ -0,0 +1,34 @@
+import neopixel
+from machine import Pin
+import time
+
+ws_pin = 0
+led_zahl = 64
+helligkeit = 0.05
+
+matrix = neopixel.NeoPixel(Pin(ws_pin), led_zahl)
+
+def setze_helligkeit(farbe):
+    r, g, b = farbe
+    r = int(r * helligkeit)
+    g = int(g * helligkeit)
+    b = int(b * helligkeit)
+    return (r, g, b)
+
+def setze_pixel(i):
+    farbe = (255, 255, 255)
+    farbe = setze_helligkeit(farbe)
+    matrix[i] = farbe
+
+x = 0
+
+while True:
+    if x == 63:
+        x = 0
+    else:
+        x = x + 1
+
+    matrix.fill((0, 0, 0))
+    setze_pixel(x)
+    matrix.write()
+    time.sleep(0.05)

04_pixel_xy.py

@@ -0,0 +1,45 @@
+import neopixel
+from machine import Pin
+import time
+
+ws_pin = 0
+led_zahl = 64
+helligkeit = 0.05
+
+matrix = neopixel.NeoPixel(Pin(ws_pin), led_zahl)
+
+def setze_helligkeit(farbe):
+    r, g, b = farbe
+    r = int(r * helligkeit)
+    g = int(g * helligkeit)
+    b = int(b * helligkeit)
+    return (r, g, b)
+
+def setze_pixel(x, y, farbe):
+    farbe = setze_helligkeit(farbe)
+    i = y * 8 + x
+    matrix[i] = farbe
+
+i = 0
+richtung = "vor"
+
+while True:
+    matrix.fill((0, 0, 0))
+    
+    if i == 0:
+        richtung = "vor"
+    if i == 7:
+        richtung = "zurueck"
+
+    if richtung == "vor":
+        i = i+1
+    elif richtung == "zurueck":
+        i = i-1
+    
+    setze_pixel(i, 0, (255, 0, 0))
+    setze_pixel(7, i, (0, 255, 0))
+    setze_pixel(7-i, 7, (0, 0, 255))
+    setze_pixel(0, 7-i, (255, 255, 0))
+    
+    matrix.write()
+    time.sleep(0.2)

05_taster.py

@@ -0,0 +1,18 @@
+from machine import Pin
+import time
+
+taster_hoch = Pin(1, Pin.IN, Pin.PULL_UP)
+taster_runter = Pin(2, Pin.IN, Pin.PULL_UP)
+taster_rechts = Pin(3, Pin.IN, Pin.PULL_UP)
+taster_links = Pin(4, Pin.IN, Pin.PULL_UP)
+
+def schleife():
+    if not taster_runter.value(): print('Runter gedrueckt!')
+    if not taster_rechts.value(): print('Rechts gedrueckt!')
+    if not taster_links.value(): print('Links gedrueckt!')
+    if not taster_hoch.value(): print('Hoch gedrueckt!')
+
+while True:
+    schleife()
+    time.sleep(0.2)
+    

06_richtungen.py

@@ -0,0 +1,54 @@
+import neopixel
+from machine import Pin
+import time
+
+ws_pin = 0
+led_zahl = 64
+helligkeit = 0.05
+
+matrix = neopixel.NeoPixel(Pin(ws_pin), led_zahl)
+
+taster_hoch = Pin(1, Pin.IN, Pin.PULL_UP)
+taster_runter = Pin(2, Pin.IN, Pin.PULL_UP)
+taster_rechts = Pin(3, Pin.IN, Pin.PULL_UP)
+taster_links = Pin(4, Pin.IN, Pin.PULL_UP)
+
+def setze_helligkeit(farbe):
+    r, g, b = farbe
+    r = int(r * helligkeit)
+    g = int(g * helligkeit)
+    b = int(b * helligkeit)
+    return (r, g, b)
+
+def setze_pixel(x, y, farbe):
+    farbe = setze_helligkeit(farbe)
+    i = y * 8 + x
+    matrix[i] = farbe
+
+x = 0
+y = 0
+
+def neue_position(x, y):
+    if not taster_runter.value():
+        y = y + 1
+        if y > 7: y = 7
+    if not taster_rechts.value():
+        x = x + 1
+        if x > 7: x = 7
+    if not taster_links.value():
+        x = x - 1
+        if x < 0: x = 0
+    if not taster_hoch.value(): 
+        y = y - 1
+        if y < 0: y = 0
+    return (x, y)
+
+while True:
+    matrix.fill((0, 0, 0))
+
+    (x, y) = neue_position(x, y)
+    setze_pixel(x, y, (255, 255, 0))
+
+    matrix.write()
+    time.sleep(0.2)
+    

07_zufall.py

@@ -0,0 +1,65 @@
+import neopixel
+from machine import Pin
+import time
+from random import randint, random, seed
+
+seed()
+
+ws_pin = 0
+led_zahl = 64
+helligkeit = 0.05
+
+matrix = neopixel.NeoPixel(Pin(ws_pin), led_zahl)
+
+taster_hoch = Pin(1, Pin.IN, Pin.PULL_UP)
+taster_runter = Pin(2, Pin.IN, Pin.PULL_UP)
+taster_rechts = Pin(3, Pin.IN, Pin.PULL_UP)
+taster_links = Pin(4, Pin.IN, Pin.PULL_UP)
+
+scalar = float # a scale value (0.0 to 1.0)
+def hsv2rgb(h:scalar, s:scalar, v:scalar) -> tuple:
+    if s:
+        if h == 1.0: h = 0.0
+        i = int(h*6.0); f = h*6.0 - i
+        
+        w = int(255*( v * (1.0 - s) ))
+        q = int(255*( v * (1.0 - s * f) ))
+        t = int(255*( v * (1.0 - s * (1.0 - f)) ))
+        v = int(255*v)
+        
+        if i==0: return (v, t, w)
+        if i==1: return (q, v, w)
+        if i==2: return (w, v, t)
+        if i==3: return (w, q, v)
+        if i==4: return (t, w, v)
+        if i==5: return (v, w, q)
+    else: v = int(255*v); return (v, v, v)
+
+def zufall_farbe():
+    return hsv2rgb(random(), 1.0, 1.0)
+
+def setze_helligkeit(farbe):
+    r, g, b = farbe
+    r = int(r * helligkeit)
+    g = int(g * helligkeit)
+    b = int(b * helligkeit)
+    return (r, g, b)
+
+def setze_pixel(x, y, farbe):
+    farbe = setze_helligkeit(farbe)
+    i = y * 8 + x
+    matrix[i] = farbe
+
+def neue_position():
+    x = randint(0, 7)
+    y = randint(0, 7)
+    return (x, y)
+
+while True:
+    matrix.fill((0, 0, 0))
+
+    (x, y) = neue_position()
+    setze_pixel(x, y, zufall_farbe())
+
+    matrix.write()
+    time.sleep(0.5)

08_snake.py

@@ -0,0 +1,225 @@
+import neopixel
+from machine import Pin
+import time
+from random import randint, random, seed, choice
+
+seed()
+
+ws_pin = 0
+led_zahl = 64
+helligkeit = 0.05
+
+matrix = neopixel.NeoPixel(Pin(ws_pin), led_zahl)
+
+taster_hoch = Pin(1, Pin.IN, Pin.PULL_UP)
+taster_runter = Pin(2, Pin.IN, Pin.PULL_UP)
+taster_rechts = Pin(3, Pin.IN, Pin.PULL_UP)
+taster_links = Pin(4, Pin.IN, Pin.PULL_UP)
+
+scalar = float # a scale value (0.0 to 1.0)
+def hsv2rgb(h:scalar, s:scalar, v:scalar) -> tuple:
+    if s:
+        if h == 1.0: h = 0.0
+        i = int(h*6.0); f = h*6.0 - i
+        
+        w = int(255*( v * (1.0 - s) ))
+        q = int(255*( v * (1.0 - s * f) ))
+        t = int(255*( v * (1.0 - s * (1.0 - f)) ))
+        v = int(255*v)
+        
+        if i==0: return (v, t, w)
+        if i==1: return (q, v, w)
+        if i==2: return (w, v, t)
+        if i==3: return (w, q, v)
+        if i==4: return (t, w, v)
+        if i==5: return (v, w, q)
+    else: v = int(255*v); return (v, v, v)
+
+def zufall_farbe():
+    return hsv2rgb(random(), 1.0, 1.0)
+
+def setze_helligkeit(farbe):
+    r, g, b = farbe
+    r = int(r * helligkeit)
+    g = int(g * helligkeit)
+    b = int(b * helligkeit)
+    return (r, g, b)
+
+def setze_pixel(x, y, farbe):
+    farbe = setze_helligkeit(farbe)
+    i = y * 8 + x
+    matrix[i] = farbe
+
+def neue_richtung():
+    if not taster_runter.value():
+        return "runter"
+    if not taster_rechts.value():
+        return "rechts"
+    if not taster_links.value():
+        return "links"
+    if not taster_hoch.value(): 
+        return "hoch"
+
+RICHTUNGEN = {
+    "hoch": (0, -1),
+    "runter": (0, 1),
+    "links": (-1, 0),
+    "rechts": (1, 0)
+}
+
+def anzeigen(snake, essen):
+    matrix.fill((0, 0, 0))
+
+    # Snake anzeigen
+    length = len(snake)
+    for i, (x, y) in enumerate(snake):
+        hue = (i / length) % 1.0  # Spread hue over the snake's body
+        color = hsv2rgb(hue, 1.0, 1.0)
+        setze_pixel(x, y, color)
+
+    # Essen anzeigen
+    fx, fy = essen
+    setze_pixel(fx, fy, zufall_farbe())
+
+    matrix.write()
+
+def neues_essen(snake):
+    leere_felder = [(x, y) for x in range(8) for y in range(8) if (x, y) not in snake]
+    return choice(leere_felder)
+
+def draw_x_pattern(color):
+    for i in range(8):
+        setze_pixel(i, i, color)
+        setze_pixel(i, 7 - i, color)
+    matrix.write()
+
+DIGIT_PATTERNS = {
+    '0': ["###",
+          "# #",
+          "# #",
+          "# #",
+          "###"],
+    '1': ["  #",
+          "  #",
+          "  #",
+          "  #",
+          "  #"],
+    '2': ["###",
+          "  #",
+          "###",
+          "#  ",
+          "###"],
+    '3': ["###",
+          "  #",
+          "###",
+          "  #",
+          "###"],
+    '4': ["# #",
+          "# #",
+          "###",
+          "  #",
+          "  #"],
+    '5': ["###",
+          "#  ",
+          "###",
+          "  #",
+          "###"],
+    '6': ["###",
+          "#  ",
+          "###",
+          "# #",
+          "###"],
+    '7': ["###",
+          "  #",
+          "  #",
+          "  #",
+          "  #"],
+    '8': ["###",
+          "# #",
+          "###",
+          "# #",
+          "###"],
+    '9': ["###",
+          "# #",
+          "###",
+          "  #",
+          "###"]
+}
+
+def draw_digit(digit, x_offset, y_offset, color):
+    pattern = DIGIT_PATTERNS.get(str(digit), ["   "]*5)
+    for y, row in enumerate(pattern):
+        for x, char in enumerate(row):
+            if char == '#':
+                px = x + x_offset
+                py = y + y_offset
+                if 0 <= px < 8 and 0 <= py < 8:
+                    setze_pixel(px, py, color)
+
+def game_over(score):
+    red = (255, 0, 0)
+    black = (0, 0, 0)
+
+    # Flash X pattern
+    matrix.fill(black)
+    flashes = 3
+    for _ in range(flashes):
+        draw_x_pattern(red)
+        time.sleep(0.3)
+        draw_x_pattern(black)
+        time.sleep(0.2)
+
+    # Fade out the X
+    steps = 10
+    for i in range(steps, -1, -1):
+        fade_color = (int(255 * i / steps), 0, 0)
+        draw_x_pattern(fade_color)
+        time.sleep(0.05)
+    matrix.fill(black)
+    matrix.write()
+
+    digits = f"{score:02}"
+
+    # Draw the two digits centered (3x5 font with 1 column space)
+    matrix.fill(black)
+    draw_digit(digits[0], 0, 1, red)
+    draw_digit(digits[1], 5, 1, red)
+    matrix.write()
+    time.sleep(1.5)
+
+    matrix.fill(black)
+    matrix.write()
+
+def spiel():
+    snake = [(4, 4)]
+    richtung = "rechts"
+    essen = neues_essen(snake)
+
+    while True:
+        naechste_richtung = neue_richtung()
+
+        if naechste_richtung in RICHTUNGEN:
+            richtung = naechste_richtung
+
+        dx, dy = RICHTUNGEN[richtung]
+        head_x, head_y = snake[0]
+        neuer_kopf = (head_x + dx, head_y + dy)
+
+        if (neuer_kopf in snake or
+            not (0 <= neuer_kopf[0] < 8 and 0 <= neuer_kopf[1] < 8)):
+            game_over(len(snake) - 1)
+            break
+
+        snake.insert(0, neuer_kopf)
+
+        if neuer_kopf == essen:
+            essen = neues_essen(snake)
+        else:
+            snake.pop()
+
+        anzeigen(snake, essen)
+        time.sleep(0.4)
+
+while True:
+    spiel()
+    time.sleep(1)

main.py

@@ -0,0 +1,225 @@
+import neopixel
+from machine import Pin
+import time
+from random import randint, random, seed, choice
+
+seed()
+
+ws_pin = 0
+led_zahl = 64
+helligkeit = 0.05
+
+matrix = neopixel.NeoPixel(Pin(ws_pin), led_zahl)
+
+taster_hoch = Pin(1, Pin.IN, Pin.PULL_UP)
+taster_runter = Pin(2, Pin.IN, Pin.PULL_UP)
+taster_rechts = Pin(3, Pin.IN, Pin.PULL_UP)
+taster_links = Pin(4, Pin.IN, Pin.PULL_UP)
+
+scalar = float # a scale value (0.0 to 1.0)
+def hsv2rgb(h:scalar, s:scalar, v:scalar) -> tuple:
+    if s:
+        if h == 1.0: h = 0.0
+        i = int(h*6.0); f = h*6.0 - i
+        
+        w = int(255*( v * (1.0 - s) ))
+        q = int(255*( v * (1.0 - s * f) ))
+        t = int(255*( v * (1.0 - s * (1.0 - f)) ))
+        v = int(255*v)
+        
+        if i==0: return (v, t, w)
+        if i==1: return (q, v, w)
+        if i==2: return (w, v, t)
+        if i==3: return (w, q, v)
+        if i==4: return (t, w, v)
+        if i==5: return (v, w, q)
+    else: v = int(255*v); return (v, v, v)
+
+def zufall_farbe():
+    return hsv2rgb(random(), 1.0, 1.0)
+
+def setze_helligkeit(farbe):
+    r, g, b = farbe
+    r = int(r * helligkeit)
+    g = int(g * helligkeit)
+    b = int(b * helligkeit)
+    return (r, g, b)
+
+def setze_pixel(x, y, farbe):
+    farbe = setze_helligkeit(farbe)
+    i = y * 8 + x
+    matrix[i] = farbe
+
+def neue_richtung():
+    if not taster_runter.value():
+        return "runter"
+    if not taster_rechts.value():
+        return "rechts"
+    if not taster_links.value():
+        return "links"
+    if not taster_hoch.value(): 
+        return "hoch"
+
+RICHTUNGEN = {
+    "hoch": (0, -1),
+    "runter": (0, 1),
+    "links": (-1, 0),
+    "rechts": (1, 0)
+}
+
+def anzeigen(snake, essen):
+    matrix.fill((0, 0, 0))
+
+    # Snake anzeigen
+    length = len(snake)
+    for i, (x, y) in enumerate(snake):
+        hue = (i / length) % 1.0  # Spread hue over the snake's body
+        color = hsv2rgb(hue, 1.0, 1.0)
+        setze_pixel(x, y, color)
+
+    # Essen anzeigen
+    fx, fy = essen
+    setze_pixel(fx, fy, zufall_farbe())
+
+    matrix.write()
+
+def neues_essen(snake):
+    leere_felder = [(x, y) for x in range(8) for y in range(8) if (x, y) not in snake]
+    return choice(leere_felder)
+
+def draw_x_pattern(color):
+    for i in range(8):
+        setze_pixel(i, i, color)
+        setze_pixel(i, 7 - i, color)
+    matrix.write()
+
+DIGIT_PATTERNS = {
+    '0': ["###",
+          "# #",
+          "# #",
+          "# #",
+          "###"],
+    '1': ["  #",
+          "  #",
+          "  #",
+          "  #",
+          "  #"],
+    '2': ["###",
+          "  #",
+          "###",
+          "#  ",
+          "###"],
+    '3': ["###",
+          "  #",
+          "###",
+          "  #",
+          "###"],
+    '4': ["# #",
+          "# #",
+          "###",
+          "  #",
+          "  #"],
+    '5': ["###",
+          "#  ",
+          "###",
+          "  #",
+          "###"],
+    '6': ["###",
+          "#  ",
+          "###",
+          "# #",
+          "###"],
+    '7': ["###",
+          "  #",
+          "  #",
+          "  #",
+          "  #"],
+    '8': ["###",
+          "# #",
+          "###",
+          "# #",
+          "###"],
+    '9': ["###",
+          "# #",
+          "###",
+          "  #",
+          "###"]
+}
+
+def draw_digit(digit, x_offset, y_offset, color):
+    pattern = DIGIT_PATTERNS.get(str(digit), ["   "]*5)
+    for y, row in enumerate(pattern):
+        for x, char in enumerate(row):
+            if char == '#':
+                px = x + x_offset
+                py = y + y_offset
+                if 0 <= px < 8 and 0 <= py < 8:
+                    setze_pixel(px, py, color)
+
+def game_over(score):
+    red = (255, 0, 0)
+    black = (0, 0, 0)
+
+    # Flash X pattern
+    matrix.fill(black)
+    flashes = 3
+    for _ in range(flashes):
+        draw_x_pattern(red)
+        time.sleep(0.3)
+        draw_x_pattern(black)
+        time.sleep(0.2)
+
+    # Fade out the X
+    steps = 10
+    for i in range(steps, -1, -1):
+        fade_color = (int(255 * i / steps), 0, 0)
+        draw_x_pattern(fade_color)
+        time.sleep(0.05)
+    matrix.fill(black)
+    matrix.write()
+
+    digits = f"{score:02}"
+
+    # Draw the two digits centered (3x5 font with 1 column space)
+    matrix.fill(black)
+    draw_digit(digits[0], 0, 1, red)
+    draw_digit(digits[1], 5, 1, red)
+    matrix.write()
+    time.sleep(1.5)
+
+    matrix.fill(black)
+    matrix.write()
+
+def spiel():
+    snake = [(4, 4)]
+    richtung = "rechts"
+    essen = neues_essen(snake)
+
+    while True:
+        naechste_richtung = neue_richtung()
+
+        if naechste_richtung in RICHTUNGEN:
+            richtung = naechste_richtung
+
+        dx, dy = RICHTUNGEN[richtung]
+        head_x, head_y = snake[0]
+        neuer_kopf = (head_x + dx, head_y + dy)
+
+        if (neuer_kopf in snake or
+            not (0 <= neuer_kopf[0] < 8 and 0 <= neuer_kopf[1] < 8)):
+            game_over(len(snake) - 1)
+            break
+
+        snake.insert(0, neuer_kopf)
+
+        if neuer_kopf == essen:
+            essen = neues_essen(snake)
+        else:
+            snake.pop()
+
+        anzeigen(snake, essen)
+        time.sleep(0.4)
+
+while True:
+    spiel()
+    time.sleep(1)