Basisprincipes van Arduino-programmeervoorbeelden. Arduino voor beginners: stapsgewijze instructies

Je zult nodig hebben

• - Arduino UNO-bord,
• - USB-kabel (USB A - USB B),
• - pc,
• - LED,
• - weerstand 220 Ohm,
• - een paar draden van 5-10 cm,
• - indien aanwezig - broodplank.

Instructies

Download de Arduino-ontwikkelomgeving voor uw besturingssysteem (Windows, Mac OS X, Linux worden ondersteund) op de pagina http://arduino.cc/en/Main/Software, u kunt deze installeren, dat kan. Het gedownloade bestand bevat ook stuurprogramma's voor Arduino-borden.

Installeer het stuurprogramma. Overweeg de optie voor Windows OS. Wacht hiervoor totdat het besturingssysteem u vraagt ​​het stuurprogramma te installeren. Afwijzen. Druk op Win + Pauze, start Apparaatbeheer. Zoek het gedeelte 'Poorten (COM & LPT)'. Je zult daar een poort zien genaamd "Arduino UNO (COMxx)". Klik er met de rechtermuisknop op en selecteer "Stuurprogramma bijwerken". Selecteer vervolgens de locatie van het stuurprogramma dat u zojuist hebt gedownload.

De ontwikkelomgeving bevat al veel voorbeelden om de werking van het bord te bestuderen. Open het "Blink"-voorbeeld: Bestand > Voorbeelden > 01.Basics > Blink.

Wijs uw ontwikkelomgeving naar uw bord. Om dit te doen, selecteert u in het menu Extra > Bord de optie "Arduino UNO".

Selecteer de poort waaraan het Arduino-bord is toegewezen. Om erachter te komen op welke poort het bord is aangesloten, start u Apparaatbeheer en zoekt u naar het gedeelte Poorten (COM & LPT). De poort wordt tussen haakjes achter de naam van het bord aangegeven. Als het bord niet in de lijst staat, probeer het dan vanaf de computer, wacht een paar seconden en probeer het opnieuw.

Koppel het bord 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 via een weerstand op digitale pin 13 van het Arduino-bord. Het is handiger om een ​​breadboard te gebruiken, maar als deze niet beschikbaar is, kunt u de draden aansluiten door ze te draaien.
Belangrijke opmerking! Digitale pin 13 heeft al een eigen weerstand op het bord. Daarom is het bij het aansluiten van een LED op het bord niet nodig om een ​​externe weerstand te gebruiken. Bij het aansluiten van een LED op andere Arduino-pinnen is het gebruik verplicht!

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 "Uploaden" en de jouwe wordt naar het geheugen van het Arduino-bord geschreven. Programmeren met Arduino is zeer intuïtief en helemaal niet moeilijk. Kijk naar de afbeelding - er staan ​​kleine uitleg in de opmerkingen bij het programma. Dit is voldoende om u op weg te helpen met uw eerste experiment.

Video over het onderwerp

Let op

Wees voorzichtig bij het werken met het Arduino-bord - dit is een elektronisch product dat een zorgvuldige omgang vereist. Er bevinden zich blootliggende geleiders aan de onderkant van het bord en als u het bord op een geleidend oppervlak plaatst, bestaat de kans dat het bord verbrandt. Raak de plank ook niet aan met vochtige of natte handen en vermijd vochtige plekken tijdens het werken.

Nuttig advies

Er zijn veel sites op internet gewijd aan Arduino. Lees, beheers, wees niet bang om te experimenteren en nieuwe dingen te leren!

Bronnen:

• Knipperende LED

