Raspberry Pi PICO- CircuitPython ali MicroPython?

To je v nasprotju z mojimi preteklimi izkušnjami. Menim, da je C / C ++ prevedeni jezik, ker je besedilna izvorna koda, ki jo napišete, prevedena v binarno kodo (strojni jezik, ki ga MCU lahko neposredno izvaja). To se izvede enkrat na cikel urejanja / odpravljanja napak in binarna koda je tista, ki jo MCU izvrši med izvajanjem. Ta postopek prevajanja / povezovanja se imenuje “gradnja” (angl. build) in jo opravi osebni računalnik, ciljni MCU pa shrani / izvede samo dejansko binarno kodo. Strogo rečeno, ta postopek je navzkrižno prevajanje, saj se prevajanje izvaja v drugem računalniku, kot v računalniku (MCU), ki izvaja kodo.

Niti MicroPython niti CircuitPython ne delujeta na ta način. Nasprotno pa je dejanska besedilna izvorna koda shranjena v Flash pomnilniku MCU-ja. V tem Flash pomnilniku je tudi blok kode, ki deluje kot tolmač. Ta tolmač deluje tako, da bere besedilno izvorno kodo, po en stavek naenkrat, in jo naenkrat prevede v binarno kodo, ki jo lahko MCU neposredno izvede.

Vsakdo, ki je programiral v C / C ++, ve, da je postopek prevajanja / nalaganja lahko dolgotrajen – tudi če uporabljate zmogljiv računalnik. Zato bi pričakovali, da bi tolmač, ki temelji na ARM MCU, izvajal kodo veliko počasneje, kot če bi isti program napisali v jeziku C, ga prevedli (vnaprej) na računalniku in binarno kodo nato izvedli na istem MCU-ju.

Lahko pričakujete, da bo dani MCU izvajal določen program precej počasneje, če se izvaja v Pythonu, kot če izvaja prevedeno C / C ++ kodo. Zakaj bi se torej odločil za Python? Pri nekaterih aplikacijah hitrost izvajanja ni preveč kritična. Python je jezik na visoki ravni – v mnogih primerih obstajajo Python knjižnice, ki izvajajo zapletene funkcije in potrebujejo zelo malo uporabniško napisane kode. Ko Python razčleni stavek programa, ki vsebuje tako ukaz na visoki ravni, je čas, ki je potreben za razčlenitev tega stavka, zanemarljiv v primerjavi s časom, potrebnim za izvedbo samega stavka. Mnoge zapletene Python knjižnice so same napisane v C-ju in te knjižnice je mogoče prevesti vnaprej. V CircuitPython na primer knjižnice, ki so bile vnaprej prevedene, uporabljajo razširitev .mpy in ne .py.

Če ste torej pripravljeni žrtvovati nekaj hitrosti izvajanja, vas bo Python nagradil s tem, da vam bo na voljo veliko rutin in knjižnic na visoki ravni, ki nekoliko olajšajo delo pri programiranju.

Druga lepa lastnost Pythona je REPL (kar pomeni Branje, Ocenjevanje, Natisni, Zanka, angl. Read, Evaluate, Print, Loop). To uporabniku omogoča, da uvozi vse potrebne knjižnice, spremenljivkam dodeli vrednosti in nato izvede kateri koli stavek – vse iz terminalskega okna. Rezultati funkcij te izvedbe bodo takoj natisnjeni v terminalskem oknu. Torej, lahko preizkusite dele svojega programa (vključno s klici funkcij knjižnice), ne da bi dejansko naložili kodo v ciljni MCU.

Če naložite in zaženete Python program, boste po enakih poteh dobili zelo opisna sporočila o napakah, natisnjena med izvajanjem programa (ob predpostavki, da so v programu napake!). Te kode napak bodo vključevale številko vrstice stavka, ki vsebuje napako. Navedena napaka je lahko tudi “ugnezdena”, če se napaka v eni funkciji širi skozi klicne rutine. Da bi to delovalo, vam v program ni treba vpisovati posebne kode za odpravljanje napak.
Šele v zadnjem času imajo ARM MCU-ji dovolj Flash pomnilnika, da lahko hranijo tako ugnezdeno programsko opremo Python tolmača, kot tudi uporabnikovo Python izvorno kodo in so bili dovolj hitri, da so lahko praktično izvajali običajne naloge, ki temeljijo na MCU-ju. Seveda je tisto, kar velja za “dovolj hitro”, lestvica, ki se nenehno dviguje. Ko sem prvič začel uporabljati mikrokontrolerje (že zdavnaj!), so bili za nekatere 8-bitne MCU-je na voljo tolmači za BASIC, ki temeljijo na ROM-u, in zanje smo našli uporabo, ki so jo zlahka izvrševali.

Python je v ARM MCU najprej prenesel Avstralec Damien George. Uporabil je STM32F4 MCU in to različico Pythona imenoval MicroPython. MicroPython je bil prenesen na številne različne ARM MCU-je, vključno s številnimi drugimi STM32 MCU-ji, Teensy 4.x z MCU NXP MIMXRT1062 ploščami, Atmelovim SAM21 / 51 in MCU družino nRF podjetja Nordic. Podprti so tudi brezžični MCU ESP8266 / ESP32, ki temeljijo na MCU jedru podjetja Tensilica xtensa.

Podjetje Adafruit iz New Yorka v ZDA je dobro znano po tem, da je razvilo številne MCU razvojne plošče za ljubitelje / izdelovalce (Feather itd.), kot tudi prototipne plošče za številne različne senzorje. Že od začetka so bili zelo marljivi pri pisanju knjižnic gonilnikov itd. za vse njihove proizvode. Večina teh gonilnikov je bila sprva napisana za Arduino IDE. Ko je bil MicroPython na voljo, so morali biti Adafruitu navdušeni, saj so se odločili ustvariti MicroPython varianto, ki so jo poimenovali CircuitPython. CircuitPython različice 4 je bila varianta MicroPythona 1.9.4. Verjamem, da so v Adafruit ustvarili CircuitPython, da bi lahko:

• Ustvarili skupen razvojni jezik (CircuitPython) za vse različne razvojne MCU plošče, ki jih razvijajo / prodajajo.
• Zagotovili standardizirano in izčrpno CircuitPython knjižnico gonilnikov za vse senzorje / zunanje naprave / razvojne plošče, ki jih razvijajo / prodajajo.

Kot mnogi DIY mojstri / izdelovalci, sem tudi v mnogih svojih projektih uporabljal Adafruit Arduino knjižnice. Zato sem bil nagnjen k izbiri CircuitPython kot MicroPython. Vendar ima vsaka različica svoje prednosti in slabosti, nekatere pa bom opisal v naslednjem poglavju.

CircuitPython v primerjavi z MicroPython
Nisem strokovnjak za Python – obe različici Pythona gledam iz oči C / C ++ programerja. Na koncu sem se osredotočil na CircuitPython in z njim pridobil nekaj praktičnih izkušenj. Ko delam primerjavo z MicroPythonom, lahko primerjam le tisto, kar sem prebral. Če upoštevamo to opozorilo, si poglejmo nekaj razlik med obema različicama.

Podpora različnim MCU družinam
Tabela 1 prikazuje podporo številnim MCU družinam / razvojnim ploščam. Kot lahko vidite, imata obe različici podporo za številne različne MCU družine. V primeru CircuitPython so to podporo zagotovili v podjetju Adafruit sami. Za MicroPython so prenos izvedli zainteresirani posamezniki, povezani s samim MCU ali razvojno ploščo.

Tabela 1

Bootloader
Nalaganje kode v Flash pomnilnik ciljnega MCU-ja lahko izvedemo na več načinov. Najbolj priročna metoda je tista, pri kateri ni potreben programator. Arduino je poenostavil programiranje Flash pomnilnika z uporabo PC-jevih USB vrat in serijske USB povezave, ki je bila na vgrajena na ciljni razvojni plošči. Številni drugi MCU-ji (tj. ESP8266 / ESP32) uporabljajo to metodo ali njeno različico s pomočjo HID USB profila (tj. vse Teensy razvojne plošče).

Enostavnost programiranja Flash pomnilnika se nahaja v shemi, v kateri ARM MCU sam izvaja tako imenovani UF2 zagonski nalagalnik. V tem primeru ARM MCU vsebuje zagonski nalagalnik v ROM pomnilniku, ki posnema USB Flash pogon, ko je priključen na USB vrata računalnika. Glede na določen MCU se v ta način zagonskega nalagalnika običajno vstopi s pritiskom na ločeno BOOTSEL stikalo med resetom ali dvakratnim zaporednim pritiskom na običajno stikalo za reset. V Windows / Linux / MAC OS operacijskem sistemu se bo plošča prikazala kot na novo vstavljen Flash pogon z imenom nosilca RPI-RP2 (v primeru RP Pico). V tem načinu bo katera koli .hex datotek , ki jo povlečete / spustite na ta emulirani Flash pogon, programirana v Flash pomnilnik MCU-ja. Šestnajstiške datoteke vsebujejo informacije o naslovu nalaganja, ki določajo, kam v Flash pomnilnik bo datoteka kopirana.

Tako v CircuitPythonu kot v MicroPythonu je prva datoteka, ki jo morate naložiti na ciljno napravo tista, ki vsebuje paket Python tolmačev / izvajalnih programov. To je ena velika šestnajstiška datoteka. Ko obiščete MicroPython ali CircuitPython spletna mesta, lahko določeno datoteko, ki jo potrebujete poiščete tako, da se pomaknete na stran s seznamom vašega ciljnega MCU (ali razvojne plošče). Prenesite to šestnajstiško datoteko in jo povlecite na emuliran USB pogon na plošči. Ko se ta datoteka naloži, obstoječi Flash pogon izgine in prikaže se še en z imenom nosilca CIRCUITPY (če ste naložili CircuitPython). Nekatere razvojne plošče imajo že vnaprej naložen MicroPython ali CircuitPython. Predvsem Adafruit vnaprej naloži CircuitPython na številne razvojne plošče, ki jih izdelujejo.
Seveda zgornji postopek samo namesti ugnezdeno programsko opremo Micro / CircuitPython na ciljni MCU. Do sedaj še vedno niste naložili svojega python programa. V CircuitPython poimenujete svoj glavni program code.py in v mapo lib položite vse potrebne knjižnične datoteke. To storite tako, da povlečete / spustite potrebne datoteke na CIRCUITPY Flash pogon in ustvarite lib mapo (če ta že ne obstaja). V nekaterih primerih boste morda potrebovali tudi boot.py datoteko. Primer te zagonske datoteke bom podal v nadaljevanju članka.

Knjižnice
V Python MCU skupnosti poteka veliko dejavnosti, zato so stvari zelo dinamične. Na tej stopnji pa mislim, da je varno trditi, da je Adafruit zagotovil več uporabnih CircuitPython knjižnic, kot jih ima MicroPython. Filozofija podjetja Adafruit v zvezi s temi CircuitPython knjižnicami je zagotoviti čim več “univerzalnih” sklopov knjižnic / gonilnikov naprav, ki se lahko izvajajo na čim več njihovih razvojnih ploščah. To na splošno pomeni, da njihovi gonilniki vsebujejo več “plasti” – plast abstrakcije strojne opreme in sloj, specifičen za MCU. Primer tega dajem v oddelku za analogno zbiranje podatkov v članku. Slaba stran takšnega pristopa je, da večina knjižnic ne bo tako hitra kot C / C ++ gonilniki, ki so bili napisani posebej za delo z izkoriščanjem zmogljivih funkcij določenega MCU.

