Använd Arduinos breakout-kort (BOB) för att utvärdera sensorer och kringutrustning snabbt

Internet of Things (IoT) frammarsch har varit inspirationskälla för många innovativa startup-företag som vill haka på nästa stora grej. Men många av de nystartade företagen har relativt små och slimmade utvecklingsteam, och måste försöka förkorta tiden till marknad. Det leder till att enskilda utvecklare arbetar inom flera tekniska domäner och utför uppgifter inom många olika fält, däribland digitalteknik, RF-teknik och trådlösa/fasta nätverk. Därför vill de hitta sätt som gör att det går snabbare att utvärdera integrerade kretsar, sensorer och kringutrustning, och sätt som gör utvärderingsprocessen billigare.

Ett alternativ är att använda utvärderings- och utvecklingssatser från kretsleverantörerna, för att stödja deras lösningar. Förutsatt att det finns väl fungerande support är det här en helt ok lösning. Men ett annat alternativ är att se närmare på Arduinos ekosystem. Det har utvecklats från att vara en enklare ”lekplats” för hobbyutvecklare till ett komplett och gediget ekosystem för design och support.

I den här artikeln visar vi hur utvecklare kan använda Arduino för att börja utvärdera integrerade kretsar, kringutrustning och sensorer i ett tidigt skede av designcykeln, med hjälp av öppenkodsmaskinvara i form av breakout-kort, kombinerade med öppenkodsprogramvara i form av bibliotek och exempelprogram. I artikelexemplen använder vi realtidsklockor (RTC:er) från Maxim Integrated och breakout-kort från Adafruit Industries.

IoT-teknikens framväxt

Ett av de första verkliga exemplen på IoT är från början av 1980-talet, då en Coca-Cola-maskin hos Carnegie Mellon University kopplades upp mot nätet, så att programmerarna kunde använda internet för att kontrollera om drycker behövde fyllas på och om de var tillräckligt kalla, istället för att kontrollera det på plats vid maskinen. IoT som koncept fick sitt officiella namn först 1999.

Den exakta tidpunkten för när IoT blev till, råder det delade meningar om. Den kanske bästa definitionen för IoT-teknikens tillblivelse är nog ”den tidpunkt då fler föremål än människor hade anslutits till internet”. Utgår man från den definitionen, kan man säga att IoT kom till någon gång mellan 2008 och 2009, då kvoten föremål/personer hade ökat från 0,08 år 2003 till 1,84 år 2010.

Arduinos framväxt

IoT-teknikens initiala framväxt sammanföll med framväxten av ”maker-rörelsen” i början av 2000-talet. Världens första driftsättning av en Arduino-enhet skedde 2005, dvs. samma år som magasinet Make startades och bara ett år innan den första upplagan av Maker Faire hölls.

Sedan dess har Arduino utvecklat avancerade ekosystem för öppenkodsbaserad programvara och maskinvara. Vad som behövdes var ett sätt att få professionella utvecklare att uppmärksamma Arduinos väl underbyggda ekosystem, för att förenkla utvecklarnas arbete och förkorta tiden till marknad för deras produkter.

Lösningen växte fram organiskt: Det enorma ekosystem som växte fram kring Arduino ledde till en oväntad bieffekt – professionella utvecklare började använda Arduino för att utvärdera sensorer och kringenheter innan de använde dem i sina egna system. Det här finns det många exempel på nu, varav ett är realtidsklockor (RTC).

Exempel på utvärdering av kringutrustning med realtidsklocka

Nästan alla moderna 32-bitars microcontrollers har en inbyggd realtidsklocka, vilket även gäller många 16-bitars och 8-bitars microcontrollers. Med en inbyggd realtidsklocka blir kortet mindre, komponentlistan enklare och kostnaden lägre, men trots det finns ett antal nackdelar.

En sådan nackdel är att microcontrollern måste använda programvarustyrning för att aktivera och stänga av den interna realtidsklockan. Om problem inträffar, exempelvis strömavbrott, programvarufel eller att microcontrollern låser sig, kanske realtidsklockan stängs av oavsiktligt. En extern realtidsklocka anses vara mer robust, eftersom den har en separat strömtillförsel och kristall, och inte lika enkelt stängs av oavsiktligt på grund av programvarufel hos microcontrollern. Den externa realtidsklockan brukar dessutom implementeras med en större tillverkningsprocessnod än microcontrollern, och större kiselyta gör den mindre känslig mot bitfel och oavsiktliga tillståndsförändringar (SEU-händelser, single event upsets) på grund av strålning.

Exempel på realtidsklocka-IC: Maxim Integrateds DS1307 och DS3231