Programmeren trekt en interesseert veel moderne mensen, vooral jonge en beginnende professionals die net beginnen met het kiezen van een toekomstig beroep. Ze worden vaak geconfronteerd met de vraag: waar moeten ze beginnen bij het leren programmeren? Als u besluit te leren programmeren, mag u geen veelgemaakte fout maken - neem niet meteen complexe systemen en talen aan (bijvoorbeeld C). Als u begint met een taal die te complex is, kunt u een verkeerde indruk krijgen van programmeren in het algemeen. Beginners wordt aangeraden om met de eenvoudigste systemen te werken - leer bijvoorbeeld programma's schrijven in BASIC. Door deze taal te leren, kunt u in korte tijd goede resultaten behalen. PureBasic is gemakkelijk te leren - deze veelzijdige, krachtig gecompileerde taal zal u helpen de basisprincipes van programmeren te begrijpen en uw vaardigheden in de toekomst te verbeteren.

Instructies

Het kan ongeveer een jaar duren voordat u de basisbeginselen van programmeren onder de knie heeft. Je leert de kenmerken van procedureel en objectgeoriënteerd programmeren, principes van het werken met binaire bomen, arrays, lijsten, enz. Pas nadat je de basis hebt geleerd, kun je doorgaan met complexere taken.

Bezoek websites van programmeertaalontwikkelaars en bestudeer documentatie. Zorg ervoor dat u communiceert op programmeursforums; zij beantwoorden meestal de meeste vragen van beginners.

Wiskunde

Het leren eindigt nooit

Het is onmogelijk om altijd alles in je hoofd te houden. Voel je vrij om naslagwerken over programmeertalen te gebruiken.

Programmeerproblemen, hoe eenvoudig ze ook zijn, worden nooit in één keer opgelost. Ze vereisen altijd de ontwikkeling van het juiste algoritme van acties dat effectief is in een bepaalde specifieke situatie. Het vinden van optimale algoritmen vereist constante oefening en training. Probeer vaker kleine programmeerproblemen op te lossen (je kunt ze vinden op gespecialiseerde sites), dit zal je helpen je vaardigheden op dit gebied geleidelijk aan te scherpen.

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 harde 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 de vermelding 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 ingebouwd, 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 KLOK = 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, mag u ook niet vergeten 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 heb kunnen 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!

De basis van de programmeertaal van de Arduino-module is de C-taal (hoogstwaarschijnlijk C++). Om precies te zijn, dit dialect van de taal wordt Processing/Wiring genoemd. In de bijlage vindt u een goed overzicht van de taal. Maar ik wil het niet meer hebben over de taal, maar over programmeren.

Een programma is een bepaalde reeks opdrachten die worden begrepen door de processor, de processor van uw computer of de microcontrollerprocessor van de Arduino-module, het maakt niet uit. De processor leest de instructies en voert deze uit. Alle opdrachten die de processor begrijpt, zijn binaire getallen. Dit zijn gewoon binaire getallen en niets anders. Door de rekenkundige bewerkingen uit te voeren waarvoor de processor ooit is ontworpen, werkt de processor met getallen. Binaire getallen. En het blijkt dat zowel de commando's als waar ze naar verwijzen alleen maar binaire getallen zijn. Zoals dit. Maar hoe sorteert de processor deze ‘hoop’ binaire getallen?

Eerst worden al deze binaire getallen naar opeenvolgende RAM-cellen geschreven die adressen hebben. Wanneer je een programma laadt en het begint te draaien, krijgt de processor het eerste adres van het programma, waar het commando geschreven moet worden. De instructies die vereisen dat de processor met getallen werkt, hebben ‘identificatiemarkeringen’, bijvoorbeeld dat er in de volgende twee geheugencellen twee getallen moeten worden toegevoegd. En de teller, laten we het een programmateller noemen, waar het adres van het volgende commando wordt geschreven, verhoogt in dit geval het adres zodat het programma het volgende commando op dit adres zal bevatten. Als het programma niet correct werkt of als er fouten optreden, kan de processor een fout maken, en nadat hij een getal heeft gelezen in plaats van een commando, doet de processor iets heel anders dan hij zou moeten doen, en het programma "loopt vast".

Elk programma is dus een reeks binaire getallen. En programmeren is het vermogen om de juiste reeks binaire getallen correct te schrijven. Heel lang geleden werden speciale tools, programmeertalen genaamd, gebruikt om programma's te schrijven.

