MicroPython → Mini projekti → Serial komunikacija i Processing

MicroPython — serial komunikacija (most ka Processing-u)

Završna oblast kursa

MicroPython početna: Povratak na Processing hub

Povezivanje micro:bit-a i računara

U ovoj lekciji učimo kako micro:bit šalje podatke računaru i kako ti podaci mogu da se koriste za:

vizualizaciju podataka
grafike i animacije
interaktivne aplikacije
mini igre i kontrolere

Processing (Python mod) omogućava da ove podatke pretvorimo u grafiku u realnom vremenu.

Važna ideja:

Ovo je prvi put u kursu da micro:bit postaje deo većeg sistema. Micro:bit više nije samo uređaj koji prikazuje LED animacije — sada komunicira sa drugim programom na računaru.

Ovo je ključna veza između:

fizičkog sveta (senzori i pokret)
MicroPython programa
grafičkih aplikacija na računaru

Šta je serial komunikacija?

Serial komunikacija je način da uređaji razmenjuju podatke jedan deo po jedan deo — kao tekstualne poruke.

U našem slučaju:

micro:bit ➝ šalje podatke
računar ➝ prima i obrađuje podatke

Možeš zamisliti da:

micro:bit „piše poruke“
Processing ih čita i pretvara u grafiku

Kako ovo izgleda u praksi?

Na primer:

micro:bit meri temperaturu
šalje broj računaru
Processing crta grafikon temperature

Isto možemo raditi sa:

nagibom
dugmadima
pokretom
svetlom

UART — serijska komunikacija na micro:bit-u

MicroPython koristi ugrađeni uart interfejs za komunikaciju sa računarom preko USB kabla.

UART znači:

Universal Asynchronous Receiver/Transmitter

To je hardverski modul koji omogućava:

slanje podataka
prijem podataka
komunikaciju između uređaja

Kod micro:bit-a UART je povezan sa USB interfejsom, pa računar može direktno da prima podatke.

Napomena:

Iako koristimo USB kabl, micro:bit interno i dalje koristi UART komunikaciju. USB ovde služi kao „most“ između računara i micro:bit uređaja.

Da bismo koristili UART u MicroPython-u, potrebno je da uvezemo modul:


from microbit import *

Objekat uart je već ugrađen u ovaj modul.

Šta možemo slati?

Najčešće šaljemo:

brojeve (temperatura, nagib, svetlost)
tekstualne poruke
više vrednosti odjednom

Na primer:

ili:


23,512

U ovom slučaju:

23 može biti temperatura
512 može biti vrednost senzora svetlosti

Mini eksperiment:

Pokušaj da zamisliš:

Kako bi izgledala poruka za X i Y nagib?
Kako bi izgledala poruka za temperaturu i dugme A?

Na primer:


120,-340

ili


24,1

Primer: slanje temperature računaru

Sada pravimo prvi pravi serial program.

Micro:bit će:

čitati temperaturu
pretvarati broj u tekst
slati podatke računaru svake sekunde


from microbit import *
import utime

# Pokretanje UART komunikacije
uart.init(baudrate=115200)

while True:

    # Očitavanje temperature
    temp = temperature()

    # Slanje temperature računaru
    uart.write(str(temp) + "\r\n")

    # Pauza od jedne sekunde
    utime.sleep(1)

Šta znači baudrate?

baudrate=115200 određuje brzinu prenosa podataka. I računar i micro:bit moraju koristiti istu brzinu komunikacije.

Zašto koristimo str()?

Funkcija uart.write() šalje tekst.

Zato broj moramo prvo pretvoriti u tekst:


str(temp)

Bez toga program bi prijavio grešku.

Kraj poruke — znak novog reda

Na kraju poruke dodajemo:


"\r\n"

ili jednostavnije:


"\n"

To označava kraj jedne poruke.

Zahvaljujući tome računar zna:

gde se završava jedna vrednost
gde počinje sledeća

Zamisli ovo kao Enter taster.

Kada micro:bit pošalje \n, to je kao da je prešao u novi red teksta.

Računar tada može da primi nešto ovako:

Serial monitor — prvi test

Pre povezivanja sa Processing-om, uvek prvo proveravamo komunikaciju pomoću serial monitora.

Možeš koristiti:

Thonny → Tools → Serial
MakeCode → Serial Monitor

Serial monitor prikazuje tekst koji micro:bit šalje računaru.

Probaj:

Pokreni prethodni program i otvori serial monitor. Ako vidiš brojeve koji se menjaju svake sekunde, komunikacija radi ispravno.

MakeCode serial dokumentacija:

https://makecode.microbit.org/reference/serial

Zašto je ovo važno za Processing?

Processing može da koristi serial podatke za:

