Arduino
Arduino je mikrokrmilnik na matični plošči, ki je zasnovan tako, da bi bil postopek z uporabo elektronike v multidisciplinarnih projektih, bolj dostopen. Strojno opremo sestavljajo odprtokodna oblika plošče in 8-bitni mikrokontroler Atmel AVR ali 32-bitni Atmel ARM. Programska oprema je sestavljena iz standardnega programskega jezika, prevajalnika in zagonskega nalagalnika, ki se izvaja na mikrokrmilniku. Razvojne plošče Arduino so naprodaj že sestavljene ali pa v »sestavi sam« izvedbi.
Mikrokrmilnik so razvili na šoli oblikovanja v italijanskem mestu Ivrea in predstavlja enega zgodnjih mejnikov v gibanju odprtokodne strojne opreme.[1]
Sklici in opombe
# Mornar Filip
#
# Mornar Filip rad zahaja na kozarec ruma na bližnji otok. Zadnjič pa ga je ob
# vračanju z enega njegovih izletov ujela nevihta, ki mu je močno poškodovala
# barko. Na srečo je opazil, da skozi nastalo luknjo v barki padajo različni
# predmeti. Kljub rumu je zbral dovolj koncentracije in si v zvezek začel
# pisati koordinate, kjer so določeni predmeti padli z barke. Poleg predmeta si
# je v zvezek napisal tudi vrednost, ki mu določen predmet pomeni. Pomagaj
# mornarju Filipi rešiti predmete, preden jih odnesejo morski tokovi.
# =====================================================================@030011=
# 1. podnaloga
# Najprej je treba, za boljšo preglednost, sestaviti seznam koordinat, ki
# označujejo mesta predmetov. Napišite funkcijo `koordinate(slovar)`. Sprejme
# naj slovar, ki ima za ključe koordinate in za vrednosti pare (ime, vrednost),
# vrne pa naj seznam koordinat, urejene padajoče po vrednosti predmetov, ki se
# tam nahajajo. V primeru, da ima več predmetov enako vrednost, jih uredite po
# abecednem vrstnem redu po imenih. Predpostavite, da ne moreta biti dva enaka
# predmeta z isto vrednostjo na dveh različnih koordinatah.
#
# Primer:
#
# >>> koordinate({(1, 4) : ("kipec", 14),
# (8, 7) : ("zoga", 55),
# (3, 1) : ("vrv", 1),
# (11, 6) : ("sotor", 27),
# (7, 10) : ("abakus", 27),
# (5, 3) : ("rum", 78)})
# [(5, 3), (8, 7), (7, 10), (11, 6), (1, 4), (3, 1)]
# =============================================================================
def koordinate(slo):
nov_sez = []
for koordinate in slo.keys():
# =====================================================================@030012=
# 2. podnaloga
# Sedaj je pa treba te predmete tudi pobrati. Sestavite funkcijo `pot(slovar)`,
# ki bo sprejela enak slovar kot zgoraj, vrnila pa skupno dolžino Filipove
# poti, če želi pobrati vse predmete. Njegova pot se začne v domačem
# pristanišču (na koordinatah (0, 0)), gre do najvrednejšega predmeta, nato do
# drugega najvrednejšega in tako dalje, na koncu pa se spet vrne v domače
# pristanišče.
#
# Razdaljo med dvema točkama izračunamo po običajni formuli:
#
# razdalja med `(x1, y1)` in `(x2, y2)` je
# enaka `((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5.`
#
# Primer:
#
# >>> pot({(1, 4): ("kipec", 14),
# (8, 7): ("zoga", 55),
# (3, 1): ("vrv", 1),
# (11, 6): ("sotor", 27),
# (7, 10): ("abakus", 27),
# (5, 3): ("rum", 78)})
# 36.615951767324
# =============================================================================
# =====================================================================@030013=
# 3. podnaloga
# Ta naivna pot je že skoraj prava, ampak Filip te predmete pobira s
# prijateljevo barko, ki je manjša od njegove. Zato je prostorsko omejen in se
# mora vmes vračati domov. Napišite funkcijo `pot_omejena(slovar, kapaciteta)`,
# ki sprejme slovar predmetov in največjo kapaciteto barke. Filip bo začel
# svojo pot enako kot prej, le da bo moral, preden bo kapaciteta barke
# presežena, nazaj v domače pristanišče odložit predmete. Vsak predmet ima
# velikost enako dolžini njegovega imena. Naprimer, velikost predmeta "sodcek"
# je 6. Predpostavite, da je kapaciteta barke večja od vseh velikosti
# posameznih predmetov.
#
# Primer:
#
# >>> pot_omejena({(1, 4): ("kipec", 14),
# (8, 7): ("zoga", 55),
# (3, 1): ("vrv", 1),
# (11, 6): ("sotor", 27),
# (7, 10): ("abakus", 27),
# (5, 3): ("rum", 78)}, 8)
# 85.50490368290278
# ============================================================================= # Izpiti #
# Svetovno znani profesor Leopold Poldi je tako pameten gospod, da se mu vse
# naloge na izpitih zdijo trivialne. Raziskave pa so pokazale, da je smiselno
# naloge na izpitu razvrstiti po težavnosti. Ker on ne ve, kaj je težko,
# potrebuje vašo pomoč (očitno le ne zna vsega ;) ).
#
# *OPOMBA*: Pri nalogah uporabljaj kodiranje "utf-8".
# =====================================================================@030014=
# 1. podnaloga
# Vaša prva naloga je, da iz besedila naloge odstranite vse matematične/fizikalne
# formule in izraze. Vsaka formula se začne z znakom `$` in konča z znakom `$`.
# Predpostavite lahko, da pred znakom `$` ni nikoli presledka.
#
# Primer naloge:
#
# .)1.) Določi nihajni čas matematičnega nihala z maso$m = 10g$, ki visi
# na vrvici dolžine$10cm$.
#
# Napišite funkcijo `odstrani_formule(naloga)`, ki iz naloge `naloga` odstrani
# vse formule in vrne novo besedilo naloge v eni vrstici (brez znakov za
# novo vrstico `\n`), torej `\n` zamenjaj s `" "`. Po klicu funkcije na zgornji
# nalogi, naša funkcija torej vrne:
#
# .)1.) Določi nihajni čas matematičnega nihala z maso, ki visi na vrvici dolžine.
# =============================================================================
# =====================================================================@030015=
# 2. podnaloga
# Leopold ima naloge shranjene v tekstovni datoteki `ZAUPNO.txt`, ki zgleda
# takole:
#
# .)1.) Izračunaj nihajni čas matematičnega nihala z maso$m = 10g$, ki visi
# na vrvici dolžine$10cm$.
# .)*2.) Dokaži, da barvo krave, če je glasnost njenega zvonca izračunana
# po formuli$c = \pi * 9 - 6 \psi^2$, izračunamo kot$a^2 + b^2 = c^2$.
# .)3.) Izračunaj današnji datum v Inkovskem koledarskem načinu.
# .)*4.) Pokaži, da si je besedilo naslednje naloge težko izmisliti na$3$
# decimalke natančno.
# .)5.) Pokaži, da mi je ime$Leopold Poldi$.
#
# Sestavite funkcijo `loci_po_nalogah(vhodna)`, ki sprejme ime vhodne datoteke
# in vrne seznam nalog, ki ne vsebujejo več formul (namesto `\n`, pa vsebuje `" "`).
# Klic funkcije naj torej na datoteki `vhodna = "ZAUPNO.txt"` vrne naslednji seznam:
#
# ['.)1.) Izračunaj nihajni čas matematičnega nihala z maso, ki visi na vrvici dolžine.',
# '.)*2.) Dokaži, da barvo krave, če je glasnost njenega zvonca izračunana po formuli, izračunamo kot.',
# '.)3.) Izračunaj današnji datum v Inkovskem koledarskem načinu.',
# '.)*4.) Pokaži, da si je besedilo naslednje naloge težko izmisliti na decimalke natančno.',
# '.)5.) Pokaži, da mi je ime.']
#
# Predpostavite, da se nikjer v besedilu, razen pred in za zaporedno številko naloge, ne pojavi `.)`.
# =============================================================================
# =====================================================================@030016=
# 3. podnaloga
# Za konec je vaša naloga, da uredite naloge po težavnosti. Težavnost naloge
# določamo na treh nivojih. Najprej najtežje naloge pred zaporedno številko
# naloge vsebujejo `*`, potem se težavnost določa na podlagi besed, ki jih
# naloga vsebuje. Če navodilo naloge vsebuje besedo `dokaži`, je naloga težja,
# kot če vsebuje besedo `pokaži`, najlažja pa je naloga, ki ne vsebuje nobene
# od teh besed.
# Predpostavite, da ti besedi upoštevamo samo v imenovalniku (nominativu),
# torej le dobesedno tako, kot sta napisani v navodilu te naloge (lahko spreminjamo
# le velike in male črke), nadalje gledamo zaporedno številko naloge (večja številka,
# težja naloga).
# Ni nujno, da naloga vsebuje besede "dokaži" ali "pokaži", nobena naloga pa ne
# vsebuje več teh besed.
#
# Napišite funkcijo `uredi_po_tezavnosti(vhodna, izhodna)`, ki sprejme vhodno datoteko
# v taki obliki, kot je napisano zgoraj (v daoteki `ZAUPNO.txt`) in v izhodno
# datoteko `izhodna` zapiše zaporedne številke nalog, vsako v svojo vrstico, od
# najlažje do najtežje.
#
# Po klicu `uredi_po_tezavnosti("ZAUPNO.txt", "test.txt")` se torej v datoteki
# `test.txt` nahaja:
#
# 1
# 3
# 5
# 4
# 2
#
#
# namig: Vsaki od besed, ki določa težavnost, priredite ustrezno številko in
# si v slovar za vsako nalogo zabeležite, katero od besed vsebuje.
# =============================================================================
- =============================================================================
- Formula E gre visss! - Numpy
- Formula E je najprestižnejše tekmovanje dirkalnikov na električni pogon na
- svetu. Sedaj prosijo vas za pomoč. V zameno za nekaj točk na izpitu jim
- pomagajte napisati program, ki bo določil razvrstitev dirkalnikov v
- kvalifikacijskem krogu. Vsak dirkalnik prevozi en tak krog. Dirkalniki
- imajo vgrajen števec za hitrost, katerega vrednosti si vsako sekundo
- shranjujemo v tabelo.
- Kot primer tabele hitrosti definirajmo:
- primer_hitrosti = np.array([[4.11, 52.54, 79.04, 82.01],
- [4.14, 53.41, 81.34, 90.23],
- [5.33, 50.01, 90.81, 92.24]])
- V vsaki vrstici so podatki pripadajoči posameznemu drikalniku, v stolpcih
- pa so njihove hitrosti ob različnih časovnih intervalih.
- Prva meritev hitrosti je narejena 1s po začetku, vse ostale ji sledijo
- s časovnimi zamiki 1s. Vse hitrosti so merjene v m/s.
- Za reševanje naloge uporabite knjižnjico numpy, zanke so prepovedane.
- Če ne gre brez uporabe zank, poskusite nalogo rešiti z uporabo zank,
- saj vam taka rešitev še vedno lahko prinese 1/2 vseh možnih točk.
- Pri nalogi vam bodo v pomoč tudi funkcije na [povezavi](https://numpy.org/doc/stable/reference/routines.sort.html).
- =====================================================================@030017=
- 1. podnaloga
- Najprej moramo iz podatkov o hitrostih dirkalnikov ugotoviti njihovo
- prevoženo razdaljo ob vsakem času. To naredimo s preprostim "integralom"
- (dejansko gre za diskretno vsoto), kjer predpostavimo, da je bila hitrost
- na preteklem intervalu konstantna, prevožena pot na intervalu pa se tako
- izračuna po enačbi
- $$ s = v \cdot \Delta t $$
- Sestavite funkcijo `prevozena_razdalja(hitrosti)`, ki sprejme tabelo
- `hitrosti`, ter vrne tabelo prevožene razdalje do vsakega časovnega intervala.
- >>> prevozena_razdalja(primer_hitrosti)
- np.array([[4.11, 56.65, 135.69, 217.7 ]
- [4.14, 57.55, 138.89, 229.12]
- [5.33, 55.34, 146.15, 238.39]])
- =============================================================================
- =====================================================================@030018=
- 2. podnaloga
- Za primerjavo med različnimi načini vožnje skozi ovinke, je zanimivo
- pogledati, kakšna je bila razvrstitev mest v vsakem trenutku med
- kvalifikacijskim krogom.
- Sestavite funkcijo `trenutni_vodilni(hitrosti)`, ki sprejme tabelo `hitrosti`,
- ter izračuna indeks vodilnega dirkača ob vsakem času. Indekse vrne v 1D tabeli.
- >>> trenutni_vodilni(primer_hitrosti)
- np.array([2, 1, 2, 2])
- =============================================================================
- =====================================================================@030019=
- 3. podnaloga
- Seveda pa organizatorje najbolj zanima končna razporeditev dirkalnikov
- od najhitrejšega do najpočasnejšega. Dirkalnikov čas je merjen od začetka
- tabele, pa do časovnega intervala, pri katerem doseže ali pa preseže
- dolžino kroga. V nalogi lahko privzamete, da nobena dva dirkalnika cilja
- ne dosežeta ob istem času. Števec hitrosti preneha beležiti hitrosti
- šele, ko se dirkalnik pripelje nazaj v bokse, zato konec dirke nikoli
- ni na koncu tabele, ampak že nekje vmes.
- Sestavite funkcijo `koncna_razporeditev(hitrosti, dolzina_proge)`, ki
- sprejme tabelo `hitrosti` in `dolzina_proge` v metrih, ter vrne 2D
- tabelo, kjer so v prvem stolpcu zapisani indeksi dirkalnikov od
- najhitrejšega do napočasnejšega, v drugem stolpcu pa so zapisani
- njihovi časi v sekundah.
- >>> koncna_razporeditev(primer_hitrosti, 137)
- np.array([[1, 3]
- [2, 3]
- [0, 4]])
- Namig: Prav vam lahko pride numpy funkcija po imenu `argsort()`.
- =============================================================================
- ↑ Lahart, Justin (27. november 2009). »Taking an Open-Source Approach to Hardware«. The Wall Street Journal. Pridobljeno 27. oktobra 2013.
Zunanje povezave
| Narodne knjižnice | |
|---|---|
| Drugo | |
