Enhver hjemmemikroelektronikudvikler, før eller senere, står over for behovet for at styre sin egen, skabt af ham selv, enhed gennem en slags fjernbetjening, som vil være praktisk at skifte driftstilstand eller blot se den aktuelle tilstand. Generelt ville udtrykket "udvikler af mikroelektronik til hjemmet" for 15 år siden have forårsaget frygtelig latter, for på det tidspunkt kunne ingen have forestillet sig, at nogen derhjemme ville rode med miniaturetavler, beskæftige sig med firmware og faktisk. Men det viste sig, at individuelle entusiaster blev til værter af entusiastiske mennesker, og selve virksomheden fik en masseomsætning.

Men der er gået flere år, og stædige virksomheder har skabt en rigtig niche, et helt marked, hvor millioner af entusiastiske ikke-professionelle er i kog, og entusiastisk samler endnu en "arduino-enhed". Det er netop disse entusiaster, der betaler store penge til producenter af skjolde og sensorer, og der er behov for at styre deres smarte enheder med en fjernbetjening. Og mærkeligt nok blev deres behov opfyldt på den mest elegante måde som muligt. Blynk er født.

Blynk app

Hvad bringer Blynk til hjemmeautomationselskeren? Svaret på det stillede spørgsmål er todelt. På den ene side - slet ikke meget, men på den anden side bliver lidt til næsten halvdelen af ​​"omkostningen" for hele projektet. Blynk giver dig mulighed for at forvandle en almindelig smartphone eller tablet, der kører Android eller iOS, til et rigtigt kontrolpanel til egenudviklet elektronik. Blynk passede meget godt ind i Arduino-økostrukturen og dukkede op på det mest passende tidspunkt.

Faktisk er Blynk intet andet end en applikation til en mobilenhed, der giver dig mulighed for at skabe applikationer med alle funktioner i form af grafisk design til at forbinde dem med Arduino-baserede og kompatible enheder (hvis sandt, der vil være mange flere kompatible platforme snart). Jeg kan roligt kalde hovedtrækket i Blynk for den enkelhed, hvormed både selve applikationen er oprettet, og hvordan forbindelsen med programkoden i enheden er implementeret.

For at komme i gang, og for at fortsætte det, skal du blot installere Blynk-applikationen på din mobil eller tablet. Derefter skal du bare flytte fingeren hen over skærmen, placere elementer som knapper, skydere, kontakter, pærer, plottere og mere, mere, mere. Hvert element har mulighed for at konfigurere nogle få parametre, men grundlaget ligger i at binde kontrollerne eller displayet til stifterne på den fysiske enhed. Og selve stifterne kan være ægte, fysiske, eller de kan være virtuelle. Men jeg vil anbefale at arbejde med virtuelle, da logikken i deres behandling kan konfigureres meget mere fleksibelt end med fysiske.

På enhedssiden skal du bare forbinde biblioteket, oprette et link mellem kildekoden og registreringskoden for den installerede applikation, sætte en hændelseshandler i løkken, ja ... Ja, generelt er det alt. Hvis applikationen kun er bundet til fysiske stifter, skal der ikke gøres andet.

Lige sådan får du en praktisk fjernbetjening til din enhed, der ikke kun kan sende kommandoer til den, men også vise alt, hvad du har brug for på din skærm. Udviklerne brød sig ikke engang om avanceret og detaljeret dokumentation. Alt er samlet i et enkelt dokument på én side på Blynks hjemmeside. Nå, ja, for at lette implementeringen sender jeg udviklere en fuldgyldig "respekt"!

Hvor kom Blynk fra?

Blynks optræden skete ikke ved et rent tilfælde. Jeg vil endda bemærke, at Blynks fødsel ikke er andet end et eksemplarisk, lykkeligt tilfælde af vellykket crowdfunding. En vis Pasha Baidurin, jeg håber, at jeg ikke fordrejede navnet, startede en Kikstarter-kampagne med et beskedent beløb på kun $10.000. Som et resultat opnåede kampagnen fem gange så meget, hvilket gjorde det muligt for den at vende fuldt ud. Indsamlingen startede i midten af ​​januar 2015, og ved udgangen af ​​måneden havde den indsamlet det nødvendige beløb. Det er præcis den måde, hjernen vinder byttet på, vind det på dit overskæg.

På lidt mindre end et år, og jeg skriver denne anmeldelse i december 2016, lykkedes det Blynk at vokse op, erhverve alle de nødvendige egenskaber og, håber jeg, var i stand til at overvinde problemet med vækst og forvandlet til et fuldgyldigt selskab. . I det mindste nu tilbydes Blynk ikke kun til enkeltpersoner, men også til juridiske enheder. Monetiseringsmodeller for forskellige typer brugere er forskellige, men mere om det nedenfor.

Det unikke ved forretningsmodellen

Så hvad er ellers unikt ved Blynk end evnen til at oprette en telefonapp på fem minutter og linke den til en Arduino for fem ekstra? Det, der gør det unikt, er den anvendte forretningsmodel. I softwareverdenen accepteres standardbrugsbetingelser for produkter: Freeware (gratis), Shareware (shareware, med en prøveperiode), Donationware (betal hvis du kan lide det), betalte produkter. Forskellige kombinationer er tilladt, for eksempel til privat brug, produktet kan være gratis, mens erhvervslivet skal betale for hvert eksemplar. Der er dog andre typer licenser, for eksempel mange OpenSource, når produktet betragtes som en slags mursten af ​​kildekode, der er tilgængelig for alle. Men lad os ikke dykke ned i naturen og se nærmere på Blynk.

Interface i Blynk-appen på en smartphone

Som standard får en almindelig privat bruger, der har downloadet Blynk fra markedet, et begrænset sæt, nej, ikke elementer, men batteristrøm. Denne afgift bruges på at bruge grænsefladeelementer til at oprette din applikation. Lad os sige, at du oprindeligt har en værdi på 1000 enheder. Hver knap, der er installeret i projektet, vil koste dig 200 enheder, og noget mere kompliceret, for eksempel en grafbygger, vil komme ud så tidligt som 400. Når du opbygger din applikation fra elementer, bruger du den energi, du oprindeligt har fået tildelt. Når energien er opbrugt, vil det ikke længere være muligt at tilføje nye elementer til applikationen. Du bliver enten nødt til at købe ekstra energi for rigtige penge, og betjeningen er ekstremt enkel, ligesom alt andet i Blynk, eller slette elementer fra applikationen. Når den fjernes, returneres den energi, der er brugt på installationen fuldt ud.