grafikone u realnom vremenu
animacije
interaktivne projekte
mini igre

Na primer:

graf temperature kroz vreme
kontrola objekta naginjanjem micro:bit-a
vizuelni alarm kada temperatura poraste

Velika ideja:

Micro:bit postaje „kontroler“ za program na računaru. To je osnova:

IoT sistema
interaktivnih instalacija
gaming kontrolera
vizualizacije senzora

Mini zadatak

Napiši program koji:

šalje temperaturu ili nagib
šalje podatke svake sekunde
koristi znak novog reda \n

Razmisli:

Kako bi izgledala poruka?
Kako bi Processing mogao da prikaže te podatke?

Dodatni izazov:

Pokušaj da šalješ dve vrednosti odjednom. Na primer:


24,512

Šta bi mogla predstavljati druga vrednost?

Šta sledi?

U narednim lekcijama učićemo:

kako Processing čita serial podatke
kako se crtaju grafikoni i animacije
kako micro:bit postaje kontroler igre

Ovo je pravi most između:

hardvera
programiranja
grafike
interaktivnih sistema

Proširenje — Napredna serial komunikacija

Kada micro:bit šalje podatke računaru, važno je da komunikacija bude:

jasno formatirana
dosledna
laka za obradu

U ozbiljnijim projektima način slanja podataka je podjednako važan kao i sam program.

Važna ideja:

Kada dva programa komuniciraju, moraju da se „dogovore“ kako izgleda poruka. Ako format nije jasan, računar neće znati kako da razume podatke.

1. Slanje više vrednosti odjednom

Često želimo da pošaljemo više podataka istovremeno.

Na primer:

temperaturu
nagib po X osi
stanje dugmeta

Jedan od najčešćih načina je korišćenje zareza kao razdjelnika.


from microbit import *
import utime

while True:

    temp = temperature()
    x = accelerometer.get_x()

    # Pravljenje jedne tekstualne poruke
    poruka = str(temp) + "," + str(x) + "\n"

    # Slanje poruke računaru
    uart.write(poruka)

    utime.sleep(1)

Računar može da primi nešto ovako:


23,145
24,132
24,160

Šta je delimiter?

Zarez ovde služi kao delimiter (razdvojnik podataka). Processing kasnije može razdvojiti tekst pomoću funkcije:


split(',')

Na taj način dobijamo više odvojenih vrednosti iz jedne poruke.

2. Mini komunikacioni protokol

U većim projektima korisno je označiti šta tačno šaljemo.

Na taj način pravimo mali komunikacioni protokol.

Na primer:


uart.write("TEMP:" + str(temperature()) + "\n")

ili:


uart.write("DATA:" + str(temp) + "," + str(x) + "\n")

Processing tada može proveriti:

da li poruka počinje sa DATA:
koji tip podataka je stigao
kako treba obraditi poruku

Ovo koriste i pravi sistemi.

Mrežni protokoli, IoT uređaji i serveri takođe koriste jasno definisane formate poruka. Na primer:

HTTP
JSON
MQTT

3. Stabilnost komunikacije

Da bi serial komunikacija radila pouzdano, potrebno je pratiti nekoliko pravila.

uvek koristi \n na kraju poruke
šalji podatke u pravilnim intervalima
ne šalji previše podataka odjednom

Prebrzo slanje može izazvati:

zagušenje porta
spojene poruke
kašnjenje grafike
gubitak podataka

Eksperiment:

Pokušaj da ukloniš:


utime.sleep(1)

Šta se dešava sa serial monitorom? Da li se poruke pojavljuju previše brzo?

Zato često koristimo:


utime.sleep()

ili preciznije vremenske intervale.

4. Mini projekat — graf temperature

Sada već imamo dovoljno znanja za prvi pravi projekat vizualizacije.

Ideja projekta:

micro:bit šalje temperaturu
Processing prima podatke
Processing crta grafikon u realnom vremenu

Takav sistem može prikazivati:

temperaturu
svetlost
nagib
pokret

Razmisli:

Kako čuvati stare vrednosti?
Kako pomerati graf ulevo?
Kako skalirati podatke?
Kako promeniti boju kada temperatura poraste?

Ovo je prvi korak ka:

data vizualizaciji
interaktivnim dashboard-ima
real-time sistemima

5. Dvosmerna komunikacija

Do sada je micro:bit samo slao podatke.

Ali serial komunikacija može biti i:

računar ➝ micro:bit
micro:bit ➝ računar

To znači da računar može slati komande micro:bit-u.

Na primer:


LED_ON

MicroPython tada može reagovati:


if uart.any():

    # Čitanje pristigle poruke
    komanda = uart.read().decode().strip()

    # Provera komande
    if komanda == "LED_ON":
        display.show(Image.HEART)

