Visuele programmering van Arduino in het Russisch. Arduino-programmering

Je hebt dus een processor. U begrijpt waarschijnlijk dat de processor op de een of andere manier kan worden geprogrammeerd om te doen wat u wilt. Om nuttig werk te kunnen doen, is het noodzakelijk om (a) een nuttig programma te schrijven en (b) dit ter uitvoering aan de processor te geven.

Over het algemeen maakt het niet uit wat voor processor je hebt: de nieuwste Intel Pentium in je laptop of een microcontroller op een Arduino-bord. Principes van het schrijven van een programma, d.w.z. programmering, in beide gevallen hetzelfde. Het enige verschil is de snelheid en reikwijdte van de mogelijkheden voor het werken met andere apparaten.

Wat is een programma en waar schrijf je het?

De processor is, ondanks alle complexiteit van de productie, in wezen een vrij eenvoudig en duidelijk ding. Hij weet niet hoe hij moet denken. Hij kan alleen blindelings, byte voor byte, de instructies uitvoeren die hem zijn overhandigd. Een ruw voorbeeld van de volgorde van instructies kan worden gegeven:

Als gevolg van het uitvoeren van deze reeks instructies wordt de paniekerige zin “AAAH!” weergegeven op het scherm.

Heel veel code voor zo'n eenvoudig doel! Het is duidelijk dat als alle programma's rechtstreeks op deze manier zouden worden geschreven, de ontwikkeling van complexe producten eeuwen zou duren.

Waarom zijn programmeertalen nodig?

Om de taak een miljoen keer te vereenvoudigen, werden programmeertalen uitgevonden. Er zijn er veel, en zelfs van degenen die constant worden gehoord, kun je er snel een tiental of twee onthouden: Assembler, C, C++, C#, Java, Python, Ruby, PHP, Scala, JavaScript.

Programma's in deze talen staan ​​veel dichter bij de natuurlijke menselijke taal. En daarom zijn ze gemakkelijker, sneller en prettiger om te schrijven, en vooral: ze zijn veel eenvoudiger lezen: aan jou direct na het schrijven, aan jou een jaar later, of aan je collega.

Het probleem is dat dergelijke talen niet begrijpelijk zijn voor de processor en voordat je hem dit programma geeft, moet je dat doen compileren: vertalen vanuit natuurlijke taal naar dezelfde instructies in de vorm van nullen en enen. Dit wordt gedaan door programma's genaamd compilers. Elke taal heeft, tenzij deze op fantasieniveau blijft, zijn eigen compiler. Voor populaire talen zijn er meestal meerdere talen om uit te kiezen, van verschillende fabrikanten en voor verschillende platforms. De meeste ervan zijn gratis beschikbaar op internet.

Er zijn dus programma's in een taal die voor mensen volkomen begrijpelijk is: ze worden ook wel ‘broncode’ genoemd, simpelweg ‘code’ of ‘broncodes’. Ze worden naar eenvoudige tekstbestanden geschreven met behulp van elk teksteditor, zelfs met Kladblok. Vervolgens worden ze omgezet in sets van nullen en enen die begrijpelijk zijn voor de processor die de compiler gebruikt: de compiler ontvangt de broncode als invoer en creëert binair uitvoerbaar, degene die begrijpelijk is voor de processor.

Binaire bestanden zijn niet leesbaar en zijn doorgaans alleen bedoeld voor uitvoering door de processor. Ze kunnen van verschillende typen zijn, afhankelijk van waarvoor ze zijn ontvangen: .exe zijn programma's voor Windows, .hex zijn programma's voor uitvoering door een microcontroller van het Arduino-type, enz.

Waarom zijn er zoveel programmeertalen en wat is het verschil?

Waarom? Omdat er veel mensen en bedrijven op aarde zijn, en velen geloofden dat zij het beste konden: handiger, duidelijker, sneller, slanker.

Wat is het verschil: verschillende talen hebben een andere balans tussen schrijfsnelheid, leesbaarheid en uitvoeringssnelheid.

Laten we eens kijken naar hetzelfde programma dat een liedje over 99 flessen bier op het scherm weergeeft in verschillende programmeertalen.

