import machine
import neopixel
import time

# Pin waar de NeoPixel op is aangesloten
PIN = 5
# Aantal LEDs in de NeoPixel-ring
LED_COUNT = 16
# Pin waar de potentiometer op is aangesloten
POTENTIOMETER_PIN = 2  # Voor ESP32 is pin 34 een analoge pin
# Maximale waarde die de potentiometer kan bereiken
POT_MAX_VALUE = 4095

# Setup van de NeoPixel
np = neopixel.NeoPixel(machine.Pin(PIN), LED_COUNT)

# Functie om een specifiek aantal LEDs in te schakelen van LED 1 tot de opgegeven index
def illuminate_leds(num_leds):
    for i in range(LED_COUNT):
        if i < num_leds:
            if i < LED_COUNT / 4:
                np[i] = (0, 255, 0)  # Groen voor LED 1 tot 4
            elif i < LED_COUNT / 2:
                np[i] = (255, 255, 0)  # Geel voor LED 5 tot 8
            elif i < 3 * LED_COUNT / 4:
                np[i] = (255, 165, 0)  # Oranje voor LED 9 tot 12
            else:
                np[i] = (255, 0, 0)  # Rood voor LED 13 tot 16
        else:
            np[i] = (0, 0, 0)  # Zet de rest van de LEDs uit
    np.write()

# Functie om de waarde van de potentiometer te lezen en te vertalen naar het aantal geactiveerde LEDs
def read_potentiometer_value():
    pot_value = machine.ADC(machine.Pin(POTENTIOMETER_PIN)).read()
    # Omgekeerde mapping van de potentiometerwaarde naar het bereik van 1 tot LED_COUNT
    reversed_value = POT_MAX_VALUE - pot_value
    return round((reversed_value / POT_MAX_VALUE) * LED_COUNT) + 1

# Functie om alle LED's twee keer te laten knipperen in het wit
def flash_all_leds():
    for _ in range(2):
        for i in range(LED_COUNT):
            np[i] = (255, 255, 255)  # Wit voor alle LED's
        np.write()
        time.sleep(0.2)  # Wacht een korte tijd voordat de LED's opnieuw worden uitgeschakeld
        for i in range(LED_COUNT):
            np[i] = (0, 0, 0)  # Schakel alle LED's uit
        np.write()
        time.sleep(0.2)  # Wacht een korte tijd voordat de LED's opnieuw worden ingeschakeld

# Functie om het spel uit te voeren
def run_game():
    timer_start = time.time()  # Start de timer
    while True:
        elapsed_time = time.time() - timer_start  # Bereken de verstreken tijd
        if elapsed_time >= 6:  # Als de verstreken tijd 6 seconden bereikt
            flash_all_leds()  # Laat alle LED's twee keer wit flikkeren
            break  # Stop de lus
        num_leds = read_potentiometer_value()  # Lees het aantal geactiveerde LEDs van de potentiometer
        illuminate_leds(num_leds)  # Schakel de LEDs in van LED 1 tot het gelezen aantal

# Voer het spel uit
run_game()

import machine
import neopixel
import time
import urandom

# Pin waar de NeoPixel op is aangesloten
PIN = 5
# Aantal LEDs in de NeoPixel-ring
LED_COUNT = 16
# Pin waar de potentiometer op is aangesloten
POTENTIOMETER_PIN = 2
# Maximale waarde die de potentiometer kan bereiken
POT_MAX_VALUE = 4095
# Aantal stappen per volledige rotatie van de potentiometer
STEPS_PER_ROTATION = 1024

# Setup van de NeoPixel
np = neopixel.NeoPixel(machine.Pin(PIN), LED_COUNT)

# Kleuren voor elk rijtje van 4 LED's
ROW_COLORS = [
    (255, 0, 0),     # Rood
    (0, 255, 0),     # Groen
    (0, 0, 255),     # Blauw
    (255, 255, 0),   # Geel
]

# Functie om alle LEDs uit te schakelen
def clear():
    np.fill((0, 0, 0))
    np.write()

# Functie om een specifiek aantal LEDs in te schakelen met een bepaalde kleur, beginnend bij de opgegeven startindex
def illuminate_leds(start_index, num_leds, color):
    for i in range(start_index, start_index + num_leds):
        np[i % LED_COUNT] = color  # Zorg ervoor dat de index binnen het bereik van LED_COUNT blijft
    np.write()

# Functie om de waarde van de potentiometer te lezen en te vertalen naar het aantal rotaties
def read_potentiometer_value():
    pot_value = machine.ADC(machine.Pin(POTENTIOMETER_PIN)).read()
    return pot_value / POT_MAX_VALUE  # Deel de huidige waarde door het maximale bereik van de potentiometer