Udviklere tillader således en ny bruger at evaluere mulighederne i Blynk og skabe mindst en mere eller mindre funktionel applikation. Og så - hvis du vil betale, hvis du ikke vil, så adskille det du har lavet og genbrug. Det unikke ved situationen ligger i det faktum, at brugeren bliver tilbudt at købe ikke en applikation, ikke et abonnement på den, ikke en trafikbegrænsning, men elementer af grænsefladen til hans applikation! Genopladning af Blynks batteri er ikke dyrt og kan klassificeres som en mikrobetaling. Derfor sker afsked med hårdt tjente penge umærkeligt og smertefrit.

Men sætter stadig pris på ideen. Forestil dig, at du bruger MS Word, og du bliver bedt om at skrive tekster på højst ti sider. Og for at skrive det ellevte skal du enten købe mere virtuelt papir eller gøre kortheden til en velgører og reducere din tekst til et minimum. Og efter udskrivning skal du slette det hele fuldstændigt. På trods af det absurde i implementeringen af ​​eksemplet fungerer alt med Blynk. Og det fungerer fantastisk.

For virksomhedsbrugere, hvis arbejde er direkte relateret til frigivelse af applikationer til kommercielle eller nærmest kommercielle formål, tilbydes en lidt anderledes betalingsordning for udviklernes arbejde i Blynk. Virksomheder får en selvstændig applikation, der ikke fungerer i Blynks sandkasse, men separat. Blynk vil stadig være der, gemt bag en facade. Og du skal betale for et abonnement, hvor applikationen forbliver i drift.

Forestil dig, at du fremstiller ultralydsbefugtere. Du har allerede dekoreret hver af dine modeller med blå LED'er og overvejer seriøst, hvordan du også skruer IoT der. Blynk giver dig en næsten klar løsning. Du skruer noget som en ESP8266 til luftfugteren og tilbyder brugerne at downloade applikationen. Voila! Alt fungerer, alle er glade. Præcis indtil du beslutter dig for at frigive en ny, forbedret linje af luftfugtere, der ikke kun viser blå, men også lilla lysdioder. Og du tror ganske rimeligt, at du ikke længere kan betale for den gamle ansøgning. Det bruger penge, og det er på tide, at forbrugeren kommer efter en ny luftfugter, fordi du har børn, de skal på college.

Den programmerbare levetid for forbrugerprodukter er en elsket drøm for enhver producent. Løsning, som ved hjælp af Blynk er meget let. Som dog og alt hvad Blynk angår.

Hvad er til gengæld?

Men ikke alle individer er villige til at betale penge, især for noget, der kan gøres gratis. Og folks tanke er øjeblikkeligt orienteret, entusiaster begynder at udgrave alternative muligheder for gratis brug af en analog af Blynk-funktioner. Og hvor mærkeligt det end lyder, så er jeg en af ​​dem.

Webserver

Den nemmeste måde at implementere fjernbetjening på, vil jeg sige, er at bruge en webserver på din enhed. Sådanne moderne chips som EPS8266 og mange andre giver dig mulighed for at oprette forbindelse til IP-netværk, inklusive lokale netværk i lejligheden og endda med internetadgang. Og der er nok ledig plads i controllerens hukommelse til at rumme en fuldgyldig server.

Derfor kan du på en sådan enhed installere en simpel webserver, der er optimeret til skærme på mobile enheder. Du kan kalde det via en genvej på skrivebordet på din smartphone. Ja, i de fleste tilfælde skal både enheden og mobilen være inden for samme netværk, men hvor ofte falder det dig ind at tænde for din luftfugter derhjemme, når du selv er i Himalaya og klatrer med reb til næste top?

Når du bruger webserverindstillingen, skal du behandle svar fra klienten og vise kontroller som HTML. Det bliver måske ikke så smukt og hurtigt som med Blynk, men det er helt gratis.

Cayenne

Tilføjelse af elementer til kontrolpanelet i Caynne (browser)

Hvad blev der gjort? Med hjælp fra Cayenne-specialister blev CayenneWiFiClient-metoden overbelastet, hvortil der blev tilføjet en konstruktør for at oprette et Cayenne-objekt med kun godkendelsesidentifikatoren på Cayenne-tjenesten videregivet til den. I dette tilfælde skal du selv oprette en internetforbindelse.

Det er nødvendigt at opgradere standard Cayenne-biblioteket og lægge den ændrede fil i mappen med din skitse:

#ifndef _CAYENNEESP8266WIFICLIENT_h #define _CAYENNEESP8266WIFICLIENT_h #include "CayenneClient.h"-klasse CayenneWiFiClient: offentlig CayenneClient (offentlig: /** * Begynder Cayenne-session @@param-token-netværk @WiFi-token-netværket parat Cayenm-netværk *WiFi-token-parameter-netværk *WiFi password */ void start(const char* token, const char* ssid, const char* pass) ( Blynk.begin(token, ssid, pass, CAYENNE_DOMAIN, CAYENNE_PORT); ) /* void config(const char* auth, const char * domæne = CAYENNE_DOMAIN, uint16_t port = CAYENNE_PORT) (Base::begin(auth); this->conn.begin(domæne, port); )*/ void config(const char* auth) ( Blynk.config(auth, CAYENNE_DOMAIN) , CAYENNE_PORT); ) ); CayenneWiFiClient Cayenne; #Afslut Hvis

Og selve skitsen:

#omfatte #define CAYENNE_PRINT Serial // Kommenter dette for at deaktivere udskrifter og spare plads #include "CayenneDefines.h" #include "BlynkSimpleEsp8266.h" #include "CayenneESP8266WiFiClient.h" #define VIRTUAL_PIN V0 D4 #define/ledPinboard token = "YourCayenneSecurityToke"; const char* ssid = "DitWiFiNetværk"; const char* password = "YourWiFiNetworkKeyPhrase"; void setup() ( // sæt din opsætningskode her, for at køre én gang: Serial.begin(115200); Serial.println("YaHoo..."); WiFi.mode(WIFI_STA); WiFi.begin(ssid, adgangskode ); while (WiFi.waitForConnectResult() != WL_CONNECTED) ( Serial.println("Forbindelse mislykkedes! Genstarter..."); delay(5000); ESP.restart(); ) Cayenne.config(token); pinMode( ledPin, OUTPUT); ) CAYENNE_IN(VIRTUAL_PIN)( int værdi = getValue.asInt(); // Hent værdi som heltal Serial.print("Værdi modtaget V1P: "); Serial.print(value); Serial.println(" "); if (værdi==1)( digitalWrite(ledPin, LOW); )else( digitalWrite(ledPin, HIGH); ) ) void loop() ( // sæt din hovedkode her, for at køre gentagne gange: Cayenne.run (); delay(100); //Serial.print("."); )

