import neopixel
from random import randrange
from machine import Pin, ADC
from time import sleep

led = 16
np = neopixel.NeoPixel(Pin(5),led)

led1 = 16
np1 = neopixel.NeoPixel(Pin(17),led1)

led2 = 16
np2 = neopixel.NeoPixel(Pin(16),led2)

led3 = 16
np3 = neopixel.NeoPixel(Pin(4),led3)
nakl = (randrange(255),randrange(255),randrange(255))
nakl1 = (randrange(255),randrange(255),randrange(255))

NUM_LED = 16
sz = [4,8,12,16]

n1 = 16
pot = ADC(Pin(25))
leds = neopixel.NeoPixel(Pin(15),n1)

t1 = 0

while True:
    t = (randrange(255),randrange(255),randrange(255))
    for i in range(led):
        np[i] = t
    np.write()
    sleep(0.5)
    for i in range(led):
        np[i] = [0,0,0]
    np.write()
    sleep(0.1)

    if t1 >= led1:
        t1 = 0
    for p in range(led1):
        np1[p] = [0,0,0]
    np1[t1] = [155,155,155]
    t1 = t1 + 1
    np1.write()
    sleep(0.001)

    t2 = (randrange(255),randrange(255),randrange(255))
    for k in range(led2):
        np2[k] = t2
    np2.write()
    sleep(0.01)

    for z in range(led3):
        np3[z] = nakl
        np3.write()
        sleep(0.02)
    for z in range(led3 -1,-1,-1):
        np3[z] = nakl1
        np3.write()
        sleep(0.02)

    for m in range(n1):
        leds[m-1] = [0, 0, 0]
        leds[m] = [150, 500, 50]

        sleep(max(pot.read() / 1000, 0.1))
        leds.write()
        

# Poenostavljena koda:

import neopixel
from random import randrange
from machine import Pin, ADC
from time import sleep

def set_leds_color(strip, color):
    for i in range(NUM_LED):
        strip[i] = color
    strip.write()

def blink_random_color(strip, delay_on, delay_off):
    color = (randrange(255), randrange(255), randrange(255))
    set_leds_color(strip, color)
    sleep(delay_on)
    set_leds_color(strip, (0, 0, 0))
    sleep(delay_off)

NUM_LED = 16
np = [neopixel.NeoPixel(Pin(pin), NUM_LED) for pin in [5, 17, 16, 4]]

pot = ADC(Pin(25))

t1 = 0
while True:
    blink_random_color(np[0], 0.5, 0.1)

    if t1 >= NUM_LED:
        t1 = 0
    set_leds_color(np[1], (0, 0, 0))
    np[1][t1] = (155, 155, 155)
    t1 += 1
    np[1].write()
    sleep(0.001)

    blink_random_color(np[2], 0.01, 0)


    gradient_color = (randrange(255), randrange(255), randrange(255))
    for z in range(NUM_LED):
        np[3][z] = gradient_color if z % 2 == 0 else (gradient_color[2], gradient_color[1], gradient_color[0])
        np[3].write()
        sleep(max(pot.read() / 1000, 0.02))

# DHT SENZOR

import neopixel
from machine import Pin
import dht

NUM_LEDS = 30  # Število LED diod na traku
PIN_NUM = 5  # Pin, na katerega je priključen LED trak
np = neopixel.NeoPixel(Pin(PIN_NUM), NUM_LEDS)
dht_sensor = dht.DHT22(Pin(4))  # Nadomestite s številko pina, na katerega je priključen DHT22

def update_color():
    dht_sensor.measure()
    temp = dht_sensor.temperature()
    humidity = dht_sensor.humidity()
    # Spremenite formulo za barvo glede na vaše potrebe
    return (int(temp * 2), int(humidity * 2), 0)

while True:
        np.fill(update_color())
        np.write()

# VSE V ENEM
Utripajoči LED-pikseli (2 točki):

Pikseli na traku morajo utripati namerno.
Kroženje svetlobe (2 točki):

Svetloba na traku mora krožiti okoli LED-kroga.
Spreminjanje barve LED-pikselov:

