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.

Deze simulator werkt het beste in de Chrome-browser
Laten we Arduino eens nader bekijken.

Arduino is geen grote computer die op externe circuits kan worden aangesloten. Arduino Uno maakt gebruik van Atmega 328P
Dit is de grootste chip op het bord. Deze chip voert programma's uit die in zijn geheugen zijn opgeslagen. Je kunt het programma downloaden via usb met behulp van Arduino IDE. De USB-poort levert ook stroom aan de Arduino.

Er is een aparte stroomaansluiting. Het bord heeft twee pinnen met de aanduiding 5v en 3,3v, die nodig zijn om verschillende apparaten van stroom te voorzien. Ook vind je pinnen gemarkeerd met GND, dit zijn de aardingspinnen (aarde is 0V). Het Arduino-platform heeft ook 14 digitale pinnen, gelabeld met 0 tot 13, die verbinding maken met externe knooppunten en twee statussen hebben: hoog of laag (aan of uit). Deze contacten kunnen werken als uitgangen of als ingangen, d.w.z. ze kunnen bepaalde gegevens verzenden en externe apparaten besturen, of gegevens van apparaten ontvangen. De volgende pinnen op het bord hebben het label A0-A5. Dit zijn analoge ingangen die data van verschillende sensoren kunnen ontvangen. Dit is vooral handig als u een bepaald bereik moet meten, zoals de temperatuur. De analoge ingangen hebben extra functies die afzonderlijk kunnen worden ingeschakeld.

Hoe een ontwikkelbord te gebruiken.

Het breadboard is nodig om de onderdelen tijdelijk met elkaar te verbinden, controleer hoe het apparaat werkt, voordat je alles aan elkaar soldeert.
Alle volgende voorbeelden zijn op een breadboard gemonteerd, zodat u snel wijzigingen in het circuit kunt aanbrengen en onderdelen kunt hergebruiken zonder dat u zich hoeft te bekommeren om solderen.

Het breadboard heeft rijen gaten waarin je onderdelen en draden kunt steken. Sommige van deze gaten zijn elektrisch met elkaar verbonden.

De twee bovenste en onderste rijen zijn in rijen over het hele bord met elkaar verbonden. Deze rijen worden gebruikt om het circuit van stroom te voorzien. Het kan 5V of 3,3V zijn, maar hoe dan ook, het eerste dat u hoeft te doen is 5V en GND op het breadboard aansluiten, zoals weergegeven in de afbeelding. Soms zijn deze rijverbindingen in het midden van het bord verbroken. Als dat nodig is, kunt u ze aansluiten zoals weergegeven in de afbeelding.

De overige gaten, gelegen in het midden van het bord, zijn gegroepeerd in groepen van vijf gaten. Ze worden gebruikt om circuitonderdelen aan te sluiten.

Het eerste dat we op onze microcontroller aansluiten, is een LED. Het elektrische aansluitschema wordt weergegeven in de afbeelding.

Waarom is een weerstand nodig in een circuit? In dit geval beperkt het de stroom die door de LED gaat. Elke LED is ontworpen voor een bepaalde stroom, en als deze stroom hoger is, zal de LED uitvallen. Met behulp van de wet van Ohm kun je uitvinden welke waarde de weerstand moet hebben. Voor degenen die het niet weten of vergeten zijn: de wet van Ohm zegt dat er een lineair verband bestaat tussen stroom en spanning. Dat wil zeggen: hoe meer spanning we op de weerstand toepassen, hoe meer stroom er doorheen zal stromen.
V=I*R
Waar V- spanning over de weerstand
I- stroom door de weerstand
R- weerstand die gevonden moet worden.
Eerst moeten we de spanning over de weerstand bepalen. De meeste 3 mm of 5 mm LED's die u gebruikt, hebben een bedrijfsspanning van 3V. Dit betekent dat we 5-3 = 2V bij de weerstand moeten doven.

Vervolgens berekenen we de stroom die door de weerstand gaat.
De meeste 3 mm en 5 mm LED's gloeien op volledige helderheid bij 20 mA. Een stroom groter dan deze kan ze uitschakelen, terwijl een stroom van lagere intensiteit hun helderheid zal verminderen zonder enige schade aan te richten.

We willen de LED dus op het 5V-circuit aansluiten, zodat deze een stroom van 20 mA voert. Omdat alle onderdelen in één circuit zitten, heeft de weerstand ook een stroomsterkte van 20 mA.
Wij krijgen
2V = 20 mA *R
2V = 0,02A *R
R = 100 Ohm
100 Ohm is de minimale weerstand, het is beter om iets meer te gebruiken, omdat LED's enige variatie in eigenschappen hebben.
In dit voorbeeld wordt een weerstand van 220 ohm gebruikt. Alleen maar omdat de auteur er veel heeft: knipoog: .

Steek de LED in de gaten in het midden van het bord, zodat de lange kabel is aangesloten op een van de weerstandsdraden. Sluit het tweede uiteinde van de weerstand aan op 5V en sluit de tweede draad van de LED aan op GND. De LED moet oplichten.

Houd er rekening mee dat er een verschil zit in de manier waarop je de LED aansluit. De stroom vloeit van de langere terminal naar de kortere. In het diagram kun je je voorstellen dat de stroom vloeit in de richting waarin de driehoek is gericht. Probeer de LED ondersteboven te draaien en u zult zien dat deze niet oplicht.

Maar hoe je de weerstand aansluit maakt helemaal niets uit. Je kunt hem omdraaien of proberen hem op een andere pin van de LED aan te sluiten, dit heeft geen invloed op de werking van het circuit. Het zal nog steeds de stroom door de LED beperken.

Anatomie van Arduino-schets.

Programma's voor Arduino worden sketch genoemd. Ze bestaan ​​uit twee hoofdfuncties. Functie opstelling en functie lus
Binnen deze functie stelt u alle basisinstellingen in. Welke pinnen zullen werken als invoer of uitvoer, welke bibliotheken moeten worden aangesloten, initialiseren variabelen. Functie Installatie() wordt slechts één keer uitgevoerd tijdens de schets, wanneer de programma-uitvoering start.
dit is de hoofdfunctie die daarna wordt uitgevoerd instellen(). In feite is het het programma zelf. Deze functie blijft voor onbepaalde tijd actief totdat u de stroom uitschakelt.

Arduino knipperende LED

In dit voorbeeld zullen we een LED-circuit aansluiten op een van de digitale pinnen van de Arduino en deze met een programma aan- en uitzetten, en je leert ook verschillende handige functies.

Deze functie wordt gebruikt bij instellen() onderdeel van het programma en dient om de pinnen te initialiseren die u als invoer gaat gebruiken (INVOER) of uitgang (OUTPUT). U kunt geen gegevens van de pin lezen of schrijven totdat u deze op respectievelijk instelt pinModus. Deze functie heeft twee argumenten: pinNummer is het pinnummer dat u gaat gebruiken.