Två mycket populära realtidsklockor är DS1307 och DS3231 från Maxim Integrated. Båda enheterna håller reda på sekunder, minuter, timmar, veckodag, datum, månad och årtal, och månader som är kortare än 31 dagar justeras automatiskt. Enheterna tar hänsyn till skottår och har stöd för 24-timmarsklocka och 12-timmarsklocka. Båda enheterna kommunicerar också med värd-microcontrollern, via en seriell I²C-buss, och de har en avkänningskrets som detekterar strömfel och automatiskt växlar över till reservförsörjning (vanligtvis ett batteri), så att tidsfunktionerna inte störs (figur 1).

Figur 1: DS1307 är ett bra exempel på en extern realtidsklocka. En fördel är att den har en egen kristall och strömförsörjning och att den inte är känslig mot kodfel. Den kommunicerar med värd-microcontrollern via ett I²C-gränssnitt. (Bildkälla: Maxim Integrated)

För att ta reda på vilka skillnader det är mellan enheterna, kontrollerar man databladen. För DS1307 krävs till exempel 5-volts försörjning kombinerat med en extern kristall. Som jämförelse kan den mer exakta DS3231-klockan drivas med 2,3–5,5 volt, och den levereras med en integrerad temperaturkompenserad kristalloscillator (TCXO) och kristall.

Skillnaderna mellan de två enheterna är inte alltid så uppenbara. Till exempel har båda enheterna en fyrkantvågsutgång (square wave, SQW), vilket – om utgången aktiveras via programvara – gör att det krävs ett externt pull-up-motstånd. Men när det gäller DS1307 kan SQW-utgången programmeras för att generera en signal på 1 Hz; 4,096 kHz; 8,192 kHz eller 32,768 kHz. Som jämförelse kan motsvarande utgång hos DS3231 programmeras för att generera en signal på 1 Hz; 1,024 kHz; 4,096 kHz eller 8,192 kHz.

För DS1307 beror klockans noggrannhet dels på kristallens exakthet och dels på hur väl oscillatorkretsens kapacitiva last överensstämmer med den kapacitiva last som kristallen har trimmats för. Som jämförelse har den temperaturkompenserade DS3231-klockan en mer specifik noggrannhet på ±2 minuter per år, från -40 °C till +85 °C (figur 2).

Figur 2: DS3231 är en temperaturkompenserad kristalloscillator med en noggrannhet på ±2 minuter per år i temperaturområdet -40 °C till 85 °C. (Bildkälla: Maxim Integrated)

Om vi antar att man i databladet inte påträffar några avgörande nackdelar hos någon av de båda enheterna – hur går man tillväga för att utvärdera dem i praktiken? En lösning kan vara att designa och bygga anpassade breakout-kort, och att även från grunden utveckla den kod som driver dem. En snabbare och mer kostnadseffektiv lösning är att använda färdiga breakout-kort och kod som har utvecklats inom Arduinos ekosystem av maskinvaror och programvaror.

Exempel på utbrytningskort för realtidsklockor: Adafruit DS1307 och ChronoDot

Två populära utbrytningskort för kretsarna DS1307 och DS3231 är Adafruit 3296 DS1307 Real-Time Clock BOB (figur 3) och 255 ChronoDot Ultra-Precise Real-Time Clock V2.1 BOB (figur 4).

Figur 3: Adafruit DS1307 RTC BOB. (Bildkälla: Adafruit Industries)

Figur 4: Utbrytningskortet ChronoDot Ultra-Precise Real-Time Clock v2.1. (Bildkälla: Adafruit Industries)

Kombinerat med ett lämpligt microcontroller-utvecklingskort, såsom Arduino Uno R3, plus öppenkodsbibliotek och exempelkod som kan laddas ner från internet, står professionella utvecklare av inbäddade system och IoT-enheter väl rustade för att komma igång snabbt.

Efter slutförd utvärdering kan utvecklaren ta lämpliga delar av den öppenkodsbaserade maskinvarudesignen för utbrytningskorten, och integrera dessa delar direkt i sin egen konstruktion. Även öppenkodsbiblioteken och den kod som har utvecklats baserat på öppenkodsexemplen, kan användas i utvecklarens egen produkt.

Maskinvarutips för programvaruutvecklare

Båda realtidsklockorna DS1307 och DS3231 kommunicerar med värd-microcontrollern via en seriell I²C-buss, som redan har nämnts. En sak som kanske kommer som en överraskning för programvaruutvecklaren är att det krävs pull-up-motstånd för båda de signaler som bussen består av (SCL och SDA).

Inget av breakout-korten för DS1307 eller DS3231 (ChronoDot) från Adafruit innehåller pull-up-motstånd. ChronoDot har dock plattor med R1- och R2-beteckningar där motstånden kan anslutas.