Šta rade ove funkcije?

uart.any() proverava da li postoji nova poruka
uart.read() čita pristigle podatke
decode() pretvara bajtove u tekst
strip() uklanja prazne karaktere i novi red

Ovo je veoma važan koncept.

Na ovaj način računar može upravljati hardverom. To je osnova:

robotike
IoT sistema
interaktivnih instalacija
gaming kontrolera

Šta si zapravo naučio?

U ovoj oblasti naučio si:

kako uređaji razmenjuju podatke
kako funkcioniše serial komunikacija
kako se definiše format poruka
kako se povezuje hardver i grafika
kako razmišljati sistemski

Ovo je veliki korak:

od jednostavnog MicroPython-a
ka pravim interaktivnim sistemima

Zapamti:

Programiranje nije samo pisanje koda. Pravi sistemi često imaju:

više uređaja
komunikaciju
grafiku
senzore
razmenu podataka

Dijagram arhitekture — micro:bit ↔ Serial ↔ Processing

Da bismo razumeli kako ceo sistem funkcioniše, korisno je da ga posmatramo kao više povezanih slojeva.

Svaki sloj ima svoju ulogu:

jedan prikuplja podatke
drugi ih prenosi
treći ih prikazuje i obrađuje

Važna ideja:

U velikim sistemima različiti delovi programa često imaju različite odgovornosti. To se naziva: razdvajanje odgovornosti (separation of concerns).

1. Fizički sloj — Hardware

Prvi sloj predstavlja sam micro:bit uređaj i njegove senzore.

Ovde spadaju:

temperaturni senzor
akcelerometar
kompas
dugmad A i B
LED matrica

Ovaj sloj:

meri podatke iz realnog sveta
pretvara ih u brojeve
prosleđuje ih programu

Primer:

Ako nagneš micro:bit, akcelerometar vraća numeričke vrednosti koje predstavljaju nagib uređaja.

2. Komunikacioni sloj — Serial veza

Drugi sloj služi za prenos podataka između micro:bit-a i računara.

Ovde koristimo:

USB kabl
UART interfejs
tekstualne poruke

Na primer:


23,145

ili:


120,-45

Na kraju poruke obično šaljemo:


"\n"

To označava kraj jedne linije podataka.

Važno:

Serial sloj ne „razume“ značenje podataka. On samo prenosi tekst sa jednog uređaja na drugi.

3. Aplikacioni sloj — Processing

Treći sloj predstavlja program na računaru.

U našem slučaju to je: Processing Python Mode.

Ovaj sloj:

čita serial podatke
razdvaja vrednosti
obrađuje informacije
crta grafiku i animacije

Na primer:

pomera objekat na ekranu
crta grafikon temperature
reaguje na pritisak dugmeta

Razmisli:

Da li micro:bit treba da zna kako izgleda grafikon? Ili je njegov posao samo da šalje podatke?

Vizuelni dijagram sistema

[ Senzori / Dugmad ]
          ↓
       micro:bit
          ↓
   uart.write("23,145\n")
          ↓
      USB / Serial
          ↓
  Processing Serial.read()
          ↓
   Parsiranje (split)
          ↓
 Grafika / Animacija / Igra

Svaka strelica predstavlja prenos podataka iz jednog dela sistema u drugi.

Važno:

Podaci se kreću samo u jednom smeru:

senzor ➝ micro:bit
micro:bit ➝ računar
računar ➝ grafika

Kasnije ćemo videti i dvosmernu komunikaciju.

Primer toka podataka

Pogledajmo jedan kompletan primer.

Šta se dešava kada učenik nagne micro:bit?

Akcelerometar meri nagib
MicroPython dobija numeričke vrednosti
Program šalje poruku:
```
120,-45
```
Processing pročita celu liniju
Program razdvoji podatke pomoću split()
Objekat na ekranu promeni poziciju

Sve ovo se dešava veoma brzo — gotovo u realnom vremenu.

Real-time sistem:

Sistem reaguje odmah nakon promene senzora. To omogućava:

interaktivne igre
kontrolere pokreta
vizualizaciju uživo

Razdvajanje odgovornosti

U našem sistemu svaki deo ima jasnu ulogu.

micro:bit ➝ meri i šalje podatke
Serial komunikacija ➝ prenosi podatke
Processing ➝ prikazuje i obrađuje podatke

Ovakav pristup koristi se u:

IoT uređajima
robotici
industrijskim sistemima
interaktivnim instalacijama

Dobra arhitektura:

Kada svaki deo sistema ima jasan posao, program postaje:

lakši za razumevanje
lakši za popravku
lakši za proširenje

Napredna perspektiva

Ovaj sistem možemo posmatrati i kao pravu softversku arhitekturu.