Modus-stelt in hoe de pin werkt. Bij de ingang (INVOER) of uitgang (OUTPUT). Om de LED te laten branden moeten we een signaal geven VAN Arduino. Om dit te doen, configureren we de uitvoerpin.
- deze functie wordt gebruikt om de status in te stellen (staat) pina (pinNummer). Er zijn twee hoofdstaten (eigenlijk drie), één is dat HOOG, er komt 5V op de pin, dat is iets anders Laag en de pin zal 0v zijn. Dit betekent dat om de LED te laten branden, we de pin die op de LED is aangesloten op een hoog niveau moeten instellen HOOG.

Vertraging. Dient om de werking van het programma te vertragen gedurende een periode gespecificeerd in msec.
Hieronder staat de code die de LED laat knipperen.
//LED Knippert int ledPin = 7;//Arduino-pin waarmee de LED is verbonden void setup() ( pinMode(ledPin, OUTPUT);// de pin instellen als OUTPUT) void loop() ( digitalWrite(ledPin, HIGH) ;// schakel de LED-vertraging in (1000);// vertraging 1000 ms (1 sec) digitalWrite (ledPin, LOW);// Schakel de LED-vertraging uit (1000); // wacht 1 sec)

Kleine uitleg over de code.
Regels die beginnen met "//" zijn commentaar en worden door Arduino genegeerd.
Alle opdrachten eindigen met een puntkomma; als u ze vergeet, krijgt u een foutmelding.

ledPin is een variabele. Variabelen worden in programma's gebruikt om waarden op te slaan. In dit voorbeeld de variabele ledPin de waarde is toegewezen aan 7, dit is het Arduino-pinnummer. Wanneer het Arduino-programma een regel met een variabele tegenkomt ledPin, zal het de waarde gebruiken die we eerder hebben opgegeven.
Dus opnemen pinModus(ledPin, UITGANG) vergelijkbaar met opnemen pinMode(7, UITGANG).
Maar in het eerste geval hoeft u alleen maar de variabele te wijzigen en deze verandert op elke regel waar deze wordt gebruikt, en in het tweede geval moet u, om de variabele te wijzigen, handmatig wijzigingen aanbrengen in elke opdracht.

De eerste regel geeft het type van de variabele aan. Bij het programmeren van Arduino is het belangrijk om altijd het type variabelen te declareren. Voor nu is het genoeg dat je dat weet INT kondigt negatieve en positieve cijfers aan.
Hieronder ziet u een simulatie van de schets. Klik op start om het circuit in actie te zien.

Zoals verwacht gaat de LED uit en gaat na één seconde weer aan. Probeer de vertraging te wijzigen om te zien hoe dit werkt.

Aansturing van meerdere LED's.

In dit voorbeeld leert u hoe u meerdere LED's kunt aansturen. Om dit te doen, installeert u nog 3 LED's op het bord en sluit u deze aan op weerstanden en Arduino-pinnen, zoals hieronder weergegeven.

Om de LED's één voor één aan en uit te zetten, moet je een programma schrijven dat er ongeveer zo uitziet:
//Multi LED Knippert int led1Pin = 4; int led2Pin = 5; int led3Pin = 6; int led4Pin = 7; void setup() ( //stel pinnen in als OUTPUT pinMode(led1Pin, OUTPUT); pinMode(led2Pin, OUTPUT); pinMode(led3Pin, OUTPUT); pinMode(led4Pin, OUTPUT); ) void loop() ( digitalWrite(led1Pin, HIGH );//zet de LED-vertraging aan (1000);//delay 1 sec digitalWrite(led1Pin, LOW);//zet de LED-vertraging uit (1000);//delay 1 sec //doe hetzelfde voor de andere 3 LED's digitalWrite(led2Pin, HIGH);//steek de LED-vertraging op(1000);//vertraging 1 sec digitalWrite(led2Pin, LOW);//doof de LED-vertraging(1000);//vertraging 1 sec digitalWrite(led3Pin, HIGH);//vertraging 1 sec digitalWrite(led3Pin, HIGH); );//de LED-vertraging aansteken(1000);//vertraging 1 sec digitalWrite(led3Pin, LOW);//de LED-vertraging doven(1000);//vertraging 1 sec digitalWrite(led4Pin, HIGH);//inschakelen de LED-vertraging (1000); // vertraging 1 sec digitalWrite (led4Pin, LOW); // doof de LED-vertraging (1000); // vertraging 1 sec)

Dit programma zal prima werken, maar het is niet de meest rationele oplossing. De code moet worden gewijzigd. Om het programma keer op keer te laten werken, zullen we een constructie gebruiken genaamd .
Loops zijn handig als u dezelfde actie meerdere keren moet herhalen. In de bovenstaande code herhalen we de regels

DigitalWrite(led4Pin, HOOG); vertraging(1000); digitalWrite(led4Pin, LAAG); vertraging(1000);
volledige schetscode in bijlage (downloads: 1187)

Aanpassing van de LED-helderheid

Soms moet u de helderheid van de LED's in het programma wijzigen. Dit kan gedaan worden met behulp van het commando analoogSchrijven() . Met dit commando wordt de LED zo snel aan- en uitgeschakeld dat het oog het flikkeren niet kan zien. Als de LED de helft van de tijd aanstaat en de helft van de tijd uit, zal het visueel lijken alsof hij op de helft van zijn helderheid gloeit. Dit wordt pulsbreedtemodulatie genoemd (PWM of PWM in het Engels). Shim wordt vrij vaak gebruikt, omdat hiermee een “analoge” component kan worden aangestuurd met behulp van een digitale code. Niet alle Arduino-pinnen zijn geschikt voor deze doeleinden. Alleen die terminals in de buurt waar een dergelijke aanduiding is getekend " ~ ". Je ziet het naast pinnen 3,5,6,9,10,11.
Sluit een van je LED's aan op een van de PWM-pinnen (voor de auteur is dit pin 9). Voer nu de LED-knipperende schets uit, maar verander eerst het commando digitaalSchrijven() op analoogSchrijven(). analoogSchrijven() heeft twee argumenten: het eerste is het pinnummer en het tweede is de PWM-waarde (0-255), in relatie tot LED's is dit hun helderheid, en voor elektromotoren de rotatiesnelheid. Hieronder vindt u een voorbeeldcode voor verschillende LED-helderheden.
//Verander de helderheid van de LED int ledPin = 9;//een LED is verbonden met deze pin void setup() ( pinMode(ledPin, OUTPUT);// initialiseert de pin naar de uitgang) void loop() ( analogWrite( ledPin, 255);// volledige helderheid (255/255 = 1) vertraging(1000);//pauze 1 sec digitalWrite(ledPin, LOW);//schakel LED vertraging uit(1000);//pauze 1 sec analogWrite( ledPin, 191);//helderheid met 3/4 (191/255 ~= 0,75) vertraging(1000);//pauze 1 sec digitalWrite(ledPin, LOW);//schakel de LED-vertraging uit(1000);// pauzeer 1 sec analogWrite(ledPin, 127); //halve helderheid (127/255 ~= 0,5) vertraging(1000);//pauzeer 1 sec digitalWrite(ledPin, LOW);//zet LED-vertraging uit(1000);/ /pauze 1 sec analogWrite(ledPin, 63); //kwart helderheid (63/255 ~= 0,25) vertraging(1000);//pauze 1 sec digitalWrite(ledPin, LOW);//zet de LED-vertraging uit(1000) ;//pauze 1 sec)