Hvis intet er klart ud fra ovenstående, så vil jeg forsøge at forklare. For det første stoler Cayenne på Blynk... Ja, Cayenne bruger Blynk, men ikke den applikation, som jeg beskrev et par afsnit ovenfor, men Blynk-rammen, der er udgivet under MIT-licensen. Det viser sig således, at både Blynk-applikationen og Cayenne på den ene eller anden måde udfører den samme funktion. Faktisk er det sådan.

Færdiglavet kontrolpanel i Cayenne, når det ses gennem en browser

Forskellen mellem projekterne er som følger: Blynk fokuserer på den mobile applikation og nem applikationsudvikling, Blynk er allerede aktivt indtjent. Cayenne tilbyder udover mobilapplikationen også et fuldt funktionelt kontrolpanel på sin hjemmeside. Og alligevel ikke indsamle penge fra sine brugere. Betjeningskonceptet for Cayenne er identisk med Blynks. I applikationen eller gennem en webbrowser opretter brugeren et projekt, tilføjer knapper, pærer og andre indikatorer, der kan forbindes med en virtuel eller ægte pin på netop din enhed. Derudover har Cayenne en mekanisme til triggere og hændelser. Triggere håndterer hændelser modtaget fra enheder. Og eventmodellen er baseret på kalenderplanen.

Kommunikation mellem enheden og applikationen foregår på samme måde som med Blynk, ved at tilføje små stykker programkode til at behandle forretningslogikken, der er fastkablet i din enhed. Men i første omgang blev projektet finpudset til at bruge et minimum af programmering på siden af ​​klientenheden. Alt burde på en eller anden måde samles op af Cayenne-bibliotekerne. Det er af denne grund, at du i Cayenne kan finde mange boards og muligheder for tilslutning til netværket, herunder forskellige sensorer fra specifikke producenter. På den ene side reducerer mangfoldighed behovet for programmeringsskitser, på den anden side reducerer det muligheden for at bruge universelle enheder.

Cayenne betjeningspanel interface på tablet

Det er af denne grund, at jeg havde svært ved at forbinde Cayenne til en allerede tilsluttet Wi-Fi-forbindelse. Og jeg var nødt til at forklare udviklerne, hvorfor jeg havde brug for det. Det er muligt, at systemet blev udtænkt til det helt indledende uddannelsesniveau for slutudviklere, hvilket indirekte er angivet af antallet af eksempler på skitser, der kommer ud med hver handling.

Lidt overrasket over bygherren på hjemmesiden. Du skal vænne dig til hans logik. Først tilføjer vi enheden, får identifikationskoden, forbinder den derefter på enheden og prøver at oprette forbindelse til Cayenne-serverne. Hvis det lykkedes at oprette forbindelse, vil det være muligt at forbinde widgets, knapper, resultattavler og andre visualiseringsværktøjer til den tilsluttede enhed.

Sammenfattende efter at have testet Cayenne, kan jeg sige, at jeg ikke kunne beslutte mig for, om jeg kunne lide systemet eller ej. På den ene side, ja, alt hvad der kræves af hende er på plads. Til gengæld havde jeg hele tiden følelsen af, at her var noget ufærdigt. Det er forståeligt, systemet er nyt, og arbejdsplanen for implementering af alle funktioner er endnu ikke afsluttet. Endnu mere bekymrende er Prøv det gratis lokkemiddel, uden nogen offentliggørelse, men hvad sker der, når "testperioden" er forbi? I det mindste i øjeblikket (december 2016) kan Cayenne bruges til dine egne formål uden gebyr, træne, opret dine egne applikationer. Og vigtigst af alt - ingen begrænsninger i forhold til energilagring i batteriet.

Virtuino

I modsætning til Blynk eller Cayenne er Virtuino udviklet af en enkelt person. Og på trods af de meget begrænsede ressourcer, viste resultatet sig ikke at være værre, og måske endda bedre, end beskrevet ovenfor. Så Virtuino er frugten af ​​en græsk udviklers flid, som kan findes både på en separat side (på græsk) og direkte på downloadsiden af ​​Virtuino-applikationen fra markedet. For dem, der har travlt med at kæmpe, giver jeg et direkte link til tutorial om tilslutning af Virtuino, da proceduren i starten måske ikke er triviel.

Ligesom Blynk bruger Virtuino kun mobilappen til at skabe brugergrænsefladen. Ligesom Cayenne og Blynk bruger Virtuino app-in-app-teknologi. Det betyder, at dit arbejde forbliver i Virtuinos sandkasse og ikke kan eksistere bortset fra Virtuino. Men Virtuino har også en forskel fra de to konkurrenter. Virtuino bruger ikke en mellemserver.

Virtuino app interface på tablet

Jeg vil dvæle ved denne kendsgerning lidt mere detaljeret, da det for mig er nøglen. Blynk og Cayenne bruger serversiden og arbejder kun igennem den. Du kan ikke få adgang til enheden uden en internetforbindelse, i det mindste for andre forbindelser end Bluetooth- og USB-forbindelser. Og hvis forbindelsen er ustabil, vil din skitse blive langsommere på netværksforbindelser. For nogle applikationer kan det være meget kritisk at bremse udførelsen af ​​instruktioner. Desuden kan både Blynk og Cayenne arbejde fra under alvorlig NAT, hvilket betyder, at din enhed med jævne mellemrum vil polle, bogstaveligt talt i hver cyklus, serveren på internettet. Hvis forbindelsen er dårlig, kan udførelsen af ​​skitsen slet ikke gå som oprindeligt tænkt.