Primer tega bi bil grafični gonilnik za običajne TFT zaslone na osnovi ILI9341, ki uporabljajo SPI vmesnik. Glede na moje izkušnje s takšnimi zasloni, povezanimi s Teensy 4.x ploščo, lahko pri uporabi Arduino C ++ kode in posebne ILI9341 knjižnice, ki uporablja DMA, prikazujete celozaslonski videoposnetek s hitrostjo 30–60 sličic na sekundo. Nasprotno pa ta ista Teensy 4.x (s 600 MHz ARM Cortex M7 MCU) plošča potrebuje približno 1/3 sekunde za prikaz slike v celozaslonskem načinu v CircuitPython. To je približno enako zmogljivo, kot bi imeli 8-bitni AVR MCU z optimizirano Arduino C ++ kodo. Torej, priporočam, da če nameravate uporabiti precej počasnejšo RP2040 Pico ploščo bodisi s Circuit bodisi z MicroPythonom in potrebujete zaslon s hitro osvežitvijo, se morda rajši odločite, da bi uporabili inteligenten TFT zaslon, kot je modul na osnovi FT800, 4DSytems modul ali Nextion modul. Druga možnost bi bila uporaba običajnega alfanumeričnega LCD zaslona (tj. 16 x 2). CircuitPython vsebuje knjižnico za te zaslone, ki deluje zelo dobro (adafruit_character_lcd mapa v svežnju Adafruit knjižnice).

Tabela 2 prikazuje delni seznam knjižnic, ki so del jedra CircuitPython ugnezdene programske opreme za MC20 RP2040, ki se nahaja na Pico plošči.

Tabela 2

Tabela 3 prikazuje 25 knjižnic, ki jih lahko najdete v svežnju (vseh jih je 266) podjetja Adafruit. Pravkar sem jih izbral nekaj, ki so vsebovali periferne čipe, ki so mi bili znani. Tu je povezava do tega knjižničnega svežnja: https://circuitpython.org/libraries

Upoštevajte, da gre za “univerzalne” Python knjižnice, ki so bile posebej prenesene v CircuitPython (večinoma jih je preneslo osebje podjetja Adafruit). Posamezne knjižnice niso bile preizkušene z vsemi različnimi MCU-ji, ki podpirajo CircuitPython, zato nekatere morda ne bodo delovale z določenim MCU-jem.

Tabela 3

Tabela 4

Prekinitve
Če ste izvajali časovno kritične C / C ++ MCU programe, ste verjetno v programu uporabili prekinitve. To so lahko prekinitvene rutine (ISR), ki se odzivajo na asinhrone dogodke, kot so prejeta UART sporočila, spremembe GPIO priključkov s stikal ali rotacijskih enkoderjev. Lahko pa gre za naloge, za katere želite, da jih izvajate v določenih časovnih intervalih, ki jih na primer sproži eden od časovnikov znotraj MCU-ja.

Žal CircuitPython programerju ne dovoli, da v svojo kodo vključi katero koli vrsto teh prekinitvenih rutin. Tako na primer ne morete konfigurirati enega od merilnikov časa MCU-ja, da sproži prekinitev v rednem intervalu in ji prilepiti kodo za izvajanje določene naloge. Tu ima MicroPython prednost, saj je sposoben to storiti.

V mnogih primerih ta pomanjkljivost ni “prelomna”, ker ima CircuitPython veliko knjižnic, ki pri opravljanju svojih nalog uporabljajo prekinitve. Očiten primer tega je CircuitPython knjižnica “rotaryio”, ki bere rotacijske enkoderje. Ta knjižnična rutina uporablja prekinitve, ki ji omogočajo branje logičnega stanja dveh priključkov rotacijskega enkoderja. V vašem CircuitPython programu vam ni treba skrbeti za prekinitve, ki jih povzroča rotacijski enkoder – preprosto ustvarite primerek razreda rotacijskega enkoderja in s funkcijo položaja razreda sledite njegovemu položaju.

Če pričakujete, da boste za svoj projekt potrebovali obsežno podporo pri prekinitvah, vam bo morda bolje, če uporabite MicroPython ali pozabite Python in se vrnete na C / C ++. Upoštevajte pa, da je prekinitvena zakasnitev na Picu, ki poganja MicroPython, počasna – približno 55 µs. Za primerjavo ima ESP32, na katerem teče Arduino C ++ program, zakasnitev približno 3 µs.

DMA
Tu so razmere zelo podobne razmeram kot pri prekinitvah. Ne morete jih uporabiti v CircuitPython kodi, vendar se uporabljajo v nekaterih CircuitPython knjižnicah. Z RP2040 Pico nisem preizkusil nobene kode, ki vsebuje avdio zmogljivosti. Vendar CircuitPython na splošno podpira pretakanje zvoka na nekaterih MCU-jih in prepričan sem, da mora to vključevati DMA operacije. Nisem prepričan, vendar dvomim, da lahko uporabite DMA tudi v svoji MicroPython kodi.

Večnitnost
RP2040 MCU na Picu vsebuje 2 enaki ARM M0 jedri. Če programirate Pico z uporabo Arduino C ++, lahko dodelite naloge, ki se bodo izvajale na vsakem M0 ARM jedru, ter sinhronizirate izvajanje in delite globalne spremenljivke. Prepričan sem, da tudi Pico C ++ SDK lahko to obvlada. MicroPython tudi omogoča večnitnost. Vendar CircuitPython trenutno ne dovoljuje večnitnosti.

IDE
Ker prevajanje Pythona izvorne kode v binarno kodo poteka na samem ciljnem MCU, je integrirano razvojno okolje (IDE) za CircuitPython ali MicroPython veliko manj zapleteno. V računalniku bi potrebovali vsaj urejevalnik besedil in terminalski program za interakcijo z REPL (in za prejemanje sporočil za razhroščevanje). Če pa ste navajeni uporabljati popolnoma opremljen IDE, bi pričakovali tudi, da bi imel urejevalnik »intellisense« funkcije, kot so dokončanje ukaza, preverjanje napak, predlogi za sintakso, ki temeljijo na kontekstu itd.