Probeer de PWM-waarde in de opdracht te wijzigen analoogSchrijven() om te zien hoe dit de helderheid beïnvloedt.
Vervolgens leert u hoe u de helderheid soepel kunt aanpassen van vol naar nul. Je kunt een stukje code uiteraard 255 keer kopiëren
analogWrite(ledPin, helderheid); vertraging(5);//korte vertraging helderheid = helderheid + 1;
Maar u begrijpt dat dit niet praktisch zal zijn. De beste manier om dit te doen is door de FOR-lus te gebruiken die we eerder hebben gebruikt.
In het volgende voorbeeld worden twee lussen gebruikt, één om de helderheid te verlagen van 255 naar 0
for (int helderheid=0;helderheid=0;helderheid--)( analogWrite(ledPin,helderheid); vertraging(5); )
vertraging(5) gebruikt om de fade-in- en fade-outsnelheid te vertragen 5*256=1280ms=1,28sec)
De eerste regel gebruikt " helderheid-" om de helderheidswaarde elke keer dat de lus wordt herhaald met 1 te laten afnemen. Houd er rekening mee dat de lus doorloopt tot helderheid >=0.Het bord vervangen > op het bord >= we hebben 0 opgenomen in het helderheidsbereik. Deze schets is hieronder gemodelleerd. // verander de helderheid soepel int ledPin = 9; // een LED is verbonden met deze pin void setup () ( pinMode (ledPin, OUTPUT); // initialisatie van de uitvoerpin) void loop () ( // verhoog soepel de helderheid (0 tot 255 ) voor (int helderheid=0; helderheid = 0; helderheid --) ( analogWrite (ledPin, helderheid); vertraging (5); ) vertraging (1000); // wacht 1 sec // verminder de helderheid soepel (255 tot 0) voor (int helderheid=255;helderheid>=0;helderheid--)( analogWrite(ledPin,helderheid); vertraging(5); ) vertraging(1000);//wacht 1 sec ) )
Het is niet erg zichtbaar, maar het idee is duidelijk.

RGB-LED en Arduino

Een RGB-LED zijn eigenlijk drie verschillend gekleurde LED's in één pakket.

Door verschillende LED's met verschillende helderheid toe te voegen, kunt u ze combineren om verschillende kleuren te creëren. Voor Arduino, waar het aantal helderheidsniveaus 256 is, krijgt u 256^3=16581375 mogelijke kleuren. In werkelijkheid zullen het er uiteraard minder zijn.
De LED die we zullen gebruiken is de gemeenschappelijke kathode. Die. alle drie de LED's zijn structureel verbonden door kathodes met één terminal. We zullen deze pin verbinden met de GND-pin. De overige pinnen moeten via begrenzingsweerstanden worden aangesloten op de PWM-pinnen. De auteur gebruikte pinnen 9-11. Op deze manier is het mogelijk om elke LED afzonderlijk aan te sturen. De eerste schets laat zien hoe je elke LED afzonderlijk kunt inschakelen.

//RGB LED - test //pinverbindingen int rood = 9; intgroen = 10; int blauw = 11; void setup())( pinMode(rood, OUTPUT); pinMode(blauw, OUTPUT); pinMode(groen, OUTPUT); ) void loop())( //zet de rode LED aan/uit digitalWrite(rood, HOOG); delay(500); digitalWrite(rood, LAAG); //zet de groene LED digitalWrite(groen, HOOG); HOOG); digitalWrite (blauw, LAAG);

In het volgende voorbeeld worden de opdrachten gebruikt analoogSchrijven() en om verschillende willekeurige helderheidswaarden voor de LED's te krijgen. Je zult verschillende kleuren willekeurig zien veranderen.
//RGB LED - willekeurige kleuren //pinverbindingen int rood = 9; intgroen = 10; int blauw = 11; void setup())( pinMode(rood, OUTPUT); pinMode(blauw, OUTPUT); pinMode(groen, OUTPUT); ) void loop())( //kies een willekeurige kleur analogWrite(rood, willekeurig(256)); analogWrite( blauw, willekeurig(256)); analogWrite(groen, willekeurig(256));

Willekeurig(256)-retourneert een willekeurig getal in het bereik van 0 tot 255.
In het bijgevoegde bestand vindt u een schets die vloeiende kleurovergangen demonstreert van rood naar groen, vervolgens naar blauw, rood, groen, enz. (downloads: 326)
De voorbeeldschets werkt, maar er is veel dubbele code. U kunt de code vereenvoudigen door uw eigen helperfunctie te schrijven die soepel van de ene kleur naar de andere verandert.
Hier ziet u hoe het eruit zal zien: (downloads: 365)
Laten we de functiedefinitie stukje bij beetje bekijken. De functie wordt aangeroepen fader en heeft twee argumenten. Elk argument wordt gescheiden door een komma en heeft een type dat op de eerste regel van de functiedefinitie wordt gedeclareerd: ongeldige fader (int kleur1, int kleur2). Je ziet dat beide argumenten worden gedeclareerd als int, en ze krijgen namen kleur1 En kleur2 als voorwaardevariabelen om een ​​functie te definiëren. Leegte betekent dat de functie geen waarden retourneert, maar eenvoudigweg opdrachten uitvoert. Als je een functie zou moeten schrijven die het resultaat van vermenigvuldiging teruggeeft, zou het er als volgt uitzien:
int multiplier(int getal1, int getal2)( int product = getal1*getal2; retourproduct; )
Merk op hoe we Type hebben verklaard int als retourtype
leegte.
Binnen de functie bevinden zich de commando's die je al in de vorige schets hebt gebruikt, alleen de pincodes zijn vervangen kleur1 En kleur2. De functie wordt aangeroepen fader, worden de argumenten berekend als kleur1 = rood En kleur2 = groen. Het archief bevat een volledige schets met behulp van functies (downloads: 272)

Knop

In de volgende schets wordt een knop gebruikt met normaal open contacten, zonder vergrendeling.

