---
# System prepended metadata

title: UPN VAJE

---

# **UPN -Primeri iz predavanj**

## **Slika pinout**
![](https://hackmd.io/_uploads/HybQfHgxa.png)

# **VAJE**

## **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) 

prižgi vse lučke z naključno barvo 
 ```

 
 
## **NeoPixel(WS2812) ring - križ-krož**
```python=
import neopixel
from machine import Pin
import neopixel

NUM_LED = 48
leds = neopixel.NeoPixel(Pin(5), NUM_LED)
l = [0,NUM_LED//4,NUM_LED//2,(NUM_LED * 3)//4]
while True:
  leds[l[0]]=leds[l[1]]=leds[l[2]]=leds[l[3]]=[28,123,172]
  leds.write()
  leds[l[0]]=leds[l[1]]=leds[l[2]]=leds[l[3]]=[0,0,0]
  for k in range(len(l)):
    if l[k] < NUM_LED -1:
      l[k] += 1
    else:
      l[k] = 0
  
  sleep(0.2)

```
## **Vaja Zanimivi projekti**
- Hackaday - cat tracker
 https://hackaday.com/2023/09/19/open-source-tracker-keeps-an-eye-on-furry-friends/
- Instuctables - mišični signali
 https://www.instructables.com/Visualizing-Muscle-Signals-EMG-Using-Worlds-Most-A/
- makezine - Intruder alert
 https://makezine.com/projects/build-this-intruder-alarm-two-ways-using-555-timers-or-a-raspberry-pi/
- Hackster 
 https://www.hackster.io/news/learn-how-to-build-an-esp32-mini-tv-e7c6441eedad
- Adafruit
 https://learn.adafruit.com/pet-bowl-water-level-sensing-with-the-funhouse-and-home-assistant
- Reddit - Arduino
https://www.reddit.com/r/arduino/top/?t=all

# 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 8 Ledic. (R - rdeča, M - modra)
      1. R, M, R, M, R, M, R, M
      2. M, R, M, R, M, R, M, R
      3. R, M, R, M, R, M, R, M
      4. M, R, M, R, M, R, M, R 
      
- rešitev

```python=
from machine import Pin
from time import sleep
import neopixel

# Konfiguracija LED obroča
NUM_LED = 8  # Število LED diod v obroču


# Ustvarite objekt NeoPixel za nadzor LED obroča
leds=neopixel.NeoPixel(Pin(27), NUM_LED)


while True:
    for i in range(NUM_LED):
        if i%2==0:
            leds[i]= (255, 0, 0)
        else:
            leds[i]=(0, 0, 255)
    leds.write()
    sleep(1)

    for i in range(NUM_LED):
        if i%2==1:
            leds[i]= (255, 0, 0)
        else:
            leds[i]=(0,0,255)
    leds.write()
    sleep(1)

```

## 2. **Naloga: Vklop in izklop LED diod v četrtinah obroča:**
   - Razdeli Neopixel obroč na štiri dele in napiši program, ki vklopi in izklopi LED diode v vsaki četrtini zaporedoma. (naenkrat naj je prižgana samo ena četrtina)
   - **BONUS**: funkcijo pripravi, da krog razdeli na poljubno delov.

- Rešitev

```python=
import neopixel
from machine import Pin
from time import sleep

NUM_LED = 16
leds = neopixel.NeoPixel(Pin(27), NUM_LED)
velikost_četrtine = NUM_LED // 4
trenutna_četrtina = 0

while True:
    
    for i in range(NUM_LED):
        leds[i] = (0, 0, 0)
    
    
    start = trenutna_četrtina * velikost_četrtine
    end = (trenutna_četrtina + 1) * velikost_četrtine
    for j in range(start, end):
        leds[j] = (28, 123, 172)

    leds.write()
    
    
    trenutna_četrtina = (trenutna_četrtina + 1) % 4

    sleep(0.2)
```
## 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.
- rešitev
```python=
import neopixel
from machine import Pin
import random
import time

NUM_LED = 48  
leds = neopixel.NeoPixel(Pin(27), NUM_LED)

while True:
    
    selected_led = random.randint(0, NUM_LED - 1)
    
    
    for i in range(NUM_LED):
        leds.fill((0, 0, 0))
        leds[selected_led] = (28, 123, 172)  
        leds.write()
        selected_led = (selected_led + 1) % NUM_LED
        time.sleep(0.001)
    
    
    time.sleep(2)
    leds.fill((0, 0, 0))  
    leds.write()
    
    
    time.sleep(0)
```

## 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.
- Rešitev
```python=
import neopixel
from machine import Pin
import time

ŠTEVILO_LED = 60  
ledi = neopixel.NeoPixel(Pin(27), ŠTEVILO_LED)

def premikaj_kazalec(sekunda):
    if sekunda < ŠTEVILO_LED:
        ledi[sekunda] = (0, 0, 255)  
        ledi.write()
        time.sleep(1)  
        ledi[sekunda] = (0, 0, 0)   
        ledi.write()

while True:
    for sekunda in range(ŠTEVILO_LED):
        premikaj_kazalec(sekunda)
```

# BUTTON
## Uvodna vaja
```python=
from machine import Pin


btn = Pin(32, Pin.IN, Pin.PULL_UP)

while True:
    btnVal = not bool(btn.value())
    print(btnVal) 
```
![](https://hackmd.io/_uploads/H1OVWBxgp.png)

# **Potencial meter**
## **Vaja 1**
### RGB Potenciali
```pytho=
from machine import Pin, ADC
import neopixel
from time import sleep 

NUM_LED = 16


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

pot1 = ADC(Pin(14))
pot2 = ADC(Pin(12))
pot3 = ADC(Pin(27))


while True:
    b1 = (pot1.read())//16
    b2 = (pot2.read())//16
    b3 = (pot3.read())//16
    
    leds.fill([b1,b2,b3])
    leds.write()
    sleep(0.1)

```
![](https://hackmd.io/_uploads/By3RcSelT.png)

## **Vaja 2**
### **Primer 1**
```python=
from time import sleep, sleep_ms
import neopixel
from machine import ADC, Pin

# Konfiguracija Neopixel kroga
PIXEL_PIN = 15   # Pin, na katerega je priključen Neopixel krog
NUM_PIXELS = 16  # Število LED diod v krogu

# Konfiguracija potenciometra
POT_PIN = 34     # Pin, na katerega je priključen potenciometer

# Nastavitve Neopixel kroga
np = neopixel.NeoPixel(Pin(PIXEL_PIN), NUM_PIXELS)

# Nastavitve potenciometra


while True:
    # Preberi vrednost potenciometra (0-4095)
    pot1 = ADC(Pin(34))
    pot_value = pot1.read()
    print(pot_value)

    # Pretvori vrednost potenciometra v zamik (hitrost)
    # Večja vrednost potenciometra pomeni počasnejšo animacijo
    delay_val = int(pot_value//10)  # Prilagodite po potrebi

    # Premakni LEDico po krogu
    for i in range(NUM_PIXELS):
        np[i] = (255, 0, 0)  # Nastavi barvo na rdečo za trenutno LEDico
        np.write()
        sleep_ms(delay_val)  # Počakaj glede na izbran zamik
        np[i] = (0, 0, 0)  # Izbriši trenutno LEDico

    # Ponastavi vse LEDice
    np.fill((0, 0, 0))
    np.write()
```
![](https://hackmd.io/_uploads/HJJ6RG4g6.png)
## **Vaja 3**
### **Loading...**
```pyt=
import  neopixel
from machine import Pin 
from time import sleep 
from random import randrange as r


nl = 160
leds = neopixel.NeoPixel(Pin(19), nl)
d=0.007

while True:
  col1 = [r(100,255),r(100,255),r(100,255)]
  col2 = [r(100,255),r(100,255),r(100,255)]
  col3 = [r(100,255),r(100,255),r(100,255)]
  col4 = [r(100,255),r(100,255),r(100,255)]
  
  for l in range(nl):
    leds[l]= col1
    sleep(d*3)
    if l>=64:
      leds[l]=col2
      sleep(d*6)
    if l>=112:
      leds[l]=col3
      sleep(d*9)
    if l>=144:
      leds[l]=col4
      sleep(d*12)
    leds.write()
  leds.fill([0,0,0])
```
![](https://hackmd.io/_uploads/rkjA8fdlp.png)

### **Merjenje temperature**
```py=
import dht
from machine import Pin, PWM
import neopixel
# https://tinyurl.com/wokwiconvert1
def convert(x, in_min, in_max, out_min, out_max):
    return (x - in_min) * (out_max - out_min) // (in_max - in_min) + out_min

for i in range(1):
    print(i, convert(i, 0, 4096, 0, 16))
nl = 32
leds = neopixel.NeoPixel(Pin(18), nl)


# DHT senzor!!
sense = dht.DHT22(Pin(4))

while True:
    sense.measure()
    hum = sense.humidity()
    temp=sense.temperature()
    print(sense.humidity(), sense.temperature())
    h = convert(hum, 0,100,0,10)
    t = convert(temp,0,80,0,10)
    
    for c in range(nl):
        leds[c]=([0,0,25*int(h)])
        leds.write()
        if c>=16:
            leds[c]=([25*int(t),0,0])
            leds.write()
        
        
```
![](https://hackmd.io/_uploads/BymclUbba.png)

### Potenciometer krog
```python=
from machine import Pin, ADC
import neopixel
def convert(x, in_min, in_max, out_min, out_max):
    return (x - in_min) * (out_max - out_min) // (in_max - in_min) + out_min
nl = 16
leds = neopixel.NeoPixel(Pin(18), nl)
while True:
    pot = ADC(Pin(4)) 
    num_led=convert(pot.read(),0,4095,0,(nl-1))
    print(num_led)
    leds.fill((0,0,0))
    leds[num_led]=[255,0,0]
    leds.write()
    
```
 ![](https://hackmd.io/_uploads/H1DRScM-p.png)

 ## 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 |