Bijvoorbeeld de Perl-taal. Het is snel geschreven; het is onmogelijk om te begrijpen wat de programmeur bedoelde; langzaam uitgevoerd:

\n\n"

"" : "S" ;

, 13 , 10 , "$" line2_3 db "flessen bier," 13 , 10 ,

'Neem er één mee en geef hem door,'

Daarom hebben we een taal nodig die efficiënt kan compileren en uitvoeren. Dat wil zeggen, het wordt zo optimaal mogelijk vertaald in die nullen en enen uit instructies, zonder kostbare instructies en geheugen te verspillen. De bovengenoemde talen hebben dit soort efficiëntie. Door ze zelfs binnen de beperkte grenzen van de microcontrollerbronnen te gebruiken, kun je programma's met veel functies schrijven die snel werken.

Assembler kan, zoals je hebt gezien, niet de eenvoudigste en meest elegante worden genoemd en als gevolg daarvan is C/C++ de vlaggenschiptaal voor Arduino.

Veel bronnen zeggen dat Arduino is geprogrammeerd in de taal Arduino, Processing, Wiring. Dit is niet een geheel correcte uitspraak. Arduino is geprogrammeerd in C/C++, en wat in deze woorden wordt genoemd is slechts een handige “bodykit” waarmee je veel voorkomende problemen kunt oplossen zonder elke keer het wiel opnieuw uit te vinden.

Waarom worden C en C++ in dezelfde zin genoemd? C++ is een bovenbouw van C. Elk C-programma is een geldig C++-programma, maar niet andersom. Je kunt beide gebruiken. Meestal zul je niet eens nadenken over wat je gebruikt bij het oplossen van het huidige probleem.

Dichter bij het punt: het eerste programma

Laten we het eerste programma voor Arduino schrijven en het bord het laten uitvoeren. U moet een tekstbestand maken met de broncode, dit compileren en het resulterende binaire bestand naar de microcontroller op het bord sturen.

Laten we in volgorde gaan. Laten we de broncode schrijven. U kunt het in Kladblok of een andere editor schrijven. Om het werk echter gemakkelijker te maken, zijn er zogenaamde ontwikkelomgevingen (IDE: Integrated Development Environment). In de vorm van één enkele tool bieden ze een teksteditor met accenten en hints, een compiler die met een knop wordt gestart, en vele andere geneugten. Voor Arduino wordt deze omgeving Arduino IDE genoemd. Het is gratis te downloaden op de officiële website.

Installeer de omgeving en voer deze uit. In het venster dat verschijnt, zie je: de meeste ruimte wordt gegeven aan de teksteditor. De code wordt erin geschreven. Code wordt in de Arduino-wereld ook wel genoemd schetsen.

Laten we dus een schets schrijven die niets doet. Dat wil zeggen, het minimaal mogelijke correcte programma in C++, dat simpelweg tijd verspilt.

Laten we ons voorlopig niet concentreren op de betekenis van de geschreven code. Laten we het compileren. Om dit te doen, is er in de Arduino IDE een knop "Verifiëren" op de werkbalk. Klik erop en binnen een paar seconden is het binaire bestand klaar. Dit wordt aangekondigd door de inscriptie "Klaar met compileren" onder de teksteditor.

Als resultaat hebben we een binair bestand met de extensie .hex, dat door de microcontroller kan worden uitgevoerd.

Nu moet je het in de Arduino stoppen. Dit proces wordt opstarten, flashen of flooden genoemd. Om te uploaden naar de Arduino IDE is er een knop "Uploaden" op de werkbalk. Sluit de Arduino via een USB-kabel aan op uw computer, klik op “Uploaden” en binnen enkele ogenblikken wordt het programma naar de Arduino geüpload. In dit geval wordt het programma dat er eerder was, gewist.

Het bericht “Done Uploading” geeft een succesvolle firmware-installatie aan.

Als u een fout tegenkomt tijdens het downloaden, zorg er dan voor dat:

Selecteer in het menu Extra → Bord de poort waarop de Arduino daadwerkelijk is aangesloten. Je kunt de USB-kabel erin en eruit steken om te zien welke poort verschijnt en verdwijnt: dit is de Arduino.

