---
# System prepended metadata

title: UPN -Primeri iz predavanj

---

# UPN -Primeri iz predavanj

[Wokwi main page](https://wokwi.com/)
[New ESP32 MicroPy project](https://wokwi.com/projects/new/micropython-esp32)


## 2 LED blink 
![prva](https://hackmd.io/_uploads/BydqL5Jka.png "Screenshot nalepim kar iz clipboarda")

```python

from machine import Pin 

from utime import sleep 

p18 = Pin(18, Pin.OUT) 

p5 = Pin(5, Pin.OUT) 

d = 0.1 

while True: 

  #prva ledica 

  p18.value(1) 

  sleep(d) 

  p18.value(0) 

  sleep(d) 

  #druga ledica 

  p5.value(1) 

  sleep(d) 

  p5.value(0) 

  sleep(d) 

 
 

# naj LEDice izmenično utripajo. 

 

 
```
## 2 LEDici blink list var 

```python

from machine import Pin 

from utime import sleep 


pList = [5, 18] 

pins = [] 

d = 0.2 

for p in pList: 

  pins.append(Pin(p, Pin.OUT)) 


while True: 

  for p in pins: 

    p.value(1) 

    sleep(d) 

    p.value(0) 

    sleep(d) 

 
 

# naj LEDice utripajo sinhrono (obe naenkrat). 

 ```

 
 
## NeoPixel(WS2812) ring - intro
```python

import neopixel 

from machine import Pin 

... (1,054 lines left)
Collapse
message.txt
32 KB
﻿
# UPN -Primeri iz predavanj

[Wokwi main page](https://wokwi.com/)
[New ESP32 MicroPy project](https://wokwi.com/projects/new/micropython-esp32)


## 2 LED blink 
![prva](https://hackmd.io/_uploads/BydqL5Jka.png "Screenshot nalepim kar iz clipboarda")

```python

from machine import Pin 

from utime import sleep 

p18 = Pin(18, Pin.OUT) 

p5 = Pin(5, Pin.OUT) 

d = 0.1 

while True: 

  #prva ledica 

  p18.value(1) 

  sleep(d) 

  p18.value(0) 

  sleep(d) 

  #druga ledica 

  p5.value(1) 

  sleep(d) 

  p5.value(0) 

  sleep(d) 

 
 

# naj LEDice izmenično utripajo. 

 

 
```
## 2 LEDici blink list var 

```python

from machine import Pin 

from utime import sleep 


pList = [5, 18] 

pins = [] 

d = 0.2 

for p in pList: 

  pins.append(Pin(p, Pin.OUT)) 


while True: 

  for p in pins: 

    p.value(1) 

    sleep(d) 

    p.value(0) 

    sleep(d) 

 
 

# naj LEDice utripajo sinhrono (obe naenkrat). 

 ```

 
 
## NeoPixel(WS2812) ring - intro
```python

import neopixel 

from machine import Pin 

from time import sleep 

NUM_LED = 24 


leds = neopixel.NeoPixel(Pin(5), NUM_LED) 


while True: 

  for l in range(NUM_LED): 

    leds[l] = [200, 100, 10] 

    leds.write() 

    sleep(0.2) 


  for l in range(NUM_LED): 

    leds[l] = (0, 0, 0) 

    leds.write() 

    sleep(0.2) 
 ```

 
 
# Moje vaje
```python=
#Moje vaje UPNja
from neopixel import NeoPixel
from utime import sleep
from machine import Pin, ADC
import random

NUM_LED = 16

leds = NeoPixel(Pin(18), NUM_LED)

while True:
    a = random.randint(0, NUM_LED - 1)
    leds[a] = (255, 0, 0)
    leds.write()

    cycles = random.randint(1, 5)
    b = random.randint(0, 1)

    for _ in range(cycles):
        for i in range(NUM_LED):
            if leds[i] == leds[a] and b != 1:
                leds[i] = (255, 0, 0)
            else:
                leds[i] = (0, 0, 255)
            leds.write()
            sleep(0.4)
            leds[i] = (0, 0, 0)
            leds.write()

    if b == 1 and leds[a] != (0, 0, 0):
        leds[a] = (0, 0, 0)
        leds.write()

    sleep(1)

```
## Vaja12.py
```python=
from neopixel import NeoPixel 
from utime import sleep
from machine import Pin, ADC
import random
num_led = 16

leds = NeoPixel(Pin(18), num_led)

a = random.randint(0, 255)
b = random.randint(0, 255)
c = random.randint(0, 255)

while True:
  d = a//16
  e = b//16
  f = c//16

  for i in range(num_led):
    leds[i] = (a, b, c)
    leds.write()
    sleep(0.5)
    a -= d
    b -= e
    c -= f

  for i in reversed(range(num_led)):
    leds[i] = (0, 0, 0)
    leds.write()
    sleep(0.5)
  
  a = random.randint(0, 255)
  b = random.randint(0, 255)
  c = random.randint(0, 255)

```
## Vaja11.py
```python=
from machine import Pin
button1 =  Pin(18, Pin.IN, Pin.PULL_UP)
button2 =  Pin(19, Pin.IN, Pin.PULL_UP)
ledO = Pin(2, Pin.OUT)
ledP = Pin(4, Pin.OUT)

while True:
    if not button1.value():
        ledO.value(1)
    elif not button2.value():
        ledO.value(1)
        ledP.value(1)
    else:
        ledO.value(0)
        ledP.value(0)
```
## Vaja10.py
```python=
from machine import Pin, ADC
from utime import sleep
from neopixel import NeoPixel
num_led = 16
leds = NeoPixel(Pin(18), num_led) 

pot1 = ADC(Pin(15))
pot2 = ADC(Pin(2))
pot3 = ADC(Pin(4))

while True:
    leds.fill([pot1.read()//16,pot2.read()//16,pot3.read()//16])
    leds.write()
```
## Vaja9.py
```python=
from neopixel import NeoPixel
from machine import Pin
from utime import sleep
import time

led_num = 60
leds = NeoPixel(Pin(18), led_num)

while True:
    current_time = time.localtime() 
    minutes, seconds = current_time[4:6] 

    minutes_pixel = int((minutes % 60) * (led_num / 60))
    seconds_pixel = int((seconds % 60) * (led_num / 60))

    leds.fill((0, 0, 0))
    leds[minutes_pixel] = (0, 255, 0) 
    leds[seconds_pixel] = (255, 0, 0)  
    leds.write()
    sleep(1)
```  
## Vaja8.py
```python=
from neopixel import NeoPixel
from machine import Pin
from utime import sleep
import random
led = 16
st = 0
st2 = 0
leds = NeoPixel(Pin(18), led)

while True:
    a = random.randint(100, 256)
    for i in range(led):
        if st > a:
            st = 0
            leds[st2%led] = (25, 100, 250)
            leds.write()
            sleep(4)
        if st2 == led:
            st2 = 0
        leds[i] = (25, 100, 250)
        leds.write()
        sleep(0.1)
        leds[i] = (0, 0, 0)
        leds.write()
        st2 += 1
        st += random.randint(0, 16)
```
## Vaja7.py
```python=
from neopixel import NeoPixel
from utime import sleep
from machine import Pin
led = 24
st = led//3
leds = NeoPixel(Pin(18), led) 

while True:
    for i in range(st):
        leds[i] = (113, 50, 200)
    leds.write()
    sleep(1)
    for i in range(st):
        leds[i] = (0, 0, 0)
    leds.write()
    for i in range(st, (2*st)):
        leds[i] = (113, 50, 200)
    leds.write()
    sleep(1)
    for i in range(2*st):
        leds[i] = (0, 0, 0)
    leds.write()
    for i in range((2*st), led):
        leds[i] = (113, 50, 200)
    leds.write()
    sleep(1)
    for i in range((2*st), led):
        leds[i] = (0, 0, 0)
    leds.write()

```
## Vaja6.py
```python=
from neopixel import NeoPixel
from utime import sleep
from machine import Pin
led = 16
st = 0
leds = NeoPixel(Pin(18), led) 

while True:
    for i in range(led):
        if st == led:
            st = 0
        leds[i] = (255, 0, 0)
        leds[st] = (0, 0, 255)
        st+=2
    leds.write()
    sleep(1)
    for i in range(led):
        if st == led:
            st = 0
        leds[i] = (0, 0, 255)
        leds[st] = (255, 0, 0)
        st+=2
    leds.write()
    sleep(1)


```
## Vaja5.py
```python

from neopixel import NeoPixel
from utime import sleep
from machine import Pin
import random
NUM_LED = 160
count = 0
st = NUM_LED//4
leds = NeoPixel(Pin(18), NUM_LED) 


while True:
  leds[count] = (random.randint(0, 255), random.randint(0, 255),random.randint(0, 255))
  leds[count + 40] = (random.randint(0, 255), random.randint(0, 255),random.randint(0, 255))
  leds[count + 80] = (random.randint(0, 255), random.randint(0, 255),random.randint(0, 255))
  leds[count + 120] = (random.randint(0, 255), random.randint(0, 255),random.randint(0, 255))
  leds.write()
  sleep(0.0000000000000000000000000000000000000001)
  count+=1

  for i in range(NUM_LED):
    leds[i] = (0, 0, 0)
  leds.write()
  if count == NUM_LED//4:
    count = 0
 ```
    
## Vaja4.py
```python=
"""import neopixel
from machine import Pin
from utime import sleep
NUM_LED = 16
i = 0
sez = ""

led = neopixel.NeoPixel(Pin(18), NUM_LED)

while True: 
  sez = str(bin(i))
  print(sez)
  for index in sez:
    if index == "1":
      led[index] = (255, 0, 0)
      led.write()
    else:
      led[index] = (102, 3, 5)
      led.write()
  i += 1"""

import neopixel
from machine import Pin
from utime import sleep

NUM_LED = 16
i = 0

led = neopixel.NeoPixel(Pin(18), NUM_LED)

while True:
    sez = bin(i)[2:]  
    sez = '5' * (NUM_LED - len(sez)) + sez  
    print(sez)
    for index, value in enumerate(sez):
        if value == "1":
            led[index] = (25, 60, 120)
        elif value == "0":
            led[index] = (102, 23, 45)
    led.write()
    i += 1
    sleep(1)  
 ```
 ## Vaja3.py
```python=
import neopixel
from machine import Pin
from utime import sleep

NUM_LED = 16

leds = neopixel.NeoPixel(Pin(18), NUM_LED)

while True:
  for l in range(NUM_LED):
    leds[l] = (204, 102, 143)
    leds.write()
    sleep(0.2)

    for l in range(NUM_LED):
      leds[l] = (0, 0, 0)
      leds.write()
      sleep(0.2)

 ```
 ## Vaja2.py
```python=
import neopixel
from machine import Pin
from utime import sleep

NUM_LED = 16

leds = neopixel.NeoPixel(Pin(18), NUM_LED)

while True:
  for l in range(NUM_LED):
    leds[l] = (204, 102, 143)
    leds.write()
    sleep(0.2)

    for l in range(NUM_LED):
      leds[l] = (0, 0, 0)
      leds.write()
      sleep(0.2)
 ```

 ## Moj projekt
 ### Vremenska postaja
 # Načrtovanje Domače Vremenske Postaje s Flaskom

### Uvod

Projekt bo zdaj nadgrajen z vključitvijo Flask strežnika, ki bo omogočal zajem, shranjevanje ter prikazovanje meteoroloških podatkov v spletnem vmesniku. Poleg tega bomo dodali možnost procesiranja povprečnih, maksimalnih in minimalnih vrednosti vremenskih podatkov za določeno obdobje.

### Cilji in Izzivi

Poleg prvotnih ciljev, kot so sestava postaje in programiranje mikrokrmilnika, bodo zdaj vključeni tudi naslednji izzivi:

- **Ustvarjanje Flask Aplikacije:** Spoznati Flask okolje in vzpostaviti povezavo med vremensko postajo in spletnim vmesnikom.

- **Izbira Komponent:** Izbrati najustreznejše senzorje in mikrokrmilnik za zanesljivo delovanje.

- **Sestava Delov:** Sestaviti komponente in jih pravilno povezati, da bodo delovale kot dobro uigrana ekipa.

- **Programiranje Mikrokrmilnika:** Razviti program za zajem in posredovanje podatkov.

- **Implementacija Podatkovne Baze:** Ustvariti podatkovno bazo za shranjevanje meteoroloških podatkov.

- **Oblikovanje Frontenda:** Ustvariti pregledno spletno stran za prikazovanje meteoroloških podatkov v realnem času.

- **Povezovanje Backend-Frontend:**
   - Zagotoviti, da se podatki pravilno prenašajo iz Flask strežnika v spletni vmesnik.
   - Dodati možnost prikaza povprečnih, maksimalnih in minimalnih vrednosti vremenskih podatkov za določeno obdobje.

## Komponente in Oprema

Oprema za ta projekt bo enako uporabna kot žlica za juho - neizogibna! Vključuje:

- **Senzor Temperature:** Za natančno merjenje temperature zraka v okolici.

- **Vlažnostni Senzor:** Meri količino vlage v zraku, brez pretiravanja.

- **Mikrokrmilnik:** Glavni možgani operacije, ki bodo skrbeli za obdelavo in posredovanje podatkov.

- **Zaslon ali Povezava z Računalnikom:** Za prikaz rezultatov meritev, da bodo jasni kot sončen dan.

- **Podatkovna Baza:** Za shranjevanje meteoroloških podatkov za kasnejšo analizo.

**Nasvet:** Ne pozabi na čarobno zaklinjanje "Hokus Pokus - Delaj!". Nekateri komponenti se obnašajo kot pubertetniki, ki potrebujejo malo dodatne vzpodbude.

##  Načrt Dela

1. **Izdelava Flask Aplikacije:**
   - bolje spoznati Flask okolje.
   - Ustvariti Flask aplikacijo za sprejemanje in obdelavo podatkov od vremenske postaje.

2. **Pisanje API Endpointov:**
   - Določiti ustrezne API endpointe, preko katerih bo vremenska postaja pošiljala podatke na Flask strežnik.

3. **Implementacija Podatkovne Baze:**
   - Ustvariti podatkovno bazo za shranjevanje meteoroloških podatkov.

4. **Oblikovanje Frontenda:**
   - Ustvariti pregledno spletno stran za prikazovanje meteoroloških podatkov v realnem času.

5. **Povezovanje Backend-Frontend:**
   - Zagotoviti, da se podatki pravilno prenašajo iz Flask strežnika v spletni vmesnik.
   - Dodati možnost prikaza povprečnih, maksimalnih in minimalnih vrednosti vremenskih podatkov za določeno obdobje.

6. **Testiranje Delovanja Spletne Aplikacije:**
   - Preveriti, ali spletni vmesnik pravilno prikazuje in ažurira meteorološke podatke.

7. **Optimizacija in Izboljšave:**
   - Po potrebi izboljšati delovanje spletne aplikacije in uporabniške izkušnje.

## Zaključek

S tem projektom bomo pridobili dragocene izkušnje na področju elektronike, programiranja, razvoja spletnih aplikacij in uporabe podatkovnih baz. Z veseljem pričakujem rezultate in upam, da bomo ustvarili zanesljivo vremensko postajo z odličnim spletnim vmesnikom, ki bo omogočal analizo povprečnih, maksimalnih in minimalnih vrednosti vremenskih podatkov za določeno obdobje! 🌦️🔧📊

 | Del postaje       | Cena (v EUR) |     URL      |
 | ----------------- |:------------ |:------------:|
 | Senzor temp/vlage | 1            | alilink.com  |
 | ESP32             | 3            | alilink2.com |
 | Sončni panel      | 30           | alilink3.com |
 
 
# Wokwi - Neopixel LED ring 

Navodila vaj kopiraj k sebi in zraven dopiši kodo rešitev. Dodaj še screenshot za boljšo preglednost.

Nov projekt.
[Wokwi mPy ESP32](https://wokwi.com/projects/new/micropython-esp32)
## 1. **Naloga: Alternirajče utripanje vsake druge LED diode:**
   - Napiši program, ki naj  prižge vsako prvo in drugo LED diodo v različni barvi. Barvi naj se izmenjujeta na eno sekundo.
      Primer 4 Ledic. (R - rdeča, M - modra)
      1. LED R, 2. LED M, 3. LED R, 4. LED M
      2. LED M, 2. LED R, 3. LED M, 4. LED R
      3. LED R, 2. LED M, 3. LED R, 4. LED M
      4. LED M, 2. LED R, 3. LED M, 4. LED R

## 2. **Naloga: Vklop in izklop LED diod v tretjinah obroča:**
   - Razdeli Neopixel obroč na tri dele in napiši program, ki vklopi in izklopi LED diode v vsaki tretjini zaporedoma.
   - **BONUS**: funkcijo pripravi, da krog razdeli na poljubno delov.

## 3. **Naloga: LED ruleta:**
   - Ustvari program, ki naključno izbere eno LED diodo in jo prižge. Pred tem naj se lučka vrti po krogu kot pri ruleti, nato pa se ustavi na naključno izbrani LED diodi. Po kratkem časovnem zamiku jo ugasne, nato pa izbere novo LED diodo.

## 4. **Naloga: Gibanje kazalca za sekunde na uri:**
   - Simuliraj gibanje sekundnega kazalca ure tako, da prižgeš LED diodo, ki predstavlja sekunde. Posodobi jo vsako sekundo.
**Uporabi 60 LED krog.**
   - **BONUS**: implementiraj še minutni kazalec.

```python=
#uporabi kar
import time
sec = time.time()
```

# API naloge

**Velik del vaje je učenje branja dokumentacije**
**Dokumentacija Requests knjižnice:** [Docs](https://requests.readthedocs.io/en/latest/)
## Osnoven API klic
```python=
response = requests.get("https://example.com/api")
```
## Parametri klica (ponavadi, ko delamo GET klic)
```python=
params = {"param1": "value1", "param2": "value2"}
response = requests.get("https://example.com/api", params= params)
```
## Body klica (ponavadi, ko delamo POST klic)
```python=

headers = {
    "User-Agent": "my-app/1.0",
    "Authorization": "Bearer token123",
    "Accept": "application/json"  # zahteva JSON podatkov
}

response = requests.get("https://example.com/api", headers=headers)

```

Seveda lahko kombiniramo headers in params.

## Primerjava GET in POST (za spodnje vaje bomo večino uporabljali GET)

| Lastnost                 | GET                                | POST                              |
|--------------------------|------------------------------------|-----------------------------------|
| **Podatki v URL-ju**    | Podatki so priloženi v URL-ju.     | Podatki niso v URL-ju.           |
| **Omejitev dolžine**    | Omejitev dolžine URL-ja (običajno omejeno na približno 2.000 znakov). | Ni omejitve dolžine podatkov v telesu zahteve. |
| **Varnost**             | Manj varno, ker so podatki vidni v URL-ju in jih je mogoče videti v zgodovini brskalnika ali dnevnikih strežnika. | Bolj varno, ker se podatki prenašajo v telesu zahteve in niso vidni v URL-ju. |
| **Podatki v telesu**     | Podatki se ne prenašajo v telesu zahteve, zato so primerni za zahteve, ki ne spreminjajo stanja na strežniku (samo read). | Podatki se prenašajo v telesu zahteve, zato so primerni za zahteve, ki spreminjajo stanje na strežniku (npr. dodajanje ali urejanje podatkov). |
| **Uporaba v obrazcih HTML** | Primeren za branje podatkov iz strežnika, na primer iskanje rezultatov iskanja. | Primeren za pošiljanje obrazcev s podatki na strežnik, na primer prijavo ali oddajo obrazca. |

[Za radovedne](https://www.guru99.com/difference-get-post-http.html)

## Naloge

1. Seznam vseh sposobnosti poljubnega Pokémona (Uporaba Pokémon API)
2. Iskanje aktivnosti glede na kriterije (Uporaba Bored API)
3. Odkrivanje dejstev o sadju (Uporaba Trefle API)
4. Sledenje Mednarodni vesoljski postaji
   ├── 4.1 Sledenje lokaciji MVP
   └── 4.2 Kako daleč je MVP od mene zdaj? (Zahteva vnos vaše lokacije)
       └── Vnesite vašo lokacijo (Zemljepisna širina, Zemljepisna dolžina): [Vnos uporabnika]
5. Prevedite slovensko besedo skozi N prevodov in nazaj v slovenščino


## Navodila
**za prijavo na APIje, ki potrebujejo login (za dostop do API ključa) uporabi kar "temp mail"**
1.  **Seznam vseh sposobnosti izbranega Pokemona (Pokémon API):**
Pridobi vse sposobnosti izbranega Pokemona iz Pokémon API-ja. Uporabite API: https://pokeapi.co. 
Skripta naj nato izvleče in prikaže seznam sposobnosti, ki jih Pikachu poseduje.
```python=
import requests
import json

choice = input("Izberi pokemona: ").lower()
url = "https://pokeapi.co/api/v2/pokemon/" + choice

response = requests.get(url)
data = response.json()

for ability in data['abilities']:
  print(ability['ability']['name'])
```

2. **Iskanje aktivnosti glede na kriterije (Bored API):**
Ustvarite funkcijo, ki bo sprejela parametre, kot so cena, število ljudi in število aktivnosti, ter uporabila Bored API za iskanje primernih aktivnosti. Uporabite naslovno točko: http://www.boredapi.com. Skripta naj pošlje zahteve na Bored API s podanimi parametri in vrne seznam predlaganih aktivnosti.

3. **Odkrivanje dejstev o sadju (Trefle API):**
Napišite skripto, ki omogoča vnos imena sadja in izvedbo iskanja petih zanimivih dejstev o njem prek Trefle API-ja. Uporabite naslovno točko: https://trefle.io. Skripta naj razčleni odgovor API-ja in izvleče informacije, kot so znanstveno ime, družina, rod in druge zanimive podrobnosti. Nato izpiši še 5 poljubnih dejstev o sadju.

4. **Sledenje MVP (Mednarodna vesoljska postaja):**
    1.  Sledenje lokaciji MVP:
Izpiši trenutno lokacijo MVP.
    1. Razdalja do MVP:
    Vnesite svojo trenutno lokacijo (zemljepisno širino in dolžino) in izračunajte razdaljo med vašo lokacijo in trenutno lokacijo MVP.
    **po spletu poišči kako izračunamo razdaljo med dvema koordinatama**

5. **Prevedite slovensko besedo skozi N prevodov in nazaj v slovenščino:**
Ta naloga vključuje večkratno prevajanje slovenske besede in nato povratno prevajanje v slovenščino. Omogočite uporabniku, da določi število prevodov (N) in vpiše besedo za prevajanje. Skripta naj prevede besedo skozi N prevodov (naključnih jezikov) in jo nato ponovno prevede v slovenščino za končni rezultat. Uporabi poljuen API
**implementacija čez katere jezike gre prevod je poljubna.**

6. **implementriaj poljubno uporabnost nekega APIja**
### Oblika izbirnika
1. Poglej sposobnosti Pokémona
   └── Vnesi ime Pokémona (npr. Pikachu):
2. Išči aktivnosti
   └── Vnesi ceno, število ljudi in število aktivnosti (npr. 10, 5, 3):
3. Odkrij dejstva o sadju
   └── Vnesi ime sadja (npr. apple):
4. Sledenje MVP
   1. Sledi lokaciji MVP
   2. Izračunaj razdaljo do MVP
5. Prevajanje besed skozi N prevodov
   └── Vnesi število prevodov (npr. 3) in besedo za prevajanje (npr. hiša):
   Recimo slovensko -> angleško -> italjankso -> nemško -> slovensko 


## Pomoč pri oblikovanju menija:
```python=

import requests

def main():
    while True:
        print("Izberite nalogo:")
        print("1. Poglej sposobnosti Pokémona")
        print("2. Iskanje aktivnosti")
        print("3. Informacije o sadju")
        print("4. Sledenje MVP")
        print("5. Verižno prevajanje")
        choice = input("Izberi možnost: ")

        if choice == "1":
            pokemon_name = input("Vnesite ime Pokémona: ")
           # koda za izbiro 1
        elif choice == "2":
            # Koda za izbiro 2
            pass
        elif choice == "3":
            # Koda za izbiro 3
            pass   
        elif choice == "4":
            print("1. Sledi lokaciji MVP")
            print("2. Izračunaj razdaljo do MVP")
            mvp_choice = input("Izberite podnalogo: ")
            if mvp_choice == "1":
                pass # koda za izbiro 4.1
            elif mvp_choice == "2":
                pass # koda za izbiro 4.2
        elif choice == "5":
            # Koda za izbiro 5
            pass


main()
    
```

# vaja 2

Neopixel krog, potenciometer in gumb.

## 1. Hitrost animacije
Naredi preprosto animacijo na Neopixel krogu, kjer se ena LEDica vrti okoli kroga. S potenciometrom kontroliramo hitrost vrtenja.
```python=
from machine import Pin, ADC
from utime import sleep
from neopixel import NeoPixel
import random
num_led = 16
leds = NeoPixel(Pin(18), num_led) 

pot1 = ADC(Pin(2))
while True:
    for i in range(num_led):
        a = pot1.read()
        leds[i] = (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))
        leds.write()
        sleep(a/10000)
        leds[i] = (0, 0, 0)
        leds.write()
        sleep(a/10000)
```
## 2. Moč mutacije
Naredi animacijo na NeoPixel krogu, kjer se za prvo LEDico izbere naključna barva.
Vse nadaljne barve naj bodo naključna mutacija prve barve (torej naključno spremenimo RGB vrednosti prve barve). **Ko se krog konča, naj bodo vse LEDice prižgane.**
```python=
from neopixel import NeoPixel
from machine import Pin, ADC
from urandom import randint

NUM_LEDS = 16
leds = NeoPixel(Pin(18), NUM_LEDS)
potentiometer = ADC(Pin(4))

while True:
    barva = [randint(0, 255) for _ in range(3)]

    for i in range(NUM_LEDS):
        mocMutacije = potentiometer.read_u16() / 65535.0  
        rand_min = int(-mocMutacije * 255)
        rand_max = int(mocMutacije * 255)
        rand_r = randint(rand_min, rand_max)
        mutated_color = [(int(barva[j] + rand_r) % 256) for j in range(3)]
        leds[i] = tuple(mutated_color)
        leds.write()

```
Ko se krog obrne, naj se izbere novo prvo barvo in se animacija nadaljuje v neskončno.
S potenciometrom kontroliraj moč mutacije (torej za koliko se prva barva spremenija).
* v konzolo tudi izpiši moč mutacije


## 3. Refleks igra
Napiši refleks igrico, kjer se na začetku igre vse LEDice v krogu pobarvajo na zeleno.
Po naključno dolgem času pobarvaj vse LEDice na rdečo.
Po prehodu na rdečo, čakaj, da uporabnik klikne gumb.
Izpiši v konzolo, kako dolgo je uporabnik potreboval, da je odreagiral na spremembo barve.
* opozori uporabnika, če goljufa (klika pred rdečo)
```mermaid
flowchart TD
    A[ZELENA] -->|random delay 1-4s| B[RDEČA]
    B -->|čakaj na klik gumba| C[Izpiši čas]
    C -->|delay 2s| A
```
## vaja7
Pripomočki:
2 NeoPixel kroga
3 potenciometri
1 gumb

Navodila:
Zagon igre:

Ko se igra prižge, 1. NeoPixel krog zažari v naključno izbrani barvi.
Ugibanje barve:

Igralec z uporabo treh potenciometrov (vsak za eno izmed RGB komponent) prilagaja barvo 2. NeoPixel kroga.
Cilj je, da se izbrana barva čim bolj približa barvi, ki sveti na 1. krogu.
Ocenjevanje:

Ko je igralec zadovoljen s svojo izbiro barve, pritisne gumb.
Igra nato prikaže razliko med izbrano in ciljno barvo za vsako RGB komponento posebej ter skupno napako, ki je vsota vseh treh napak.
Nova igra:

Po končani igri se igralni proces začne znova z novo, naključno izbrano barvo na 1. NeoPixel krogu.
```python=
from neopixel import NeoPixel 
from utime import sleep
from machine import Pin, ADC
import random

num_led = 16
st1 = []
st2 = []
prime = 765
leds1 = NeoPixel(Pin(18), num_led)
leds2 = NeoPixel(Pin(19), num_led)

pot1 = ADC(Pin(15))
pot2 = ADC(Pin(2))
pot3 = ADC(Pin(4))

button = Pin(17, Pin.IN, Pin.PULL_UP)

while True:
    a = random.randint(0, 255)
    b = random.randint(0, 255)
    c = random.randint(0, 255)
    leds1.fill([a, b, c])
    leds1.write()
    st1 = [a, b, c]
    print("1. krog:", st1)
    d, e, f = 0, 0, 0 

    while button.value() == 1:
        d = pot1.read()//16
        e = pot2.read()//16
        f = pot3.read()//16
        leds2.fill([d, e, f])
        leds2.write()
    
    st2 = [d, e, f]
    print("2. krog:", st2)
    raz1 = [abs(x - y) for x, y in zip(st1, st2)]
    raz2 = sum(raz1)
    proce = round((raz2 / prime) * 100)
    print(raz1)
    print(raz2)
    print(proce, "%")
    break
    
from neopixel import NeoPixel 
from machine import Pin, ADC
from utime import sleep
import random
num_led = 16

ld = NeoPixel(Pin(19), num_led)
gld = NeoPixel(Pin(18), num_led)

bttn = Pin(5, Pin.IN, Pin.PULL_UP)

pot1 = ADC(Pin(15))
pot2 = ADC(Pin(2))
pot3 = ADC(Pin(0))

while True:
    a = random.randint(0, 255)
    b = random.randint(0, 255)
    c = random.randint(0, 255)
    for i in range(num_led):
        ld[i] = (a, b, c)
    ld.write()
    print(a, b, c)
    while bttn.value() == 1:
        e = pot1.read()//16
        d = pot2.read()//16
        f = pot3.read()//16
        gld.fill([e, d, f])
        gld.write()
    print(e, d, f)
    print(abs(a-e), abs(b-d), abs(c-f))
    rez2 = abs(a - e) + abs(b - d) + abs(c - f)
    proce = round((rez2 / 765) * 100)
    print(proce,"%")
    break
    


```

## Vaja 6
Za vajo potrebuješ NeoPixel krog in gumb.

Prva lučka se prižge samodejno na zeleno barvo.

Program čaka, da uporabnik pritisne gumb.
Ko uporabnik pritisne gumb, se naslednja ledica v zaporedju pobarva na eno od naslednjih barv.

Če je bil gumb kliknjen po manj kot 1s po prejšne prižgani ledici - ZELENA
Če je bil pritisnjen po 1s in pred 2s - MODRA
po 2s - RDEČA
```python=
from neopixel import NeoPixel 
from utime import sleep
from machine import Pin
import time

num_led = 18
button = Pin(19, Pin.IN, Pin.PULL_UP)
leds = NeoPixel(Pin(18), num_led)

zacetek = time.time()
led = 0

while True:
  if led == num_led:
    break
  cas = time.time() - zacetek

  if button.value() == 0:
      if cas < 1:
          leds[led] = (0, 255, 0)
      elif 1 <= cas < 2:
          leds[led] = (0, 0, 255)
      else:
          leds[led] = (255, 0, 0)

      leds.write()
      sleep(0.1)  
      led = (led + 1) % num_led  
      zacetek = time.time()  
```
## Vaja 5
Cilj te vaje je programirati ESP mikrokrmilnik za simulacijo metanja kocke. Ko uporabnik pritisne gumb, se bo naključno izpisalo število od 1 do 6 predstavljeno na LED diodah.

BONUS:

Naredi, da preden se izpiše met kocke simuliraš animacijo metanja kocke.
Torej se naključno preklaplja med različnimi vrednostmi, dokler ne pristane na končni izbiri.
Poskusi implementirati zvok s pomočjo Piezo zvočnika.

from machine import Pin , PWM
import utime
```python=
from neopixel import NeoPixel 
from utime import sleep
from machine import Pin, PWM
import random
num_led = 6
leds = NeoPixel(Pin(18), num_led)
while True:
  b = random.randint(1, num_led)
  vnos = input("Za zacetek pritisni q: ")
  print(f"vasa kocka je: {b}")
  while vnos == "q":
    a = random.randint(1, num_led)
    for i in range(a):
      leds[i] = (255, 0, 0)
    leds.write()
    sleep(1)
    for i in range(a):
      leds[i] = (0, 0, 0)
    leds.write()
    sleep(0.1)
    if a == b:
      vnos = input("ce zelite nadaljevati kliknite e: ")
      if vnos == "e":
        break

```

## vaja4
Cilj naloge je ustvariti igrico, kjer se na 50 LEDičnem krogu naključno prižgejo pet LEDic. Igralec bo upravljal potenciometer, s katerim bo poskušal doseči želeno LEDico. Nato pa se bo prižgala naslednja. Igralec bo moral doseči vseh pet LEDic in program bo izpisal čas, ki ga je igralec porabil za dokončanje igre.

Bonus:

LEDice se naj razmaknejo vsaj 20 narazen za vsako naključno prižigajočo se LEDico.
Igralec bo moral ostati vsaj 0.5 sekunde na pravilni LEDici.
```python=
from neopixel import NeoPixel 
from utime import sleep
from machine import Pin, ADC
import random, time
num_led = 50
rez = 0
leds = NeoPixel(Pin(18), num_led)
pot = ADC(Pin(4))
st = pot.read()
value = round(st/4096*50)

cas1 = time.time()
while rez != 5:
  a = random.randint(0, num_led)
  leds[a] = (255, 0, 255)
  leds.write()
  while value != a:
    st = pot.read()
    value = round(st/4096*50)
    print(value)
    if value == a:
      rez += 1
  leds[a] = (0, 0, 0)
  leds.write()
cas2 = time.time()

cas = cas2 - cas1
print(f"Uganil si vse točke v {cas} sekundah")
    
```
## UPN - Wokwi primeri
Wokwi main page
New ESP32 MicroPy project

2 LED blink
prva

from machine import Pin 

from utime import sleep 

## Vaja 3 - nalaganje barv
V Wokwiju izdelaj naslednjo animacijo.

naloga naj deluje na poljubne velikem krogu
```python=
from neopixel import NeoPixel 
from utime import sleep
from machine import Pin
import random
num_led = 18
st = 0

leds = NeoPixel(Pin(18), num_led)

while True:
  for i in range(num_led):
    leds[i] = (random.randint(0, 255), random.randint(0, 255),random.randint(0, 255))
    leds.write()
    sleep(0.1)
    leds[i] = (0, 0, 0)
    leds.write()
    sleep(0.1)
    st += 1
    if num_led== st:
      leds[i] = (random.randint(0, 255), random.randint(0, 255),random.randint(0, 255))
  leds.write()
  num_led -= 1
  st = 0
```
barva = [rand(255), rand(255), rand(255)]
```python=
from neopixel import NeoPixel
from machine import Pin
import utime
import urandom

NUM_LEDS = 16
leds = NeoPixel(Pin(18), NUM_LEDS)
button = Pin(2, Pin.IN)

def set_led_color(color):
    for i in range(NUM_LEDS):
        leds[i] = color
    leds.write()

def wait_for_button_press():
    while button.value() == 0:
        pass

def wait_for_button_release():
    while button.value() == 1:
        pass

while True:
    set_led_color((0, 255, 0))
    utime.sleep(urandom.randint(5, 15))
    set_led_color((255, 0, 0))
    start_time = utime.ticks_ms()
    wait_for_button_press()
    wait_for_button_release()
    end_time = utime.ticks_ms()
    reaction_time = utime.ticks_diff(end_time, start_time)
    if leds[0] == (0, 255, 0):
        print("Don't cheat!")
        break
    else:
        print("Reaction Time: {} ms".format(reaction_time))
        break

```
## Lastne vaje
```python=
from neopixel import NeoPixel
from machine import Pin
from utime import sleep
import random
num_led = 16

leds = NeoPixel(Pin(18), num_led)
button = Pin(5, Pin.IN, Pin.PULL_UP)

while True:
    if button.value() == 0:
        for i in range(num_led):
            leds[i] = (random.randint(0, 125), random.randint(0, 125), random.randint(0, 125))
            leds.write()
    else:
        for i in range(num_led):
            leds[i] = (125, 0, 255)
        leds.write()

        
        
        
        
from machine import Pin, ADC
from utime import sleep
from neopixel import NeoPixel
import random
num_led = 16
leds = NeoPixel(Pin(18), num_led) 
time = 30

while True:
    if time >= 20:
        leds.fill([0, 255, 0])
        leds.write()
        sleep(1)
    elif time < 20 and time >= 10:
        leds.fill([255, 255, 0])
        leds.write()
        sleep(1)
    else:
        leds.fill([255, 0, 0])
        leds.write()
        sleep(1)
    if time <= 0:
        print("Konec odstevanja")
        break
    time -= 1
```