Elk programma vereist echter eerst dat u een duidelijk begrip heeft van wat het programma moet doen en waarom het nodig is. Hoe duidelijker u dit begrijpt, hoe gemakkelijker het is om een ​​programma te maken. Hoewel het moeilijk te zeggen is welke programma's klein zijn en welke niet, kunnen kleine programma's als één geheel worden beschouwd. Complexere programma's kunnen het beste worden opgesplitst in delen die als onafhankelijke programma's kunnen worden behandeld. Dit maakt het beter om ze te maken, gemakkelijker te debuggen en te testen.

Ik ben niet bereid om ruzie te maken, maar ik denk dat het handiger is om een ​​programma te starten met een beschrijving in gewone taal. En in die zin ben ik van mening dat programmeren niet moet worden verward met het schrijven van programmacode. Wanneer een programma in gewone woorden wordt beschreven, kunt u bijvoorbeeld gemakkelijker bepalen welke programmeertaal u moet kiezen om de programmacode te maken.

Het dichtst bij het schrijven van een programma met behulp van binaire getallen is assembleertaal. Het wordt gekenmerkt door de overeenkomst tussen taalopdrachten en binaire opdrachten die door de processor worden begrepen. Maar het coderen van programma's in assembleertaal vergt veel inspanning en staat dichter bij een kunst dan bij formele handelingen. Talen op hoog niveau zoals BASIC of C zijn universeler en gemakkelijker te gebruiken. En lange tijd wordt een grafische taal gebruikt om programma's in een algemene vorm te schrijven, en onlangs zijn er "vertalers" van deze taal in de taal van processors verschenen.

Naast algemene programmeertalen is er altijd sprake geweest van enige specialisatie van programmeertalen, en er zijn gespecialiseerde talen geweest. Onder deze laatste zou ik ook de programmeertaal van de Arduino-module opnemen.

Alles wat we nodig hebben om de module te vertellen iets te doen wat we nodig hebben, is georganiseerd in een handige reeks opdrachten. Maar eerst: wat hebben we nodig van Arduino?

De module kan in verschillende capaciteiten worden gebruikt: het is het hart (of het hoofd) van de robot, het is de basis van het apparaat, het is ook een handige constructor om het werk met microcontrollers onder de knie te krijgen, enz.

Hierboven hebben we al eenvoudige programma's gebruikt om de verbinding van de module met de computer te controleren. Voor sommigen lijken ze misschien te simpel en daarom niet interessant, maar alle complexe programma's bestaan ​​uit eenvoudiger fragmenten, vergelijkbaar met de fragmenten waarmee we al kennis hebben gemaakt.

Laten we eens kijken wat het eenvoudigste programma "Blink an LED" ons kan vertellen.

int ledPin = 13;

pinMode(ledPin, UITGANG);

digitalWrite(ledPin, HOOG);

digitalWrite(ledPin, LAAG);