U hebt de benodigde stuurprogramma's voor Arduino geïnstalleerd. Dit is vereist op Windows, niet vereist op Linux, en alleen vereist op oudere pre-Arduino Duemilanove-borden op MacOS.

Gefeliciteerd! Je bent helemaal van een blanco lei naar een werkend programma in Arduino gegaan. Ze doet misschien niets, maar dit is al een succes.

Dit artikel helpt u op weg met Arduino en bevat een beschrijving van de verschillende typen Arduino, hoe u de Arduino-softwareontwikkelomgeving kunt downloaden en beschrijft de verschillende boards en accessoires die voor Arduino beschikbaar zijn en die u nodig hebt om Arduino-projecten te ontwikkelen.

Arduino is een open source single board-controller die in veel verschillende toepassingen kan worden gebruikt. Dit is misschien wel de eenvoudigste en goedkoopste microcontrolleroptie voor hobbyisten, studenten en professionals om op microcontrollers gebaseerde projecten te ontwikkelen. Arduino-borden gebruiken een Atmel AVR-microcontroller of een Atmel ARM-microcontroller, en sommige versies hebben een USB-interface. Ze hebben ook zes of meer analoge invoerpinnen en veertien of meer digitale invoer/uitvoer (I/O) pinnen, die worden gebruikt om sensoren, actuatoren en andere randcircuits op de microcontroller aan te sluiten. De prijs van Arduino-boards varieert, afhankelijk van de reeks functies, van zes tot veertig dollar.

Soorten Arduino-borden

Er zijn veel verschillende soorten Arduino-borden, zoals weergegeven in de onderstaande lijst, elk met hun eigen functies. Ze verschillen qua verwerkingssnelheid, geheugen, I/O-poorten en connectiviteit, maar de kernfunctionaliteit blijft hetzelfde.

• Arduino-robot
• Arduino-Ethernet

Je kunt de verscheidenheid aan Arduino-borden en hun technische beschrijvingen bekijken in de subsectie "" van de sectie "Kopen" van deze site.

Software (IDE)

De software die wordt gebruikt om de Arduino te programmeren is de Arduino IDE. De IDE is een Java-applicatie die op veel verschillende platforms draait, waaronder pc-, Mac- en Linux-systemen. Het is ontworpen voor beginners die niet bekend zijn met programmeren. Het bevat een editor, compiler en lader. De IDE bevat ook codebibliotheken voor het gebruik van randapparatuur zoals seriële poorten en verschillende soorten beeldschermen. Arduino-programma's worden "sketches" genoemd en zijn geschreven in een taal die sterk lijkt op C of C++.

De meeste Arduino-borden worden via een USB-kabel op een computer aangesloten. Met deze verbinding kun je schetsen uploaden naar je Arduino-bord en wordt het bord ook van stroom voorzien.

USB-kabel voor Arduino

Programmering

Programmeren met Arduino is eenvoudig: u gebruikt eerst de code-editor van de IDE om een ​​programma te schrijven, compileert en uploadt het vervolgens met één klik.

Het Arduino-programma bevat twee hoofdfuncties:

• instellen()
• lus()

U kunt de functie setup() gebruiken om de bordinstellingen te initialiseren. Deze functie wordt slechts één keer uitgevoerd, wanneer het bord is ingeschakeld.

De functie loop() wordt uitgevoerd nadat de functie setup() is voltooid, en in tegenstelling tot de functie setup() wordt deze continu uitgevoerd.

Programma functies

Hieronder vindt u een lijst met de meest gebruikte functies bij het programmeren van Arduino:

• pinMode - stelt de pin in op invoer- of uitvoermodus;
• analogRead - leest de analoge spanning op de analoge ingangspin;
• analogWrite - schrijft een analoge spanning naar de analoge uitgangspin;
• digitalRead - leest de waarde van de digitale invoerpin;
• digitalWrite - stelt de waarde van de digitale uitgangspin in op hoog of laag;
• Serial.print - schrijft gegevens naar de seriële poort in voor mensen leesbare ASCII-tekst.

Arduino-bibliotheken

Arduino-bibliotheken zijn verzamelingen functies waarmee u apparaten kunt besturen. Hier zijn enkele van de meest gebruikte bibliotheken:

• EEPROM - lezen en schrijven naar “permanente” opslag;
• Ethernet - om verbinding te maken met internet via het Arduino Ethernet Shield-bord;
• Firmata - voor communicatie met applicaties op een computer met behulp van een standaard serieel protocol;
• GSM - om verbinding te maken met het GSM/GRPS-netwerk met behulp van een GSM-kaart;
• LiquidCrystal - voor het besturen van liquid crystal displays (LCD);
• SD - voor het lezen en schrijven van SD-kaarten;
• Servo - voor het besturen van servo's;
• SPI - voor communicatie met apparaten die de SPI-bus gebruiken;
• SoftwareSerial - voor seriële communicatie via digitale pinnen;
• Stepper - voor het besturen van stappenmotoren;
• TFT - voor het tekenen van tekst, afbeeldingen en vormen op Arduino TFT-schermen;
• WiFi - om verbinding te maken met internet via het Arduino WiFi-schild;
• Draad - tweedraads interface (TWI/I2C) voor het verzenden en ontvangen van gegevens via een netwerk van apparaten of sensoren.

Arduino-installatiestappen

Opmerking: Mogelijk moet u stuurprogramma's installeren als uw systeem de Arduino niet detecteert.

De programmeertaal Arduino voor beginners wordt in de onderstaande tabel gedetailleerd weergegeven. De Arduino-microcontroller is geprogrammeerd in een speciale programmeertaal op basis van C/C++. De programmeertaal Arduino is een variant van C++, oftewel er is geen aparte programmeertaal voor Arduino. U kunt het PDF-boek aan het einde van de pagina downloaden.

In de Arduino IDE worden alle geschreven schetsen met minimale wijzigingen in een programma in C/C++ gecompileerd. De Arduino IDE-compiler vereenvoudigt het schrijven van programma's voor dit platform aanzienlijk en het maken van apparaten op Arduino wordt veel toegankelijker voor mensen die geen uitgebreide kennis van de C/C++-taal hebben. Hieronder geven we een korte referentie waarin de belangrijkste functies van de Arduino-taal worden beschreven met voorbeelden.

Gedetailleerde verwijzing naar de Arduino-taal

De taal kan worden onderverdeeld in vier secties: instructies, gegevens, functies en bibliotheken.

Waaruit bestaat het programma?

Om te beginnen is het de moeite waard om te begrijpen dat een programma niet kan worden gelezen en geschreven als een boek: van kaft tot kaft, van boven naar beneden, regel voor regel. Elk programma bestaat uit afzonderlijke blokken. Het begin van een codeblok in C/C++ wordt aangegeven door een accolade links ( en het einde door een accolade rechts).

Er zijn verschillende soorten blokken, en welke wordt uitgevoerd wanneer hangt af van externe omstandigheden. In het minimale programmavoorbeeld zie je 2 blokken. In dit voorbeeld worden de blokken aangeroepen het definiëren van een functie. Een functie is eenvoudigweg een codeblok met een bepaalde naam dat iemand vervolgens van buitenaf kan gebruiken.

In dit geval hebben we twee functies genaamd setup en loop. Hun aanwezigheid is verplicht in elk C++-programma voor Arduino. Ze mogen niets doen, zoals in ons geval, maar ze moeten wel geschreven worden. Anders krijgt u een foutmelding tijdens de compilatiefase.

Klassieker van het genre: knipperende LED

Laten we ons programma nu aanvullen, zodat er in ieder geval iets gebeurt. Op Arduino is een LED aangesloten op pin 13. Het kan worden gecontroleerd, en dat is wat we zullen doen.

Compileer en download het programma. Je zult zien dat de LED op het bord elke seconde knippert. Laten we uitzoeken waarom deze code elke seconde tot knipperen leidt.

Elke expressie is een opdracht aan de processor om iets te doen. Expressies binnen één blok worden na elkaar uitgevoerd, in strikte volgorde, zonder pauzes of wisselingen. Dat wil zeggen, als we het over één specifiek codeblok hebben, kan dit van boven naar beneden worden gelezen om te begrijpen wat er wordt gedaan.