Za CircuitPython je za začetek dober Mu IDE program, saj ima preprost, neurejen videz Arduino IDE. Deloval bo z drugimi različicami Pythona, vendar je optimiziran za CircuitPython (ko za okolje izberete CircuitPython). Ob zagonu bo Mu poiskal priklopljeno CircuitPython ploščo. Nisem prepričan, ali išče zgolj Flash pogon z imenom CIRCUITPY ali preverja, če imajo USB naprave določen VID / PID. Ob predpostavki, da je našel ploščo, samodejno shrani vaše programske datoteke neposredno na CIRCUITPY pogon. Ko odprete serijski terminal, se ta samodejno poveže z vašo ploščo, ne da bi morali določiti COM vrata ali baudno hitrost. Medtem ko tipkate v svoj Python program, ponuja kontekstno občutljivo pomoč. Obstaja Check ikona, ki bo izvedla preverjanje Python sintakse v izvorni kodi. Vse skupaj se izkaže kot primeren IDE za uporabo.

MicroPython ima podoben IDE, imenovan Thonny, ki ga še nisem uporabljal. Tako Mu kot Thonny sta na voljo v operacijskem sistemu Windows in v Raspberry Pi (Linux) in podobnih računalnikih.

Ali je CircuitPython ali MicroPython najboljša izbira, je izključno stvar osebnih želja in tega, kakšen je projekt. Osebno se mi je zdelo veliko število Adafruit’s CircuitPython knjižnic prodajna točka. Druga značilnost CircuitPython, ki mi je bila všeč, je zmožnost modula za shranjevanje vašega CircuitPython programa, da dostopa do istega datotečnega sistema, ki je v računalniku predstavljen kot Flash pogon, ko je priključen na USB vrata. Videl sem, kje bi bilo to priročno, če bi ciljni MCU uporabljal kot zapisovalnik podatkov ali znanstveni instrument – te podatke bi bilo enostavno prenesti v osebni računalnik tako, da bi jih preprosto priključil v USB vrata računalnika in pregledal datoteke na USB pogon, ki se namesti. V MicroPythonu nisem mogel najti nobenega načina – imel je pomnilniški modul, v katerega ste lahko brali / pisali datoteke, vendar jih osebni računalnik na nameščenem Flash USB pogonu ni videl. Vendar je možno, da tukaj nečesa ne vem, zato ne morem izključiti možnosti, da lahko isto storite z MicroPythonom, če ne trenutno, pa vsaj v prihodnosti.

V naslednjem poglavju bom podal nekaj posebnih načinov, kako lahko uporabite RP Pico s CircuitPython.

Zajemanje analognih podatkov
Za nekatere aplikacije morda zadostuje PICO-tov interni ADC. Je dovolj hiter s hitrostjo 500kS / s. Ima 4 vhode (od tega se trije nahajajo na ohišju) z 12-bitno ločljivostjo. Vendar je določeno dejansko število bitov (ENOB) le 9: verjetno zaradi zajemanja šuma iz samega MCU. Tudi na Raspberry Pi PICO plošči ADC kot referenco uporablja 3,3-V VCC napajalnik (z majhno količino RC filtriranja). Napajanje VCC precej šumi, še posebej, če je stikalni regulator RT6150B v načinu varčevanja z energijo, kar je privzeto. To lahko prekličete, če nastavite GPIO23 na logično visoko stanje. V CircuitPython je ta priključek označen s SMPS_MODE in ga lahko nastavite logično visoko stanje, kot sledi:

PSM = digitalio.DigitalInOut(board.SMPS_MODE)
PSM.direction = digitalio.Direction.OUTPUT
PSM.value = True

Na začetku programa morate vključiti naslednje vrstice, če jih še ni:

Import board
Import digitalio

Na sliki 2A je prikazana slike na osciloskopu, ki prikazuje obseg napajanja VCC v privzetem (nizka moč) načinu (A), slika 2B pa običajni način.

Izboljšanje je očitno. Čeprav se ne bom spuščal v podrobnosti, je mogoče uporabiti visokonatančen zunanji vir referenčne napetosti, tako da ga priključimo na pin 35 (ADC_VREF). Glede na izbrani čip za referenčno napetost boste morda morali odstraniti R7, če referenca ne more obvladati toka, ki ga napaja R7 iz VCC napajalnika. Ko so razvijali ploščo, so premišljeno uporabili večje 0603 SMD ohišje za R7, da bi ga lahko uporabnik zlahka odspajkal.

Za nekatere namene notranji ADC PICO ne bo zadostoval, zato priporočam uporabo Burr-Brown ADS1115 (Burr-Brown je zdaj v lasti TI-ja) To je 16-bitni ADC s 4 vhodnimi kanali. Te kanale je mogoče konfigurirati za enojni ali diferencialni način delovanja. Čip vsebuje programirljivi ojačevalnik pred ADC-jem, ki omogoča bipolarna vhodna območja, kot je prikazano v tabeli 2.

Ob tem je potrebno upoštevati sledeče:

• Vhodi so bipolarni v diferencialnem načinu, v enojnem načinu pa ne. V obeh načinih mora vhodna ADC napetost ostati v območju od – 0,3 V do VCC + 0,3. Tako lahko dejansko izmerite napetosti, ki so nekoliko negativne (<0,3 V), vendar ne več kot to.
• Območja celotnega obsega znaša od +/- 4,096 V in +/- 6,144 V in NE pomeni, da lahko te napetosti priključite na vhodne ADC priključke. To pomeni, da je ojačenje PGA manjše – bodisi 1 ali 2/3. Najvišja vhodna ADC napetost je tista, navedena v 1) zgoraj.

Če želite nastaviti polni obseg ADS1115 v CircuitPython, uporabite naslednjo vrstico:

ads.gain= 2/3 # or 1,2,4,8,16

