SLO - NAVODILA ZA UPORABO IN MONTAŽO Kat. št.: 12 25 953 www.conrad.si NAVODILA ZA UPORABO Učni komplet za Raspberry Pi Conrad Components Kataloška št.
Kazalo 1 Od namestitve operacijskega sistema do prvega programa Python ............................ 3 1.1 Kaj potrebujete? ................................................................................................................ 3 1.1.1 Polnilnik za mobilni telefon Micro USB .................................................................... 3 1.1.2 Spominska kartica .................................................................................................... 4 1.1.3 Tipkovnica ..............
10.3.1 Tako deluje .......................................................................................................... 76 11 PiDance z LED ................................................................................................................ 77 11.1.1 Tako deluje .......................................................................................................... 81 Kolofon .................................................................................................................
so zunanji trdi diski brez lastnega napajanja, potem potrebujete močnejši napajalnik. Napajalnik mora nuditi 5 V in minimalno 2.000 mA. Vgrajen regulator moči prepreči, da bi pri premočnih napajalnikih naprave ''pregorele''. Pokazatelj prešibkega napajalnika Ko se Raspberry Pi sicer zažene, vendar pa nato ne morete premikati miškinega kazalca ali pa se sistem ne odziva na vnose prek tipkovnice, to pomeni, da je na voljo prešibko napajanje.
video izhod je kombiniran z avdio izhodom. Za priključitev na značilni rumeni priključek televizorja potrebujete adapterski kabel s 3,5 mm banana vtičem. Za televizorje brez rumenega FBAS-vhoda so na voljo adapterji iz FBAS na SCART. Pri analogni ločljivosti televizorja imate omejeno možnost upravljanja grafičnega vmesnika. 1.2 Namestitev operacijskega sistema Raspbian ............................................................................................................................................
najmanj 4 GB. Preizkusi v tem učnem kompletu so bili testirani s programom NOOBS v različici 1.9.2. Starejše različice so samo omejeno združljive z aktualnimi modeli Raspberry Pi. Sedaj s to spominsko kartico zaženite Raspberry Pi. Pri tem jo vstavite v režo na Raspberry Pi in priključite tipkovnico, miško, monitor in omrežni kabel. Električni USB-priključek je na vrsti nazadnje. Prek njega se Raspberry Pi vključi. Ločena tipka za vklop ni na voljo.
Raspbian Linux za Raspberry Pi uporablja vmesnik LXDE (Lightweight X11 Desktop Environment), ki po eni strani potrebuje zelo malo sistemskih virov, po drugi strani pa je s svojim menijem Start in upraviteljem datotek zelo podoben znanemu vmesniku Windows – s to razliko, da se opravilna vrstica nahaja na zgornjem robu zaslona. Prijava v Linux Celo prijava uporabnika, ki je značilna za Linux, se opravi v ozadju.
Nastavitev se nato potrdi z besedilnim prikazom datuma in časa: Di 22. Mär 08:00:00 CET 2016 Ta nastavitev velja samo do naslednjega ponovnega zagona. Ura z rezervnim baterijskim napajanjem ni na voljo. 1.3.2 Shranjevanje lastnih datotek na Raspberry Pi Upravljanje datotek pri operacijskem sistemu Linux sicer poteka malce drugače kot pri operacijskem sistemu Windows, vendar ni nič težje. Raspbian nudi upravitelja datotek, ki je neverjetno podoben programu Windows Explorer.
1.4 Prvi program s programskim jezikom Python ..................................................................................................................................................................................................................................................................................................................................................................................................................................................................................
Ta prvi ''program'' nato zapiše Pozdravljen svet v naslednji vrstici na zaslonu. Slika 1.6: »Pozdravljen svet« v programskem jeziku Python (zgoraj vidite še izpis izračuna). Tukaj tudi takoj vidite, da Python Shell za ponazoritev samodejno uporablja različne barve besedila. Ukazi Python so oranžne barve, zaporedja znakov so zelene barve, rezultati pa so modre barve. Kasneje boste odkrili še dodatne barve.
1.4.1 Ugibanje števil s Python Namesto da bi se zadrževali s teorijo o programiranju, algoritmi in tipi podatkov, bomo kar napisali prvo majhno igro v Python. Gre za enostavno igro ugibanja, pri kateri mora igralec v karseda malo korakih uganiti število, ki ga naključno izbere računalnik. 1. V meniju okna Python Shell izberite možnost File/New Window (Datoteka/Novo okno). Pri ....tem se odpre novo okno, v katerega vtipkate naslednjo programsko kodo: import random zahl = random.
Slika 1.8: Pravilna nastavitev za prikaz preglasov v Python. 4. Sedaj aktivirajte igro s pritiskom tipke [F5] ali izbiro točke menija Run/Run Module ....(Zaženi/Zaženi modul). 5..V namen enostavnosti igra nima nobenega grafičnega vmesnika, prav tako nima ....pojasnjevalnih besedil ali verjetnostnih poizvedb glede vnosa. Računalnik v ozadju ....generira naključno število med 0 in 1.000. Preprosto vnesite poljubno število in izvedeli ....boste, če je iskano število večje ali manjše.
Slika 1.9: Ugibanje števil v Python. 1.4.2 Tako deluje Če igra deluje, lahko enostavno preizkusite. Sedaj se seveda pojavi nekaj vprašanj: Kaj se dogaja v ozadju? Kaj pomenijo posamezne programske vrstice? import random Za generiranje naključnega števila se uvozi eksterni Python modul z imenom random, ki vsebuje različne funkcije za naključne generatorje. zahl = random.
Kako nastajajo naključna števila? Pogosto velja mnenje, da se v programu ne more nič naključno zgoditi. Kako lahko ima torej program sposobnost generiranja naključnih števil? Če veliko praštevilo delite s kakršnokoli vrednostjo, se po X-tem decimalnem mestu pojavijo števila, ki jih je komajda še možno predvideti. Ta se tudi spreminjajo brez kakršnekoli rednosti, ko delitelj redno povečujemo.
print "Uganili ste število v ",i,". poskusu" Ta vrstica je bolj zamaknjena, kar pomeni, da je tudi zanka while končana. Ko torej njen pogoj več ne drži, torej število tipp, ki ga je vtipkal uporabnik, več ni neenako (temveč je enako) skritemu številu zahl, se pojavi to besedilo, ki je sestavljeno iz dveh stavčnih delov in spremenljivke i ter tako navaja, koliko poskusov je uporabnik potreboval. Programi Python ne potrebujejo lastnega navodila za ustavitev. Ustavijo se preprosto po zadnjem ukazu oz.
Pin 2 in pin 4 nudita +5 V napetost za napajanje zunanje strojne opreme. Tukaj je možno odjemati toliko toka, kolikor ga nudi USB-napajalnik računalnika Raspberry Pi. Vendar pa teh pinov ne smete povezati z GPIO-vhodom. 2.1 Komponente v paketu Učni komplet vsebuje različne elektronske komponente, s katerimi lahko sestavite preizkuse, ki so opisani v teh navodilih za uporabo (in seveda tudi lastne preizkuse). Na tem mestu so komponente samo na kratko predstavljene.
čemer je na sredini preizkusne ploščice prazen prostor. Tako lahko tukaj na sredini vstavite večje komponente in jih ožičite navzven. 2.1.2 Priključni kabli Barvni priključni kabli imajo vsi na eni strani majhen žični vtič, s katerim jih lahko vstavite v preizkusno ploščico. Na drugi strani se nahaja vtični priključek, ki je primeren za priključitev na GPIO-pin računalnika Raspberry Pi. Poleg tega je učnemu kompletu priložena stikalna žica.
Učni komplet vsebuje upore v treh različnih vrednostih: 1 kΩ 2. 1. obroč obroč (desetica) (enica) Rdeča Rdeča Črna Rjava 10 kΩ Rjava Vrednost 220 Ω 3. obroč 4. obroč Uporaba (množitelj) (toleranca) Rjava Zlata Predupor za LED Rdeča Zlata Zaščitni upor za GPIO-vhode Pull-down upor oz. spodnji upor za GPIO-vhode Tabela 2.2: Barvne kode uporov v učnem kompletu. Črna Oranžna Zlata Predvsem pri 1 kΩ in 10 kΩ uporih bodite zelo pozorni na barve, saj jih lahko hitro zamenjate. 2.
Slika 2.3: Sestav preizkusne ploščice za priključitev LED.
Slika 2.4: Prva LED na Raspberry Pi. V tem prvem preizkusu se Raspberry Pi uporablja samo kot napajanje za LED. LED vedno sveti in za to ne potrebujete nobene programske opreme. V naslednjem preizkusu v napajalni kabel LED vstavite tipkalo. LED sedaj sveti samo takrat, ko je to tipkalo pritisnjeno. Tudi za to ne potrebujete programske opreme.
Slika 2.5: Sestav preizkusne ploščice za LED, ki jo preklapljate s stikalom.
Slika 2.6: LED s tipkalom na Raspberry Pi. 2.3 GPIO s Python Da lahko uporabljate GPIO-vrata prek programov Python, mora biti nameščena knjižnica Python GPIO. V zgodnejših različicah Raspbian so morali uporabniki to knjižnico še ročno nameščati. To danes več ni potrebno, pa tudi dostop ''sudo'', ki je bil včasih potreben, je sedaj že stvar preteklosti. 2.4 Vklapljanje in izklapljanje LED .........................................................................................................................
GPIO.setmode(GPIO.BCM) GPIO.setup(25, GPIO.OUT) GPIO.output(25, 1) time.sleep(2) GPIO.output(25, 0) GPIO.cleanup() Slika 2.7: LED na GPIO-vratih 25. 2.4.1 Tako deluje Primer prikazuje najpomembnejše osnovne funkcije knjižnice RPi.GPIO. import RPi.GPIO as GPIO Knjižnico RPi.GPIO je treba uvoziti v vsak program Python, v katerem jo nameravate uporabljati. S tem načinom pisanja je možno krmiljenje vseh funkcij knjižnice prek predpone GPIO.
Oštevilčenje GPIO-vrat Knjižnica RPi.GPIO podpira dve različni metodi za označevanje vrat. V načinu BCM se uporabljajo znane številke GPIO-vrat, ki se uporabljajo tudi na nivoju ukaznih vrstic ali v skriptih Shell. V alternativnem načinu BOARD se oznake skladajo s številkami pinov od 1 do 40 na vezju Raspberry Pi. GPIO.setup(25, GPIO.OUT) Funkcija GPIO.setup inicializira GPIO-vrata kot izhod ali kot vhod.
Slika 3.1: Sestav preizkusne ploščice za semafor.
Slika 3.2: Enostaven semafor. Program ampel01.py krmili semafor: import RPi.GPIO as GPIO import time GPIO.setmode(GPIO.BCM) rot = 0; gelb = 1; gruen = 2 Ampel=[4,18,23] GPIO.setup(Ampel[rot], GPIO.OUT, initial=False) GPIO.setup(Ampel[gelb], GPIO.OUT, initial=False) GPIO.setup(Ampel[gruen], GPIO.OUT, initial=True) print ("Ctrl+C zaključi program") try: while True: time.sleep(2) GPIO.output(Ampel[gruen],False); GPIO.output(Ampel[gelb],True) time.sleep(0.6) GPIO.output(Ampel[gelb],False); GPIO.
GPIO.output(Ampel[gruen],True) except KeyboardInterrupt: GPIO.cleanup() 3.1.1 Tako deluje Prve vrstice so že znane in uvozijo knjižnice RPi.GPIO za krmiljenje GPIO-vrat in time za časovne zakasnitve. Nato sledi oštevilčenje GPIO-vrat na BCM v skladu s prejšnjim primerom. rot = 0; gelb = 1; gruen = 2 Te vrstice definirajo tri spremenljivke rot, gelb in gruen za tri LED (rdeča, rumena in zelena).
S to kombinacijo tipk se sproži KeyboardInterrupt, zanka pa se samodejno zapusti. Zadnja vrstica zapre uporabljena GPIO-vrata in s tem izklopi vse LED. Nato se program zaključi. Z nadzorovanim zapiranjem GPIO-vrat ne prihaja do sistemskih opozoril ali sporočil o prekinitvi, ki bi lahko zmedla uporabnika. Dejanski cikel semaforja poteka v neskončni zanki: while True : Takšne neskončne zanke vedno potrebujejo pogoj za prekinitev, sicer se program nikoli ne bi zaključil. time.
Slika 4.1: Sestav preizkusne ploščice za semafor in utripajočo luč za pešce.
Slika 4.2: Semafor z utripajočo lučjo za pešce. Program ampel02.py krmili nov sistem semaforja. Za razliko od prejšnje različice je program malce nadgrajen. import RPi.GPIO as GPIO import time GPIO.setmode(GPIO.BCM) rot = 0; gelb = 1; gruen = 2; blau = 3 Ampel=[4,18,23,24] GPIO.setup(Ampel[rot], GPIO.OUT, initial=False) GPIO.setup(Ampel[gelb], GPIO.OUT, initial=False) GPIO.setup(Ampel[gruen], GPIO.OUT, initial=True) GPIO.setup(Ampel[blau], GPIO.
GPIO.output(Ampel[blau],False); time.sleep(0.05) time.sleep(0.6) GPIO.output(Ampel[gelb],True); time.sleep(0.6) GPIO.output(Ampel[rot],False) GPIO.output(Ampel[gelb],False) GPIO.output(Ampel[gruen],True) except KeyboardInterrupt: GPIO.cleanup() 4.1.1 Tako deluje Potek programa je v veliki meri znan. Med rdečo fazo, ki je sedaj malce daljša, mora modri semafor za pešce hitro utripati. blau = 4 Nova spremenljivka definira LED za semafor za pešce na seznamu.
4.2 Tipkalo na GPIO-priključku .................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................
Slika 4.5: Sestav preizkusne ploščice za semafor za pešce s tipko. Potrebne komponente: 1 x preizkusna ploščica 1 x rdeča LED 1 x rumena LED 1 x zelena LED 1 x modra LED 4 x 220 Ω upor 1 x tipkalo 1 x 1 kΩ upor 1 x 10 kΩ upor 7 x priključni kabel 1 x kratek žični mostiček Spodnja kontaktna letev tipkala na sliki je prek plus letve preizkusne ploščice povezana s +3,3 V kablom računalnika Raspberry Pi (pin 1).
Slika 4.6: Utripajoča luč za pešce s tipkalom. Program ampel03.py krmili nov sistem semaforja s tipkalom za utripajočo luč za pešce. # -*- coding: utf-8 -*import RPi.GPIO as GPIO import time GPIO.setmode(GPIO.BCM) rot = 0; gelb = 1; gruen = 2; blau = 3; taster = 4 Ampel=[4,18,23,24,25] GPIO.setup(Ampel[rot], GPIO.OUT, initial=False) GPIO.setup(Ampel[gelb], GPIO.OUT, initial=False) GPIO.setup(Ampel[gruen], GPIO.OUT, initial=True) GPIO.setup(Ampel[blau], GPIO.OUT, initial=False) GPIO.
try: while True: if GPIO.input(Ampel[taster])==True: GPIO.output(Ampel[gruen],False) GPIO.output(Ampel[gelb],True) time.sleep(0.6) GPIO.output(Ampel[gelb],False) GPIO.output(Ampel[rot],True) time.sleep(0.6) for i in range(10): GPIO.output(Ampel[blau],True); time.sleep(0.05) GPIO.output(Ampel[blau],False); time.sleep(0.05) time.sleep(0.6) GPIO.output(Ampel[gelb],True) time.sleep(0.6) GPIO.output(Ampel[rot],False); GPIO.output(Ampel[gelb],False) GPIO.output(Ampel[gruen],True); time.
je UTF-8. Gre za kodiranje, ki deluje v več računalniških okoljih in se pri prvih 128 znakih popolnoma sklada z ASCII, s čimer je združljivo navzdol s skoraj vsemi sistemi, ki prikazujejo besedila. Kodiranje se vnese v vrstico s komentarjem. Vseh vrstic, ki se začnejo z znakom #, tolmač Python ne interpretira. Kodiranje, ki se mora vedno nahajati čisto na začetku programa, Python Shell da navodila, kako naj prikazuje znake, vendar ne gre za dejansko programsko navodilo.
5 Pisani LED-vzorci in tekoče luči .............................................................................................................................................................................................................................................................................................................................................................................................................................................................................................
Slika 5.2: Štiri LED s predupori. Na podlagi različnih vzorcev utripanja LED bomo razložili nadaljnje zanke in metode programiranja v Python. Naslednji program nudi različne vzorce LED, ki jih lahko izbere uporabnik z vnosom prek tipkovnice. Program ledmuster.py poskrbi za utripanje LED v različnih vzorcih. # -*- coding: utf-8 -*import RPi.GPIO as GPIO import time import random GPIO.setmode(GPIO.BCM) LED = [4,18,23,24] for i in LED: GPIO.setup(i, GPIO.OUT, initial=0) z = len(LED); w = 5; t = 0.
print print print print print ("2 – tekoča luč naprej in nazaj"); ("3 – naraščajoča in padajoča") ("4 – vse utripajo hkrati"); ("5 – vse utripajo naključno") ("Ctrl+C zaključi program") try: while True: e = raw_input ("Prosimo, izberite vzorec: ") if e == "1": for i in range(w): for j in range(z): GPIO.output(LED[j], True); time.sleep(t) GPIO.output(LED[j], False) elif e == "2": for i in range(w): for j in range(z): GPIO.output(LED[j], True); time.sleep(t) GPIO.
Pri razvoju programa smo pazili na to, da je karseda vsestransko uporaben, torej da ga je možno enostavno nadgraditi na več kot štiri LED. K dobremu slogu programiranja danes sodi takšna fleksibilnost. Na primeru računalnika Raspberry Pi je možno na ta način programirane programe ne samo nadgraditi z novimi GPIO-vrati, temveč jih je možno enostavno predelati na druga GPIO-vrata, če je to potrebno zaradi tehnike strojne opreme.
Slika 5.3: Program na zaslonu. Po prikazu izbire se začne glavna zanka programa. Pri tem tudi tukaj uporabimo neskončno zanko while True:, ki je vključena v navodilu try...except. e = raw_input ("Prosimo, izberite vzorec: ") Takoj na začetku zanke program čaka na vnos uporabnika, ki se shrani v spremenljivki e. Funkcija raw_input() prevzame vnos v besedilni obliki in ga ne interpretira. Ravno nasprotno pa se z input() vnesene matematične operacije ali imena spremenljivk neposredno interpretirajo.
for j in range(z): GPIO.output(LED[j], True); time.sleep(t) GPIO.output(LED[j], False) V primeru enostavne ciklične tekoče luči ta zanka zaporedoma steče enkrat za vsako LED na seznamu. Koliko LED to je, ste shranili na začetku programa v spremenljivki z. Vklopi se LED s številko trenutnega stanja zančnega števca. Nato program počaka, da preteče čas, ki ste ga shranili na začetku v spremenljivki t, nato pa ponovno izklopi LED. Takoj nato se začne naslednji prehod zanke z naslednjo LED.
Vzorec št. 3 Ko uporabnik vnese številko 3, se začne podobna zanka. Tukaj se LED prav tako preštevajo v obeh smereh, vendar se ne izklopijo takoj po vklopu. elif e == "3": for i in range(w): for j in range(z): GPIO.output(LED[j], True); time.sleep(t) time.sleep(2*t) for j in range(z-1, -1, -1): GPIO.output(LED[j], False); time.sleep(t) time.sleep(2*t) Prva notranja zanka vklopi LED eno za drugo s časovno zakasnitvijo. Na koncu zanke, ki ga prepoznate po zamiku vrstice time.
Ker se tukaj ne uporabljajo zanke, ki se nahajajo ena v drugi, poskrbimo za to, da zanka pogosteje teče. Z množenjem spremenljivk w in z vsaka LED utripa v povprečju tako pogosto kot v prvem vzorcu. Funkcija random.randint() zapiše naključno število v spremenljivko j. To naključno število je večje ali enako prvemu parametru in manjše ali enako drugemu parametru, tako da lahko v našem primeru prevzame vrednosti 0, 1, 2, 3. Naključno izbrana LED se vklopi in po preteku časa zakasnitve ponovno izklopi.
Slika 6.2: Sestav preizkusne ploščice z LED.
Slika 6.3: LED na GPIO-vratih 18. Program leddimmen01.py ciklično zatemnjuje LED svetleje in temneje ter pri tem uporablja lastno funkcijo pulznoširinske modulacije (PWM) iz GPIO-knjižnice. PWM-signal (signal pulznoširinske modulacije) se generira kot lastna nit. Na ta način lahko zatemnjeno LED uporabljate v programu (skoraj) tako kot LED, ki običajno sveti. import RPi.GPIO as GPIO import time GPIO.setmode(GPIO.BCM); LED = 18 GPIO.setup(LED, GPIO.OUT) print ("Ctrl+C zaključi program") p = GPIO.
6.1.1 Tako deluje Del tega programa se vam bo zdel znan, nekateri elementi pa vam bodo popolnoma neznani, saj na tem mestu naredimo ekskurz v programiranje, ki je orientirano na objekt. Na začetku se uvozijo knjižnice, tako kot vam je že znano. Tokrat se za GPIO-vrata 18 določi ena sama spremenljivka LED, ki se inicializira kot izhod. print ("Ctrl+C zaključi program") Ker tudi ta program deluje s konstruktom try...except in ga mora ustaviti uporabnik, je prikazana ustrezna informacija za uporabnika.
except KeyboardInterrupt: p.stop(); GPIO.cleanup() KeyboardInterrupt sedaj dodatno sproži metodo stop() pri PWM-objektu. Ta metoda zaključi ustvarjanje PWM-signala. Nato se GPIO-vrata ponastavijo, tako kot vam je že znano iz prejšnjih programov. 6.1.2 Neodvisno zatemnjevanje dveh LED Ker za programiranje PWM-signala ni potreben programski čas v skripti Python, je možno tudi zatemnjevanje več LED neodvisno druga od druge, tako kot ponazarja tudi naslednji preizkus.
Slika 6.5: Druga LED na GPIO-vratih 25. Program leddimmen02.py eno LED ciklično zatemnjuje svetleje in temneje, medtem ko druga LED sicer skupaj s prvo LED postane svetlejša, vendar v drugem ciklu ne postane temnejša, temveč ponovno postaja svetlejša od 0 naprej in pri tem hitro utripa. import RPi.GPIO as GPIO import time GPIO.setmode(GPIO.BCM); LED = [18,25] GPIO.setup(LED[0], GPIO.OUT); GPIO.setup(LED[1], GPIO.OUT) print ("Ctrl+C zaključi program") p = GPIO.PWM(LED[0], 50); q = GPIO.PWM(LED[1], 50) p.
for c in range(0, 101, 2): p.ChangeDutyCycle(100-c); q.ChangeDutyCycle(c) time.sleep(0.1) q.ChangeFrequency(50) except KeyboardInterrupt: p.stop(); GPIO.cleanup() 6.1.3 Tako deluje Osnovna struktura programa se sklada s strukturo prejšnjega preizkusa z nekaj majhnimi nadgradnjami. LED = [18,25]; GPIO.OUT) GPIO.setup(LED[0], GPIO.OUT); GPIO.
7 Prikaz zasedenosti spominske kartice z LED ...................................................................................................................................................................................................................................................................................................................................................................................................................................................................................
Slika 7.3: Tri LED prikazujejo nezaseden pomnilniški prostor na spominski kartici. Program speicheranzeige.py v odvisnosti od nezasedenega pomnilniškega prostora na spominski kartici nudi različne LED-prikaze: Nezaseden pomnilniški prostor LED-prikaz < 1 MB Rdeč 1 MB do 10 MB Rdeče-rumen 10 MB do 100 MB Rumen 100 MB do 500 MB Rumeno-zelen > 500 MB Zelen Tabela 7.1: Tako je prikazana zasedenost spominske kartice. import RPi.GPIO as GPIO import time import os g1 = 1; g2 = 10; g3 = 100; g4 = 500 GPIO.
try: while True : s = os.statvfs('/') f = s.f_bsize * s.f_bavail / 1000000 if f < g1: x = "100" elif f < g2: x = "110" elif f < g3: x = "010" elif f < g4: x = "011" else: x = "001" for i in range(3): GPIO.output(LED[i], int(x[i])) time.sleep(1.0) except KeyboardInterrupt: GPIO.cleanup() Ko pustite, da program deluje, LED ves čas prikazujejo nezaseden pomnilniški prostor na spominski kartici. Preizkusite, kako deluje, tako da prek omrežja kopirate velike datoteke na spominsko kartico in jih spet izbrišete.
Statistični modul os.statvfs() iz knjižnice os nudi različne statistične informacije o datotečnem sistemu. Te informacije se znotraj neskončne zanke pri vsakem prehodu zanke na novo zapišejo kot objekt v spremenljivko s. f = s.f_bsize * s.f_bavail / 1048576 Sedaj metoda s.f_bsize nudi velikost pomnilniškega bloka v bajtih,. s.f_bavail pa navaja število nezasedenih blokov. Proizvod iz teh dveh vrednosti nato navaja število nezasedenih bajtov, ki se pri tem deli z 1.048.
8 Grafična igralna kocka .......................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................
while mainloop: for event in pygame.event.get(): if event.type == QUIT or (event.type == KEYUP event.key == K_ESCAPE): mainloop = False if event.type == KEYDOWN: FELD.fill(BLAU) ZAHL = random.randrange (1, 7); print ZAHL if ZAHL == 1: pygame.draw.circle(FELD, WEISS, P1, 40) if ZAHL == 2: pygame.draw.circle(FELD, WEISS, P2, 40) pygame.draw.circle(FELD, WEISS, P7, 40) if ZAHL == 3: pygame.draw.circle(FELD, WEISS, P1, 40) pygame.draw.circle(FELD, WEISS, P4, 40) pygame.draw.
Ta pomembna funkcija v vsakem programu, ki uporablja grafični izhod, definira risalno površino, tako imenovani surface, ki ima v našem primeru velikost 320 x 320 slikovnih točk in dobi ime FELD. Upoštevajte način pisanja v dvojnih oklepajih, ki se v splošnem uporablja za grafične koordinate zaslona. Takšni surface je prikazan v novem oknu na zaslonu. pygame.display.set_caption("Wuerfel") Ta vrstica vnese ime okna.
Slika 8.2: Pike kock in njihove koordinate. Na tem mestu se skupaj z drugimi spremenljivkami nastavi na True tudi spremenljivka po imenu mainloop, ki jo boste kasneje potrebovali za glavno zanko igre. mainloop = True S tem so ustvarjene osnove in dejanska igra se lahko začne. print "Za metanje zaključite z igro" kocke pritisnite poljubno tipko, z [Esc] Ta vrstica uporabniku na kratko razloži, kaj mora storiti. Z vsakim pritiskom poljubne tipke na tipkovnici na novo vržete kocko.
Ta vrstica prebere zadnjo aktivnost uporabnika in jo shrani kot event. V igri sta na voljo samo dve vrsti aktivnosti uporabnika, ki sta relevantni za igro: Uporabnik pritisne eno tipko in z njo meče kocko ali pa uporabnik želi zaključiti z igro. if event.type == QUIT or (event.type == KEYUP and event.key == K_ESCAPE): mainloop = False Obstajata dve možnosti za zaključitev igre: Lahko kliknete na simbol x v zgornjem desnem robu okna ali pa pritisnete tipko [Esc]. Ko kliknete na simbol x, gre za event.
pygame.display.update() Šele ta vrstica na koncu zanke posodobi grafiko na zaslonu. Nato lahko dejansko vidite pike kocke. Slika 8.3: Šest možnih rezultatov metanja kocke. Zanka se takoj začne od začetka in ponovno čaka na pritisk tipke s strani uporabnika. Če se med izvajanjem zanke mainloop nastavi na False, ker želi uporabnik zaključiti z igro, se zanka več ne ponovi, temveč se izvede naslednja vrstica: pygame.
9 Analogna ura na zaslonu ......................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................
mainloop = True; s1 = 0 while mainloop: zeit = time.localtime() s = zeit.tm_sec; m = zeit.tm_min; h = zeit.tm_hour if h > 12: h = h – 12 hm = (h + m / 60.0) * 5 if s1 <> s: pygame.draw.circle(FELD, WEISS, MP, 182) pygame.draw.line(FELD, SCHWARZ, MP, punkt(120, hm), 6) pygame.draw.line(FELD, SCHWARZ, MP, punkt(170, m), 4) pygame.draw.line(FELD, ROT, MP, punkt(180, s), 2) s1 = s pygame.display.set_caption("Aktuelle Zeit: " + time.asctime()) pygame.display.update() for event in pygame.event.get(): if event.
def punkt(A, W): w1 = radians(W * 6 – 90); x1 = int(MX + A * cos(w1)) y1 = int(MY + A * sin(w1)); return((x1, y1)) Funkcija uporablja dva parametra: A je razdalja želene točke od središča, W pa je kot glede na središče. Za poenostavitev prikaza v primeru ure vzamemo kot v smeri urnega kazalca glede na navpično smer za 12:00. Kot se prav tako ne preda funkciji v stopinjah, temveč v minutah, in sicer 1/60 polnega kroga. Takšne predpostavke prihranijo številne vmesne izračune.
Sedaj se začne glavna zanka programa, ki v vsakem prehodu – ne glede na to, kako dolgo traja – zapiše trenutni čas v objekt zeit. Pri tem se uporabi funkcija time.localtime() iz knjižnice time. Rezultat je podatkovna struktura, ki je sestavljena iz različnih posameznih vrednosti. s = zeit.tm_sec; m = zeit.tm_min; h = zeit.tm_hour Tri vrednosti, ki so relevantne za kazalce – sekunde, minute in ure – se kot struktura zapišejo v tri spremenljivke s, m in h.
Ta vrstica nariše urni kazalec kot linijo širine 6 slikovnih točk z izhodiščem v središču in z dolžino 120 slikovnih točk. Risanje poteka v kotu, ki ga navaja spremenljivka hm. Funkcija pygame.draw.line() doslej ni bila uporabljena. Potrebuje pet parametrov: • Površina nudi podatek o risalni površini, na kateri se riše, v našem primeru FELD. • Barva navaja barvo kroga, v našem primeru je to predhodno definirana barva SCHWARZ. • Začetna točka navaja začetno točko linije, v našem primeru je to središče ure.
10 Grafična pogovorna polja za upravljanje programov ...........................................................................................................................................................................................................................................................................................................................................................................................................................................................................
import RPi.GPIO as GPIO from Tkinter import * LED = 4; GPIO.setmode(GPIO.BCM); GPIO.setup(LED,GPIO.OUT) def LedEin(): GPIO.output(LED,True) def LedAus(): GPIO.output(LED,False) root = Tk(); root.title("LED") Label(root, text="Prosimo, da za vklop in izklop LED gumb").pack() Button(root, text="Ein", command=LedEin).pack(side=LEFT) Button(root, text="Aus", command=LedAus).pack(side=LEFT) root.mainloop() GPIO.cleanup() kliknete Slika 10.2: Tako bo videti gotovo pogovorno polje. 10.1.
Do sedaj je bil vse čisti Python, sedaj pa se nadaljuje s Tk in njegovimi posebnostmi. root = Tk() Tkinter uporablja tako imenovane gradnike. Pri tem gre za samostojne zaslonske elemente – v večini primerov so to pogovorna polja – ki vsebujejo različne elemente. Vsak program potrebuje gradnik root, iz katerega poteka priklic vseh ostalih objektov. Ta gradnik root se vedno imenuje Tk(), samodejno generira okno in tudi inicializira knjižnico Tkinter. root.
Simbola x zgoraj desno za zapiranje okna vam pri Tkinter ni treba posebej definirati. Ko uporabnik zapre glavno okno root, se glavna zanka mainloop() samodejno zaključi. GPIO.cleanup() Program teče dalje do zadnje vrstice in zapre odprta GPIO-vrata. Po začetku programa se na zaslonu pojavi pogovorno polje. Za vklop LED kliknite na gumb Vklop, ko jo želite spet izklopiti, pa kliknite na gumb Izklop. 10.2 Upravljanje tekoče luči z grafičnim vmesnikom ...........................................................
Slika 10.4: Sestav preizkusne ploščice pri preizkusu 10.2.
Slika 10.5: Štiri LED utripajo v različnih vzorcih. Program ledtk02.py temelji na prejšnjem programu, vendar je bil nadgrajen z radijskimi gumbi in funkcijami za LED tekoče luči in vzorce utripanja. import RPi.GPIO as GPIO import time from Tkinter import * GPIO.setmode(GPIO.BCM) LED = [4,18,23,24] for i in LED: GPIO.setup(i, GPIO.OUT, initial=0) w = 5; t = 0.2 muster = [ ("Tekoča luč v levo",1), ("Utripanje",2), ("Tekoča luč v desno",3) ] root = Tk(); root.title("LED"); v = IntVar(); v.
GPIO.output(LED[j], False) elif e == 2: for i in range(w): for j in range(4): GPIO.output(LED[j], True) time.sleep(t) for j in range(4): GPIO.output(LED[j], False) time.sleep(t) else: for i in range(w): for j in range(4): GPIO.output(LED[3-j], True); time.sleep(t) GPIO.output(LED[3-j], False) Label(root, text="Prosimo, da za aktivacijo tekoče luči kliknete gumb").pack() for txt, m in muster: Radiobutton(root, text = txt, variable = v, value = m).pack(anchor=W) Button(root, text="Start", command=LedEin).
Inicializacija gradnika root se ponovno sklada s prejšnjim programom, razlika je samo v vsebinah pogovornega polja. v = IntVar(); v.set(1) Spremenljivke, ki se uporabljajo v pogovornih poljih Tk, je treba za razliko od običajnih spremenljivk Python pred prvo uporabo deklarirati. Ti dve vrstici deklarirata spremenljivko v kot celo število in jo na začetku nastavita na vrednost 1. def LedEin(): e = v.
Label(root, text="Prosimo, da za aktivacijo tekoče luči kliknete gumb").pack() Besedilo pogovornega polja se ponovno definira kot objekt Label. Nova je definicija treh radijskih gumbov. for txt, m in muster: Radiobutton(root, m).pack(anchor=W) text = txt, variable = v, value = Radijski gumbi se definirajo s posebno obliko zanke for. Namesto zančnega števca sta tukaj podani dve spremenljivki, ki se vzporedno štejeta. Oba števca zaporedoma stečeta skozi elemente seznama muster.
Slika 10.6: Izbira med tremi LED-vzorci in nastavljiva hitrost utripanja. Uporaba drsnih regulatorjev Drsni regulatorji nudijo zelo intuitivno metodo za vnos številskih vrednosti znotraj določenega območja. Na ta način si prihranite verjetnostno poizvedbo, ki ugotovi, če je uporabnik vnesel vrednost, ki jo lahko program tudi smiselno udejanji, saj vrednosti izven območja, ki ga določa drsni regulator, niso možne. Drsni regulator vedno nastavite tako, da si lahko uporabnik predstavlja vrednosti.
for j in range(4): GPIO.output(LED[j], False) time.sleep(t) else: for i in range(w): for j in range(4): GPIO.output(LED[3-j], True): time.sleep(t) GPIO.output(LED[3-j], False) Label(root,text="Prosimo, gumb").pack() for txt, m in muster: Radiobutton(root, m).pack(anchor=W) da za text = aktivacijo txt, tekoče variable luči = v, kliknete value = Label(root, text="Geschwindigkeit").pack() Scale(root, g).
Definicija oznake in radijskih gumbov v pogovornem polju se prevzame iz prejšnjega primera. Label(root, text="Hitrost").pack() Za razlago drsnega regulatorja se v pogovorno polje zapiše dodatna oznaka. Ker ne vsebuje nobenih parametrov v metodi pack(), se vstavi vodoravno centrirano pod radijskimi gumbi. Scale(root, g).
Slika 11.1: Igra Simulate iz Python Games. Naša igra PiDance prav tako temelji na principu te igre. LED utripajo v naključnem vrstnem redu. Uporabnik mora nato pritisniti enako zaporedje s pomočjo tipk. V vsakem naslednjem krogu sveti dodatna LED, tako da si vedno težje zapomnite zaporedje. Takoj ko naredite napako, je igre konec.
Slika 11.2: Sestav preizkusne ploščice pri preizkusu št. 11.
Slika 11.3: PiDance z LED in tipkali na dveh preizkusnih ploščicah. Tipkala so pritrjena nasproti ustreznih LED. Dve sredinski vzdolžni vrsti preizkusnih ploščic na obeh straneh mesta povezave služita kot 0 V in +3,3 V kabel za vezje. Program pidance01.py vsebuje gotovo igro. # -*- coding: utf-8 -*import time, random import RPi.GPIO as GPIO GPIO.setmode(GPIO.BCM) rzahl = 10; farbe = [] for i in range(rzahl): farbe.append(random.randrange(4)) LED = [23,24,25,8] for i in LED: GPIO.setup(i, GPIO.
for runde in range(1, rzahl +1): print "Krog", runde for i in range(runde): LEDein(farbe[i], 1) for i in range(runde): taste = Druecken() LEDein(taste, 0.2) if(taste != farbe[i]): print "Izgubili ste!" print "Dosegli ste krog ", krog – 1, " " for j in range(4): GPIO.output(LED[j], True) for j in range(4): time.sleep(0.5) GPIO.output(LED[j], False) ok = False break if(ok == False): break time.sleep(0.5) if(ok == True): print "Odlično opravljeno!" for i in range(5): for j in range(4): GPIO.
TAST = [4,17,21,22] for i in TAST: GPIO.setup(i, GPIO.IN) Po istem principu se GPIO-vrata za štiri tipkala nastavijo kot vhodi v seznamu TAST. S tem je poskrbljeno za osnove, poleg tega pa se definirata še dve funkciji, ki ju boste večkrat potrebovali v programu. def LEDein(n, z): GPIO.output(LED[n], True); time.sleep(z) GPIO.output(LED[n], False); time.sleep(0.15) Funkcija LEDein() vključi LED in poskrbi, da nekaj časa sveti. Funkcija uporablja dva parametra.
začne z 1, že v prvem krogu sveti točno 1 LED. Za aktivacijo svetenja LED se uporabi funkcija LEDein(), katere prvi parameter je barva iz ustreznega položaja na seznamu, drugi parameter pa poskrbi, da vsaka LED sveti eno sekundo. for i in range(runde): Po predvajanju barvnega vzorca se začne dodatna zanka, v kateri mora igralec prek tipkal ponovno vnesti isti vzorec iz spomina. taste = Druecken() Pri tem se prikliče funkcija Druecken(), ki čaka, dokler igralec ne pritisne tipkala.
Če se ok še vedno nahaja na True, sledi potrditev zmagovalca. V nasprotnem primeru se ta blok preskoči in igra izvede samo še zadnjo programsko vrstico. print "Odlično opravljeno!" for i in range(5): for j in range(4): GPIO.output(LED[j], True) time.sleep(0.05) for j in range(4): GPIO.output(LED[j], False) time.sleep(0.05) Če igralec zmaga, se v oknu Python Shell pojavi ustrezno sporočilo. Nato vse LED petkrat zaporedoma kratko utripajo. GPIO.cleanup() Zadnja vrstica se vedno izvede.
Izjava o skladnosti Ta izdelek je v skladu z veljavnimi direktivami CE, v kolikor ga uporabljate v skladu s priloženimi navodili za uporabo. Ta navodila za uporabo sodijo k izdelku. Če izdelek predate v uporabo tretji osebi, priložite tudi ta navodila. Pozor! Zaščita oči in LED ........................................................................................................................................................................................................................................
Conrad Electronic d.o.o. k.d. Ljubljanska c. 66, 1290 Grosuplje Fax: 01/78 11 250, Tel: 01/78 11 248 www.conrad.si, info@conrad.si GARANCIJSKI LIST Izdelek: Učni komplet za Raspberry Pi Conrad Components Kat. št.: 12 25 953 Garancijska izjava: Proizvajalec jamči za kakovost oziroma brezhibno delovanje v garancijskem roku, ki začne teči z izročitvijo blaga potrošniku. Garancija velja na območju Republike Slovenije. Garancija za izdelek je 1 leto.