Dit betekent dat er, zolang de knop niet wordt ingedrukt, geen stroom door de knop stroomt en dat de knop na het loslaten terugkeert naar zijn oorspronkelijke positie.
Naast de knop gebruikt het circuit een weerstand. In dit geval beperkt het de stroom niet, maar "trekt" de knop naar 0V (GND). Die. Totdat de knop wordt ingedrukt, wordt de Arduino-pin waarmee deze is verbonden laag. De weerstand die in het circuit wordt gebruikt, is 10 kOhm.

// bepaal wanneer de knop wordt ingedrukt int buttonPin = 7; void setup())( pinMode(buttonPin, INPUT);//initialiseer de pin naar de ingang Serial.begin(9600);//initialiseer de seriële poort) void loop())( if (digitalRead(buttonPin)==HIGH )(//als de knop wordt ingedrukt Serial.println("gedrukt"); // geef de inscriptie "geperst" weer ) else ( Serial.println("niet ingedrukt");// anders "niet ingedrukt" ) )
Er zijn verschillende nieuwe commando's in deze schets.
-Deze opdracht neemt de hoge en lage waarden over van de uitvoer die we testen. Deze uitvoer moet eerst worden geconfigureerd als invoer in setup().
; //waar buttonPin het pinnummer is waarop de knop is aangesloten.
Via de seriële poort kan de Arduino berichten naar de computer sturen terwijl de controller zelf het programma uitvoert. Dit is handig voor het debuggen van een programma en het verzenden van berichten naar andere apparaten of applicaties. Om gegevensoverdracht via een seriële poort (ook wel UART of USART genoemd) mogelijk te maken, moet u deze initialiseren in setup()

Serieel.begin() heeft maar één argument: dit is de gegevensoverdrachtsnelheid tussen de Arduino en de computer.
De schets gebruikt een commando om een ​​bericht op het scherm weer te geven in de Arduino IDE (Tools >> Serial Monitor).
- Dankzij het ontwerp kunt u de voortgang van de programma-uitvoering controleren door verschillende controles op één plek te combineren.
Als digitalRead HOOG retourneert, wordt het woord "gedrukt" op de monitor weergegeven. Anders (anders) verschijnt het woord “vrijgegeven” op de monitor. Nu kunt u proberen de LED aan en uit te zetten door op een knop te drukken.
//knopdrukdetectie met LED-uitgang int buttonPin = 7; int ledPin = 8; void setup())( pinMode(buttonPin, INPUT);//deze keer zullen we de button pin instellen als INPUT pinMode(ledPin, OUTPUT); Serial.begin(9600); ) void loop())( if (digitalRead(buttonPin )= =HOOG)( digitalWrite(ledPin,HOOG); Serial.println("ingedrukt"); ) else ( digitalWrite(ledPin,LOW); Serial.println("niet ingedrukt"); ) )

Analoge ingang.

analoogLezen Hiermee kunt u gegevens van een van de analoge pinnen van de Arduino lezen en wordt een waarde weergegeven in het bereik van 0 (0V) tot 1023 (5V). Als de spanning op de analoge ingang 2,5V is, wordt 2,5 / 5 * 1023 = 512 afgedrukt
analoogLezen heeft slechts één argument - Dit is het nummer van de analoge ingang (A0-A5). De volgende schets toont de code voor het lezen van de spanning van de potentiometer. Om dit te doen, sluit u een variabele weerstand aan, de buitenste aansluitingen op de 5V- en GND-pinnen en de middelste aansluiting op de A0-ingang.

Voer de volgende code uit en zie in de seriële monitor hoe de waarden veranderen afhankelijk van de rotatie van de weerstandsknop.
//analoge ingang int potPin = A0;//de centrale pin van de potentiometer is verbonden met deze pin void setup())( //analoge pin is standaard inbegrepen als invoer, dus initialisatie is niet nodig Serial.begin(9600 ); ) void loop())( int potVal = analogRead(potPin);//potVal is een getal tussen 0 en 1023 Serial.println(potVal)
De volgende schets combineert de schets van de knopklik en de schets van de LED-helderheidsregeling. De LED gaat aan vanaf de knop en de helderheid wordt geregeld door een potentiometer.
//knopdrukdetectie met LED-uitgang en variabele intensiteit int buttonPin = 7; int ledPin = 9; int potPin = A0; void setup())( pinMode(buttonPin, INPUT); pinMode(ledPin, OUTPUT); Serial.begin(9600); ) void loop())( if (digitalRead(buttonPin)==HIGH)(//if knop ingedrukt int analogVal = analogRead(potPin); int scaledVal = map(analogVal, 0, 1023, 0, 255); analogWrite(ledPin, scaledVal);//zet led aan met intensiteit ingesteld door pot Serial.println("pressed"); ( digitalWrite(ledPin, LOW);//uitschakelen als de knop niet wordt ingedrukt Serial.println("niet ingedrukt"); ) )

De doelgroep van Arduino zijn niet-professionele gebruikers op het gebied van robotica en eenvoudige automatiseringssystemen. Het belangrijkste product is een set borden, door deze te combineren is het mogelijk om verschillende apparaten te creëren die een breed scala aan taken kunnen uitvoeren.

Uit een set planken geproduceerd door dit bedrijf kunt u bijvoorbeeld een voerautomaat voor uw huisdieren samenstellen. En dit is slechts een van de eenvoudigste voorbeelden. De reikwijdte van hun mogelijke toepassing wordt alleen beperkt door de verbeeldingskracht van gebruikers.

Naast printplaten geproduceerd onder het merk Arduino, hebben ze hun eigen Arduino-programmeertaal, die is gebaseerd op een taal die algemeen bekend is onder programmeurs C/C++. Laten we eens nader bekijken wat het is.

De programmeertaal Arduino is vrij eenvoudig te leren, omdat de belangrijkste doelgroep voor het gebruik ervan amateurs zijn. Het wordt echter beschouwd als een van de beste talen voor het programmeren van microcontrollers.

Arduino IDE is een gratis programma dat iedereen kan downloaden. Op onze website kunt u elke versie van de omgeving gebruiken die bij u past. Ook wordt toegang tot het downloaden van de IDE geboden op de officiële website van het bedrijf, en indien gewenst kunnen de ontwikkelaars worden bedankt door een geldoverdracht te doen.

Een programma geschreven in de programmeertaal Arduino wordt een schets genoemd. Voltooide schetsen worden op het bord vastgelegd voor uitvoering.

De IDE wordt ondersteund door besturingssystemen zoals Windows, MacO's en Linux. Op de officiële website van het bedrijf staat dat deze programmeertaal is geschreven in Wiring, maar deze bestaat in feite niet en is geschreven in C++ met kleine aanpassingen.

Wat heb je nodig om aan de slag te gaan met de Arduino IDE?

Om te beginnen hebben we de volgende dingen nodig:

• Arduino-borden;
• USB-kabel;
• een computer waarop de Arduino IDE is geïnstalleerd.

Met deze set kun je gaan experimenteren met de planken die je hebt, en je eerste schetsen erop opnemen.

Hoe installeer ik Arduino op een computer?

Dit gebeurt eenvoudig. U moet het volgende doen:

• u moet het door u samengestelde product met een USB-kabel op uw computer aansluiten;
• In Apparaatbeheer moet u controleren op welke poort uw microcontroller is aangesloten. Als het niet wordt weergegeven of als er staat dat het apparaat niet wordt herkend, betekent dit dat u het stuurprogramma niet correct hebt geïnstalleerd of dat uw bord een diagnose nodig heeft;
• De volgende stap is het lanceren van onze Arduino IDE-programmeertaal. In het menu moet u het tabblad Extra selecteren. Wanneer u erop klikt, wordt een lijst geopend waarin u het poortitem moet selecteren. Daar moet u de poort selecteren die is opgegeven in Apparaatbeheer;
• De laatste stap is het selecteren van het bord dat we zullen gebruiken om de schetsen te uploaden.

Belangrijk! Wanneer u uw bord op een andere USB-poort aansluit, moeten alle instellingen opnieuw worden uitgevoerd.

Inleiding tot de Arduino-interface

Een van de belangrijkste elementen van Arduino is het hoofdmenu van het programma, waarmee u toegang heeft tot alle beschikbare functies van ons programma.

Hieronder ziet u een paneel met pictogrammen die de meest gebruikte functies van de Arduino IDE weergeven:

controleren op fouten;

een nieuwe schets maken;

het openen van het poortvenster van de microcontroller;

Het volgende belangrijkste element is het tabblad Projectbestanden. Als dit een eenvoudige schets is, is er maar één bestand. Complexe schetsen kunnen echter uit meerdere bestanden bestaan. In dit geval kunt u snel overschakelen van het ene bestand naar het andere in de tabbladbalk. Het is erg handig.

Het grootste blok is het editorveld voor onze schetsen. Hier kunnen we de programmacode die we nodig hebben bekijken en indien nodig bewerken. Er is een apart veld geïmplementeerd voor het weergeven van systeemmeldingen. Hiermee kunt u verifiëren dat het opslaan of laden van uw schets succesvol is geweest, en kunt u doorgaan met de volgende stappen. Er is ook een venster in het programma dat de aanwezigheid van uw schets tijdens het compileren weergeeft.

Compilatie– het omzetten van broncode op hoog niveau in machinecode of assembleertaal.

Basisfuncties van de programmeertaal

Laten we eindelijk verder gaan met de meest basisfuncties van de Arduino-programmeertaal.

Laten we meteen zeggen dat u alle functies op onze handige website kunt vinden.

Puntkomma;

Na elke instructie die in de programmeertaal Arduino is geschreven, moet een puntkomma worden geplaatst. Bijvoorbeeld:

Int LED-pin = 9;

In deze uitdrukking kennen we een waarde toe aan een variabele en zien we de puntkomma aan het einde. Dit vertelt de compiler dat je een stukje code hebt voltooid en doorgaat naar het volgende stuk. Een puntkomma in Arduino-code scheidt de ene volledige expressie van de andere.

Dubbele backslash voor commentaar van één regel //

// Alles wat na de dubbele schuine streep komt, is grijs en wordt niet door het programma gelezen

Opmerkingen zijn wat u gebruikt om commentaar te geven op code. Goede code wordt goed becommentarieerd. Opmerkingen zijn bedoeld om u, en iedereen die uw code tegenkomt, te vertellen wat u dacht toen u deze schreef. Een goede opmerking zou ongeveer deze zijn:

// Sluit een LED aan op deze Arduino-pin int LEDpin = 9;

Nu, zelfs na 3 maanden als ik naar dit programma kijk, weet ik waar de LED was aangesloten.

De compiler negeert opmerkingen, zodat u kunt schrijven wat u maar wilt. Als u veel tekst nodig heeft voor een commentaar, kunt u een commentaar van meerdere regels gebruiken, zoals hieronder weergegeven:

/* Een commentaar met meerdere regels wordt geopend met een enkele backslash gevolgd door een asterisk. Alles wat volgt, wordt grijs weergegeven en door de compiler genegeerd totdat u de opmerking sluit met eerst een asterisk en vervolgens een backslash */

Opmerkingen lijken op codevoetnoten, maar komen vaker voor dan opmerkingen die onderaan pagina's in boeken worden geplaatst.

Accolades ( )

Accolades worden gebruikt om instructies toe te voegen die door een functie moeten worden uitgevoerd (we zullen de functies later bespreken). Er is altijd een open accolade en een sluitende accolade. Als u vergeet een accolade te sluiten, drukt de compiler een foutcode af.