Predpostavljamo, da ste ustvarili primerek ADS1115 in mu dali ime »ads«. Ugotovil sem, da je ojačenje natančno. Če bi uvedli shemo s samodejnim nastavljanjem, ki temelji na spreminjanju nastavitve ojačitve PGA, vam ne bi bilo treba skrbeti za umerjanje posamezne vrednosti ojačenja. Slika 3 prikazuje nekaj dejanskih odčitkov, ki sem jih posnel z ADS1115 z dodanimi 0,400 volti.

Vidite lahko, da se napetosti na različnih območjih zelo ujemajo. Stolpci so namenjeni ojačenju 2/3, 1, 2, 4,8 in 16. Samo na lestvici Gain = 16 je PGA / ADC nasičen, kar ima za posledico napačno vrednost 0,256 voltov.

ADS1115 je sigma-delta ADC, zato ni tako hiter, kot interni ADC na PICO plošči. Lahko pa ga programirate za 8 različnih hitrosti prenosa podatkov (8, 16, 32, 64, 128, 250, 475 in 860 vzorcev na sekundo). Upoštevajte, da za razliko od mnogih sigma-delta ADC-jev ADS1115 ohranja svojo 16-bitno natančnost pri vseh vzorčnih stopnjah in celotnem napetostnem območju.

Hitrost vzorčenja se nastavi na naslednji način:

ads.data_rate = 8 # or 16, 32 etc.

ADS1115 je na voljo v zelo majhnih ohišjih, največje pa je 10-pin VSSOP ohišje. Vendar pa obstajajo številna podjetja, ki izdelujejo razvojne plošče za ADS1115, kot je prikazano na sliki 4.