Naključno spreminjanje barv (1 točka).
Logično spreminjanje barv (2 točki):
Barva LED-pikselov je odvisna od prejšnje barve naslednjega piksla.
Spreminjanje smeri animacije (3 točke):

Animacija spreminja svojo smer glede na poljuben dejavnik.)

import neopixel
from machine import Pin
from time import sleep
from random import randrange

NUM_LEDS = 30 
PIN_NUM = 5 
np = neopixel.NeoPixel(Pin(PIN_NUM), NUM_LEDS)

def utripajoci_led():
    for i in range(NUM_LEDS):
        np[i] = (randrange(255), randrange(255), randrange(255))
    np.write()
    sleep(0.5)
    for i in range(NUM_LEDS):
        np[i] = (0, 0, 0)
    np.write()
    sleep(0.5)

def krozenje_svetlobe():
    for i in range(NUM_LEDS):
        np[i] = (255, 255, 255)
        if i > 0:
            np[i - 1] = (0, 0, 0)
        np.write()
        sleep(0.1)

def spreminjanje_barv(logicno=False):
    predhodna_barva = (0, 0, 0)
    for i in range(NUM_LEDS):
        nova_barva = (randrange(255), randrange(255), randrange(255))
        np[i] = predhodna_barva if logicno else nova_barva
        predhodna_barva = nova_barva
        np.write()
        sleep(0.1)

def spreminjanje_smeri_animacije(dejavnik):
    obratna_smer = dejavnik 
    range_func = range(NUM_LEDS-1, -1, -1) if obratna_smer else range(NUM_LEDS)
    for i in range_func:
        np[i] = (255, 0, 0)
        np.write()
        sleep(0.1)
        np[i] = (0, 0, 0)


while True:
    utripajoci_led()
    krozenje_svetlobe()
    spreminjanje_barv(logicno=True)
    spreminjanje_smeri_animacije(dejavnik=randrange(2))

# PREJŠNJI TEST:(3)

-------------------------------------------------------------------------
utripajoči led pixli
- led pixli na traku utripajo pomeni da se lucka prizge uganse prizge uganse...
Zrcaljenje animacije
- animacija naj bo simetricna(ali levo ali desno, ali gor ali dol)
Spreminajnje barv led pixlov
- glede na predhodni pixel(gradient)
Izmenicne barve LED pixlov
- v animaciji je vsak drugi pixel pobarvan z isto barvo. Vsak prvi pa isto s svojo barvo(recimo ledica 1-rdeča, ledica 2-modra,ledica 3-rdeca, ledica 4-modra...)
Nadzor močnosti barve z uporao potenciometra

Kontrola animacije z gumbom(animacija se zacne od začetka ob pritisku na gumb)
Animaciaj spreminja hitrost glede na DHT22 senzor(od vlage ali teperature)

To mi je naredu chatgpt:

from machine import Pin, ADC
import neopixel
import dht
import time

# Nastavitve pinov
LED_PIN = 15  # Pin, na katerega so povezani LED trakovi
BUTTON_PIN = 14  # Pin, na katerega je povezan gumb
POT_PIN = 32  # Pin, na katerega je povezan potenciometer
DHT_PIN = 4  # Pin, na katerega je povezan senzor DHT22
DHT_SENSOR_TYPE = dht.DHT22

# Nastavitve LED trakov
NUM_LEDS = 10  # Število LED pikslov
PIXEL_COLORS = [(255, 0, 0), (0, 0, 255)]  # Barve LED pikslov
BRIGHTNESS = 0.5  # Privzeta svetlost LED pikslov (0-1)

# Inicializacija komponent
leds = neopixel.NeoPixel(Pin(LED_PIN), NUM_LEDS)
button = Pin(BUTTON_PIN, Pin.IN, Pin.PULL_UP)
pot = ADC(Pin(POT_PIN))
dht_sensor = dht.DHT22(Pin(DHT_PIN))

# Funkcija za branje vrednosti potenciometra in pretvorbo v svetlost
def read_pot_brightness():
    return pot.read_u16() / 65535  # Vrednost potenciometra normaliziramo na obseg 0-1