Laten we eerst onthouden wat een LED is. In wezen is dit een gewone diode, waarbij, vanwege het ontwerp, de junctie begint te gloeien wanneer de stroom in de voorwaartse richting vloeit. Dat wil zeggen, om een ​​LED te laten gloeien, moet er stroom doorheen stromen, wat betekent dat er spanning op de LED moet worden toegepast. En zodat de stroom de toegestane waarde niet overschrijdt, moet in serie met de LED een weerstand worden aangesloten, die een stroombegrenzende weerstand wordt genoemd (zie bijlage A, digitale uitgang). De spanning wordt op de LED aangebracht door de microcontroller die de basis vormt van de Arduino-module. De microcontroller beschikt, naast de processor die onze opdrachten uitvoert, over één of meerdere I/O-poorten. Zonder in te gaan op het specifieke apparaat van de poort, laten we dit zeggen: wanneer de poortpin als uitgang werkt, kan deze worden weergegeven als de uitgang van een digitale microschakeling met twee toestanden, aan en uit (er is spanning aan de uitgang (er staat geen spanning op de uitgang).

Maar dezelfde poortpin kan ook als invoer dienen. In dit geval kan het bijvoorbeeld worden weergegeven als de ingang van een digitale microschakeling - een logisch niveau, hoog of laag, wordt op de ingang toegepast (zie bijlage A, digitale ingang).

Hoe we de LED laten knipperen:

Schakel poortuitvoerpin in. Schakel de poortuitgang uit.

Maar de processor is erg snel. We zullen geen tijd hebben om het knipperen op te merken. Om dit knipperen op te merken, moeten we pauzes toevoegen. Dat is:

Schakel poortuitvoerpin in. Pauzeer 1 seconde.

Schakel de poortuitgang uit.

Pauzeer 1 seconde.

Dit is ons programma. De processor leest het eerste commando en zet de uitgang aan, de LED gaat branden. Vervolgens pauzeert de processor en schakelt de uitvoer uit, de LED gaat uit. Maar hij knipperde maar één keer.

De herhaling van een proces of een reeks opdrachten wordt in het programmeren een lus genoemd. Er worden verschillende soorten cycli gebruikt. Er is een lus die een bepaald aantal keren wordt uitgevoerd. Dit is een for-lus. Er zijn lussen die worden uitgevoerd totdat aan een bepaalde voorwaarde is voldaan, die deel uitmaakt van de lusconstructie in de taal. En als nooit aan de voorwaarde wordt voldaan, wordt de lus een oneindig aantal keren uitgevoerd. Het is een eindeloze cyclus.

Ik denk niet dat microcontrollers worden gebruikt met programma's van het hierboven getoonde type. Dat wil zeggen dat er meerdere opdrachten één keer worden uitgevoerd en dat de controller niet meer werkt. In de regel werkt hij continu zodra er voedingsspanning op staat. Dit betekent dat de microcontroller in een eindeloze lus moet werken.

Dit is precies wat de functie void loop() zegt: een lus is een lus, een gesloten lus. Er is geen voorwaarde voor het stoppen van de cyclus, en daarom is er ook geen voorwaarde voor de voltooiing ervan.

Bovendien moeten we de Arduino-module vertellen welke poortpin we willen gebruiken en hoe we deze willen gebruiken, voor uitvoer (OUTPUT) of voor invoer (INPUT). Dit doel wordt gediend door de functie void setup(), die verplicht is voor de Arduino-taal, zelfs als deze niet wordt gebruikt, en de opdracht pinMode() om de uitvoermodus in te stellen.

pinMode(ledPin, UITGANG);

En toch gebruikt de taalconstructie variabelen om het uitvoernummer te bepalen:

int ledPin = 13;

Het gebruik van variabelen is handig. Door te besluiten dat u uitgang 12 gaat gebruiken in plaats van uitgang 13, brengt u slechts een wijziging aan op één regel. Dit geldt vooral bij grote programma's. De naam van de variabele kan naar wens worden gekozen, maar over het algemeen mag deze alleen uit tekens bestaan ​​en is het aantal tekens vaak beperkt. Als je de naam van de variabele verkeerd instelt, denk ik dat de compiler je zal corrigeren.

De digitalWrite(ledPin, HIGH)-functie zet de opgegeven pin in een hoge status, dat wil zeggen, zet de pin aan.

En vertraging (1000) betekent, zoals je al begreep, een pauze van 1000 milliseconden of 1 seconde.

Het blijft de vraag wat voorvoegsels zoals int en void betekenen. Alle waarden en variabelen bevinden zich in het geheugen, net als programmaopdrachten. Getallen die vaak uit 8 bits bestaan, worden in geheugencellen geschreven. Dit is een byte. Maar een byte is een getal van 0 tot 255. Om grote getallen op te slaan, heb je twee bytes of meer nodig, dat wil zeggen twee of meer geheugencellen. Om het voor de processor duidelijk te maken hoe hij een getal kan vinden, hebben verschillende soorten getallen verschillende namen. Dus een getal genaamd byte zal één cel in beslag nemen, int (geheel getal, geheel getal) zal er meer in beslag nemen. Bovendien retourneren functies die in programmeertalen worden gebruikt ook getallen. Om te bepalen welk type getal een functie moet retourneren, plaatst u de functie vóór het geretourneerde type getal. Maar sommige functies retourneren mogelijk geen getallen; dergelijke functies worden voorafgegaan door de notatie void (zie Bijlage A, variabelen).

Zoveel interessants kan zelfs het eenvoudigste programma vertellen.

Ik hoop dat u dit allemaal kunt lezen in de bijlage. Laten we nu eenvoudige experimenten doen, waarbij we alleen gebruiken wat we al weten uit de mogelijkheden van de taal. Laten we eerst een variabele van het type int, die veel geheugenruimte in beslag neemt, vervangen door een byte: één plaats, één geheugencel. Laten we kijken wat we kunnen doen.

byte ledPin = 13;

pinMode(ledPin, UITGANG);

digitalWrite(ledPin, HOOG);

digitalWrite(ledPin, LAAG);

Na het compileren en laden van het programma in de module zullen we geen veranderingen merken in de werking van het programma. Prima. Vervolgens zullen we het programma wijzigen om veranderingen in de werking ervan op te merken.

Om dit te doen, zullen we het getal in de vertragingsfunctie (1000) vervangen door een variabele, die we my_del noemen. Deze variabele moet een geheel getal zijn, dat wil zeggen int.

int mijn_del = 5000;

Vergeet niet om elke opdracht te beëindigen met een puntkomma. Breng wijzigingen aan in het programma, compileer het en laad het in de module. Wijzig vervolgens de variabele en compileer en laad opnieuw:

byte mijn_del = 5000;

Ik ben er zeker van dat het verschil merkbaar zal zijn.

Laten we nog een experiment doen met het wijzigen van de duur van pauzes. Laten we de duur van pauzes bijvoorbeeld vijf keer verkorten. Laten we twee seconden pauzeren en het dan ook vijf keer verhogen. En opnieuw pauzeren we 2 seconden. Een lus die een bepaald aantal keren wordt uitgevoerd, wordt een for-lus genoemd en wordt als volgt geschreven:

voor (int i = 0; ik<5; i++)

iets dat in een for-lus wordt uitgevoerd

Om de lus uit te voeren, heeft deze een variabele nodig, voor ons is dat i, de variabele moet een initiële waarde krijgen, die we eraan hebben toegewezen. Dan volgt de voorwaarde voor het beëindigen van de lus, we hebben i kleiner dan 5. En de invoer i++ is een typische invoer in de C-taal voor het verhogen van een variabele met één. Accolades beperken de reeks opdrachten die in een for-lus kunnen worden uitgevoerd. Andere programmeertalen kunnen verschillende scheidingstekens hebben om een ​​blok functiecode te markeren.

Binnen de lus doen we hetzelfde als voorheen, met een paar kleine wijzigingen:

voor (int i = 0; ik<5; i++)

digitalWrite(ledPin, HOOG);

digitalWrite(ledPin, LAAG);

mijn_del = mijn_del - 100;

We hebben het hierboven gehad over het wijzigen van het pauzerecord, en het wijzigen van de pauze zelf wordt bereikt door de variabele met 100 te verlagen.

Voor de tweede lus schrijven we hetzelfde codeblok, maar verhogen we de variabele pauzeduur met 100.

voor (int i = 0; ik<5; i++)

digitalWrite(ledPin, HOOG);

digitalWrite(ledPin, LAAG);

Je hebt gemerkt dat de opname van een afname van de pauze en een toename ervan er anders uitzien. Dit is ook een kenmerk van de C-taal. Hoewel deze invoer voor de duidelijkheid had moeten worden herhaald, waarbij alleen het minteken in plus moest worden veranderd. We krijgen dus dit programma:

int ledPin = 13;

int mijn_del = 1000;

pinMode(ledPin, UITGANG);

voor (int i = 0; ik<5; i++)

digitalWrite(ledPin, HOOG);

digitalWrite(ledPin, LAAG);

voor (int i = 0; ik<5; i++)

digitalWrite(ledPin, HOOG);

digitalWrite(ledPin, LAAG);

Laten we de code van ons programma naar het Arduin-programma kopiëren, compileren en in de module laden. De verandering in de duur van pauzes is merkbaar. En het zal nog meer opvallen, probeer het als de for-lus bijvoorbeeld 8 keer wordt uitgevoerd.

Wat we zojuist hebben gedaan, is wat professionele programmeurs doen: met een kant-en-klaar programma kan het eenvoudig worden aangepast aan uw behoeften of wensen. Daarom slaan ze al hun programma's op. Wat ik je ook adviseer te doen.

Wat hebben we gemist in ons experiment? Wij hebben geen commentaar gegeven op ons werk. Om een ​​opmerking toe te voegen, gebruikt u een dubbele schuine streep naar voren of een enkele schuine streep, maar dan met sterretjes (zie Bijlage A). Ik raad je aan dit zelf te doen, want als je na een tijdje terugkeert naar het programma, zul je het gemakkelijker begrijpen als er op een of andere plek in het programma uitleg staat over wat je doet. En ik raad je ook aan om de beschrijving ervan in gewone taal, gemaakt in een willekeurige teksteditor, op te slaan in de map bij elk programma.

Het eenvoudigste programma “knipperen met een LED” kan dienen voor nog een tiental experimenten (zelfs met één LED). Het lijkt mij dat dit deel van het werk, het op een interessante manier bedenken van wat er nog meer gedaan kan worden, het meest interessant is. Als u naar de bijlage verwijst waar de programmeertaal wordt beschreven, naar het gedeelte “programmabeheer”, kunt u de for-lus vervangen door een ander soort lus. En probeer hoe andere soorten fietsen werken.

Hoewel een microcontrollerprocessor, net als elke andere, berekeningen kan uitvoeren (daarom is hij uitgevonden) en dit bijvoorbeeld in apparaten wordt gebruikt, is de meest typische handeling voor een microcontroller het instellen van de poortuitgang op een hoge of lage status, dat wil zeggen: “knipperen van de LED” als reactie op externe gebeurtenissen.

De microcontroller leert over externe gebeurtenissen voornamelijk door de status van de ingangen. Door de poortpinnen op een digitale ingang in te stellen, kunnen we deze monitoren. Als de beginstatus van de invoer hoog is en een gebeurtenis ervoor zorgt dat de invoer laag wordt, kunnen we iets doen als reactie op die gebeurtenis.

Het eenvoudigste voorbeeld is een knop bij de ingang. Wanneer de knop niet wordt ingedrukt, bevindt de ingang zich in een hoge status. Als we op de knop drukken, wordt de ingang laag en kunnen we de LED aan de uitgang “aansteken”. De volgende keer dat u op de knop drukt, kan de LED worden uitgeschakeld.

Dit is weer een voorbeeld van een eenvoudig programma. Zelfs een beginner kan het oninteressant vinden. Dit eenvoudige programma kan echter ook behoorlijk nuttige toepassingen vinden. Ik zal slechts één voorbeeld geven: nadat we op de knop hebben gedrukt, laten we de LED niet branden, maar gaan we (op een bepaalde manier) knipperen. En laten we een LED nemen met infraroodstraling. Als gevolg hiervan krijgen we een controlepaneel. Dit is zo'n eenvoudig programma.

Er zijn verschillen in de lijst met voorbeelden in verschillende versies van het programma. Maar u kunt de taalhandleiding in de bijlage raadplegen, die een voorbeeld en een programmadiagram bevat (in de voorbeeldensectie genaamd "appendix") voor het werken met invoer. Ik kopieer het programma:

int ledPin = 13;

pinMode(ledPin, UITGANG);

pinModus(inPin, INPUT);

als (digitalRead(inPin) == HOOG)

digitalWrite(ledPin, HOOG);

digitalWrite(ledPin, LAAG);

En zoals je kunt zien, krijgen we een compleet nieuw programma door het oude aan te passen. Nu knippert de LED alleen als de knop die op pin 2 is aangesloten, wordt ingedrukt. Pin 2 is via een weerstand van 10 kOhm met de gemeenschappelijke draad (aarde, GND) verbonden. De knop wordt aan de ene kant aangesloten op de +5V voedingsspanning en aan de andere kant op pin 2.

In het programma komen we een nieuwe taalconstructie tegen uit de programmabesturingssectie. Het luidt als volgt: als aan de voorwaarde (tussen haakjes) is voldaan, wordt het programmablok tussen accolades uitgevoerd. Merk op dat in de voorwaarde (digitalRead(inPin) == HIGH) de gelijkheid van de invoer naar de hoge status wordt gedaan met behulp van twee gelijktekens! Heel vaak wordt dit haastig vergeten en blijkt de toestand niet correct te zijn.

Het programma kan worden gekopieerd en in de Arduino-module worden geladen. Om de werking van het programma te controleren, moet u echter enkele wijzigingen aanbrengen in het moduleontwerp. Dit is echter afhankelijk van het type module. De originele module heeft aansluitingen voor aansluiting op uitbreidingskaarten. In dit geval kunt u geschikte massieve draden op de gewenste plaatsen in de connector steken. Mijn module heeft bladcontacten voor aansluiting op uitbreidingskaarten. Ik kan óf op zoek gaan naar een geschikte connector, óf, wat goedkoper is, een geschikte socket gebruiken voor de chip in een DIP-pakket.

De tweede vraag is: hoe vind je de modulepinnen die in het programma worden gebruikt?

De foto die ik van de site heb genomen: http://robocraft.ru/ zal je helpen dit uit te zoeken.

Rijst. 4.1. Locatie en doel van de pinnen van de controller en Arduino-module

Alle pinnen op mijn CraftDuino-module zijn gelabeld, dus het vinden van de pin die je nodig hebt is eenvoudig. U kunt een knop en een weerstand aansluiten en de werking van het programma controleren. Trouwens, op de bovengenoemde RoboCraft-website wordt het hele proces in afbeeldingen weergegeven (maar het programma gebruikt niet precies dezelfde conclusies!). Ik raad je aan om ernaar te kijken.

Veel microcontrollers bevatten extra hardwareapparaten. Atmega168, op basis waarvan de Arduino-module is samengesteld, heeft dus een UART, een ingebouwde eenheid voor communicatie met andere apparaten via seriële gegevensuitwisseling. Bijvoorbeeld met een computer via een COM-poort. Of met een andere microcontroller die gebruik maakt van het ingebouwde UART-blok. Er is ook een analoog-digitaalomzetter. En een pulsbreedtemodulatievormer.

Het gebruik van dat laatste wordt geïllustreerd door een programma dat ik ook van de RoboCraft-website zal kopiëren. Maar het programma kan ook uit de applicatie worden gehaald. En misschien staat het in de Arduino-programmavoorbeelden.

// Fading-LED van BARRAGAN

int-waarde = 0; // variabele om de gewenste waarde op te slaan

int ledpin = 9; // LED aangesloten op digitale pin 9

// U hoeft de pinMode-functie niet aan te roepen

voor(waarde = 0; waarde<= 255; value+=5) // постепенно зажигаем светодиод

analogWrite(ledpin, waarde); // uitgangswaarde (van 0 tot 255)

vertraging(30); // wachten 🙂

for(value = 255; value >=0; value-=5) // schakel de LED geleidelijk uit

analogWrite(ledpin, waarde);

Als in het vorige programma de functie digitalRead(inPin), het lezen van digitale invoer, nieuw voor ons was, dan is in dit programma de functie analogWrite(ledpin, value) nieuw voor ons, hoewel de parameters van deze functie variabelen zijn die ons al bekend zijn . We zullen het later hebben over het gebruik van de analoge ingang, met behulp van een ADC (analoog-naar-digitaal-omzetter). Laten we nu terugkeren naar algemene programmeerproblemen.

Programmeren is iets dat iedereen kan, maar het zal tijd kosten om zowel het programmeren als welke programmeertaal dan ook onder de knie te krijgen. Tegenwoordig zijn er een aantal programma's die je helpen het programmeren onder de knie te krijgen. En een daarvan houdt rechtstreeks verband met de Arduino-module. Het heet Scratch voor Arduino of kortweg S4A. U kunt dit programma vinden en downloaden op: http://seaside.citilab.eu/scratch/arduino. Ik weet niet hoe de naam van het programma precies wordt vertaald, maar ‘van nul af aan beginnen’ wordt vertaald als ‘vanaf nul beginnen’.

De S4A-projectwebsite heeft versies voor Windows en Linux, maar voor laatstgenoemd besturingssysteem is het programma klaar om te installeren in de Debian-distributieversie. Ik wil niet zeggen dat het niet met andere Linux-distributies kan worden gebruikt, maar eerst zullen we zien hoe we met de Arduino-module in Windows kunnen werken.

Nadat u het programma op de gebruikelijke manier hebt geïnstalleerd, kunt u de interface naar het Russisch configureren met behulp van de taalschakelaar.

Rijst. 4.2. Programma-interface taalschakelaar

Het eerste werkbalkpictogram geeft, wanneer erop wordt geklikt, alle mogelijke talen van de programma-interface weer. De Russische taal is te vinden in de sectie...

Rijst. 4.3. Lijst met talen voor gebruik in de programma-interface

... gemarkeerd als "meer...".

Als u niets doet, blijft de inscriptie in het rechtervenster “Zoekbord...” staan, maar wordt de module niet gevonden. Om de Arduino-module met het S4A-programma te verbinden, moet je iets anders downloaden van de projectwebsite.

Rijst. 4.4. Bestand om te uploaden naar de Arduino-module voor S4A

Dit bestand is niets meer dan een programma voor Arduino (Sketch). Dat wil zeggen, een tekstbestand dat naar de Arduino-editor kan worden gekopieerd, gecompileerd en in de module kan worden geladen. Nadat u het Arduino-programma hebt verlaten, kunt u het S4A-programma uitvoeren en de module bevindt zich nu.

Rijst. 4.5. De module verbinden met het programma

De analoge ingangen van de module zijn niet aangesloten, evenals de digitale ingangen, waardoor de weergegeven waarden voor de module voortdurend op willekeurige wijze veranderen.

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. programmeren, 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 paniekzin “AHHH!” op het scherm weergegeven.

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 verschillende balans tussen schrijfsnelheid, leesbaarheid en uitvoeringssnelheid.

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

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

Java-taal. Het kost relatief veel tijd om te schrijven; gemakkelijk te lezen; wordt vrij snel uitgevoerd, maar neemt veel geheugen in beslag:

);

mov ah, 9 int 21h ret; Datalijn1 db

Als we het hebben over Arduino of microcontrollers van Atmel, in welke taal kun je daar programma's voor schrijven? Het theoretische antwoord: welke dan ook. Maar in de praktijk beperkt de keuze zich tot de talen Assembler, C en C++. Dit komt door het feit dat ze, vergeleken met een desktopcomputer, over zeer beperkte middelen beschikken. Kilobytes geheugen, geen gigabytes. Megahertz op de processor, niet gigahertz. Dit is een prijs die moet worden betaald voor de lage kosten en de energie-efficiëntie.

Daarom hebben we een taal nodig die efficiënt kan compileren en uitvoeren. Dat wil zeggen, het wordt zo optimaal mogelijk vertaald naar 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. Vaker wel dan niet, zult u niet eens nadenken over wat u 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.

De succesvolle firmware wordt aangekondigd met de inscriptie “Done Uploading”.

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.

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 harde 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 de vermelding 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 ingebouwd, 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 KLOK = 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, mag u ook niet vergeten 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 heb kunnen 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!