Adafruit izdeluje takšno ploščo (njihov ID # 1085) in kot običajno so zanjo zagotovili CircuitPython knjižnico. To lahko najdete v njihovem CircuitPython paketu knjižnic, ki ga lahko prenesete s te povezave: https://circuitpython.org/libraries

Na isti povezavi lahko prenesete več CircuitPython primerov programov, povezanih s tem svežnjem knjižnic. V tem svežnju je nekaj primerov za ADS1115. Imenujejo se ads1x15 (ker primeri veljajo tudi za 12-bitni ADS1015).

ADS1115 se krmili preko I2C, zato morate za uporabo je potrebno določiti I2C vrata glede na to, katere priključke uporablja in pri kateri hitrost želite, da čip komunicira. Če ste navajeni uporabljati AVR MCU-je z Arduinom, so I2C vrata povezana z dvema posebnima priključkoma, zato bo Wire (I2C) knjižnica privzeto prilagodila pravilne priključke. V PICO je na voljo dvoje neodvisnih I2C vrat, ki ju je mogoče usmeriti na vsaj 12 različnih sklopov priključkov.

V Adafruit ads1x15 primerih se za definiranje I2C vrat uporablja naslednja vrstica:

# Create the I2C bus
i2c = busio.I2C(board.SCL, board.SDA)

CircuitPython je zasnovan za prenos na številne različne MCU-je, hkrati pa ohranja podrobnosti strojne opreme pregledne za uporabnika / programerja. V tem primeru so I2C priključki vrat definirani z uporabo board.SCL in board.SDA definicij. Na nekaterih MCU-jih bi ta vrstica delovala v redu, vendar v primeru PICO plošče zaradi obstoja dveh I2C vrat in možnosti, da ju usmerita na 12 različnih priključkov, board.SCL in board.SDA niso opredeljeni.

V svojem vezju uporabljam GPIO9 za SCL in GPIO8 za SDA, zato sem namesto tega uporabil naslednje:

i2c = busio.I2C(board.GP9, board.GP8)

I2C se v CircuitPython privzeto izvajajo pri 100 kHz. Če bi ADS1115 uporabljali z visoko hitrostjo vzorčenja, bi lahko povečali I2C hitrost na 400 kHz z uporabo naslednje vrstice:

i2c = busio.I2C(board.GP9, board.GP8, frequency = 400000)

ADS1115 lahko privzeto obravnava I2C takt do 400 kHz (imenovan Fast Mode). Prav tako ga lahko postavite v način visoke hitrosti, tako da mu kreirate edinstven bitni vzorec – to poveča zmogljivost hitrosti do 3,4 MHz. Tega nisem poskusil.
Če zgolj določite določeno I2C hitrost, to še ne pomeni, da jo bo PICO-jev RP2040 MCU tudi zagotovil. Zaradi omejitev delilnika I2C ure bo dejansko začel veljati le približek določene vrednosti ure. Na sliki 5A je prikazan zajem signala „nastavljene 400 kHz ure (dejansko 333 kHz), slika 5B pa kaže nastavljenih 1000 taktov (dejanska vrednost je 746 kHz).

Do močnega zaokroževanja signala pride zato, ker sem uporabljal zgolj 10k pull-up upore, nameščene na ADS1115 razvojni plošči. Če bi uporabil 1000 kHz signal za taktni signal ure, bi pull-up upore zmanjšal na 2,2k z dodajanjem zunanjih uporov.

Čeprav je za hitri način pri ADS1115 zagotovljeno samo do 400 kHz, sem ugotovil, da deluje v redu z uporabo nastavitve RPU MCU ure na 1000 kHz (746 kHz dejansko).

Za razliko od C ++, kjer bi pogosto ustvarili predmeta razreda zunanje periferije z eno vrstico kode, je Python drugačen. Če ste STM32 MCU-je uporabljali z STM32Cube ali Mbed, boste poznali koncept sloja abstrakcije strojne opreme (HAL) glede gonilnikov naprav. V bistvu je knjižnica gonilnikov naprav razdeljena na dva dela – na visoko raven (abstrakcija strojne opreme) in na nizko raven, odvisen od strojne opreme. To olajša prenos običajnih gonilnikov naprav na številne različice MCU-jev.

Python sledi isti ideji in verjetno še korak naprej. Oglejmo si primer tega, saj velja za ADS1115 ADC. Najprej moramo uvoziti knjižnico, zasnovano za ADS1115, in sicer:

import adafruit_ads1x15.ads1115 as ADS

Iz te knjižnice moramo uvoziti nekaj razredov funkcij:

from adafruit_ads1x15.analog_in import AnalogIn
from adafruit_ads1x15.ads1x15 import Mode

Omenil sem že, da ADS1115 uporablja I2C vodilo, zato moramo to določiti na naslednji način:

i2c = busio.I2C(board.GP9, board.GP8, frequency = 400000)

Nato moramo ustvariti primerek ADS1115 ADC objekta in ga povezati z I2C vrati, ki smo jih definirali:

ads = ADS.ADS1115(i2c)

Ker ima ADS1115 4 kanale, ki jih je mogoče upravljati v sofaznem ali diferencialnem načinu, moramo vhodne kanale določiti na naslednji način:

Chan0 = AnalogIn(ads,ADS.P0) # channel 0 single-ended

in/ali

Chan1 = AnalogIn(ads,ADS.P0,ADS.P1) # channels 1,2 differential mode

Po tem lahko ADS1115 ADC konfiguriramo / upravljamo z ukazi, kot kažejo naslednji primeri:

ads.mode = Mode.Continuous # or .Single
ads.data_rate = 16
ADC_data = Chan0.value

Torej, za uporabo ADS1115 smo v bistvu uvedli ADS1115 razred, definirali nekatere funkcije, povezane s tem razredom (AnalogIn in Mode), in povezali ADS1115 razred z določenimi I2C vrati (usmerjeni na določen par GPIO priključkov).

Če se vrnemo k notranjemu 12-bitnemu ADC-ju, ki se nahaja na RP2040 plošči, bi bilo kodiranje nekoliko preprostejše, saj v tem primeru ne uporabljamo SPI ali I2C vrat. V tem primeru bi bilo potrebno:

Import analogio
Import board
ADC0 = analogio.AnalogIn(A0) # or A1,A2

Analogni priključki A0-A2 se nahajajo na GPIO26 – GPIO28. Analog A3 je interno povezan z delilnikom napetosti (R5 in R6), ki se napaja iz 5-voltnega napajalnika (VSYS). Torej, lahko uporabite A3 za merjenje napetosti Vcc. Delilno razmerje je 0,333, tako da bo nominalnih 5 voltov proizvedlo 1,666 voltov na izhodu uporovnega delilnika. To ustvari ADC vrednost po približno 32600 štetjih, saj je 12-bitna vrednost CircuitPython ADC knjižnice prilagodila na 16-bitno območje, ADC-jeva referenčna napetost pa je 3,22 V.

Iz nekega razloga morate kanal A3 za nadzor moči določiti kot “board.A3”, druge ADC kanale pa lahko določite samo z A0-A2 (kot vidite v primerih Adafruit’s CircuitPython). To je:

ADC3 = analogio.AnalogIn(board.A3)

Ločljivost RP2040 ADC sem hitro preveril s PICO-jevim stikalnim napajalnim napajalnikom, nastavljenim tako za privzeti način (nizko porabo energije), kot za običajni način. V načinu nizke porabe energije (valovanje napajanja, kot je na sliki 2A) je bilo odstopanje vrednosti pri uporabljenem čistem 1,00-voltnem enosmernem signalu +/- 135 ali 0,04% celotne skale. V običajnem načinu (čistejše napajanje, kot je prikazano na sliki 2B) je odstopanje znašalo +/- 104 ali 0,03%. Navedeni ENOB za ADC je 9-bitni, kar je enako ločljivosti 1 dela v 512 ali 0,02%. Ker moja merilna tehnika ni bila zapletena, sem menil, da so bile vrednosti, ki sem jih dobil, razumne za ADC z določenim 9-bitnim ENOB.

Medtem ko razpravljam o analognem IO, bom ugotovil, da RP2040 ne vsebuje nobenih DAC-ov. Edini način, da dobite analogni izhod je, da uporabite enega od številnih izhodnih PWM priključkov in filtrirate PWM signal, dokler ni podoben enosmerni napetosti. To je podobno kot pri AVR MCU, ki izvajajo Arduino kodo (s funkcijo AnalogOut).

Pošiljanje podatkov na PC
Ne glede na to, ali je vaš projekt zapisovalnik podatkov ali laboratorijska oprema, ki jo običajno načrtujem, morate najti priročen način prenosa zbranih podatkov v računalnik. V preteklosti sem na splošno uporabljal naslednje tri metode:

• Merilni instrument povežite z računalnikom prek USB kabla s pomočjo zaporednega CDC profila in za interakcijo z instrumentom uporabite Visual Basic program po meri. VB program bi poskrbel za shranjevanje podatkov v nekakšno diskovno datoteko.
• Instrument naj podatke shrani na µSD kartico in prebere kartico v računalniku bodisi neposredno z vgrajeno režo za µSD kartico, bodisi z µSD USB vmesnikom. Novejše kartice z visoko zmogljivostjo (HC) pa so za nekatere knjižnice MCU SD kartic problematične.
• V instrument vključite FTDI VDRIVE2 modul. Ta modul vsebuje USB vrata gostitelja, ki omogočajo prepoznavanje Flash USB pogonov, in je povezan z gostiteljskim MCU prek UART ali SPI vrat. To vam omogoča prenos datotek v računalnik z uporabo Flash USB pogona. Prvotni FTDI VDRIVE2 je deloval samo na Flash pogonih z majhno zmogljivostjo – večina novejših pogonov z večjo zmogljivostjo s tem modulom ne bi delovala. VDRIVE2 je zdaj zastarel in verjetno je, da bo njegova zamenjava VDRIVE3 bolje opravila svoje delo pri sodobnih zmogljivih Flash pogonih. Sam še nisem preizkusil novejšega modela.

Prejšnje tri pristope sem naštel kot kontrast temu, kar se mi zdi veliko boljša rešitev. Idealno bi bilo, če bi lahko datalogger ali laboratorijski instrument priključili na osebni računalnik prek USB kabla in bi se ta instrument prikazal kot Flash USB pogon. Z operacijskim sistemom Windows / Linux / MAC bo operacijski sistem odprl okno raziskovalca datotek, ki prikazuje ta Flash pogon (in njegove datoteke), takoj ko je instrument priključen na USB vrata računalnika. Tako na primer uporabnik lažje ve, kje je datoteka, zato jo lahko nato povleče / spusti v ustrezno aplikacijo.

Do nedavnega nobena od MCU družin, ki sem jih uporabljal, tega ni zmogla storiti. Nekateri od njih so se približali: razvojne plošče, ki vsebujejo STM32 ARM MCU-je bi se ob uporabi Mbed IDE prikazale kot USB pogon, ko jih priključite v računalnik. Tako so programirani – kopijo šestnajstiške datoteke svojega programa preprosto povlečete / spustite na USB pogon, ki ga posnema naprava STM32 razvojne plošče.

Vendar pa do tega datotečnega sistema, do katerega lahko dostopa osebni računalnik, ne more dostopati vaš program, ki se izvaja na samem STM32 MCU-ju . Zato te metode ne morete uporabiti za prenos podatkov, zbranih z STM32 MCU-jem, v osebni računalnik s pomočjo tega emuliranega pogona USB. Ne izključujem možnosti, da bi to lahko storili z STM32 / Mbed OS, vendar nisem našel nobene dokumentacije, ki bi pokazala, kako to storiti. Običajno uporabljam Teensy 4.x plošče, ki vsebujejo MCU, ki lahko implementira profil USB MSD, vendar se mi zdi, da je povezana podporna ugnezdena programska oprema težko razumljiva.

Ko je Adafruit razvil CircuitPython, je bil v bistvu verzija obstoječe MicroPython kode, vendar z več pomembnimi razlikami. Odločili so se, da bodo CircuitPython priključili samo na MCU-je, ki vsebujejo izvorna USB vrata, ki lahko izvajajo MSD profil. Jedro ugnezdene CircuitPython programske opreme implementira ta MSD profil – to je tisto, kar vam omogoča, da povlečete / spustite python (.py) datoteke neposredno na emulirani USB pogon, ki je v raziskovalcu datotek računalnika prikazan kot CIRCUITPY. To je popolnoma enako, kot prej opisana STM32 izvedba.

Vendar gre CircuitPython še korak dlje – ta datotečni sistem izpostavi tudi CircuitPython programu, ki se izvaja na vaši razvojni plošči. Kot dodaten bonus je ta datotečni sistem zelo dostopen z ukazi za dostop do datotek na visoki ravni v samem CircuitPythonu. Zdi se, da MicroPython ne deluje na ta način. Ima visokokakovostno strukturo datotek, ki uporablja del Flash-pomnilnika MCU-ja, vendar te datoteke niso dostopne, če je naprava prek USB kabla povezana z računalnikom. To je eden od razlogov, zakaj sem se odločil, da namesto MicroPythona preučim CircuitPython.

Pri uvajanju datotečnega sistema, do katerega lahko dostopajo tako MCU vašega projekta kot tudi osebni računalnik, je treba upoštevati en pomemben vidik. To je stvar hkratnega dostopa do datotek. Kaj bi se zgodilo, če bi računalnik in program, ki se izvaja v vašem projektu, poskušala hkrati dostopati do datotečnega sistema? Ali natančneje, kaj če vaš projekt odpre datoteko in začne občasno beležiti podatke vanjo. V določenem trenutku, tudi če vaš program ni aktivno zapisoval v to datoteko, se lahko računalnik odloči, da bo datoteko prebral ali zapisal na pogon CIRCUITPY. Kako se bo kasneje, ko bo vaš projekt nadaljeval s pisanjem v odprto datoteko, odzval datotečni sistem?

Čeprav obstaja nekaj datotek, ki jih je verjetno mogoče uspešno zagnati tako iz python programa kot tudi iz računalnika, obstaja veliko scenarijev, v katerih bi to povzročilo napake. Da se to ne bi zgodilo, CircuitPython program privzeto šteje, da je ta datotečni sistem samo za branje. Datotečni sistem je privzeto nastavljen za dostop do branja / pisanja s strani osebnega računalnika. To je potrebno, da lahko osebni računalnik prenese python program, ki ga razvijate, na MCU vašega projekta (v tem primeru na PICO ploščo).

V kolikor želite, da vaš CircuitPython program lahko shranjuje podatke v datotečni sistem, morate nekako spremeniti njegov dostop do datotečnega sistema za branje / pisanje. Tega ni mogoče storiti znotraj vašega CircuitPython programa. Izvesti ga je treba med postopkom zagona, še precej preden se program CircuitPython začne izvajati.

Če želite to narediti, morate na pogonu CIRCUITPY ustvariti boot.py datoteko. V to datoteko bi vključili vrstico:

storage.remount("/", Bootvalue)

Če je Bootvalue = 0, lahko CircuitPython piše v datotečni sistem, PC pa ne more.
Če je Bootvalue = 1, lahko PC piše v datotečni sistem, CircuitPython pa ne.

Praktično gledano ne morete samo vstaviti vrstice, ki definira Bootvalue = 0 (kar omogoča CircuitPython-u pisanje v datotečni sistem), ker bo to preprečilo zapisovanje računalnika na CIRCUITPY pogon. Z drugimi besedami, datoteke code.py ne boste mogli več urejati / znova naložiti. Prav tako si ne morete premisliti in urediti boot.py datoteko, da spremenite to vrstico, saj tudi datoteke boot.py ne morete več urejati / prepisovati! (razen ponovnega zagona s pritisnjenim gumbom BOOTSEL in ponovnega nalaganja CircuitPython programa in vseh drugih python / knjižnic datotek).

Če želite odpraviti to težavo, je najbolje, da stikalo ali mostiček priključite na eno od GPIO PICO linij. Nato bi v boot.py datoteko zapisali naslednji kratek program:

import board
import digitalio
import storage
switch = digitalio.DigitalInOut(board.GP2)
switch.direction = digitalio.Direction.INPUT
switch.pull = digitalio.Pull.UP
# If the switch pin (GPIO2) is connected to ground CircuitPython can write to the drive
storage.remount("/", switch.value)

Med razvojem programa stikalo pustite odprto. Med zagonom programa zaprete stikalo in znova zaženete. Vaš program lahko nato zapisuje podatke v datotečni sistem. Če naredite to boot.py datoteko, se ob napakah v PICO sintaksi zažene, vendar predvideno stanje zapisovanja datotečnega sistema se ne bo izvedlo. Na serijskem monitorju pa se ne prikaže nobeno sporočilo o napaki. Namesto tega, če pogledate CIRCUITPY pogon, obstaja datoteka z imenom boot_out.txt. Vsebovala bo sporočilo, katera različica Circuit pythona se izvaja, datum in “Raspberry Pi PICO” – sledil bo seznam napak, ki so se pojavile med zagonom te boot.py datoteke.

Pisanje v datotečni sistem iz CircuitPython je precej preprosto. Tu je preprost primer kode:

import microcontroller
i iterations < 10:

temp = microcontroller.cpu.temperature
fp.write('{0:f}n'.format(temp))
fp.flush()
print("file written")
iterations= iterations + 1
time.sleep(1)
except OSError as e:
print(e.args[0])
if e.args[0] == 30:

print ("Filesy mport time
try:
with open("temp.txt", "a") as fp:
iterations =0
while iterations < 10:
temp = microcontroller.cpu.temperature
fp.write('{0:f}n'.format(temp))
fp.flush()
print("file written")
iterations= iterations + 1
time.sleep(1)
except OSError as e:
print(e.args[0])
if e.args[0] == 30:
print ("Filesystem write-protected")

V tem programu uporabljamo metodo »poskusi – razen če«. To se uporablja, kadar obstaja možnost, da bo program med izvajanjem naletel na napake. V tem primeru izvedba skoči iz razdelka »poskusi« in skoči v razdelek »razen če«, kjer sporoči napako. Sprva odpremo datoteko v korenu CIRCUITPY pogona z imenom datoteke »temp.txt« in ji damo oznako »fp«. Znak „a“ pomeni, da želimo pisnim podatkom dodati tiste, ki so že tam. Nato izmerimo notranjo temperaturo PICO in jo določimo s spremenljivko “temp”. Z oznako “fp” nato v vmesnik zapišemo spremenljivko “temp”. Format (0: f) in .format povzroči, da se vrednost temperature zapiše kot niz ASCII s plavajočo vejico in ” n” postavi vsako vrednost v novo vrstico. Instrukcija “flush” zapisuje vsebino vmesnega pomnilnika v datotečni sistem. Stavek time.sleep (5) se pred ponovitvijo zaporedja ustavi za 5 sekund.

Edina napaka, do katere bo verjetno prišlo je, če je datotečni sistem še vedno zaščiten pred pisanjem glede na CircuitPython program. Ko shranite ta program, če je vklopljeno samodejno ponovno nalaganje, se bo program zagnal takoj. Ker mora biti stikalo za zaščito pred pisanjem (stikalo, ki je izbrano v boot.py programu) izklopljeno, da lahko ta program naložite v PICO, sicer bo prvič, ko se bo ta program zagnal, naletel na zaščiteni datotečni sistem. Oddelek kode “razen če” se bo torej zagnal. Natisnil bo kodo napake (ki bo 30), ki ji sledi besedilo »Zaščiteno pred zapisovanjem datotečnega sistema«. Ko vklopite to stikalo in znova zaženete, bo program lahko uspešno zapisoval v temp.txt datoteko in vsakih 5 sekund se bo prikazalo sporočilo “datoteka je zapisana”.

Čeprav se temp.txt datoteka zapiše na vsakih 5 sekund in lahko do CIRCUITPY pogona kadar koli dostopate iz osebnega računalnika, če datoteko večkrat znova odprete v računalniku in preberete njeno vsebino, ne boste videli, da datoteka postaja vse večja. To se zgodi, ker osebni računalnik ne more vedeti, da PICO nenehno dodaja podatke v datoteko in domneva, da je datoteka v enakem stanju, kot je bila, ko je bila nameščena CIRCUITPY. Pogon CIRCUITPY se namesti, kadar koli se zgodi katera od treh stvari:

• Nova/urejena python.py datoteka je shranjena na PICO
• PICO se resetira
• PICO je vklopljen v USB vrata PC-ja.

Torej, če je vaš PICO povezan z vašim računalnikom, medtem ko zbira podatke / jih shranjuje v datoteko, ga boste morali ponastaviti ali pa njegov USB kabel izključiti / priključiti nazaj v računalnik, če želite videti posodobitev vsebine podatkovne datoteke.

Zaključki
RP Pico razvojno ploščo sem naročil zgodaj, predvsem zaradi nizke cene in tudi zaradi tega, ker sem vedel, da jo bo kot Raspberry Pi izdelek uporabljalo veliko število ljudi. To bo nedvomno privedlo do odlične programske podpore. Raspberry Pi fundacija je zagotovila izvrstno dokumentacijo o RP2040 MCU, plošči Pico in njihovem C ++ SDK. Povezava je:
https://www.raspberrypi.org/documentation/rp2040/getting-started/

Zanimivo bo videti, katera izmed dveh različic Pythona in dveh IDE-jev C ++ (Arduino in Raspberry Pi C ++ SDK) se bo izkazala za najbolj priljubljeno.