Klijent (micro:bit) ➝ generiše podatke
Kanal komunikacije ➝ serial protokol
Processing engine ➝ obrađuje i prikazuje podatke

Slični principi koriste se u:

IoT mrežama
industrijskim senzorima
robotici
game kontrolerima

Tehnologije mogu biti različite, ali osnovna ideja ostaje ista.

Mini zadatak za razmišljanje

Zamisli sledeći sistem:

micro:bit šalje x, y i temperaturu
Processing reaguje samo kada temperatura pređe 30°C

Pitanje:

Gde treba napisati logiku uslova?

Razmisli:

Ako želiš manje podataka ➝ logika može biti na micro:bit-u
Ako želiš fleksibilniju grafiku ➝ logika može biti u Processing-u

Ne postoji samo jedno tačno rešenje. To je deo dizajna sistema.

Ovde više ne razmišljamo samo o kodu — već o arhitekturi cele aplikacije.

Python → MicroPython i Processing → Vizuelni kontroler nagiba

Projekat: „Vizuelni kontroler nagiba“

Lekcija 14 od 14

MicroPython + Processing: Povratak na hub

U ovom projektu micro:bit postaje kontroler pokreta, dok Processing prikazuje objekat koji se pomera u realnom vremenu.

Nagni micro:bit ➝ objekat se pomera na ekranu.

Šta je cilj projekta?

U ovom projektu povezujemo:

fizički pokret uređaja
serial komunikaciju
grafičku vizualizaciju

To je pravi primer interaktivnog sistema.

Arhitektura sistema

micro:bit (akcelerometar)
        ↓
uart.write("x,y\n")
        ↓
USB Serial
        ↓
Processing čita podatke
        ↓
Pomera objekat na ekranu

Sistem funkcioniše kao real-time kontroler pokreta.

Važna ideja:

micro:bit ne crta grafiku. Njegov posao je:

da meri nagib
da šalje podatke

Processing zatim koristi te podatke za crtanje objekata na ekranu.

Korak 1 — MicroPython kod (micro:bit)

Micro:bit šalje vrednosti nagiba po X i Y osi.


from microbit import *
import utime

while True:

    # očitavanje nagiba uređaja
    x = accelerometer.get_x()
    y = accelerometer.get_y()

    # slanje podataka kao tekst:
    # x,y\n
    uart.write(str(x) + "," + str(y) + "\n")

    # mala pauza između poruka
    utime.sleep(0.1)

Format poruke:

x,y\n

x ➝ nagib po X osi
y ➝ nagib po Y osi
\n ➝ kraj poruke

Podaci se šalju približno 10 puta u sekundi.

Korak 2 — Processing Python Mode (vizuelizacija)

Pošto učenici rade u Python Mode, koristimo Python sintaksu i Python stil pisanja koda.


add_library('serial')

from processing.serial import *

xPos = 300
yPos = 200

def setup():

    global myPort

    size(600, 400)

    # prikaz dostupnih portova
    print(Serial.list())

    # povezivanje sa prvim serial portom
    myPort = Serial(this, Serial.list()[0], 115200)

def draw():

    global xPos, yPos

    background(240)

    # crtanje objekta
    ellipse(xPos, yPos, 50, 50)

    # proveravamo da li postoje podaci
    while myPort.available() > 0:

        # čitanje jedne linije
        data = myPort.readStringUntil('\n')

        if data != None:

            # uklanjanje praznih karaktera
            data = data.strip()

            # razdvajanje po zarezu
            values = data.split(',')

            # provera da li imamo dve vrednosti
            if len(values) == 2:

                x = float(values[0])
                y = float(values[1])

                # mapiranje senzora na ekran
                xPos = width/2 + x/10
                yPos = height/2 + y/10

Važno:

Ovo je kod za: Processing Python Mode Nije isti kao klasični Java Processing mod.

Kako sistem radi?

Micro:bit meri nagib pomoću akcelerometra
Šalje podatke kao tekstualnu poruku
Processing čita kompletnu liniju
Podaci se razdvajaju po zarezu
Objekat se pomera proporcionalno nagibu

Ovo je primer direktne veze između fizičkog pokreta i grafike.

Eksperiment:

Pokušaj sledeće izmene:

Promeni veličinu kruga
Promeni boju pozadine
Promeni brzinu pomeranja

Na primer:


background(0)
fill(0, 255, 0)

Zašto delimo sa 10?

Vrednosti akcelerometra mogu biti veoma velike (često preko ±1000).

Ako bismo koristili originalne vrednosti, objekat bi se pomerao previše brzo.

Zato koristimo:


x/10
y/10

Time smanjujemo opseg kretanja.

Mapiranje podataka:

Ovo je primer pretvaranja sirovih senzorskih podataka u vizuelno upotrebljiv opseg. To se naziva: mapiranje podataka.