# Functie om het aantal LEDs te berekenen op basis van het aantal rotaties
def calculate_led_count(rotations):
    return int(rotations * LED_COUNT)  # Verdeel de NeoPixel-ring in rotaties en bereken het aantal LEDs

# Functie om LEDs in paren van 4 in of uit te schakelen op basis van het aantal rotaties van de potentiometer
def control_led_pairs(rotations):
    led_count = min(LED_COUNT, calculate_led_count(rotations))  # Bereken het aantal verlichte LEDs op basis van het aantal rotaties, met een maximum van LED_COUNT
    pairs_count = led_count // 4  # Bereken het aantal paren van 4 LEDs
    clear()  # Zet alle LEDs uit
    player_colors = []  # Lijst om de kleuren van de spelers bij te houden
    for i in range(pairs_count):
        color_index = i % len(ROW_COLORS)  # Bepaal de index van de kleur op basis van de huidige positie
        color = ROW_COLORS[color_index]  # Kies een kleur voor dit rijtje van 4 LED's
        illuminate_leds(i * 4, 4, color)  # Schakel LEDs in paren van 4 in met de gekozen kleur
        player_colors.append(color)  # Voeg de kleur van de speler toe aan de lijst
    np.write()
    return player_colors  # Retourneer de lijst met kleuren van de spelers

# Functie om alle LED's twee keer te laten knipperen in het wit
def flash_all_leds():
    for _ in range(2):
        clear()
        time.sleep(0.2)  # Wacht een korte tijd voordat de LED's opnieuw worden ingeschakeld
        illuminate_leds(0, LED_COUNT, (255, 255, 255))  # Schakel alle LED's in met witte kleur
        np.write()
        time.sleep(0.2)  # Wacht een korte tijd voordat de LED's opnieuw worden uitgeschakeld

# Functie om elk LEDje één voor één uit te laten gaan
def turn_off_leds_one_by_one():
    for i in range(LED_COUNT):
        np[i] = (0, 0, 0)  # Schakel het huidige LEDje uit
        np.write()
        time.sleep(0.1)  # Wacht een korte tijd voordat het volgende LEDje wordt uitgeschakeld

# Functie om elke speler 16 seconden te geven waarbij elke seconde een LED van zijn kleur wordt ingeschakeld
def player_time(player_colors):
    for color in player_colors:
        for i in range(LED_COUNT):
            np[i] = color  # Schakel het huidige LEDje in met de kleur van de speler
            np.write()
            time.sleep(1)  # Wacht één seconde voordat het volgende LEDje wordt ingeschakeld
    clear()  # Zet alle LEDs uit

# Functie om elk LEDje één keer wit te laten flikkeren
def flicker_all_leds_once():
    clear()
    time.sleep(0.2)  # Wacht een korte tijd voordat de LED's opnieuw worden ingeschakeld
    for i in range(LED_COUNT):
        flicker_color = (urandom.randint(150, 255), urandom.randint(150, 255), urandom.randint(150, 255))  # Kies een willekeurige flikkerkleur
        np[i] = flicker_color
        np.write()
    time.sleep(0.2)  # Wacht een korte tijd voordat de LED's opnieuw worden uitgeschakeld
    clear()  # Zet alle LEDs uit

# Functie om de hoofdfunctionaliteit uit te voeren
def run_game():
    clear()  # Zet alle LEDs uit
    start_time = time.ticks_ms()  # Tijdregistratie van het starten van het kleurenkiezen
    while time.ticks_diff(time.ticks_ms(), start_time) < 6000:  # Laat het kleurenkiezen maximaal 6 seconden duren
        rotations = read_potentiometer_value() * 2  # Lees het aantal rotaties van de potentiometer (max. 360 graden)
        control_led_pairs(rotations)  # Pas de verlichting van de LED's aan op basis van het aantal rotaties
        time.sleep(0.1)  # Wacht een korte tijd voordat je de potentiometer opnieuw leest
    flash_all_leds()  # Knipper alle LED's twee keer in het wit
    turn_off_leds_one_by_one()  # Schakel elk LEDje één voor één uit
    selected_player_colors = control_led_pairs(rotations)  # Kies de kleuren van de spelers
    player_time(selected_player_colors)  # Geef elke geselecteerde speler 16 seconden met geactiveerde LED's
    flicker_all_leds_once()  # Laat elk LEDje één keer wit flikkeren voordat de countdown opnieuw begint

# Voer het spel uit
while True:
    run_game()  # Voer het spel uit in een oneindige lus