I Virtuino kan en udvikler gå to veje. For det første kan han bruge ThingSpeak-tjenesten som den samme mellemserver. Og for det andet udføres kommunikationen mellem applikationen og enheden ved hjælp af en webserver, der er hævet på selve enheden! Ja, i dette tilfælde vil adgang til enheden uden for dit lokale netværk højst sandsynligt være umulig. På den anden side er det de færreste, der har brug for det. Men ingen forsinkelser og problemer med ekstern forbindelse. Alt er implementeret gennemsigtigt til det umulige, det mangler IoT-giganterne. Når du arbejder med Cayenne, har du hele tiden følelsen af, at der til enhver tid kan indføres et gebyr for at bruge tjenesten, og Blynks priser hæves og dit allerede betalte sæt vil være ude af drift. Med Virtuino vil du fortsætte med at bruge applikationen og administrere din enhed med den. Under alle omstændigheder kan applikationen ikke opdateres.

Ligesom Cayenne har Virtuino en fastkablet evne til at oprette forbindelse til et Wi-Fi-netværk ved hjælp af Virtuino uden mulighed for at bruge en allerede etableret forbindelse. Tilstedeværelsen af ​​to identiske tilgange til implementering fører til ulykkelige tanker. Af en eller anden utrolig grund begrænser udviklere brugeroplevelsen af ​​deres produkter markant. Hvis det med Cayenne lykkedes mig at løse problemet med at bruge min egen netværksforbindelse, så mislykkedes jeg i Virtuino. Selv med hjælp fra en udvikler var jeg ikke i stand til at forbinde min ESP8266 til netværket og bruge Virtuino. Pointen er, at Virtuino kun understøtter ESP8266 som et eksternt Wi-Fi-modul til Arduino, og ikke som et selvstændigt kort. Og jeg skiftede fuldstændigt til ESP8266 i mine enheder i lyset af deres enestående egenskaber.

Ja, i jagten på at gøre livet lettere for forbrugeren, driver nogle udviklere ham, forbrugeren, ind i meget snævre grænser og tillader ham ikke at gå ud over dem. Ved at bruge eksemplet med 1C husker vi, at jo mere fleksibel og åben platformen er, jo mere succes venter den på markedet. Hvor er alle de "sejl", "galakser" og "kulrame"? Jeg kontaktede dog udvikleren og fandt ud af hans umiddelbare planer. Først og fremmest vil brugerdefinerbare knapper og indikatorer blive implementeret. Dette arbejde skulle være færdigt, når artiklen udkommer, og så bliver det turen til at tilføje nye tavler til det almindelige bibliotek. Jeg håber, at indbygget understøttelse af ESP8266 til Arduino vises i biblioteket.

Generelt gjorde Virtuino et meget positivt indtryk på mig, først og fremmest ved, at der er en mulighed for ikke at bruge en mellemserver. Men en persons begrænsede ressourcer tillader ikke at implementere alle ideer på én gang, f.eks. tilføje en engelsk version af webstedet eller oprette en universel version af dit bibliotek, og samtidig lægge det på GitHub. Vi ser frem til videre udvikling og nyheder fra Illias.

konklusioner

Jeg er meget tilfreds med det faktum, at implementeringer af reel konvergens af mobile enheder og enheder fra IoT-verdenen er begyndt at dukke op. Indtil vi har muligheden for nemt at kommunikere med vores enheder, hvis det er muligt gennem en enkelt eller universel grænseflade, vil den samlede march af IoT rundt om planeten ikke blive observeret. En person er sådan et udyr, der er for doven til at vænne sig til noget nyt, og tilstedeværelsen af ​​et dusin forskellige grænseflader til styring af IoT-enheder vil forårsage endeløs eksistentiel smerte i slutbrugerens led.

Man skal selvfølgelig ikke regne med total ensretning. Kan du huske historien om smarte hjem? Hvornår sluttede hele højkonjunkturen? Og alt sammen på grund af systemernes inkompatibilitet med hinanden og manglen på en klar, samlet standard. En lignende risiko eksisterer med IoT. I princippet klarede vi os på en eller anden måde uden smarte stik, køleskabe og vaskemaskiner, og tilføjelse af nye "smarte" funktioner tilføjer ikke meget værdi til enheder. Derfor vil vi nøje overvåge brygningskampen, det er muligt, at en af ​​ovenstående metoder til kommunikation mellem en person og en enhed vil vinde foran vores øjne. Lad os se, lad os se.

Programmering af en række mikrocontrollere og mikrocomputere, såsom Arduino, Raspberry Pi og lignende, er en af ​​de mest interessante og relevante aktiviteter. Design af enheder på disse platforme er gået ud over hobbyen for nørder og professionelle programmører: Disse boards bruges til at bygge robotter, værktøjsmaskiner, quadcoptere, IoT-enheder (smart home), servere og endda Hi-Fi-lydgrænseflader.

Desværre er mikrocontrollermarkedet meget segmenteret. Deres programmering udføres gennem forskellige miljøer og grænseflader. Situationen kaldes for at redde projektet kaldet Blynk.

Blynk er en cloud-baseret tjeneste til at skabe grafiske kontrolpaneler og er velegnet til en lang række mikrocomputere og mikrocontrollere. Hvor det tidligere var nødvendigt at skrive et fuldgyldigt I/O-interface eller købe yderligere moduler for at indsamle information fra sensorer, kan du nu klare dig med fem minutters arbejde i Blynk.

For at oprette dit eget projekt, der styres gennem Blynk, behøver du meget lidt: installer applikationen (versioner til iOS og Android er tilgængelige) eller brug webformularen. Her skal du registrere dig i ét trin - indtast din e-mail og adgangskode. Registrering er nødvendig, da Blynk er en cloud-løsning, og uden den kan enhver bruger få kontrol over jernstykket.

De, der ønsker det, kan installere serveren lokalt. I dette tilfælde er internetadgang ikke nødvendig.

Betjening af applikationen vil kræve visse færdigheder. Først skal du forbinde en computer eller smartphone med et programmerbart kort. Programmet understøtter forbindelse med tavlerne gennem en række grænseflader:

• USB (seriel)
• Adafruit CC3000 WiFi,
• Officielt Arduino WiFi Shield,
• Officielt Ethernet Shield (W5100),
• ENC28J60,
• ESP8266 (WiFi-modem),
• SeeedStudio Ethernet Shield V2.0 (W5200),
• RN-XV WiFi,
• ESP8266.

Ud over at oprette forbindelsen behøver du kun at tilslutte modulerne på den fremtidige enhed korrekt. Derefter skal du i applikationens arbejdsform tilføje tilgængelige moduler (widgets), konfigurere de nødvendige outputadresser og angive de ønskede parametre (om nødvendigt kan du skrive din egen kode). Drag’n’drop bruges i øvrigt til at lave en widget eller et program. En masse simulatorer af kontrolenheder er tilgængelige til kontrol - kontakter, skydere, skærme, for hver af dem kan du skrive din egen logik. Der er separate formularer til visning og organisering af information fra de nødvendige sensorer i form af grafer.