Napredna verzija (izazov)

Proširi projekat:

Dodaj granice da objekat ne izađe van ekrana
Dodaj promenu boje u zavisnosti od nagiba
Dodaj „inerciju“ (glatko kretanje)
Dodaj prepreke koje treba izbegavati

Na taj način projekat prelazi iz demonstracije u pravu mini-igru.

Mini izazov:

Možeš li da napraviš:

labirint
kontrolu automobila
balansiranje lopte

koristeći samo nagib micro:bit-a?

Pedagoški cilj projekta

Učenici ovde uče:

kako se senzorski podaci prenose
kako se dizajnira format poruke
kako se parsiraju podaci
kako se fizički pokret pretvara u grafiku
kako se pravi interaktivni sistem

Ovo je pravi primer povezivanja:

hardvera
programiranja
grafike
interakcije

Mini izazov za razmišljanje

Kako bi napravio igru: „Izbegni zidove“ gde se objekat kreće samo pomoću nagiba micro:bit-a?

Razmisli:

Gde se proverava sudar?
Da li micro:bit treba da zna za prepreke?
Da li logika ostaje u Processing-u?

Važna ideja:

micro:bit ne mora da zna ništa o igri. Njegov posao može biti samo:

očitaj senzore
pošalji podatke

Sva logika igre može ostati u Processing-u.

Time prelaziš sa jednostavne vizualizacije na dizajn pravog interaktivnog sistema.

Kako izgleda čitanje sa serijskog porta u Python modu?

Ako koristiš Processing Python Mode, kod izgleda drugačije nego u Java modu.

Sintaksa je mnogo bliža standardnom Python-u, što učenicima često olakšava razumevanje.

Važno:

U Processing-u postoje različiti modovi rada:

Java Mode — podrazumevani mod
Python Mode — koristi Python sintaksu

Iako oba koriste isti Processing engine, način pisanja koda je drugačiji.

Primer — čitanje podataka sa micro:bit-a

Ovaj program:

čita podatke sa serial porta
prima vrednosti x i y
pomera objekat na ekranu


# Učitavanje biblioteke za serijsku komunikaciju
add_library('serial')

from processing.serial import *

# Globalne promenljive za poziciju objekta
xPos = 300
yPos = 200

# Promenljiva za serijski port
myPort = None


def setup():

    global myPort

    # Veličina prozora
    size(600, 400)

    # Prikaz svih dostupnih COM portova
    print(Serial.list())

    # Otvaranje prvog pronađenog porta
    myPort = Serial(this, Serial.list()[0], 115200)

    # Processing čeka kraj linije (\n)
    myPort.bufferUntil('\n')


def draw():

    global xPos, yPos

    # Boja pozadine
    background(240)

    # Crtanje objekta
    ellipse(xPos, yPos, 50, 50)


# Ova funkcija se automatski pokreće
# kada stigne nova linija podataka
def serialEvent(port):

    global xPos, yPos

    # Čitanje jedne linije teksta
    data = port.readStringUntil('\n')

    # Provera da li je nešto stiglo
    if data != None:

        # Uklanjanje praznih karaktera
        data = data.strip()

        # Razdvajanje teksta po zarezu
        values = data.split(',')

        # Očekujemo 2 vrednosti: x i y
        if len(values) == 2:

            # Pretvaranje teksta u brojeve
            x = float(values[0])
            y = float(values[1])

            # Pomeranje objekta
            xPos = width/2 + x/10
            yPos = height/2 + y/10

Kako program funkcioniše?

Pogledajmo korak po korak šta se dešava.

1. Učitavanje serial biblioteke


add_library('serial')

from processing.serial import *

Ovim uključujemo podršku za:

COM portove
USB serial komunikaciju
čitanje podataka sa micro:bit-a

Zapamti:

Bez serial biblioteke Processing ne može da komunicira sa micro:bit uređajem.

2. Otvaranje serial porta


print(Serial.list())

Ova linija prikazuje sve dostupne serial portove.

Na primer:


['COM3', 'COM5']

Zatim otvaramo prvi pronađeni port:


myPort = Serial(this, Serial.list()[0], 115200)

this ➝ trenutni Processing sketch
115200 ➝ brzina komunikacije (baudrate)

Važno:

Baudrate mora biti isti u MicroPython i Processing programu. Ako brzine nisu iste, podaci neće biti pravilno pročitani.

3. Čekanje kraja poruke


myPort.bufferUntil('\n')

Ova linija govori Processing-u:

„Sačekaj dok ne stigne znak novog reda.”

To omogućava da čitamo celu poruku odjednom.

Na primer:


120,-45

Eksperiment:

Probaj da ukloniš:


bufferUntil('\n')