Void loop() ( //deze accolade opent //cool programma hier ) //deze accolade sluit

Onthoud: geen enkele accolade mag open blijven!

Functies ()

Nu is het tijd om over functies te praten. Functies zijn stukjes code die zo vaak worden gebruikt dat ze zijn ingekapseld in specifieke trefwoorden, zodat u ze gemakkelijker kunt gebruiken. Een functie kan bijvoorbeeld de volgende reeks instructies zijn als u uw hond moet wassen:

1. Koop een emmer
2. Vul het met water
3. Voeg zeep toe
4. Zoek een hond
5. Schuim de hond
6. Was de hond
7. Spoel de hond af
8. Droog de hond
9. Zet de emmer opzij

Deze reeks eenvoudige instructies kan worden ingekapseld in een functie die we WashDog kunnen noemen. Elke keer dat we al deze instructies willen uitvoeren, typen we eenvoudigweg WashDog en voila - alle instructies worden uitgevoerd.

Arduino heeft bepaalde functies die vaak worden gebruikt in de . Wanneer u deze invoert, is de functienaam oranje. De functie pinMode() is bijvoorbeeld een veelgebruikte functie die wordt gebruikt om de Arduino-pinmodus aan te geven.

Hoe zit het met de haakjes na de pinMode-functie? Voor veel functies zijn argumenten nodig. Een argument is informatie die een functie gebruikt wanneer deze wordt uitgevoerd. Voor onze WashDog-functie kunnen de argumenten de naam van de hond en het type zeep zijn, evenals de temperatuur en grootte van de emmer.

PinModus(13, UITVOER); // Stelt de Arduino-uitvoermodus in

Argument 13 verwijst naar pin 13, en OUTPUT is de modus waarin u wilt dat de pin werkt. Wanneer u deze argumenten invoert, in terminologie heet dit data doorgeven, geeft u de benodigde informatie door aan de functies. Niet alle functies vereisen argumenten, maar haakjes openen en sluiten blijven bestaan, zij het leeg.

Millis(); //Krijgt de tijd in milliseconden waarvoor de Arduino start

Merk op dat het woord OUTPUT meestal blauw is. Er zijn bepaalde trefwoorden in de programmeertaal Arduino die vaak worden gebruikt, en de kleur blauw helpt ze te identificeren. De Arduino IDE kleurt ze automatisch blauw.

ongeldige instellingen()

De functie setup() wordt, zoals de naam al doet vermoeden, gebruikt om het Arduino-bord te configureren. Arduino voert alle code tussen de accolades na setup() slechts één keer uit. Typische dingen die gebeuren in setup() zijn bijvoorbeeld het instellen van de modus op contacten:

Void setup() (//code tussen accolades wordt slechts één keer uitgevoerd)

Je vraagt ​​je misschien af ​​wat void betekent vóór de functie setup(). Ongeldig betekent dat de functie geen informatie retourneert.

Sommige functies retourneren waarden - onze DogWash-functie kan het aantal emmers retourneren dat nodig is om een ​​hond schoon te maken. De functie analogRead() retourneert een geheel getal tussen 0 en 1023. Als dit nu een beetje vreemd lijkt, hoeft u zich geen zorgen te maken, want we zullen elke veel voorkomende Arduino-functie behandelen naarmate de cursus vordert.

Laten we eens kijken naar een paar dingen die u moet weten over setup():

1. setup() wordt slechts één keer uitgevoerd;
2. setup() zou de eerste functie in de Arduino-schets moeten zijn;
3. setup() moet accolades openen en sluiten.

lege lus()

Je moet van de Arduino-ontwikkelaars houden, omdat ze ervoor hebben gezorgd dat de functienamen voor zichzelf spreken. Zoals de naam al doet vermoeden, wordt alle code tussen de accolades in loop() keer op keer herhaald, en het woord loop betekent letterlijk ‘loop’. De functie loop() is waar de hoofdtekst van uw programma naartoe gaat.

Net als bij setup() retourneert loop() geen enkele waarde, dus wordt deze voorafgegaan door het woord void.

Void loop() (//elke code die u hier opgeeft, wordt keer op keer uitgevoerd)

Vind je het vreemd dat de code in één grote lus draait? Dit schijnbare gebrek aan variatie is een illusie. Het grootste deel van uw code heeft bepaalde wachtvoorwaarden die nieuwe acties zullen activeren.

Zijn er nog andere programma's die met Arduino werken?

Naast de officiële Arduino IDE zijn er programma's van derden die hun producten aanbieden voor het werken met Arduino-gebaseerde microcontrollers.

Een soortgelijke reeks functies kan ons worden geleverd door een programma genaamd Processing. Het lijkt erg op de Arduino IDE, omdat beide op dezelfde engine zijn gemaakt. Processing heeft een uitgebreide reeks functies die niet veel onderdoen voor het originele programma. Met behulp van de downloadbare seriële bibliotheek kan de gebruiker een verbinding tot stand brengen tussen de gegevensoverdracht die het bord en Processing naar elkaar verzenden. In dit geval kunnen we het bord programma's rechtstreeks vanaf onze pc laten uitvoeren.

Er is nog een interessante versie van het originele programma. Het heet B4R, en het belangrijkste verschil is dat het niet de C-taal als basis gebruikt, maar een andere programmeertaal: Basic. Dit softwareproduct is gratis. Er zijn goede tutorials om ermee te werken, inclusief die geschreven door de makers van dit product.

Er zijn ook betaalde opties voor Arduino IDE. Eén daarvan is het PROGROMINO-programma. Het belangrijkste voordeel is de mogelijkheid om de code aan te vullen. Bij het samenstellen van een programma hoeft u niet langer naar informatie in naslagwerken te zoeken. Het programma zelf biedt u mogelijke opties voor het gebruik van een bepaalde procedure. De set bevat nog veel meer interessante functies die in het originele programma ontbreken en die het voor u gemakkelijker kunnen maken om met borden te werken.

Arduino-concurrenten

Deze markt voor de productie van microcontrollers voor het maken van verschillende elektronische circuits en robotica heeft veel fans over de hele wereld. Deze situatie draagt ​​​​bij aan de opkomst op de markt van niet alleen concurrenten die vergelijkbare producten aanbieden. Daarnaast wordt een aanzienlijk aantal vervalsingen van verschillende kwaliteit geproduceerd. Sommige zijn erg moeilijk te onderscheiden van de originelen, omdat ze van identieke kwaliteit zijn, andere hebben zeer slechte eigenschappen en werken mogelijk helemaal niet met de originele producten.

Er zijn zelfs Arduino-borden die microprocessors ondersteunen die JavaScript-tolken draaien. Ze zijn in de eerste plaats relevant voor degenen die de Java-taal willen gebruiken in plaats van C. Het is tenslotte eenvoudiger en stelt u in staat om met hogere snelheid resultaten te bereiken. Deze borden zijn echter duurder in vergelijking met Arduino, wat een aanzienlijk nadeel is.

Als je op zoek bent naar een hobby en geïnteresseerd bent in een vakgebied als elektrotechniek, dan kun je hiervoor gerust voor Arduino kiezen. Deze hobby heeft veel voordelen. Je zult je intellectueel ontwikkelen, omdat je voor deze activiteit kennis op verschillende gebieden nodig hebt.

Naast entertainment zal je hobby je helpen veel nuttige producten te maken die je kunt gebruiken om je dagelijkse leven gemakkelijker te maken. Elke keer zul je steeds meer nieuwe manieren vinden om je passie te gebruiken.

Het beheersen van deze activiteit zal niet zo moeilijk zijn, dankzij de beschikbaarheid van een groot aantal leerboeken en tutorials. In de toekomst zul je over de hele wereld veel gelijkgestemde mensen vinden die hun kennis met je zullen delen en je de stimulans zullen geven om nieuwe experimenten te doen!

In het leven van een Arduino-ontwikkelaar komt er vroeg of laat een moment waarop de standaard ontwikkelomgeving druk wordt. Als de schetsen niet meer genoeg geheugen hebben, je hard realtime nodig hebt en met onderbrekingen werkt, of je wilt gewoon dichter bij de hardware zitten, dan is het tijd om over te stappen naar C. Ervaren elektronica-ingenieurs zullen minachtend fronsen bij het noemen van Arduino en sturen de nieuweling in een radiowinkel voor een soldeerbout. Dit is misschien niet het slechtste advies, maar we zullen het nog niet opvolgen. Als we de Arduino IDE en de bedradings-/verwerkingstaal achterwege laten, houden we een uitstekend debugging-bord over, dat al is uitgerust met alles wat nodig is voor de werking van de microcontroller. En, belangrijker nog, er is al een bootloader in het geheugen van de controller aangesloten, waardoor je de firmware kunt laden zonder een programmeur te gebruiken.

Om in C te programmeren hebben we AVR GCC Toolchain nodig.

We hebben ook de Arduino IDE nodig, omdat... het bevat het hulpprogramma avrdude, dat nodig is om de firmware naar de controller te downloaden. CrossPack bevat ook avrdude, maar de versie die erbij zit werkt niet met Arduino.

Nadat alles is geïnstalleerd, gaan we ons eerste project maken. Laten we om te beginnen schrijven Maakbestand. Hierdoor kunnen we voorkomen dat we elke keer dat we de firmware compileren en laden, handmatig lange opdrachten moeten invoeren.

#Controller geïnstalleerd op het bord. Kan anders zijn, bijvoorbeeld atmega328 DEVICE = atmega168 #Klokfrequentie 16 MHz CLOCK = 16000000 #Avrdude startcommando. Het moet worden gekopieerd van de Arduino IDE. AVRDUDE = /Applications/Arduino.app/Contents/Resources/Java/hardware/tools/avr/bin/avrdude -C/Applications/Arduino.app/Contents/Resources/Java/hardware/tools/avr/etc/avrdude.conf -carduino -P/dev/tty.usbserial-A600dAAQ -b19200 -D -p atmega168 OBJECTS = main.o COMPILE = avr-gcc -Wall -Os -DF_CPU=$(CLOCK) -mmcu=$(DEVICE) alles: main .hex .c.o: $(COMPILE) -c $< -o $@ .S.o: $(COMPILE) -x assembler-with-cpp -c $< -o $@ .c.s: $(COMPILE) -S $< -o $@ flash: all $(AVRDUDE) -U flash:w:main.hex:i clean: rm -f main.hex main.elf $(OBJECTS) main.elf: $(OBJECTS) $(COMPILE) -o main.elf $(OBJECTS) main.hex: main.elf rm -f main.hex avr-objcopy -j .text -j .data -O ihex main.elf main.hex avr-size --format=avr --mcu=$(DEVICE) main.elf

In dit bestand moeten we onze opdracht invoeren om avrdude te starten. Op verschillende systemen zal het er anders uitzien. Om uw optie te achterhalen, start u de Arduino IDE en vinkt u het vakje "Toon uitgebreide uitvoer tijdens upload" aan in de instellingen.

Nu laden we elke schets in Arduino en kijken naar de berichten die onderaan het venster worden weergegeven. We vinden daar de avrdude-aanroep, kopiëren alles behalve de parameter -Uflash en plakken deze in de Makefile na “AVRDUDE = “.

Een korte opmerking: alle inspringingen in de Makefile gebeuren met tabtekens (Tab-toets). Als uw teksteditor deze tekens vervangt door spaties, zal het make-commando weigeren het project te bouwen.

Laten we nu een bestand maken hoofd.c- de daadwerkelijke tekst van ons programma, waarin we traditioneel de LED knipperen.

#erbij betrekken #erbij betrekken #define LED_PIN 5 int main() ( DDRB |= 1<< LED_PIN; while(1) { PORTB |= 1 << LED_PIN; _delay_ms(1000); PORTB &= ~(1 << LED_PIN); _delay_ms(1000); } return 0; }

Ons project is klaar. Laten we de console in onze projectmap openen en de opdracht “make” invoeren:

Zoals u kunt zien, is de grootte van de resulterende firmware slechts 180 bytes. Een soortgelijke Arduino-schets neemt 1116 bytes in beslag in het geheugen van de controller.

Laten we nu teruggaan naar de console en "make flash" invoeren om het gecompileerde bestand in de controller te laden:

Als de download zonder fouten is voltooid, knippert de LED die is aangesloten op pin 13 van het bord vrolijk. Soms kan avrdude het bord niet vinden of valt het eraf vanwege een time-out - in dit geval kan het draaien van de USB-kabel helpen. Om conflicten met de toegang tot het bord te voorkomen, vergeet ook niet de Arduino IDE te sluiten vóór de opdracht “make flash”.

Misschien zullen veel van de dingen die in dit artikel worden beschreven voor de doorgewinterde ontwikkelaars vanzelfsprekend lijken. Ik heb geprobeerd het proces te beschrijven in een taal die zo begrijpelijk mogelijk is voor een beginnende Arduino-gebruiker en de informatie die ik uit verschillende bronnen kon verkrijgen en empirisch geverifieerd op één plek te verzamelen. Misschien bespaart dit artikel iemand een paar uur tijd.

Veel succes met het beheersen van microcontrollers!

28 09.2016

Heeft u er ooit aan gedacht om uw leven thuis gemakkelijker te maken? Om dingen te hebben die alledaagse, routinematige taken voor u zouden oplossen. Een slim apparaat dat een nuttige functie zou vervullen, bijvoorbeeld de tuin water geven, een kamer schoonmaken of een last dragen. Deze problemen kunnen worden opgelost. Maar alleen kopen is niet genoeg. Elke industriële logische controller of chip heeft een ‘brein’ nodig om een ​​bepaalde reeks acties uit te voeren. Voor het uitvoeren van bewerkingen is in ons geval de programmeertaal Arduino geschikt.

Uit dit artikel leer je:

Gegroet, vrienden! Voor degenen die mij niet kennen: mijn naam is Gridin Semyon. Je kunt over mij lezen. Het artikel van vandaag zal worden gewijd aan twee hoofdprogramma's, zonder welke we geen verdere beweging en wederzijds begrip zullen hebben.

Algemene beschrijving van programmeertalen

Zoals ik hierboven schreef, zullen we twee populaire ontwikkelomgevingen beschouwen. Naar analogie met, kan worden onderverdeeld in een grafische editor en een “slim notitieblok”. Dit zijn Arduino IDE- en FLprog-programma's.

De basis van de ontwikkelomgeving is Processing/Wiring – dit is regulier C++, aangevuld met functies en diverse bibliotheken. Er zijn verschillende versies voor Windows-, Mac OS- en Linux-besturingssystemen.

Wat is hun fundamentele verschil?? De Arduino IDE is een ontwikkelomgeving die programmacode beschrijft. En FLprog is vergelijkbaar met CFC CoDeSyS, waarmee u diagrammen kunt tekenen. Welke omgeving is beter? Beide zijn op hun eigen manier goed en handig, maar als je serieus met controllers aan de slag wilt, kun je het beste talen leren die vergelijkbaar zijn met SI. Hun belangrijkste voordeel is de flexibiliteit en het onbeperkte karakter van het algoritme. Ik hou echt van de Arduino IDE.

Beschrijving van Arduino IDE

De distributie kan worden gedownload van officiële website. Download het archief, het neemt iets meer dan 100 MB in beslag. De installatie is standaard, zoals alle applicaties voor Windows. Stuurprogramma's voor alle soorten kaarten moeten in het pakket worden geïnstalleerd. En zo ziet het werkvenster van het programma eruit.

De Arduino-ontwikkelomgeving bestaat uit:

• programmacode-editor;
• berichtgebieden;
• tekstuitvoervensters;
• werkbalken met knoppen voor veelgebruikte opdrachten;
• meerdere menu's

Arduino IDE-instellingen

Een programma dat in de Arduino-ontwikkelomgeving is geschreven, wordt aangeroepenschetsen. De schets is geschreven in een teksteditor, die kleuraccentuering heeft van de gemaakte programmacode. Een voorbeeld van een eenvoudig programma in de onderstaande afbeelding.

Extra functionaliteit kan worden toegevoegd met behulp vanbibliotheken,die code vertegenwoordigt die op een speciale manier is ontworpen. In principe is het niet toegankelijk voor de ontwikkelaar. De omgeving wordt meestal geleverd met een standaardset, die geleidelijk kan worden aangevuld. Ze staan ​​in de submapbibliotheken Arduino-map.

Bij veel bibliotheken worden voorbeelden in de map geleverdvoorbeeld.Als u een bibliotheek in het menu selecteert, wordt de volgende regel aan de broncode toegevoegd:

Arduino

#erbij betrekken

#erbij betrekken

Dit is een richtlijn - een soort instructie, een headerbestand dat objecten, functies en bibliotheekconstanten beschrijft. Voor de meest voorkomende taken zijn al veel functies ontwikkeld. Geloof me, dit maakt het leven van een programmeur gemakkelijker.

Nadat we het elektronische bord op de computer hebben aangesloten. We maken de volgende instellingen: selecteer het Arduino-bord en de Com-poort waarmee we verbinding zullen maken.

Arduino

void setup() ( // initialiseer digitale pin 13 als uitvoer. pinMode(13, OUTPUT); ) void loop() ( digitalWrite(13, HIGH); delay(1000); digitalWrite(13, LOW); delay(1000 );

ongeldige setup() ( // initialiseer digitale pin 13 als uitvoer. pinModus(13, UITVOER); lege lus() ( digitalWrite(13, HOOG); vertraging(1000); digitalWrite(13, LAAG); vertraging(1000);

Het is dus handig om de functionaliteit van het bord dat uit de winkel komt te controleren. Snel en gemakkelijk.

Er is nog iets handigs. Het heetSeriële poortmonitor (Seriële monitor). Geeft gegevens weer die naar het platform zijn verzondenArduino.Meestal kijk ik welke signalen de verschillende sensoren die op het bord zijn aangesloten mij geven.

Bibliotheken verbinden

Er zijn verschillende manieren om aangepaste functies toe te voegen. U kunt bibliotheken op drie manieren verbinden:

1. Bibliotheekbeheer gebruiken
2. Importeren als .zip-bestand gebruiken
3. Handmatige installatie.

1. Bibliotheekbeheer gebruiken.Selecteer in het werkvenster van het programma het tabblad Schets. Klik daarna op de knop Bibliotheek verbinden. De bibliotheekmanager gaat voor ons open. Het venster toont reeds geïnstalleerde bestanden met een handtekeninggeïnstalleerden die kunnen worden geïnstalleerd.

2. Importeren als .zip-bestand gebruiken.Vaak kunt u op internet bibliotheekbestanden vinden die zijn verpakt in archieven met een zip-extensie. Het bevat een headerbestand.h en een codebestand.cpp. Tijdens de installatie hoeft u het archief niet uit te pakken. Ga gewoon naar het Schetsmenu - Bibliotheek verbinden - .ZIP-bibliotheek toevoegen

3. Handmatige installatie.Sluit eerst het Arduino IDE-programma. We pakken eerst ons archief uit. En we zetten de bestanden met de extensie .h en .cpp over naar een map met dezelfde naam als het archief. Plaats de map in de hoofdmap.

Mijn Documenten\Arduino\bibliotheken

Beschrijving van FLPprog

FLprog is een gratis project van onafhankelijke ontwikkelaars waarmee u met functieblokken of ladderdiagrammen kunt werken. Deze omgeving is handig voor mensen, niet voor programmeurs. Hiermee kunt u het algoritme visueel en duidelijk zien met behulp van diagrammen en functionele blokken. Je kunt de distributie downloaden op officiële website.

Ik volg het project al een hele tijd. De jongens ontwikkelen zich, voegen voortdurend nieuwe functionaliteit toe en veranderen oude. Ik zie beloftes in deze omgeving. Omdat het twee belangrijke functies vervult:eenvoud en gebruiksgemak.

Laten we proberen een eenvoudig project te maken. We schakelen uitgang 13 naar LED.

Laten we een nieuw project maken. Voeg in het bovenste venster het vereiste aantal in- en uitgangen toe, stel een naam in en wijs een fysieke in- of uitgang toe aan de kaart.

We halen de elementen die we nodig hebben uit de objectboom en de elementen die we nodig hebben naar het bewerkingsplan. In ons geval kunnen we een eenvoudige RS-trigger gebruiken om hem aan en uit te zetten.

Nadat u het algoritme heeft gemaakt, klikt u op de compileerknop, het programma levert een kant-en-klare schets in de IDE.

We hebben gekeken naar de mogelijkheden en het gemak van programma's voor het ontwikkelen van algoritmen op de Arduino-seriecontroller. Er zijn ook programma's waarmee u structurele diagrammen en visuele afbeeldingen kunt maken. Maar ik raad aan een teksteditor te gebruiken, omdat dit later gemakkelijker voor je zal zijn. Vertel me, welke omgeving is voor jou het handigst en waarom?

Op 22 september nam ik deel aan een seminar in Krasnodar “Touchpanel-controllers OVEN SPK.” De conferentie werd gehouden in het modieuze en prachtige Bristol Hotel. Het was erg interessant en cool.

In het eerste deel van het seminar werden we verteld over de mogelijkheden en voordelen van OWEN-producten. Daarna was er een koffiepauze met donuts. Ik pakte een heleboel dingen, donuts, koekjes en snoepjes, omdat ik erg honger had =)

In het tweede deel van het seminar, na de lunch, werden we voorgesteld. Ze vertelden ons veel over webvisualisatie. Deze trend begint momentum te krijgen. Bedien de apparatuur natuurlijk via elke internetbrowser. Dit is echt gaaf. Overigens zit de apparatuur zelf in de koffer.

Ik zal in de nabije toekomst een serie artikelen over CoDeSyS 3.5 publiceren. Dus als iemand geïnteresseerd is, abonneer je dan of kom gewoon langs. Ik zal altijd blij zijn!!!

Trouwens, ik was het bijna vergeten, het volgende artikel gaat over het Arduino-elektronische bord. Het zal interessant zijn, mis het niet.

Tot ziens in de volgende artikelen.

Met vriendelijke groet, Gridin Semyon.