Laten we nu begrijpen in welke volgorde de blokken zelf worden uitgevoerd, d.w.z. setup- en lusfuncties. Maak je nog geen zorgen over wat specifieke uitdrukkingen betekenen, maar let gewoon op de volgorde.

Zodra de Arduino wordt aangezet, knippert of de RESET-knop wordt ingedrukt, “iets” roept een functie aan opstelling. Dat wil zeggen, het dwingt de expressies erin uit te voeren.

Zodra de installatie is voltooid, roept "iets" onmiddellijk de lusfunctie op.

Zodra de lus is voltooid, roept "iets" de lusfunctie onmiddellijk opnieuw aan, enzovoort tot in het oneindige.

Als we de uitdrukkingen nummeren in volgorde van hoe ze worden uitgevoerd, krijgen we:

Laten we u er nogmaals aan herinneren dat u niet moet proberen het hele programma waar te nemen door van boven naar beneden te lezen. Alleen de inhoud van de blokken wordt van boven naar beneden gelezen. Over het algemeen kunnen we de volgorde van de setup- en lusdeclaraties wijzigen.

Het resultaat hiervan zal niets veranderen: na compilatie ontvangt u een absoluut gelijkwaardig binair bestand.

Wat expressies doen

Laten we nu proberen te begrijpen waarom het geschreven programma er uiteindelijk voor zorgt dat de LED gaat knipperen.

Zoals je weet kunnen Arduino-pinnen zowel als uitgang als als ingang werken. Als we iets willen besturen, dat wil zeggen een signaal willen afgeven, moeten we de bedieningspin naar de uitgangsstatus schakelen. In ons voorbeeld sturen we de LED op de 13e pin aan, dus van de 13e pin moet voor gebruik een uitgang worden gemaakt.

Dit wordt gedaan door een expressie in de setup-functie:

PinModus(13, UITGANG) ;

Uitdrukkingen kunnen verschillend zijn: rekenkunde, declaraties, definities, conditionals, etc. In dit geval implementeren we in de expressie functie oproep. Herinneren? Wij hebben hun de setup- en loop-functies, die worden aangeroepen door iets dat we "iets" noemden. Dus nu Wij we noemen functies die al ergens zijn geschreven.

Specifiek in onze opstelling noemen we een functie genaamd pinMode. Het stelt de pin gespecificeerd door nummer in op de opgegeven modus: invoer of uitvoer. We geven aan over welke pin en over welke modus we het hebben tussen haakjes, gescheiden door komma's, direct na de functienaam. In ons geval willen we dat de 13e pin als uitvoer fungeert. OUTPUT betekent output, INPUT betekent input.

Kwalificerende waarden zoals 13 en OUTPUT worden aangeroepen functie argumenten. Het is helemaal niet nodig dat alle functies 2 argumenten moeten hebben. Hoeveel argumenten een functie heeft, hangt af van de essentie van de functie en hoe de auteur deze heeft geschreven. Er kunnen functies zijn met één argument, drie, twintig; functies kunnen helemaal geen argumenten hebben. Om ze vervolgens te bellen, wordt het haakje geopend en onmiddellijk gesloten:

GeenInterrupts() ;

Het is je misschien opgevallen dat onze setup- en lusfuncties ook geen argumenten gebruiken. En het mysterieuze ‘iets’ roept ze op dezelfde manier op, met lege haakjes, op het juiste moment.

Laten we terugkeren naar onze code. Dus omdat we van plan zijn de LED voor altijd te laten knipperen, moet de controlepin één keer een uitvoer krijgen en dan willen we er niets meer van onthouden. Dit is waar de setup-functie ideologisch voor bedoeld is: het bord naar behoefte opzetten en er vervolgens mee aan de slag.

Laten we verder gaan met de lusfunctie:

Zoals gezegd wordt het direct na het instellen aangeroepen. En het wordt keer op keer gebeld zodra het eindigt. De lusfunctie wordt de hoofdlus van het programma genoemd en is ideologisch ontworpen om nuttig werk uit te voeren. In ons geval is het nuttige werk het knipperen van de LED.