i posmatraj šta se dešava sa podacima.

4. Funkcija serialEvent()

Funkcija:


def serialEvent(port):

automatski se pokreće kada stigne nova poruka.

To znači da ne moramo stalno ručno proveravati port.

Važna ideja:

Ovo je primer: event-driven programiranja. Program reaguje na događaj (pristizanje podataka).

5. Razdvajanje podataka

Micro:bit šalje tekstualnu poruku:


120,-45

Processing zatim koristi:


values = data.split(',')

Rezultat je lista:


['120', '-45']

Nakon toga:


x = float(values[0])
y = float(values[1])

pretvaramo tekst u brojeve.

6. Pomeranje objekta


xPos = width/2 + x/10
yPos = height/2 + y/10

Na ovaj način:

nagib uređaja utiče na poziciju objekta
senzorski podaci postaju grafika

Deljenje sa 10 smanjuje prevelike vrednosti senzora.

Mapiranje podataka:

Pretvaranje senzorskih vrednosti u pozicije na ekranu naziva se: mapiranje podataka.

Zašto koristimo global?

U Python modu promenljive unutar funkcije su lokalne osim ako ne napišemo:


global xPos

Na taj način Processing zna da želimo da menjamo globalnu promenljivu, a ne da pravimo novu lokalnu kopiju.

Praktično pravilo:

Ako promenljivu menjaš unutar funkcije, a definisana je van funkcije, često će ti biti potreban global.

Java Mode vs Python Mode

Java Mode	Python Mode
`void setup()`	`def setup()`
`String[]`	`list`
`float x`	`x = float()`
Tačka-zarez ;	Nema ;
Java sintaksa	Python sintaksa

Oba moda koriste isti Processing engine, ali je sintaksa drugačija.

Ako učenici već znaju Python, Python Mode je često prirodniji izbor.

Mini izazov

Probaj da proširiš program:

promeni boju objekta kada se micro:bit nagne
dodaj više objekata
dodaj granice ekrana
dodaj „glatko“ kretanje

Ideja za projekat:

Možeš li da napraviš mini igru u kojoj se lopta kontroliše isključivo nagibom micro:bit-a?

Kako izgleda čitanje sa serijskog porta u Python modu?

Ako koristiš Processing Python Mode, kod izgleda bliže standardnom Python-u nego Java verzija.

To znači:

koristi se def setup() umesto Java funkcija
nema tačka-zarez sintakse
liste i stringovi rade kao u Python-u

Važno:

Ovo je i dalje Processing engine, ali sa Python sintaksom preko Jython-a.

Primer: čitanje podataka sa micro:bit-a


# Uključivanje serial biblioteke Processing-a
add_library('serial')

from processing.serial import *

# Globalne promenljive (pozicija objekta)
xPos = 300
yPos = 200

# Serijski port
myPort = None


def setup():
    global myPort

    size(600, 400)

    # Prikaz dostupnih portova
    print(Serial.list())

    # Otvaranje serijske veze
    myPort = Serial(this, Serial.list()[0], 115200)

    # Čekamo kraj linije (\n)
    myPort.bufferUntil('\n')


def draw():
    background(240)

    # Crtanje objekta
    ellipse(xPos, yPos, 50, 50)


def serialEvent(port):
    global xPos, yPos

    # Čitanje jedne linije
    data = port.readStringUntil('\n')

    if data is not None:

        # Čišćenje stringa
        data = data.strip()

        # Razdvajanje x,y
        values = data.split(',')

        if len(values) == 2:

            x = float(values[0])
            y = float(values[1])

            # Mapiranje na ekran
            xPos = width/2 + x/10
            yPos = height/2 + y/10

Eksperiment:

Promeni skalu kretanja:


xPos = width/2 + x/20
yPos = height/2 + y/20

Šta se dešava kada povećavaš ili smanjuješ delilac?

Kako ovo zapravo radi?

Logika sistema:

micro:bit šalje tekst: x,y\n
Processing prima celu liniju
split(',') razdvaja vrednosti
float() pretvara tekst u broj
objekat se pomera na ekranu

Zašto je bufferUntil('\n') važan?

Bez ovog, Processing bi čitao “polu-poruke”.

Objašnjenje:

\n označava kraj jedne poruke. Processing tada zna:
□ “sada imam kompletnu informaciju”

Mini zaključak

Ovo je osnovni obrazac svih real-time sistema:

uređaj šalje podatke
računar ih parsira
grafika reaguje u realnom vremenu

Završni projekat: micro:bit kao gejming kontroler

U ovom projektu micro:bit postaje interaktivni kontroler igre. Nagib uređaja kontroliše kretanje, dok tasteri A i B aktiviraju posebne akcije.