# Funkcija za branje temperature iz senzorja DHT22
def read_temperature():
    dht_sensor.measure()
    return dht_sensor.temperature()

# Funkcija za branje vlage iz senzorja DHT22
def read_humidity():
    dht_sensor.measure()
    return dht_sensor.humidity()

# Funkcija za izmenične barve LED pikslov
def alternate_colors():
    for i in range(NUM_LEDS):
        if i % 2 == 0:
            leds[i] = PIXEL_COLORS[0]
            leds.write()
        else:
            leds[i] = PIXEL_COLORS[1]
            leds.write()

# Funkcija za zrcaljenje animacije
def mirror_animation():
    for i in range(NUM_LEDS):
        leds[i] = PIXEL_COLORS[i % len(PIXEL_COLORS)]
        leds.write()

# Funkcija za utripajoči led piksli
def flashing_pixels():
    while True:
        for color in PIXEL_COLORS:
            for i in range(NUM_LEDS):
                leds[i] = color
                leds.write()
            time.sleep(0.5)

# Funkcija za nadzor močnosti barve z uporabo potenciometra
def control_brightness():
    while True:
        brightness = read_pot_brightness()
        leds.brightness(brightness)
        time.sleep(0.1)

# Funkcija za nadzor animacije z gumbom
def control_animation():
    while True:
        if not button.value():
            flashing_pixels()  # Na pritisni gumb zaženemo utripajoče piksle

# Funkcija za spreminjanje hitrosti animacije glede na temperaturo
def control_speed():
    while True:
        temperature = read_temperature()
        # Prilagodite hitrost animacije glede na temperaturo
        delay = int(1000 / (temperature + 1))  # Lahko prilagodite glede na potrebe
        time.sleep_ms(delay)

# Začetek izvajanja kode
flashing_pixels() 
mirror_animation()  # Začetna animacija (na primer zrcaljena animacija)
control_animation()  # Začne nadzor animacije z gumbom

par stvari mi dela ostalo ne

tam k pise #zacetek izvajanja kode das ime funkcije, v funkcije pa dodas se leds.write()

# OD DORIANA

#utripajoči led pixli
# - led pixli na traku utripajo pomeni da se lucka prizge uganse prizge uganse...
# Zrcaljenje animacije
#  - animacija naj bo simetricna(ali levo ali desno, ali gor ali dol)
#Spreminajnje barv led pixlov
# - glede na predhodni pixel(gradient)
# Izmenicne barve LED pixlov
# - v animaciji je vsak drugi pixel pobarvan z isto barvo. Vsak prvi pa isto s svojo barvo(recimo ledica #1-rdeča, ledica 2-modra,ledica 3-rdeca, ledica 4-modra...)
# Nadzor močnosti barve z uporao potenciometra
#
# Kontrola animacije z gumbom(animacija se zacne od začetka ob pritisku na gumb)
# Animaciaj spreminja hitrost glede na DHT22 senzor(od vlage ali teperature)

from machine import Pin, ADC
from time import sleep
import neopixel
import random

nl = 16
led = neopixel.NeoPixel(Pin(18), nl)
speed = ADC(Pin(32))
btn = Pin(2, Pin.IN, Pin.PULL_UP)

def off():
    led.fill([0,0,0])
    led.write()

def fill():
    led.fill([255,0,0])
    led.write()

def zrcaljenje():
    zb = []
    for i in range(16):
        if i == 0 or i == 8:
            led[i] = (255, 0, 0)
            led.write()
            zb.append((255, 0, 0))
            sleep(0.2)
        elif i < 8:
            led[i] = (0, 255, 0)
            led.write()
            zb.append((0, 255, 0))
            sleep(0.2)
        else:
            led[i] = (0, 0, 255)
            led.write()
            zb.append((0, 0, 255))
            sleep(0.2)
    for i in range(5):
        off()
        sleep(0.5)
        for i in range(16):
            led[i] = zb[i]
        led.write()
        sleep(0.5)

while True:
    for i in range(5):
        fill()
        sleep(0.5)
        off()
        sleep(0.5)
    zrcaljenje()
    sleep(5)

# jernej poglj u grupo z alenam za test mas not cis ucpodi