Laten we de uitdrukkingen in volgorde doornemen. De eerste expressie is dus een aanroep van de ingebouwde functie digitalWrite. Het is ontworpen om een ​​logische nul (LAAG, 0 volt) of een logische nul (HOOG, 5 volt) toe te passen op een bepaalde pin. Er worden twee argumenten doorgegeven aan de digitalWrite-functie: het pinnummer en de logische waarde. Het resultaat is dat het eerste wat we doen de LED op de 13e pin aansteekt en er 5 volt op zet.

Zodra dit is gebeurd, gaat de processor onmiddellijk verder met de volgende uitdrukking. Voor ons is dit een oproep aan de vertragingsfunctie. De vertragingsfunctie is wederom een ​​ingebouwde functie die de processor een bepaalde tijd laat slapen. Er is slechts één argument nodig: de tijd in milliseconden om te slapen. In ons geval is dit 100 ms.

Terwijl we slapen, blijft alles zoals het is, d.w.z. de LED blijft branden. Zodra de 100 ms is verstreken, wordt de processor wakker en gaat onmiddellijk verder met de volgende expressie. In ons voorbeeld is dit opnieuw een aanroep van de bekende ingebouwde digitalWrite-functie. Het is waar dat we deze keer de waarde LAAG als tweede argument doorgeven. Dat wil zeggen, we stellen een logische nul in op de 13e pin, dat wil zeggen dat we 0 volt leveren, dat wil zeggen dat we de LED uitschakelen.

Nadat de LED is gedoofd, gaan we verder met de volgende uitdrukking. Opnieuw is dit een oproep aan de vertragingsfunctie. Deze keer vallen we 900 ms in slaap.

Zodra de slaap voorbij is, wordt de lusfunctie afgesloten. Bij voltooiing roept “iets” onmiddellijk opnieuw en alles gebeurt opnieuw: de LED brandt, licht op, gaat uit, wacht, enz.

Als je vertaalt wat er in het Russisch is geschreven, krijg je het volgende algoritme:

Het verlichten van de LED

Slaap 100 milliseconden

De LED uitschakelen

We slapen 900 milliseconden

Laten we naar punt 1 gaan

Zo kregen we een Arduino met een baken dat elke 100 + 900 ms = 1000 ms = 1 seconde knippert.

Wat kan er veranderd worden

Laten we alleen de kennis gebruiken die we hebben opgedaan om verschillende variaties op het programma te maken om het principe beter te begrijpen.

U kunt een externe LED of ander apparaat dat moet "knipperen" op een andere pin aansluiten. Bijvoorbeeld op de 5e. Hoe moet het programma in dit geval veranderen? We moeten het nummer vervangen door het 5e, waar we ook toegang hadden tot de 13e pin:

Compileren, downloaden, testen.

Wat moet er gedaan worden om de LED 2 keer per seconde te laten knipperen? Verkort de slaaptijd zodat het totaal 500 ms is:

Hoe kan ik ervoor zorgen dat de LED twee keer flikkert telkens wanneer deze knippert? Je moet hem twee keer aansteken met een korte pauze tussen het inschakelen:

Hoe kan ik ervoor zorgen dat het apparaat 2 LED's heeft die elke seconde afwisselend knipperen? Je moet communiceren met twee pinnen en in een lus werken met de een of de ander:

Hoe zorg ik ervoor dat het apparaat 2 LED's heeft die schakelen als een spoorwegverkeerslicht: eerst de ene en dan de andere? U hoeft alleen de brandende LED niet meteen uit te schakelen, maar te wachten tot het moment van schakelen:

Voel je vrij om zelf andere ideeën te bekijken. Zoals je kunt zien, is het eenvoudig!

Over lege ruimte en mooie code

In C++ doen spaties, regeleinden en tabtekens er niet zoveel toe voor de compiler. Waar er een spatie is, kan er een regelbreuk zijn en omgekeerd. In feite zijn 10 spaties op rij, 2 regeleinden en 5 extra spaties het equivalent van één spatie.

Lege ruimte is het gereedschap van een programmeur, waarmee je een programma begrijpelijk en visueel kunt maken, of onherkenbaar kunt vervormen. Onthoud bijvoorbeeld het programma voor het knipperen van een LED:

We kunnen het als volgt veranderen:

Het enige wat we deden was een beetje met de lege ruimte werken. Nu kun je duidelijk het verschil zien tussen harmonieuze code en onleesbare code.

Om de onuitgesproken wet van programmaontwerp te volgen, die op forums wordt gerespecteerd, door andere mensen wordt gelezen en gemakkelijk door u wordt waargenomen, volgt u een paar eenvoudige regels:

1. Vergroot altijd de inspringing tussen ( en ) wanneer u een nieuw blok start. Meestal worden er 2 of 4 spaties gebruikt. Kies een van de waarden en houd je daar de hele tijd aan.

Slecht:

Prima:

2. Net als in natuurlijke taal: plaats een spatie na komma's en niet ervoor.

Slecht:

Digitaal schrijven(5,HOOG) ;

Prima:

digitalWrite(5, HOOG) ;

3. digitalWrite(5,HOOG) ;

Slecht:

Prima:

4. void setup() ( pinMode(5, OUTPUT); ) void setup() ( pinMode(5, OUTPUT); ) void setup() ( pinMode(5, OUTPUT); )

Prima:

void setup() ( pinMode(5, UITVOER); ) void setup() ( pinMode(5, OUTPUT); )

Nog beter:

void loop() ( digitalWrite(5, HOOG) ; vertraging(100 ) ; digitalWrite(5 , LAAG) ; vertraging(900 ) ; digitalWrite(6 , HOOG) ; vertraging(100 ) ; digitalWrite(6 , LAAG) ; vertraging( 900 ); Over puntkomma's Je vraagt ​​je misschien af: waarom staat er een puntkomma aan het einde van elke uitdrukking? Dit zijn de regels van C++. Dergelijke regels worden genoemd

taal syntaxis

Het programma is correct en gelijkwaardig aan wat we al hebben gezien. Dit soort schrijven is echter een slechte vorm. De code is veel moeilijker te lezen. Dus tenzij je een 100% goede reden hebt om meerdere uitdrukkingen op dezelfde regel te schrijven, doe het dan niet.

Over opmerkingen

Een van de regels van goed programmeren is: “schrijf code zo dat deze zo duidelijk is dat deze geen uitleg nodig heeft.” Dit is mogelijk, maar niet altijd. Om enkele niet voor de hand liggende punten in de code aan de lezers uit te leggen: uw collega's of uzelf over een maand, zijn er zogenaamde opmerkingen.

Dit zijn constructies in de programmacode die volledig worden genegeerd door de compiler en alleen betekenis hebben voor de lezer. Opmerkingen kunnen uit meerdere regels of uit één regel bestaan:

) void loop() ( digitalWrite(13, HIGH) ; delay(100) ; // slaap gedurende 100 ms digitalWrite(13, LOW) ; delay(900) ; )

Zoals u kunt zien, kunt u tussen de symbolen /* en */ zoveel commentaarregels schrijven als u wilt. En na de reeks / / wordt alles wat volgt tot het einde van de regel als commentaar beschouwd.

We hopen dus dat de meest fundamentele principes van het schrijven van programma's duidelijk zijn geworden. Met de opgedane kennis kun je de stroomtoevoer naar de Arduino-pinnen programmatisch regelen volgens bepaalde timingschema's. Dit is niet zo veel, maar toch genoeg voor de eerste experimenten.

• Je zult nodig hebben
• Arduino UNO-bord;
• USB-kabel (USB A - USB B);
• personal computer;
• LED;
• een paar verbindingsdraden van 5-10 cm lang;

Arduino-IDE Download de Arduino-ontwikkelomgeving (Arduino IDE) van de officiële website voor uw besturingssysteem (Windows, Mac OS X, Linux worden ondersteund). U kunt het installatieprogramma selecteren ( Installateur ), kunt u archiveren ( ZIP-bestand voor niet-beheerdersinstallatie

). In het tweede geval wordt het programma eenvoudigweg vanuit de map gestart, zonder installatie. Het gedownloade bestand bevat naast de ontwikkelomgeving stuurprogramma's voor borden uit de Arduino-familie.

2 Download de Arduino IDE van de officiële website Arduino-verbinding

naar de computer

3 Kabel "USB-A - USB-B" voor het aansluiten van Arduino op computer Installatie van stuurprogramma

Installeer het stuurprogramma voor Arduino. Overweeg de installatieoptie op het Windows-besturingssysteem. Wacht hiervoor totdat het besturingssysteem u vraagt ​​het stuurprogramma te installeren. Afwijzen. Druk op de toetsen Winnen+Pauze, loop apparaatbeheer. Zoek een sectie "Poorten (COM en LPT)". Je ziet daar een poort met de naam Arduino UNO (COMxx). Klik er met de rechtermuisknop op en selecteer Stuurprogramma bijwerken. Vertel het besturingssysteem de locatie van het stuurprogramma. Het bevindt zich in de submap chauffeurs in de map die we zojuist hebben gedownload.

Let op de poort waarop het Arduino-bord is aangesloten. Om het poortnummer te achterhalen, start u Apparaatbeheer en zoekt u naar het gedeelte 'Poorten (COM en LPT)'. Het poortnummer wordt tussen haakjes achter de bordnaam aangegeven. Als het bord niet in de lijst staat, koppel het dan los van de computer, wacht een paar seconden en sluit het vervolgens opnieuw aan.

4 Instellingen indien beschikbaar - broodplank.

Wijs uw ontwikkelomgeving naar uw bord. Om dit in het menu te doen Gereedschapsbord selecteren Arduino UNO.

Geef het COM-poortnummer op waarop het Arduino-bord is aangesloten: Gereedschapspoort.

5 Open het voorbeeld programma's

De ontwikkelomgeving bevat al veel voorbeeldprogramma's om de werking van het bord te bestuderen. Open het voorbeeld "Blink": Bestandsvoorbeelden 01.Basisbeginselen Knipperen.Programma's voor Arduino worden trouwens "sketches" genoemd.

6 Circuitmontage met LED

Koppel de Arduino los van de computer. Monteer het circuit zoals weergegeven in de afbeelding. Houd er rekening mee dat het korte been van de LED moet worden aangesloten op de GND-pin, het lange been op de digitale pin “13” van het Arduino-bord. Het is handig om een ​​breadboard te gebruiken, maar als je die niet hebt, sluit je de draden met een draai aan.

Digitale pin "13" heeft een ingebouwde weerstand op het bord. Daarom is het bij het aansluiten van een LED op het bord niet nodig om een ​​externe stroombegrenzende weerstand te gebruiken. Wanneer u een LED op andere Arduino-pinnen aansluit, is het noodzakelijk om een ​​weerstand te gebruiken, anders verbrandt u de LED, en in het ergste geval de Arduino-poort waarop de LED is aangesloten!

Nu kunt u het programma in het geheugen van het bord laden. Sluit het bord aan op de computer, wacht een paar seconden terwijl het bord initialiseert. Klik op de knop Downloaden en je schets wordt naar het geheugen van het Arduino-bord geschreven. De LED zou elke 2 seconden vrolijk naar je moeten knipperen (1 seconde aan, 1 seconde uit). Hieronder vindt u de code voor ons eerste Arduino-programma.

// dan herhaalt de cyclus zich Lees de opmerkingen in de tekst van het programma - ze zijn voldoende om ons eerste experiment te begrijpen. Eerst beschrijven we het initialisatieblok instellen() , waarin we de beginwaarden van de variabelen en de functies van de Arduino-pinnen instellen. Er volgt een eindeloze lus lus() , wat zich keer op keer herhaalt zolang er stroom aan het bord wordt geleverd. In deze cyclus voeren we alle noodzakelijke acties uit. In dit geval schakelen we de LED in en uit. Exploitant vertraging() specificeert de uitvoeringsduur (in milliseconden) van de voorgaande instructie. Exploitant digitaalschrijven() vertelt Arduino op welke pin spanning moet worden toegepast en op welk spanningsniveau.

Je eerste schets is klaar!

Er zijn veel sites op het netwerk die zich toeleggen op het werken met Arduino-familieborden. Lees, beheers, wees niet bang om te experimenteren en nieuwe dingen te leren! Dit is een leuke en lonende activiteit waar je veel plezier aan zult beleven.

Let op