Dermed er platformen velegnet til både begyndere og mere avancerede brugere, der ikke ønsker at bruge tid på at skrive projektledelsesapplikationer: fra at læse data fra en vejrstation og styre et smart hjem til at styre robotter.

Al den information, du behøver for at komme i gang, er tilgængelig på den officielle hjemmeside. Blynk er , så alle kan være med til at skabe nye funktioner. I øjeblikket er brugen af ​​tjenesten helt gratis, i fremtiden vil situationen ændre sig noget - primært på grund af indtægtsgenerering af nye funktioner. Så det er allerede kendt, at adgang til GPIO-grænseflader vil blive købt som et køb i appen.

Blynk arbejder i øjeblikket med følgende bestyrelser:

• Arduino: Uno, Nano, Mini, Pro Mini, Pro Micro, Mega, YÚN (Bridge), Due;
• Raspberry Pi;
• Partikel (ex Spark Core);
• ESP8266;
• TinyDuino (CC3000);
• Wicked WildFire (CC3000).

• 220 ohm modstand

Kredsløb

Dette eksempel bruger den indbyggede LED, som de fleste Arduino og Genuino boards har. Denne LED er forbundet til en digital pin, og dens antal kan variere fra korttype til korttype. For at gøre dit liv lettere, har vi en konstant, der er specificeret i hver bestyrelsesbeskrivelsesfil. Denne konstant er LED_BUILTIN og giver dig mulighed for nemt at styre den indbyggede LED. Her er overensstemmelsen mellem konstanten og den digitale pin.

• D13-101
• D13- Forfald
• D1-Gemma
• D13 - Intel Edison
• D13 - Intel Galileo Gen2
• D13 - Leonardo og Micro
• D13 - LilyPad
• D13 - LilyPad USB
• D13-MEGA2560
• D13 - Mini
• D6-MKR1000
• D13-Nano
• D13-Pro
• D13-Pro Mini
• D13- UNO
• D13 - Yun
• D13-Nul

Hvis du vil tænde en ekstern LED med denne skitse, skal du bygge dette kredsløb, hvor du forbinder den ene ende af modstanden til den digitale pin korrespondent til LED_BUILTIN konstant. Forbind LED'ens lange ben (det positive ben, kaldet anoden) til den anden ende af modstanden. Forbind LED'ens korte ben (det negative ben, kaldet katoden) til GND. I diagrammet nedenfor viser vi et UNO-kort, der har D13 som LED_BUILTIN-værdien.

Værdien af ​​modstanden i serie med LED'en kan være af en anden værdi end 220 ohm; LED'en lyser også med værdier op til 1K ohm.

Skematisk

Kode

Når du har bygget kredsløbet, skal du tilslutte dit Arduino- eller Genuino-kort til din computer, starte Arduino-softwaren (IDE) og indtaste koden nedenfor. Du kan også indlæse den fra menuen Fil/Eksempler/01.Grundlæggende/Blink . Den første ting du gør er at initialisere LED_BUILTIN pin som en output pin med linjen

pinMode(LED_BUILTIN, OUTPUT);

I hovedsløjfen tænder du LED'en med linjen:

digitalWrite(LED_BUILTIN, HIGH);

Denne leverer 5 volt til LED-anoden. Det skaber en spændingsforskel over LED'ens ben og lyser den op. Så slår du den fra med linjen:

digitalWrite(LED_BUILTIN, LOW);

Det tager LED_BUILTIN-stiften tilbage til 0 volt og slukker LED'en. Mellem tænd og sluk vil du have tid nok til, at en person kan se ændringen, så delay()-kommandoerne fortæller bestyrelsen, at den ikke skal gøre noget i 1000 millisekunder eller et sekund. Når du bruger delay()-kommandoen, sker der ikke andet i det tidsrum. Når du har forstået de grundlæggende eksempler, kan du tjekke eksemplet for at lære, hvordan du opretter en forsinkelse, mens du gør andre ting.

Når du har forstået dette eksempel, så tjek eksemplet for at lære, hvordan du læser en switch, der er tilsluttet kortet.