Ovo je kompletan real-time sistem koji povezuje: senzore → serijsku komunikaciju → grafičku igru.

Cilj projekta

Micro:bit šalje nagib (X, Y)
Taster A aktivira boost (brže kretanje)
Taster B daje poene
Processing prikazuje igru i upravlja logikom

Ključna ideja:

Micro:bit je “kontroler”, a Processing je “igra”.

Arhitektura sistema

micro:bit (senzori + dugmad)
        ↓
uart.write("x,y,A,B\n")
        ↓
USB Serial
        ↓
Processing (Python Mode)
        ↓
Igra: kretanje + bodovi + boost

MicroPython kod (micro:bit)


from microbit import *
import utime

while True:
    x = accelerometer.get_x()
    y = accelerometer.get_y()

    a = button_a.is_pressed()
    b = button_b.is_pressed()

    # slanje 4 vrednosti u jednom redu
    uart.write(
        str(x) + "," +
        str(y) + "," +
        str(int(a)) + "," +
        str(int(b)) + "\n"
    )

    utime.sleep(0.05)

Format poruke:

x,y,A,B\n

A = boost (0 ili 1)
B = poeni (0 ili 1)

Processing kod (Python Mode – logika igre)


import processing.serial.*

Serial myPort

xPos = 350
yPos = 250

speedMultiplier = 1
score = 0


def setup():
    global myPort

    size(700, 500)

    print(Serial.list())

    myPort = Serial(this, Serial.list()[0], 115200)
    myPort.bufferUntil('\n')



def draw():
    background(30)

    fill(0, 150, 255)
    ellipse(xPos, yPos, 50, 50)

    fill(255)
    textSize(20)
    text("Score: " + str(score), 20, 30)



def serialEvent(port):
    global xPos, yPos, speedMultiplier, score

    data = port.readStringUntil('\n')

    if data is not None:

        data = data.strip()
        values = data.split(',')

        if len(values) == 4:

            x = float(values[0])
            y = float(values[1])
            a = int(values[2])
            b = int(values[3])

            # boost
            speedMultiplier = 2 if a == 1 else 1

            # kretanje
            xPos += (x / 200) * speedMultiplier
            yPos += (y / 200) * speedMultiplier

            # granice ekrana
            xPos = constrain(xPos, 25, width - 25)
            yPos = constrain(yPos, 25, height - 25)

            # poeni
            if b == 1:
                score += 5

Kako igra radi?

Nagib pomera igrača
Taster A ubrzava kretanje
Taster B dodaje poene
Processing obrađuje sve u realnom vremenu

Eksperiment:

Promeni delilac u kretanju:


xPos += (x / 100) * speedMultiplier

Šta se dešava kada povećavaš ili smanjuješ vrednost?

Šta učenici uče?

Kako se dizajnira komunikacioni protokol
Kako se kombinuju više senzora u jednoj poruci
Kako se podaci parsiraju i validiraju
Kako se senzor mapira na kretanje
Osnove dizajna 2D igre

Napredni izazovi

Dodaj više neprijatelja
Dodaj život (health system)
Dodaj restart igre
Dodaj zvuk pri sudaru
Dodaj nivoe težine

Zaključak

Ovaj projekat povezuje hardver i softver u jednu celinu:

micro:bit = senzor i kontroler
Serial = komunikacioni kanal
Processing = grafička igra

Finalni cilj:

Učenici prelaze iz “pisanja koda” u razumevanje čitavog interaktivnog sistema.

Kako podaci putuju od micro:bit-a do grafike?

U ovoj lekciji smo videli kako micro:bit šalje podatke preko serial komunikacije.

Sada je važno razumeti šta se dešava “iza scene” — ceo put podataka.

Ključna ideja:

Micro:bit ne pravi grafiku.
On samo šalje podatke, a računar ih interpretira.

Tok podataka u sistemu

micro:bit → UART → USB → računar → Processing → grafika

micro:bit čita senzore (nagib, temperatura, dugmad)
uart.write() pretvara podatke u tekst
USB kabl prenosi podatke do računara
Processing čita dolazne poruke
podaci postaju grafika, animacija ili igra

Šta micro:bit zapravo šalje?

micro:bit ne šalje “grafiku” ili “objekte”, već samo običan tekst.

Primer jednostavnih poruka:

23
24
25

Processing te vrednosti može pretvoriti u:

kretanje objekta
graf temperature
promenu boje ili animaciju

Primer više vrednosti u jednoj poruci

Često se šalju dve ili više vrednosti zajedno:

23,512

To može značiti:

23 → temperatura
512 → svetlost ili drugi senzor

Zašto zarez?

Zarez je jednostavan “separator” koji omogućava Processing-u da lako razdvoji podatke pomoću split(',').

Mini eksperiment razumevanja