Orsaken till att man inte har inkluderat pull-up-motstånd är att en I²C-buss kan ha flera anslutna enheter (integrerade kretsar eller breakout-kort). I²C-bussen använder en 7-bitars adress, där 2⁷ = 128. Men adressen 0000000 är en generell anropsadress som används för alla enheter på bussen, vilket gör att bussen har teoretisk kapacitet för att stödja 127 diskreta enheter. Hur många enheter som stöds i praktiken beror på bussens kapacitans, inklusive kapacitansen för kretsbanor och laster, vilken är begränsad till totalt 400 pF.

Maskinvaruutvecklare använder en särskild formel för att beräkna det ekvivalenta värdet för flera parallellt inkopplade motstånd. Som stöd för våra resonemang i den här artikeln, kan vi ta följande enkla exempel: Om två enheter har pull-up-motstånd med samma värde, blir resistansen hälften av värdet; om fyra enheter har pull-up-motstånd med samma värde, blir resistansen en fjärdedel av värdet.

Om det redan finns en I²C-enhet med pull-up-motstånd på bussen, behöver man inte vidta ytterligare åtgärder. Men om det inte finns några pull-up-motstånd och utvecklaren är helt säker på att inget breakout-kort med inbyggda pull-up-motstånd kommer att tillföras i framtiden, så är det bäst att använda ett par av 4,7 kΩ-motstånd. Om det finns en möjlighet att ett utbrytningskort med pull-up-motstånd kommer att läggas till i framtiden bör man dock, i det här skedet, lägga till två 10 kΩ-motstånd. De fungerar både före och efter att eventuella breakout-kort lagts till.

Programvarutips för maskinvaruutvecklare

”Wire-biblioteket” är ett kommunikationsbibliotek för att förenkla tvåtrådskommunikation med I²C-enheter. För Arduinos del levereras detta som en del av den integrerade utvecklingsmiljön (IDE), så det enda utvecklaren behöver göra är att lägga till uttrycket #include <Wire.h> i början av programmet.

Det avgörande knepet är att använda ett lämpligt RTC-bibliotek. Ett bra förslag är Adafruits RTClib-bibliotek, som kan laddas ner från Github. Lägg sedan till uttrycket #include "RTClib.h" i början av programmet.

Senare – vanligen när konstantvärden har definierats – är det dags att skapa en instans av realtidsklockan, vilket sker med hjälp av uttrycket RTC_ DS1307 RTC; eller RTC_DS3231 RTC;, beroende på vilket breakout-kort som används.

Därefter – när ”setup” utförs i programmet (med funktionen setup() för en Arduino-sketch) – måste utvecklaren lägga till uttrycken Wire.begin(); och RTC.begin(); för att initiera I²C-kommunikationen och RTC-subsystemet.

De exempel som visas på den nämnda Github-sidan hjälper utvecklaren att snabbt komma åt och ställa in datum och klockslag. Hur man kommer åt SQW-utgången är dock inte lika självklart. Som standard är utgången avstängd för att spara ström. Ett sätt att använda stiftet är att aktivera det och konfigurera det för till exempel 1 Hz, och sedan använda signalen för att utlösa ett interrupt på värd-microcontrollern.

För en programvaruutvecklare är det enkelt att hitta rätt kod i biblioteket, men för någon som främst utvecklar maskinvara kan det vara svårare. Därför följer en kort genomgång här:

Vad gäller DS1307 behöver du bara lägga till ett eller flera av följande uttryck på formen RTC.Ds1307SqwPinMode(<alternativ>); där tillgängliga alternativ är ON, OFF, SquareWave1HZ, SquareWave4kHz, SquareWave8kHz och SquareWave32kHz.

För DS3231 lägger du till ett eller flera av följande uttryck på formen RTC.Ds3231SqwPinMode(<alternativ>); där tillgängliga alternativ är ON, OFF, DS3231_SquareWave1Hz, DS3231_SquareWave1kHz, DS3231_SquareWave4kHz och DS3231_SquareWave8kHz.

Slutsats

Mindre utvecklingsteam och krav på kortare tid till marknad gör att utvecklarna måste arbeta inom flera tekniska domäner och utföra uppgifter inom flera olika fält. Därför vill de hitta sätt att minska kostnaderna för utvärdering av integrerade kretsar, sensorer och kringutrustning, samt metoder för att accelerera utvärderingsprocessen. Ett sätt att göra det, som vi beskriver i den här artikeln, är att använda Arduino, plus öppenkodsmaskinvara i form av breakout-kort för sensorer och kringutrustning kombinerat med öppenkodsprogramvara i form av bibliotek och exempelprogram.