Så lad os begynde at lære. Den første lektion vil ikke kræve noget materiale fra dig og er simpelthen designet til at introducere dig til enkelheden ved ARDUINO. Som med de fleste programmer begynder introduktionen med "Hello World!" så vi starter med det enkleste - blinkende LED. Hvad du skal bruge til dette: selve ARDUINO-kortet, et USB-kabel til at forbinde ARDUINO til en computer, ARDUINO-programmeringsskallen. Shells udgives nye, men version 1.0.6 er anerkendt som den mest stabile. Hent du kan på officiel hjemmeside. Dette er Windows-versionen, download til Linux. Det er værd at forstå med det samme, at for at fortsætte med at studere, skal du bruge et brødbræt (bestil i Kina eller køb i en onlinebutik), ledninger (du kan købe samme sted eller finde gamle systemenheder og trække ledningerne ud til frontpanelet, før selv USB på frontpanelet blev forbundet med enkelte ledninger og ikke et helt stik, er det dem der vil passe dig - træk ledningen ud, lod stifterne fra stikkene på kortet til den anden ende , så sæt et lille stykke varmekrympeslange på loddepunktet, så ledningen ikke knækker ved loddepunktet, varm op og du har en færdig wire mom (stik med hul) - han (stift fra brættet).

Hjemmelavede ledninger til ARDUINO

På samme måde skal du lave han-han-ledninger, de er nyttige til at tænde for brødbrættet og forbinde ARDUINO til brødbrættet. Forresten er det muligt, endda nødvendigt, at lave sådanne ledninger i form af en løkke - det er meget mere praktisk at forbinde ARDUINO med blokke) og de blokke, som du vil arbejde med (også købt i Kina eller online butikker). Udvalget af sensorer og aktuatorer er enormt og begrænser ikke din fantasi. Men i første omgang vil en temperatursensor være nok Dallas, indikator (du kan selvfølgelig også have 7-segment LED'er, men de bruger en strøm flere gange større end 1602, og dette vil negativt påvirke, når de drives af batterier og batterier, og de viser kun digital information), relæ Alt hvad du har brug for, kan du altid købe. For dem, der ikke er begrænset af midler, er det bedre straks at købe et sæt. Selvom det er lidt dyrt, kasserer det straks alle problemer med at anskaffe sensorer, og du vil være i stand til at fremstille enheder med det samme. Valget vil stadig være dit. Okay, taler, tættere på emnet.

Vi forbinder ARDUINO til computeren, kører programmet, i programmet går vi til Service-Pay-vælg dit bord, det er alt-du kan arbejde!

En kinesisk klon kan i øvrigt samles på en chip ch340 og din computer kræver en driver til USB-porten. For at installere skal du downloade driveren, pakke ud og, når du bliver bedt om driveren, peg på mappen med de udpakkede filer.

Gør følgende uden at spilde tid: Fil-Eksempler-Grundlæggende-Blink. Et nyt vindue åbnes

hvor du ser programmet, kan du straks klikke på den anden knap i programpanelet med en pil, programmet vil blive kompileret og overført til ARDUINO, LED'en på tavlen begynder at blinke! 1 sekund tændt, 1 sekund slukket. Overvej selve programmet. Du vil først og fremmest se kommentarerne markeret med /* tekst */ Og //tekst . Den første betyder, at teksten fra skiltet /* op til at underskrive */ er en kommentar, og compileren behandler simpelthen ikke og tager ikke hensyn til disse oplysninger, det er meget praktisk at skrive i sådanne kombinationer beskrivelsen af ​​programmet, dets algoritme, forfatterskab og meget mere. Skilt // kommenterer kun linjen. Desuden kan du skrive dette tegn både i begyndelsen af ​​linjen og efter nogen linjer i programmet, men i intet tilfælde før linjerne i programmet - programmet vil betragte hele linjen som en kommentar.

For eksempel:

digitalWrite(13, HIGH); // tænd for LED'en (HØJ er spændingsniveauet)- højre

// tænd for LED'en (HIGH er spændingsniveauet) digitalWrite(13, HIGH);- ikke rigtigt

Hvis du vil lave en kommentar før operatøren på én linje, så brug kombinationen /* tekst */ , de der. linjen vil se sådan ud: /* tænd for LED'en (HIGH er spændingsniveauet) */ digitalWrite(13, HIGH);

Prøv at kommentere dine handlinger så ofte som muligt, compileren skærer dem ud af programmet, og over tid vil du simpelthen glemme, hvad og hvordan du gjorde.

Den næste ting du vil se er følgende tekst:

// opsætningsfunktionen kører én gang, når du trykker på reset eller tænder for kortet
ugyldig opsætning()(
// initialiser digital pin 13 som et output.
pinMode(13, OUTPUT);
}

Kommentaren siger, at opsætningsfunktionen kun kaldes én gang, når du nulstiller eller tænder for ARDUINO igen. De der. enten tryk på reset-knappen på selve kortet eller tilslut strømmen igen.

Så kommer operatøren void setup() (….)- start af den faktiske indstillingssektion for denne skitse (dette er navnet på programmet til ARDUINO).

Den næste kommentar siger, at vi definerer ARDUINO pin 13 som et output. Jeg vil minde dig om, at tavlens ben er beskrevet på siden, og så er den 13. udgang digital (hvilket er skrevet i billedteksterne til udgangene) og kan kun tage 2 tilstande - på (samtidigt, en spænding på omkring 5V påføres det), dvs logisk 1 (én), eller slukket (ingen spænding) dvs. boolsk 0 (nul). Ved nul er der stadig en lille spænding på pinden, men de er lave i forhold til den logiske enhed. Derudover er en LED på selve printet forbundet til pin 13 gennem en modstand, det er ham der blinker når programmet køres.

pinMode(13, OUTPUT);- pinMode - oversættes som pin mode, 13 - pin nummer, OUTPUT - output, dvs. linje betyder at ben 13 vil fungere som output, OUTPUT , hvis du skriver INPUT så vil det allerede være en DIGITAL INPUT, dvs. du kan behandle de DIGITALE data, der kommer til denne pin.

Hvis du tilslutter til pin 13 en LED med en 1kΩ modstand i serie, og den anden pin til GND pin, vil LED'en blinke sammen med LED'en på kortet. Hvis den ikke blinker, skal du vende LED'ens polaritet.

Følgende linjer er programmet, der beskriver handlingerne med porten:

// loop-funktionen kører igen og igen for evigt
void loop()(
digitalWrite(13, HIGH); // tænd for LED'en (HØJ er spændingsniveauet)

digitalWrite(13, LAV); // sluk LED'en ved at gøre spændingen LAV
forsinkelse(1000); // vent et øjeblik

void loop() (…)- afsnit af programmet, hvor handlingerne for arbejdet er beskrevet, dataene i denne cyklus kan ændres og behandles i overensstemmelse med betingelserne Kommentaren siger, at den næste cyklus vil blive udført igen og igen altid

digitalWrite(13, HIGH);// tænd for LED'en (HIGH er spændingsniveauet) - digitalWrite - skriv et DIGITALT signal, 13 - pin nummer, HIGH - højt niveau, dvs. logisk enhed (spænding ca. 5V), så en kommentar om, at vi tænder for LED'en med et højt logisk niveau.

forsinkelse(1000);// vent på en sekund-forsinkelse (forsinkelse), vent 1000 millisekunder eller 1 sekund. Den nødvendige operatør, især ved behandling af knaptryk, i dette tilfælde bruges den som en indikation på at vente 1 sekund efter at have tændt for pin 13.

digitalWrite(13, LAV);// sluk LED'en ved at gøre spændingen LAV - ligesom den første linje i cyklussen indikerer, at ben 13 skal skiftes, først nu til LAV niveau - lavt niveau, logisk nul (spænding er ca. 0V).

forsinkelse(1000);// vent et sekund - igen en forsinkelse på 1 sekund, før løkken starter igen.

Prøv at ændre forsinkelsesværdierne, du vil se, at varigheden af ​​tænding og pausen mellem blinkene ændres.

Programmet er enkelt, forståeligt fra første gang, men det har ulemper: forsinkelsesoperatøren får ARDUINO til at vente, indtil den er færdig med sit arbejde, dvs. i dette øjeblik behandler MK ingen data, blot at tale, den venter på udførelsen af ​​operatøren, okay, hvis værdierne er lave, men hvis du hurtigt skal behandle dataene? I 1 sekund kan dataene ændre sig mere end hundrede gange, og MK tager dem ikke i betragtning, den venter på, at programmet kører. For ikke at gå glip af indgående data, kan du bruge følgende skitse. Åbning af skitsen: Fil- Eksempler- Digital- BlinkWithoutDelay. Følgende vindue åbnes:

/* Blink uden forsinkelse

Tænder og slukker en lysemitterende diode (LED) forbundet til en digital
pin, uden at bruge delay()-funktionen. Det betyder, at anden kode
kan køre på samme tid uden at blive afbrudt af LED-koden.

Kredsløbet:
* LED fra tilsluttet ben 13 til jord.
*Bemærk: på de fleste Arduinoer er der allerede en LED på brættet
der er fastgjort til ben 13, så der kræves ingen hardware til dette eksempel.

oprettet 2005
af David A. Mellis
8. februar 2010
af Paul Stoffregen
11. november 2013
af Scott Fitzgerald

Denne eksempelkode er i det offentlige domæne.

http://www.arduino.cc/en/Tutorial/BlinkWithoutDelay
*/

// konstanter vil ikke ændre sig. Bruges her til at angive en pinkode:
const int ledPin = 13; // nummeret på LED-stiften

// Variabler vil ændre sig:
int ledState = LAV; // ledState bruges til at indstille LED'en

// Generelt skal du bruge "unsigned long" for variabler, der holder tid
// Værdien bliver hurtigt for stor til, at en int kan gemme
unsigned long previousMillis = 0; // gemmer sidste gang LED blev opdateret

// konstanter vil ikke ændre sig:
const langt interval = 1000; // interval, hvormed der skal blinke (millisekunder)

ugyldig opsætning()(

pinMode(ledPin, OUTPUT);
}

void loop()
{

// blinker LED'en.

if (currentMillis - forrigeMillis >= interval) (

if (ledState == LAV)
ledState = HØJ;
andet
ledState = LAV;

}
}

Spring alle kommentarer over og gå til linjen:

// konstanter vil ikke ændre sig. Bruges her til at angive en pinkode:
const int ledPin = 13;// nummeret på LED-stiften

Kommentarlinjen siger, at konstanterne ikke skal ændres, det vil sige, at konstanternes navn ikke skal ændres. Men du kan ændre cifferet, der betyder pin-nummeret.

const int ledPin = 13; // nummeret på LED pin-const betyder en konstant, dvs. en konstant værdi, der ikke kan ændres i programmet, int-kort for heltal, betyder en datatype, der kan tage værdier fra -32768 til 32768. Derudover til heltal er der 5 flere typer data. Hvad er forskellen? De adskiller sig i størrelse, dvs. for eksempel kan kun 256 værdier skrives til en bytetypevariabel, forskellen i størrelse er int-2 bytes (bortset fra ARDUINO DUE, INT tager allerede 4 bytes i den, men tager værdier fra -2147483648 til 2147483647), byte, som det er skrevet - 1 byte. I store programmer er det at spare på hukommelsen et meget vigtigt punkt, og forsøg derfor at undgå at bruge mere "tunge" typer, hvor det er muligt, hvis du kan klare dig med "lette" typer. For eksempel ville bytetypen være tilstrækkelig her. 13 passer ind i grænsen mellem 0 og 255, og resten af ​​de digitale ben vil også passe ind i denne datatype. ledPin er navnet på selve konstanten. 13 er værdien af ​​konstanten, fra kommentaren ovenfor er det klart, at denne konstant vil blive brugt til at vælge stiften.

// Variabler vil ændre sig:
int ledState = LAV;// ledState bruges til at indstille LED'en

Kommentaren siger, at variablen vil ændre sig i programmet

int ledState = LAV;// ledState bruges til at indstille LED - erklærer en ledState variabel med en startværdi på LOW (logisk nul) og en kommentar om, at ledState variablen vil blive brugt til LED (ikke vores LED).

// Generelt skal du bruge "unsigned long" for variabler, der holder tid
// Værdien bliver hurtigt for stor til, at en int kan gemme
// gemmer sidste gang LED blev opdateret

Kommentaren siger, at du skal bruge en lang variabel uden fortegn for tiden, den næste linje advarer om, at værdien vil være for stor til, at en int-variabel kan gemme. Usigned long bruges til at gemme NUMBERS og kan gemme værdier fra 0 til 4294967295 i 4 bytes.

unsigned long previousMillis = 0;// vil gemme sidste gang LED blev opdateret - opretter en variabel forrigeMillis af typen unsigned long og tildeler værdien 0, det vil gemme tidspunktet hvor LED'ens tilstand blev opdateret.

// konstanter vil ikke ændre sig:
const langt interval = 1000;// interval, hvormed der skal blinke (millisekunder)

Også en konstant, af typen lang, er beregnet til at gemme NUMBERS, tager 4 bytes og kan tage værdier fra -2147483648 til 2147483647, interval er navnet på variablen, 1000 er værdien af ​​variablen. Kommentaren siger, at dette vil være blinkintervallet i millisekunder.

ugyldig opsætning()(
// sæt den digitale pin som output:
pinMode(ledPin, OUTPUT);
}

Funktionen er kendt fra det foregående eksempel, kun her er stiften angivet ikke eksplicit, men gennem en variabel ledPin, som af os beskrives som en konstant og har en værdi på 13. Det vil sige, at dette svarer til, at hvis det var skrevet pinMode(13, OUTPUT);

Nå, selve programmets krop:

void loop()
{
// her er hvor du vil sætte kode, der skal køre hele tiden.

// tjek for at se, om det er tid til at blinke LED'en; det vil sige, hvis
// forskel mellem det aktuelle klokkeslæt og sidste gang du blinkede
// LED'en er større end det interval, du ønsker
// blinker LED'en.

Her beskriver kommentarerne, hvordan programmet fungerer. Du kunne forresten bruge kombinationen /*tekst*/ i stedet for at skrive på hver linje // . Der står her, at når forskellen mellem den nuværende og sidste gang, hvor LED'en blinkede, er mere end det angivne interval, så skal du tænde LED'en igen.

usigneret lang strømMillis = millis();

Den aktuelle Millis-variabel af typen unsigned long erklæres, som gemmer operatørdataene millis(). millis()- den interne operatør af MK angiver, hvor mange millisekunder ARDUINO har arbejdet.

if (currentMillis - forrigeMillis >= interval) (
// gem den sidste gang du blinkede LED'en
forrigeMillis = nuværendeMillis;

Vi kom til regnestykket. Nu er der en vidunderlig hvis tilstand operatør (hvis) - som har været brugt, bliver brugt og vil blive brugt i meget lang tid. Lad os overveje det mere detaljeret. Tilstandsstrukturen ser således ud:

if (tilstand==værdi)(

Handling, hvis betingelsen er opfyldt

andet(

Handling, hvis betingelsen ikke er opfyldt

== tegnet kan ændres til et hvilket som helst andet > tegn,<,>=, <=, != (не равно). Условие как и значение может высчитываться. Если условие не выполнено то программа переходит в секцию else. Довольно часто секцию else не используют а просто пишут программу дальше. Это уже зависит от алгоритма работы программы и должно быть продумано заранее. Условий может быть сколько угодно и они могу быть вложены друг в друга, т.е. пока не выполнится одно условие- другое даже выполняться не начнет.

Så if-sætningen trækker den foregående værdi fra de aktuelle millisekunder og sammenligner den med intervalvariablen. Hvis værdien er mindre, forlader programmet betingelsen og starter forfra, hvis den er større end eller lig med, tildeles den forrige Millis-variabel den aktuelle Millis-værdi, og programmet går til næste trin:

// hvis LED'en er slukket, tænd den og omvendt:
if (ledState == LAV)
ledState = HØJ;
andet
ledState = LAV;

I dette afsnit finder man ud af, hvilken tilstand LED'en har, hvis LOW blev anvendt på LED'en, så tildeles ledState-variablen værdien HIGH, og omvendt (sektion else), hvis der var et højt niveau HIGH, så ledState variabel tildeles værdien LAV. Bemærk, at hvis bruges her uden (). Dette er tilladt, hvis du ikke skal behandle mere end 1 linje i udførelsessektionen.

// indstil LED'en med LEDState for variablen:
digitalWrite(ledPin, ledState);

Og til sidst skriver vi til værdien af ​​variablen ledPin (den var lig med 13), værdien af ​​variablen ledState. De der. denne streng kan skrives som digitalWrite(13, LOW); eller digitalWrite(13, HIGH); afhængig af MC'ens driftstid. Vær opmærksom på, at digitalWrite-operatøren bruges - det er ham, der angiver, at værdien skal videregives i et logisk format, dvs. nul eller en. Det kan ikke antage flere værdier. Alle andre ledState-værdier vil automatisk blive sat til boolesk 1.

}
}

Her er arbejdet med det andet program. Hvad er forskellen mellem det første og andet program, hvis de udfører den samme handling, men det andet er skrevet 5 gange flere linjer? Som sagt venter det første program simpelthen på, at forsinkelsesoperatøren afslutter sit arbejde og fortsætter først derefter med at arbejde. Under forsinkelsen vil du ikke være i stand til at behandle nogen data. Det andet program giver dig mulighed for at modtage, behandle og sende data, mens LED'en blinker. Bare tilføj den nødvendige kode til loop-sektionen og nyd arbejdet! Min ven og jeg beregnede, at koden køres i det andet tilfælde omkring 4 millioner gange i sekundet, så der er praktisk talt ingen forsinkelser.

Nå, nu er det vigtigste. Efter nogen tid, efter at have spillet nok, vil du sige: "Hvad er meningen med at blinke en pære ... Hvor kan jeg bruge den? Kun en indikator på, at enheden virker ... "Du vil ikke have helt ret. Du har et værktøj, hvad du kan gøre med det er kun din skyld, hvis du ikke kan komme i tanke om noget. Det er som at give enhver person et komplet sæt værktøj og bede dem om at gøre noget, for eksempel at give et sæt tømrerværktøj til en mand, nogen vil planlægge det samme bræt hele sit liv og undre sig over den renhed, hvormed flyet flyver og forsøger at slibe jernstykket så skarpt som muligt, og nogen vil så lave møbler af høj kvalitet på netop dette tidspunkt. Hvem du vil bestemme er op til dig. Et andet råd, jeg læste et sted, som jeg ikke engang husker, er "SØG IKKE EFTER PROBLEMER, SØG EFTER DERES LØSNINGER!" Hvis du bruger denne tilgang, vil du have meget mindre HVORDAN og HVORFOR. Nå, nu om den blinkende LED. Der er en masse tips på internettet til hvordan man bruger forskellige indikatorer, selvfølgelig er det smukt, det giver en vis betydning for forfatteren osv... men det rører ved det vigtigste - at spare pins og hukommelse. For at tilslutte indikatoren 1602 skal du tage 6 digitale ben + 2 strømledninger! Dette er, hvis du ikke bruger I2C-protokollen. Derudover tager biblioteket på LCD'en 4kB. Og ingen tænker på yderligere funktionalitet, ja, de legede med indikatoren, og det er alt, de har også opgivet det. Sikkert ingen undrede sig over, at det er muligt at modtage al den nødvendige information med en LED? For eksempel fejl. Skriv en funktion og send en fejlkode til den. Dette er praktisk - du behøver ikke at adskille koden igen, men bare se, hvad der ikke fungerer på den måde. Eller min ven har for eksempel samlet en gaskedelregulator på ARDUINO mini, dvs. i henhold til temperaturen i huset (registreret af Dallas-sensoren), blev cirkulationspumpen tændt/slukket. Da pumpen blev slukket, varmede kedlen op til 40 ° C og stod på tænderen, temperaturen i rummet faldt - pumpen tændte, og når kølevæsken kølede ned, tændte kedlen sig selv. Meget praktisk, og der var en betydelig gasbesparelse! I alt sparede han for omkring 200-300 rubler adskillige kubikmeter gas hver dag! Så blev han ved med at tænke - hvordan man sporer temperaturen i rummet uden at forbinde nogen WiFi og computere, foreslog jeg - lad LED'en blinke lige så mange gange, som der er grader i rummet ... De grinede selvfølgelig - du kan lave en fejl tæller 20-25 gange, så foreslog jeg - lad det blinke først ti grader og efter en pause - enheder, for eksempel 24 grader, blinkede først 2 gange, efter en pause yderligere 4. Alt! Ikke flere indikatorer! Og det kan anvendes i ethvert område! Se efter ikke-standardiserede tilgange og prøv at spare energi og input. Også selvom du bruger I2C. Held og lykke til alle med at mestre MK og i særdeleshed ARDUINO.