Razmisli:

Ako micro:bit pošalje:

120,-40

šta bi moglo da znači:

prvi broj?
drugi broj?

Kako bi to pretvorio u kretanje na ekranu?

Zašto je ovo važno?

Ovo je osnova svih sistema koji povezuju hardver i softver:

IoT uređaji
robotika
igre sa senzorima
interaktivne instalacije

U svim tim sistemima važi isti princip: uređaj šalje podatke → program ih interpretira.

Šta dalje učimo?

U sledećoj lekciji prelazimo na drugu stranu sistema: Processing program koji prima i crta podatke.

Učićemo:

kako se čita serial port
kako se razdvajaju podaci
kako se pravi real-time grafika

Finalna ideja:

micro:bit = senzor
Processing = mozak + grafika

Skriveni mini kviz — Vizuelna igra (micro:bit ↔ Processing)

Klikni da proveriš da li razumeš ključne koncepte igre: serial komunikaciju, mapiranje nagiba i logiku bodova/sudara.

Otvori kviz

Mini kviz: Vizuelna igra

1. Koji mikro:bit modul koristimo da šaljemo X i Y nagib računaru?

radio
uart
accelerometer

2. Koja linija u Processing kodu čita podatke sa micro:bit-a?


myPort.bufferUntil('\n');

Serial.read()
myPort.bufferUntil('\n')
readString()

3. Kako se mapira X nagib na horizontalnu poziciju objekta?

xPos = x
xPos = width/2 + x/10
xPos = random(width)

4. Kako igra detektuje sudar?

Ako distanca između objekta i prepreke < 40
Ako xPos > width
Ako obstacleY > height

5. Kada igrač dobija poene?

Svaki put kada prepreka dođe do dna ekrana
Kada pritisne dugme A
Kada se dogodi sudar

⬅ Prethodna lekcija: MicroPython – mini projekti

Sledeća oblast: Processing sa Python-om ➡

↩ Povratak na micro:bit hub

MicroPython — serial komunikacija (most ka Processing-u)

Povezivanje micro:bit-a i računara

Šta je serial komunikacija?

UART — serijska komunikacija na micro:bit-u

Šta možemo slati?

Primer: slanje temperature računaru

Zašto koristimo str()?

Kraj poruke — znak novog reda

Serial monitor — prvi test

Zašto je ovo važno za Processing?

Mini zadatak

Šta sledi?

Proširenje — Napredna serial komunikacija

1. Slanje više vrednosti odjednom

2. Mini komunikacioni protokol

3. Stabilnost komunikacije

4. Mini projekat — graf temperature

5. Dvosmerna komunikacija

Šta rade ove funkcije?

Šta si zapravo naučio?

Dijagram arhitekture — micro:bit ↔ Serial ↔ Processing

1. Fizički sloj — Hardware

2. Komunikacioni sloj — Serial veza

3. Aplikacioni sloj — Processing

Vizuelni dijagram sistema

Primer toka podataka

Razdvajanje odgovornosti

Napredna perspektiva

Mini zadatak za razmišljanje

Projekat: „Vizuelni kontroler nagiba“

Arhitektura sistema

Korak 1 — MicroPython kod (micro:bit)

Korak 2 — Processing Python Mode (vizuelizacija)

Kako sistem radi?

Zašto delimo sa 10?

Napredna verzija (izazov)

Pedagoški cilj projekta

Mini izazov za razmišljanje

Kako izgleda čitanje sa serijskog porta u Python modu?

Primer — čitanje podataka sa micro:bit-a

Kako program funkcioniše?

1. Učitavanje serial biblioteke

2. Otvaranje serial porta

3. Čekanje kraja poruke

4. Funkcija serialEvent()

5. Razdvajanje podataka

6. Pomeranje objekta

Zašto koristimo global?

Java Mode vs Python Mode

Mini izazov

Kako izgleda čitanje sa serijskog porta u Python modu?

Primer: čitanje podataka sa micro:bit-a

Kako ovo zapravo radi?

Zašto je bufferUntil('\n') važan?

Mini zaključak

Završni projekat: micro:bit kao gejming kontroler

Cilj projekta

Arhitektura sistema

MicroPython kod (micro:bit)

Processing kod (Python Mode – logika igre)

Kako igra radi?

Šta učenici uče?

Napredni izazovi

Zaključak

Kako podaci putuju od micro:bit-a do grafike?

Tok podataka u sistemu

Šta micro:bit zapravo šalje?

Primer više vrednosti u jednoj poruci

Mini eksperiment razumevanja

Zašto je ovo važno?

Šta dalje učimo?

Skriveni mini kviz — Vizuelna igra (micro:bit ↔ Processing)

Mini kviz: Vizuelna igra

Podešavanja kolačića