I den här artikeln bestämde jag mig för att samla en komplett steg för steg guide för nybörjare i Arduino. Vi kommer att titta på vad Arduino är, vad du behöver för att börja lära dig, var man laddar ner och hur man installerar och konfigurerar programmeringsmiljön, hur det fungerar och hur man använder programmeringsspråket och mycket mer som är nödvändigt för att skapa fullfjädrad komplexa enheter baserade på familjen av dessa mikrokontroller.

Här ska jag försöka ge ett förtätat minimum så att du förstår principerna för att arbeta med Arduino. För en mer fullständig fördjupning i världen av programmerbara mikrokontroller, var uppmärksam på andra avsnitt och artiklar på denna webbplats. Jag kommer att lämna länkar till annat material på denna sida för en mer detaljerad studie av vissa aspekter.

Vad är Arduino och vad är det till för?

Arduino är elektronisk designer, vilket gör att vem som helst kan skapa en mängd olika elektromekaniska enheter. Arduino består av mjukvara och hårdvara. Programvara del innehåller en utvecklingsmiljö (ett program för att skriva och felsöka firmware), många färdiga och bekväma bibliotek och ett förenklat programmeringsspråk. Hårdvaran inkluderar en stor linje av mikrokontroller och färdiga moduler för dem. Tack vare detta är det väldigt enkelt att arbeta med Arduino!

Med hjälp av Arduino kan du lära dig programmering, elektroteknik och mekanik. Men det här är inte bara en pedagogisk konstruktör. Baserat på det kan du göra riktigt användbara enheter.
Börjar från enkla blinkljus, väderstationer, automationssystem och slutar med Smart hem, CNC-maskiner och obemannade luftfarkoster. Möjligheterna begränsas inte ens av din fantasi, eftersom det finns ett stort antal instruktioner och idéer för implementering.

Arduino startpaket

För att börja lära dig Arduino måste du skaffa själva mikrokontrollerkortet och ytterligare delar. Det är bäst att köpa ett Arduino startpaket, men du kan välja allt du behöver själv. Jag rekommenderar att du väljer ett set eftersom det är enklare och ofta billigare. Här är länkar till de bästa uppsättningarna och individuella delarna som du definitivt kommer att behöva studera:

Grundläggande Arduino-kit för nybörjare:	köpa
Stort set för utbildning och första projekt:	köpa
Uppsättning av ytterligare sensorer och moduler:	köpa
Arduino Uno är den mest grundläggande och bekväma modellen från linjen:	köpa
Lödfri brödbräda för enkel inlärning och prototyper:	köpa
Uppsättning av ledningar med praktiska kontakter:	köpa
LED-uppsättning:	köpa
Motståndssats:	köpa
Knappar:	köpa
Potentiometrar:	köpa

Arduino IDE utvecklingsmiljö

För att skriva, felsöka och ladda ner firmware måste du ladda ner och installera Arduino IDE. Det är väldigt enkelt och bekvämt program. På min hemsida har jag redan beskrivit processen att ladda ner, installera och konfigurera utvecklingsmiljön. Så här lämnar jag bara länkar till senaste versionen program och

Version	Windows	Mac OS X	Linux
1.8.2

Arduino programmeringsspråk

När du har ett mikrokontrollkort i dina händer och en utvecklingsmiljö installerad på din dator kan du börja skriva dina första skisser (firmware). För att göra detta måste du bli bekant med programmeringsspråket.

Arduino-programmering använder en förenklad version av C++-språket med fördefinierade funktioner. Precis som i andra C-liknande programmeringsspråk finns det ett antal regler för att skriva kod. Här är de mest grundläggande:

• Varje instruktion måste följas av ett semikolon (;)
• Innan du deklarerar en funktion måste du ange vilken datatyp som returneras av funktionen, eller ogiltig om funktionen inte returnerar ett värde.
• Det är också nödvändigt att ange datatypen innan en variabel deklareras.
• Kommentarer betecknas: // Inline och /* block */

Du kan lära dig mer om datatyper, funktioner, variabler, operatorer och språkkonstruktioner på sidan på Du behöver inte memorera och komma ihåg all denna information. Du kan alltid gå till referensboken och titta på syntaxen för en viss funktion.

All Arduino firmware måste innehålla minst 2 funktioner. Dessa är setup() och loop().

inställningsfunktion

För att allt ska fungera måste vi skriva en skiss. Låt oss få lysdioden att lysa efter att ha tryckt på knappen och slockna efter nästa tryck. Här är vår första skiss:

// variabler med stift för anslutna enheter int switchPin = 8; int ledPin = 11; // variabler för att lagra knappens status och LED boolean lastButton = LÅG; boolean currentButton = LÅG; boolesk ledOn = false; void setup() ( pinMode(switchPin, INPUT); pinMode(ledPin, OUTPUT); ) // funktion för att debouncing boolean debounse(boolean last) ( boolean current = digitalRead(switchPin); if(last != current) ( delay ( 5); current = digitalRead(switchPin); ) returström; ) void loop() ( currentButton = debounse(lastButton); if(lastButton == LOW && currentButton == HIGH) ( ledOn = !ledOn; ) lastButton = currentButton ; digitalWrite(ledPin, ledOn); )

// variabler med stift för anslutna enheter int switchPin = 8 ; int ledPin = 11 ; // variabler för att lagra status för knappen och lysdioden boolean lastButton = LÅG ; boolean currentButton = LÅG ; boolean ledOn = false ; void setup() ( pinMode(switchPin, INPUT); pinMode(ledPin, OUTPUT); // funktion för avstudsning boolean debounse (boolean sist ) ( boolesk ström = digitalRead(switchPin); if (sista != aktuell ) ( fördröjning(5); ström = digitalRead(switchPin); returström ; void loop() ( currentButton = debounse(lastButton); if (lastButton == LOW && currentButton == HIGH ) ( ledOn = ! ledOn ; lastButton = currentButton ; digitalWrite(ledPin, ledOn);

I den här skissen skapade jag ytterligare funktion debounse för att undertrycka kontaktstuds. Det finns information om kontaktstuds på min hemsida. Var noga med att kolla in detta material.

PWM Arduino

Pulsbreddsmodulering (PWM) är processen att styra spänningen med hjälp av en signals arbetscykel. Det vill säga att med PWM kan vi smidigt kontrollera belastningen. Till exempel kan du smidigt ändra ljusstyrkan på en LED, men denna förändring i ljusstyrka erhålls inte genom att minska spänningen, utan genom att öka intervallen för den låga signalen. Funktionsprincipen för PWM visas i detta diagram:

När vi applicerar PWM på lysdioden börjar den snabbt lysa och slockna. Det mänskliga ögat kan inte se detta eftersom frekvensen är för hög. Men när du spelar in video kommer du med största sannolikhet att se ögonblick när lysdioden inte lyser. Detta kommer att hända förutsatt att kamerans bildhastighet inte är en multipel av PWM-frekvensen.

Arduino har en inbyggd pulsbreddsmodulator. Du kan bara använda PWM på de stift som stöds av mikrokontrollern. Till exempel har Arduino Uno och Nano 6 PWM-stift: dessa är stift D3, D5, D6, D9, D10 och D11. Stiften kan skilja sig åt på andra brädor. Du kan hitta en beskrivning av tavlan du är intresserad av

För att använda PWM i Arduino finns det en funktion.Den tar som argument pinnumret och PWM-värdet från 0 till 255. 0 är 0% fyllning med en hög signal, och 255 är 100%. Låt oss skriva en enkel skiss som ett exempel. Låt oss få lysdioden att lysa mjukt, vänta en sekund och tona ut lika smidigt, och så vidare i oändlighet. Här är ett exempel på hur du använder den här funktionen:

// Lysdioden är ansluten till stift 11 int ledPin = 11; void setup() ( pinMode(ledPin, OUTPUT); ) void loop() ( för (int i = 0; i< 255; i++) { analogWrite(ledPin, i); delay(5); } delay(1000); for (int i = 255; i >0; i--) ( analogWrite(ledPin, i); delay(5); ) )

// LED ansluten till stift 11 int ledPin = 11 ; void setup() ( pinMode(ledPin, OUTPUT); void loop() ( för (int i = 0 ; i< 255 ; i ++ ) { analogWrite(ledPin, i); fördröjning(5); fördröjning(1000); för (int i = 255; i > 0; i -- ) (

Hur man väljer Arduino′ Den här frågan uppstår för alla som bestämde sig för att skapa ett projekt med Arduino för första gången. Vi bestämde oss för de nödvändiga detaljerna: sensorer, sensorer, moduler, etc., och stod inför ett stort sortiment av Arduino-kort, dessutom har varje kort också två eller tre analoger. Vissa människor tror att ju dyrare och kraftfullare desto bättre, de köper seriösa lösningar, som Arduino Due, och sedan inser de att inte alla skisser fungerar på det, och det är svårt för dem att klara av den här enhetens fulla kraft själva. Andra tar den motsatta vägen och möter resursbegränsningar (minne, stift, portar, klockfrekvens, näring). Hur hittar man den gyllene medelvägen? Låt oss försöka lista ut det...

Betala	fördelar	Minus
Arduino Uno funktionalitet som ProMini och Nano	Brädan är den vanligaste i Arduino-familjen, det största antalet lektioner har skapats för det. Tack vare närvaron av en DIP-panel kan du byta mikrokontroller	Med samma funktionalitet som Arduino ProMini, Nano och Micro är brädan många gånger större i storlek
Arduino Mega 2560	Sköldar skapade för Arduino UNO är lämpliga Maximalt antal stift Utökad kapacitet för alla typer av minne	Kan inte installeras på Breadboard utan att använda kablar
Arduino Leonardo funktionalitet som MICRO	Sköldar skapade för Arduino UNO är lämpliga Tavlan är en förbättrad version av Arduino UNO och fungerar med de flesta av dess skisser	Kan inte installeras på Breadboard utan att använda kablar Vissa skisser skapade för Arduino Uno fungerar inte på Leonardo, eftersom... olika mikrokontroller används
Arduino Due	Antal pins som Arduino Mega Två analoga utgångar har implementerats Använder en kraftfull 32-bitars mikrokontroller med en klockfrekvens på 84 MHz	Kan inte installeras på Breadboard utan att använda kablar Största brädstorleken i hela Arduino-familjen Alla skisser ger inte så hög klockfrekvens Allt är inte sköld tillhandahålla överföring av signaler med en gränsspänning på 3,3V Matningsspänning 3,3V
Arduino ProMini 3.3V funktionalitet som Nano och UNO		Den lägsta klockfrekvensen för en mikrokontroller, endast 8 MHz Matningsspänning 3,3V
Arduino ProMini 5V funktionalitet som Nano och UNO	Kan användas för att designa diagram på Breadboard Den minsta brädan i Arduino-familjen Levereras utan lödstiftskontakter, möjliggör ytmontering	Sköldar skapade för Arduino UNO är inte lämpliga Det finns ingen USB-kontroller, vilket kräver en extern programmerare
Arduino NANO V3.0 funktionalitet som ProMini och UNO	Kan användas för att designa diagram på Breadboard Kortet är något större än Arduino ProMini, men har en USB-port och kräver inte användning av en extern programmerare	Sköldar skapade för Arduino UNO är inte lämpliga Införandet av en USB-port med en kontroller ledde till en ökning av mängden flashminne som allokerats för bootloadern (jämfört med Arduino ProMini)
Arduino MICRO funktionalitet som Leonardo	Kan användas för att designa diagram på Breadboard Brädan är något större än Arduino Nano, men har alla funktioner som Arduino Leonardo Det går att simulera olika USB-enheter när den är ansluten till en PC (kortet kommer att upptäckas som en mus, tangentbord, etc.)	Sköldar skapade för Arduino UNO är inte lämpliga Överföring av USB-kontrollfunktionen till mikrokontrollern ledde till en ökning av mängden flashminne som allokerats för bootloadern

Den första frågan som påverkar valet av Arduino- vilket projekt vill du genomföra?

Om du vill skapa ett färdigt projekt, vänligt tillhandahållna av andra utvecklare, då skulle det logiska köpet vara Arduino som projektet ursprungligen skapades på. Det är värt att notera här det faktum att nu, i Ryska federationen, distribueras Arduino-brädor under varumärket Geduino . Det vill säga, som du korrekt förstått, skiljer sig Arduino Micro från Geduino Micro i namn och logotyp (detta är inte en analog), som skrivet på den officiella hemsidan. Och eftersom det senare är billigare är valet självklart.

Om du inte har bestämt dig för ett projekt, men vill köpa en Arduino för dina egna experiment, då är en viktig faktor kvantiteten olika exempel på nätverket, under en eller annan Arduino. Den otvivelaktiga ledaren här är Arduino UNO , detta förklaras av det faktum att denna bräda är den äldsta i Arduino-linjen, men är inte föråldrad, eftersom den har genomgått en hel del förändringar sedan den skapades.

Om du planerar att genomföra ditt eget projekt, då valet av Arduino bör närma sig genom metod för eliminering. Om ditt projekt har moduler med stift för Arduino Uno, exkludera Arduino ProMini 3.3V, Arduino ProMini 5V, en analog till Arduino Nano), men kan ha en annan typ av USB-kontakt, vara något annorlunda i storlek, ha en annan USB-kontroller, en annan typ av mikrokontrollerfodral, kortfärg osv. Här måste du förstå att dessa kort upprepar funktionaliteten för deras original (som de liknar i namn), eftersom de använder samma ATmega-mikrokontroller i samma serie. Kortdimensioner, mikrokontrollerhus och typ USB uttag, kan avgöras från bilden. Och närvaron av "CH340G" i namnet betyder att USB-styrenheten inte är ett standard FTDI-chip för Arduino, utan dess analoga CH340G, därför, för att ansluta en sådan Arduino till en dator, måste du installera en drivrutin för CH340G-chippet . Dessa brädor är lämpliga för dem som anser att en engångsinstallation av drivrutiner inte är en olägenhet, och det reducerade priset är en fördel jämfört med det ursprungliga namnet.

Arduino är mycket populär bland alla designentusiaster. De som aldrig hört talas om det bör också introduceras för det.

Vad är Arduino?

Hur kan du kort beskriva Arduino? Med optimala ord kommer att vara: Arduino är ett verktyg med vilket du kan skapa olika elektroniska apparater. I grund och botten är detta en äkta maskinvaruplattform för allmänna ändamål. Den kan användas för att bygga enkla kretsar, och för genomförandet av ganska komplexa projekt.

Designern är baserad på dess hårdvara, som är ett input-output-kort. För att programmera kortet används språk som är baserade på C/C++. De kallas respektive Processing/Wiring. Från grupp C ärvde de extrem enkelhet, tack vare vilken de kan bemästras mycket snabbt av vilken person som helst, och att tillämpa kunskap i praktiken är inte ett ganska betydande problem. Så att du förstår hur lätt det är att arbeta, sägs det ofta att Arduino är för nybörjare som trollkarlar. Även barn kan förstå Arduino-brädor.

Vad kan du samla på den?

Tillämpningarna av Arduino är ganska olika; den kan användas både för de enklaste exemplen, som kommer att rekommenderas i slutet av artikeln, och för ganska komplexa mekanismer, inklusive manipulatorer, robotar eller produktionsmaskiner. Vissa hantverkare lyckas använda sådana system för att göra surfplattor, telefoner, hemövervaknings- och säkerhetssystem, smarta hemsystem eller helt enkelt datorer. Arduino-projekt för nybörjare, som även de utan erfarenhet kan komma igång med, finns i slutet av artikeln. De kan till och med användas för att skapa primitiva system virtuell verklighet. Allt tack vare den ganska mångsidiga hårdvaran och kapaciteten som Arduino-programmering ger.

Var kan jag köpa komponenterna?

Komponenter tillverkade i Italien anses vara original. Men priset på sådana kit är inte lågt. Därför tillverkar ett antal företag eller till och med individer hantverksmetoder av Arduino-kompatibla enheter och komponenter, som skämtsamt kallas produktionskloner. När man köper sådana kloner kan man inte med säkerhet säga att de kommer att fungera, men viljan att spara pengar tar ut sin rätt.

Komponenter kan köpas antingen som en del av kit eller separat. Det finns till och med förberedda kit att montera bilar, helikoptrar med olika typer kontroller eller fartyg. Ett set som det på bilden ovan, tillverkat i Kina, kostar $49.

Mer om utrustningen

Arduino-brädet är enkelt AVR mikrokontroller, som flashades med en bootloader och har minsta nödvändiga USB-UART-port. Det finns andra viktiga komponenter, men inom ramen för artikeln vore det bättre att bara fokusera på dessa två komponenter.

Först, om mikrokontrollern, en mekanism byggd på en enda krets där det utvecklade programmet finns. Programmet kan påverkas genom att trycka på knappar, ta emot signaler från komponenterna i skapelsen (motstånd, transistorer, sensorer, etc.), etc. Dessutom kan sensorerna vara väldigt olika i sitt syfte: belysning, acceleration, temperatur, avstånd, tryck, hinder etc. Enkla delar kan användas som displayenheter, från lysdioder och diskanthögtalare till komplexa enheter, såsom grafiska displayer. Den kvalitet som beaktas är motorer, ventiler, reläer, servon, elektromagneter och många andra, som skulle ta väldigt, väldigt lång tid att lista. MK arbetar direkt med några av dessa listor med anslutningskablar. Vissa mekanismer kräver adaptrar. Men när du väl börjar designa blir det svårt för dig att slita dig ifrån dig. Låt oss nu prata om Arduino-programmering.

Lär dig mer om styrelseprogrammeringsprocessen

Ett program som redan är redo att köras på en mikrokontroller kallas firmware. Det kan finnas antingen ett projekt eller Arduino-projekt, så det skulle vara lämpligt att lagra varje firmware i en separat mapp för att påskynda processen att hitta nödvändiga filer. Den blinkar på MK-kristallen med hjälp av specialiserade enheter: programmerare. Och här har Arduino en fördel - den behöver ingen programmerare. Allt är gjort för att programmera Arduino för nybörjare inte är svårt. Den skrivna koden kan laddas in i MK via en USB-kabel. Denna fördel uppnås inte av någon förbyggd programmerare, utan av speciell firmware - en bootloader. Bootloadern är ett speciellt program som startar direkt efter anslutning och lyssnar på om det finns några kommandon, om man ska flasha kristallen, om det finns Arduino-projekt eller inte. Det finns flera mycket attraktiva fördelar med att använda en bootloader:

1. Använder endast en kommunikationskanal, vilket inte kräver extra tidskostnader. Så Arduino-projekt kräver inte att du ansluter många olika ledningar och det kommer att uppstå förvirring när du använder dem. En USB-kabel räcker för framgångsrik drift.
2. Skydd mot krokiga händer. Det är ganska enkelt att föra mikrokontrollern till ett stentillstånd med hjälp av direkt firmware; du behöver inte arbeta hårt. När du arbetar med en bootloader kommer du inte att kunna komma åt potentiellt farliga inställningar (med hjälp av ett utvecklingsprogram förstås, annars kan allt gå sönder). Därför är Arduino för nybörjare inte bara avsedd ur synvinkeln att det är förståeligt och bekvämt, det kommer också att tillåta dig att undvika oönskade ekonomiska utgifter i samband med oerfarenhet hos den person som arbetar med dem.

Projekt för att komma igång

När du har skaffat ett kit, en lödkolv, kolofonium och lod bör du inte omedelbart skulptera mycket komplexa strukturer. Naturligtvis kan du göra dem, men chansen att lyckas i Arduino för nybörjare är ganska låg med komplexa projekt. För att träna och förbättra dina färdigheter kan du försöka implementera några enklare idéer som hjälper dig att förstå interaktionen och driften av Arduino. Som sådana första steg i arbetet med Arduino för nybörjare kan vi råda dig att överväga:

1. Skapa en som fungerar tack vare Arduino.
2. Ansluter en separat knapp till Arduino. I det här fallet kan du göra det så att knappen kan justera lysdiodens sken från punkt nr 1.
3. Potentiometeranslutning.
4. Servostyrning.
5. Ansluta och arbeta med en trefärgad LED.
6. Anslutning av det piezoelektriska elementet.
7. Ansluta ett fotomotstånd.
8. Anslutning av en rörelsesensor och signalerar om dess funktion.
9. Anslutning av en fukt- eller temperatursensor.

Projekt för framtiden

Det är osannolikt att du är intresserad av Arduino för att kunna ansluta individuella lysdioder. Troligtvis lockas du av möjligheten att skapa din egen bil, eller flygande skivspelare. Dessa projekt är svåra att genomföra och kommer att kräva mycket tid och uthållighet, men när de är klara kommer du att få det du vill ha: värdefull Arduino-designupplevelse för nybörjare.

Förseningar i Arduino spelar en väldigt stor roll. Utan dem kan inte ens det enklaste exemplet på Blink, som blinkar en lysdiod efter en viss tidsperiod, fungera. Men de flesta nybörjare programmerare vet lite om tidsfördröjningar och använder bara Arduino-fördröjning utan att känna till biverkningarna av detta kommando. I den här artikeln kommer jag att prata i detalj om timingfunktioner och hur man använder dem i Arduino IDE.

Det finns flera olika kommandon i Arduino som är ansvariga för att arbeta med tid och pauser:

• dröjsmål()
• delayMicroseconds()
• millis()
• micros()

De skiljer sig i noggrannhet och har sina egna egenskaper som bör beaktas när man skriver kod.

Använder arduino fördröjningsfunktionen

Syntax

Arduino delay är det enklaste kommandot och används oftast av nybörjare. I huvudsak är det en fördröjning som pausar programmet under det antal millisekunder som anges inom parentes. (Det går 1000 millisekunder på en sekund.) Det maximala värdet kan vara 4294967295 ms, vilket är ungefär lika med 50 dagar. Låt oss titta på ett enkelt exempel som tydligt visar hur detta kommando fungerar.

Void setup() ( pinMode(13, OUTPUT); ) void loop() ( digitalWrite(13, HIGH); // skicka en hög signal till pin 13 delay(10000); // paus 10000ms eller 10 sekunder digitalWrite13, LOW) ; // skicka en låg signal till pin 13 delay(10000); // pausa 10 000 ms eller 10 sekunder)

I metod uppstart Vi specificerar att stift 13 kommer att användas som utgång. I huvuddelen av programmet skickas först en hög signal till stiftet, sedan gör vi en fördröjning på 10 sekunder. Under denna tid verkar programmet vara avstängt. Sedan ges en låg signal och återigen blir det en fördröjning och allt börjar om igen. Som ett resultat får vi att stiftet växelvis matas med antingen 5 V eller 0.

Du måste tydligt förstå att under en paus med fördröjning avbryts programmets arbete, applikationen kommer inte att ta emot några data från sensorerna. Detta är den största nackdelen med att använda Arduino-fördröjningsfunktionen. Du kan komma runt denna begränsning med avbrott, men vi kommer att prata om detta i en separat artikel.

Exempel på fördröjning med blinkande lysdiod

Ett exempel på krets för att illustrera hur fördröjningsfunktionen fungerar.
Du kan bygga en krets med en LED och ett motstånd. Då kommer vi att ha ett standardexempel - blinkande en LED. För att göra detta måste du ansluta en lysdiod med en positiv kontakt till stiftet, som vi angav som utgång. Vi ansluter det fria benet på lysdioden till jord genom ett motstånd på cirka 220 Ohm (lite mer är möjligt). Du kan bestämma polariteten genom att titta på dess insida. Den stora koppen inuti är kopplad till minus, och det lilla benet till plus. Om din LED är ny kan du bestämma polariteten genom längden på ledningarna: det långa benet är plus, det korta benet är minus.

delayMicroseconds funktion

Denna funktion är en komplett analog av fördröjning, förutom att dess måttenheter inte är millisekunder, utan mikrosekunder (på 1 sekund finns det 1 000 000 mikrosekunder). Det maximala värdet kommer att vara 16383, vilket är lika med 16 millisekunder. Upplösningen är 4, det vill säga talet kommer alltid att vara en multipel av fyra. Ett exempelutdrag skulle se ut så här:

DigitalWrite(2, HIGH); // skicka en hög signal till pin 2 delayMicroseconds(16383); // paus 16383 µs digitalWrite(2, LÅG); // skicka en låg signal till pin 2 delayMicroseconds(16383); // paus 16383 µs

Problemet med delayMicroseconds är exakt detsamma som med delay - dessa funktioner "hänger" programmet helt och det fryser bokstavligen ett tag. För närvarande är det omöjligt att arbeta med portar, läsa information från sensorer och utföra matematiska operationer. Det här alternativet är lämpligt för blinkande ljus, men erfarna användare använder det inte för stora projekt, eftersom sådana fel inte behövs där. Därför är det mycket bättre att använda funktionerna som beskrivs nedan.

Millis funktion istället för fördröjning

Millis()-funktionen gör att du kan utföra en fördröjning utan fördröjning på Arduino, och därigenom kringgå bristerna i de tidigare metoderna. Det maximala värdet för parametern millis är detsamma som för fördröjningsfunktionen (4294967295ms eller 50 dagar).

Med hjälp av millis stoppar vi inte exekveringen av hela skissen, utan anger helt enkelt hur länge Arduino helt enkelt ska "förbigå" det exakta kodblocket som vi vill pausa. Till skillnad från delay millis stoppar den ingenting av sig själv. Detta kommando returnerar helt enkelt till oss från mikrokontrollerns inbyggda timer antalet millisekunder som har gått sedan starten. Med varje call to loop mäter vi själva tiden som har gått sedan det senaste anropet av vår kod och om tidsskillnaden är mindre än den önskade pausen så ignorerar vi koden. Så snart skillnaden blir större än den nödvändiga pausen, exekverar vi koden, hämtar den aktuella tiden med samma millis och kommer ihåg den - den här gången blir den nya startpunkten. I nästa cykel kommer nedräkningen redan att vara från den nya punkten och vi kommer återigen att ignorera koden tills den nya skillnaden mellan millis och vårt tidigare sparade värde når önskad paus igen.

Fördröjning utan fördröjning med hjälp av millis kräver mer kod, men med dess hjälp kan du blinka en lysdiod och pausa en skiss utan att stoppa systemet.

Här är ett exempel som tydligt illustrerar lagets arbete:

Osignerad lång timing; // Variabel för att lagra referenspunkten void setup() ( Serial.begin(9600); ) void loop() ( /* Vid denna punkt börjar exekveringen av delay() analogen. Beräkna skillnaden mellan det aktuella momentet och tidigare sparad referenspunkt. Om skillnaden är större det önskade värdet, exekvera koden. Om inte, gör ingenting */ if (millis() - timing > 10000)( // Istället för 10000, ersätt pausvärdet som du behöver timing = millis(); Serial.println ("10 sekunder") ; ) )

Först introducerar vi tidsvariabeln, som kommer att lagra antalet millisekunder. Som standard är värdet på variabeln 0. I huvuddelen av programmet kontrollerar vi villkoret: om antalet millisekunder från början av mikrokontrollern minus talet som skrivits i tidsvariabeln är större än 10 000, då åtgärden att mata ut ett meddelande till portmonitorn utförs och det aktuella tidsvärdet skrivs till variabeln. Som ett resultat av programmets funktion kommer meddelandet 10 sekunder att visas på portmonitorn var 10:e sekund. Den här metoden låter dig blinka lysdioden utan fördröjning.

Micros fungerar istället för fördröjning

Denna funktion kan också utföra en fördröjning utan att använda fördröjningskommandot. Det fungerar precis som millis, men det räknar mikrosekunder snarare än millisekunder med en upplösning på 4 μs. Dess maximala värde är 4294967295 mikrosekunder eller 70 minuter. Om det svämmar över återställs värdet helt enkelt till 0, glöm inte det.

Sammanfattning

Arduino-plattformen ger oss flera sätt att implementera en försening i vårt projekt. Med hjälp av fördröjning kan du snabbt pausa utförandet av en skiss, men samtidigt blockerar du mikrokontrollerns funktion. Genom att använda kommandot millis kan du göra det utan fördröjning i Arduino, men detta kommer att kräva lite mer programmering. Välja Det bästa sättet beroende på hur komplext ditt projekt är. Som regel, i enkla skisser och med en fördröjning på mindre än 10 sekunder, används fördröjning. Om driftlogiken är mer komplex och en stor fördröjning krävs, är det bättre att använda millis istället för fördröjning.

En serie artiklar och träningsdiagram med amatörradioexperiment på Arduino för nybörjare. Detta är en slags amatörradiokonstruktionsleksak, från vilken, utan lödkolv, etsning tryckta kretskort och liknande kan vilken elektronikhobbyist som helst sätta ihop en fullfjädrad fungerande enhet, lämplig för både professionella prototyper och amatörexperiment i studier av elektronik.

Arduino-kortet är främst avsett för att lära nybörjare radioamatörer grunderna i att programmera mikrokontroller och skapa mikrokontrollerenheter med sina egna händer utan seriös teoretisk träning. Arduinos utvecklingsmiljö låter dig kompilera och ladda färdig programkod till kortets minne. Dessutom är det extremt enkelt att ladda koden.

Arduino var man ska börja för en nybörjare

Först och främst, för att arbeta med Arduino-kortet, måste en nybörjare elektronikingenjör ladda ner Arduino-utvecklingsprogrammet; det består av en inbyggd textredigerare där vi arbetar med programkod, ett meddelandeområde, ett textutmatningsfönster (konsoll) ), ett verktygsfält med knappar för ofta använda kommandon och flera menyer. För att ladda ner sina program och kommunicera är detta program anslutet till Arduino-kortet via en vanlig USB-kabel.

Kod inskriven Arduino miljö, ringde skiss. Det är skrivet i textredigerare, som har specialverktyg för att infoga/klippa ut, ersätta/söka text. Under lagring och export visas förklaringar i meddelandefältet (se bilden i första lektionen för nybörjare, precis nedan), och fel kan också visas. Konsolen visar Arduino-meddelanden inklusive fullständiga felrapporter och annat användbar information. Verktygsfältsknappar låter dig kontrollera och spela in en skiss, öppna, skapa och spara den, öppna seriell bussövervakning och mycket mer.

Så låt oss gå vidare till den första. Arduino lektion kretsscheman för nybörjare elektronikingenjörer.

För nybörjares bekvämlighet har Arduino UNO-kontrollern redan ett motstånd och en lysdiod ansluten till stift 13 på kontakten, så vi behöver inga externa radioelement i det första experimentet.

Genom att ladda koden tillåter Arduino vårt program att delta i systeminitieringen. För att göra detta indikerar vi för mikrokontrollerns kommandon att den kommer att köras vid tidpunkten för den första uppstarten och sedan helt glömma bort dem (dvs dessa kommandon kommer att utföras av Arduino endast en gång vid start). Och det är för detta ändamål som vi i vår kod väljer ett block där dessa kommandon lagras. void setup(), eller snarare i utrymmet innanför den här funktionens lockiga hängslen, se programskissen.

Glöm inte de lockiga hängslen! Förlusten av minst en av dem kommer att göra hela skissen helt ogenomförbar. Men lägg inte in extra parentes heller, eftersom detta också kommer att orsaka ett fel.

Ladda ner kod:

Skiss med kommentarer och förklaringar i filen 001-1_mig-led.ino

Fungera void loop() det är här vi lägger kommandona som kommer att köras så länge som Arduino är påslagen. Efter att ha börjat köra från det första kommandot, kommer Arduino att nå slutet och omedelbart gå till början för att upprepa samma sekvens. Och så vidare ett oändligt antal gånger, så länge kortet får ström. I dess kärna är en void loop huvudfunktionen, ingångspunkten till Arduino.

Fungera dröjsmål(1000) fördröjer programbehandlingen med 1000 millisekunder. Allt pågår i en evig cykel slinga().

Huvudslutsatsen efter att ha förstått vårt första program på Arduino: Med hjälp av void loop och void setup-funktionerna skickar vi våra instruktioner till mikrokontrollern. Allt som finns inuti inställningsblocket kommer endast att köras en gång. Innehållet i loopmodulen kommer att upprepas i en loop så länge som Arduino förblir påslagen.

I det föregående programmet var det en andra fördröjning mellan att tända och släcka lysdioden. Det fanns ett stort minus i den enklaste koden för en nybörjare Arduino-operatör som användes ovan. För att hålla en paus mellan att slå på och av lysdioden i en sekund använde vi funktionen dröjsmål() och därför kan styrenheten för närvarande inte utföra andra kommandon i huvudfunktionen slinga(). Korrigera kod i en funktion slinga(), som presenteras nedan löser detta problem.

Istället för att ställa in värdet på HIGH och sedan till LOW, kommer vi att få värdet på ledPin och invertera det. Låt oss säga att om den var HÖG kommer den att bli LÅG osv.

Andra Arduino-kodalternativ för LED-kontroll Här:

Då kan du byta ut funktionen dröjsmål(). Istället är det bättre att använda funktionen millis(). Den returnerar antalet millisekunder som har gått sedan programmet startade. Funktionen kommer att svämma över efter cirka 50 dagars körning av programkoden.

En liknande funktion är micros(), som returnerar antalet mikrosekunder som har gått sedan programkoden lanserades. Funktionen återgår till noll efter 70 minuters programdrift.

Naturligtvis kommer detta att lägga till några rader kod till vår skiss, men det kommer säkert att göra dig mer erfaren programmerare och kommer att öka potentialen för din Arduino. För att göra detta behöver du bara lära dig hur du använder millis-funktionen.

Det bör tydligt förstås att den enklaste fördröjningsfunktionen pausar exekveringen av hela Arduino-programmet, vilket gör att det inte kan utföra några uppgifter under denna tidsperiod. Istället för att pausa hela vårt program kan vi räkna hur lång tid som har gått innan åtgärden slutförs. Detta implementeras fint med hjälp av funktionen millis() . För att göra allt lätt att förstå kommer vi att överväga följande alternativ för att blinka en LED utan tidsfördröjning.

Början av detta program är densamma som alla andra vanliga Arduino-skisser.

I i detta exempel två Arduino digitala I/O-stift används. Lysdioden är ansluten till stift 8, som är konfigurerad som OUTPUT. En knapp är ansluten till 9 via, som är konfigurerad som INPUT. När vi trycker på knappen är stift 9 inställt på HÖG, och programmet växlar stift 8 till HÖG, och tänder därmed lysdioden. Genom att släppa knappen återställs stift 9 till LÅG. Koden växlar sedan stift 8 till LÅG, vilket släcker indikatorlampan.

För att styra fem lysdioder kommer vi att använda olika manipulationer med Arduino-portar. För att göra detta skriver vi data direkt till Arduino-portar, detta gör att du kan ställa in värdena för lysdioderna med bara en funktion.

Arduino UNO har tre portar: B(digitala ingångar/utgångar från 8 till 13); C(analoga ingångar); D(digitala ingångar/utgångar 0 till 7)

Varje port kontrollerar tre register. Den första DDR anger om stiftet ska vara en ingång eller utgång. Med det andra PORT-registret kan du ställa in stiftet på HÖG eller LÅG. Med hjälp av den tredje kan du läsa information om Arduino-benens tillstånd, om de fungerar som en ingång.

För att driva kretsen använder vi port B. För att göra detta, ställ in alla portstift som digitala utgångar. Port B har bara 6 ben. DDRB-registerbitarna måste ställas in på "1" , om stiftet kommer att användas som en utgång (OUTPUT), och in "0" , om vi planerar att använda stiftet som en ingång (INPUT). Portbitar är numrerade 0 till 7, men har inte alltid alla 8 stift

Låt oss säga: DDRB = B00111110;// ställ in port B stift 1 till 5 som utgång och 0 som ingång.

I vår körljuskrets använder vi fem utgångar: DDRB = B00011111; // ställ in port B-stiften 0 till 4 som utgångar.

För att skriva data till port B måste du använda PORTB-registret. Du kan tända den första lysdioden med kontrollkommandot: PORTB = B00000001;, första och fjärde lysdioden: PORTB = B00001001 och så vidare

Det finns två binära skiftoperatorer: vänster och höger. Den vänstra växlingsoperatören gör att alla databitar flyttas åt vänster, medan den högra växlingsoperatören flyttar dem åt höger.

Exempel:

varA = 1; // 00000001
varA = 1 varA = 1 varA = 1

Låt oss nu återgå till källkoden för vårt program. Vi måste ange två variabler: upp ner kommer att inkludera värdena för var man ska flytta - upp eller ner, och den andra cylon kommer att indikera vilka lysdioder som ska tändas.

Strukturellt har en sådan lysdiod en gemensam terminal och tre terminaler för varje färg. Nedan är ett diagram över anslutning av en RGB LED till ett Arduino-kort med en gemensam katod. Alla motstånd som används i anslutningskretsen måste ha samma värde från 220-270 Ohm.

För en anslutning med en gemensam katod kommer anslutningsschemat för en trefärgad LED att vara nästan detsamma, förutom att det gemensamma stiftet inte kommer att anslutas till jord (gnd på enheten), utan till +5 volts stiftet. Stift Röd, grön och blå är i båda fallen anslutna till styrenhetens digitala utgångar 9, 10 och 11.

Vi kommer att ansluta en extern LED till det nionde stiftet på Arduino UNO genom ett motstånd på 220 Ohm. Använd funktionen för att smidigt kontrollera ljusstyrkan för den senare analogWrite(). Den ger utmatning av en PWM-signal till styrenhetens ben. Dessutom laget pinMode() du behöver inte ringa. Därför att analogWrite(pin,värde) innehåller två parametrar: pin - pinnummer för utgång, värde - värde från 0 till 255.

Koda:
/*
Ett handledningsexempel för en nybörjare i Arduino som avslöjar funktionerna hos kommandot analogWrite() för att implementera fade-effekten av en LED
*/
int ljusstyrka = 0; // LED-ljusstyrka
int fadeAmount = 5; // ljusstyrka ändra steg
unsigned long currentTime;
osignerad lång loopTime;

Void setup() (
pinMode(9, OUTPUT); // ställ in stift 9 som utgång
aktuellTid = millis();
loopTime = aktuellTid;
}

Void loop() (
aktuellTid = millis();
if(currentTime >= (loopTime + 20))(
analogWrite(9, ljusstyrka); // ställ in värdet på stift 9

Ljusstyrka = ljusstyrka + fadeAmount; // lägg till ett steg för att ändra ljusstyrkan, vilket kommer att fastställas i nästa cykel

// om min. eller max. värden, då går vi i motsatt riktning (omvänd):
if (ljusstyrka == 0 || ljusstyrka == 255) (
fadeAmount = -fadeAmount ;
}
loopTime = aktuellTid;
}
}

Arduino-drift med kodare

Kodaren är utformad för att omvandla rotationsvinkeln till en elektrisk signal. Från den får vi två signaler (A och B), som är motsatta i fas. I den här handledningen kommer vi att använda SparkFun COM-09117-kodaren, som har tolv positioner per varv (varje position är exakt 30°). Bilden nedan visar tydligt hur utgång A och B är beroende av varandra när pulsgivaren rör sig medurs eller moturs.

Om signal A går från en positiv nivå till noll läser vi värdet på utgång B. Om utgång B är i ett positivt tillstånd vid denna tidpunkt, så rör sig kodaren i medurs riktning, om B matar ut en nollnivå, då pulsgivaren rör sig i motsatt riktning. Genom att läsa båda utgångarna kan vi beräkna rotationsriktningen med hjälp av en mikrokontroller, och genom att räkna pulser från A-utgången på kodaren, rotationsvinkeln.

Vid behov kan du använda frekvensberäkningar för att bestämma hur snabbt kodaren roterar.

Med hjälp av en kodare i vårt handledningsexempel kommer vi att justera ljusstyrkan på lysdioden med PWM-utgången. För att läsa data från kodaren kommer vi att använda en metod baserad på mjukvarutimer, som vi redan har täckt.

Med tanke på det faktum att vi i det snabbaste fallet kan vrida kodarvredet 180° på 1/10 av en sekund, skulle detta vara 6 pulser på 1/10 av en sekund eller 60 pulser på en sekund.

I verkligheten går det inte att rotera snabbare. Eftersom vi behöver spåra alla halvcykler bör frekvensen vara cirka 120 Hertz. För att vara helt säker, låt oss ta 200 Hz.

Eftersom vi i det här fallet använder en mekanisk kodare är kontaktstuds möjlig, och låg frekvens filtrerar perfekt bort sådant prat.

Baserat på programmeringstimersignalerna är det nödvändigt att ständigt jämföra det aktuella värdet på kodarutgången A med det föregående värdet. Om tillståndet ändras från positivt till noll, frågar vi tillståndet för utgång B. Beroende på resultatet av tillståndsundersökningen ökar eller minskar vi värderäknaren LED-ljusstyrka LED. Programkoden med ett tidsintervall på cirka 5 ms (200 Hz) presenteras nedan:

Arduino nybörjarkod:
/*
** Encoder
** För att styra ljusstyrkan på lysdioden används en kodare från Sparkfun
*/

Int ljusstyrka = 120; // LED-ljusstyrka, börja på hälften
int fadeAmount = 10; // ljusstyrka ändra steg
unsigned long currentTime;
osignerad lång loopTime;
const int pin_A = 12; // stift 12
const int pin_B = 11; // stift 11
osignerad char encoder_A;
osignerad char encoder_B;
osignerad char encoder_A_prev=0;
void setup() (
// förklara pin 9 vara en utgång:
pinMode(9, OUTPUT); // ställ in stift 9 som utgång
pinMode(pin_A, INPUT);
pinMode(pin_B, INPUT);
aktuellTid = millis();
loopTime = aktuellTid;
}
void loop() (
aktuellTid = millis();
if(currentTime >= (loopTime + 5))( // kontrollera tillstånd var 5:e ms (frekvens 200 Hz)
encoder_A = digitalRead(pin_A); // läs tillståndet för utgång A från kodaren
encoder_B = digitalRead(pin_B); // kodarutgång B
if((!encoder_A) && (encoder_A_prev))( // om tillståndet ändras från positivt till noll
if(kodare_B) (
// utgång B är i positivt tillstånd, vilket betyder att rotationen är medurs
// öka ljusstyrkan på glöden, inte mer än 255
if(ljusstyrka + fadeAmount)
annan(
// utgång B är i nollläge, vilket betyder att rotationen är moturs
// minska ljusstyrkan, men inte under noll
if(ljusstyrka - fadeAmount >= 0) ljusstyrka -= fadeAmount;
}

}
encoder_A_prev = encoder_A; // spara värdet på A för nästa loop

AnalogWrite(9, ljusstyrka); // ställ in ljusstyrkan på det nionde stiftet

LoopTime = aktuellTid;
}
}

I det här nybörjarexemplet ska vi titta på att arbeta med en piezosändare för att generera ljud. För att göra detta, låt oss ta en piezoelektrisk sensor som låter oss generera ljudvågor i frekvensområdet 20 Hz - 20 kHz.

Detta är en amatörradiodesign där lysdioder är placerade över hela volymen. Med detta schema kan du generera olika ljus- och animationseffekter. Komplexa kretsarär till och med kapabla att visa olika tredimensionella ord. Det här är med andra ord en elementär surroundmonitor

Servodrivningen är huvudelementet i designen av olika radiostyrda modeller, och dess kontroll med hjälp av en styrenhet är enkel och bekväm.

Styrprogrammet är enkelt och intuitivt. Det börjar med att ansluta en fil som innehåller alla nödvändiga kommandon för att styra servoenheten. Därefter skapar vi ett servoobjekt, till exempel servoMain. Nästa funktion är setup(), där vi anger att servot är anslutet till det nionde stiftet på styrenheten.

Koda:
/*
Arduino Servo
*/
#omfatta
Servo servoMain; // Servoobjekt

Ogiltig installation()
{
servoMain.attach(9); // Servo ansluten till stift 9
}

void loop()
{
servoMain.write(45); // Vrid servo åt vänster 45°
fördröjning(2000); // Vänta 2000 millisekunder (2 sekunder)
servoMain.write(0); // Vrid servo åt vänster med 0°
fördröjning(1000); // Paus 1 s.

fördröjning(1500); // Vänta 1,5 s.
servoMain.write(135); // Vrid servo åt höger 135°
fördröjning(3000); // Paus 3 s.
servoMain.write(180); // Vrid servo åt höger 180°
fördröjning(1000); // Vänta 1 s.
servoMain.write(90); // Vrid servo 90°. Centralt läge
fördröjning(5000); // Paus 5 s.
}

I huvudfunktionen slinga(), ger vi kommandon till servomotorn, med pauser mellan dem.

Arduino-räknarkrets på en 7-segmentsindikator

Detta enkla Arduino-projekt för nybörjare innebär att skapa en räknarkrets med en vanlig 7-segments gemensam katoddisplay. Programkod, som anges nedan, låter dig börja räkna från 0 till 9 när du trycker på en knapp.

Sjusegmentsindikator - är en kombination av 8 lysdioder (den sista är ansvarig för punkten) med en gemensam katod, som kan slås på i önskad sekvens så att de skapar siffror. Det bör noteras att i denna krets, se figuren nedan, är stift 3 och 8 allokerade till katoden.

Korrespondenstabellen visas till höger Arduino-stift och LED-indikatorstift.

Kod för detta projekt:

byte nummer = (
B11111100, B01100000, B11011010, B11110010, B01100110,
B10110110, B10111110, B11100000, B11111110, B11100110
};
void setup() (
for(int i = 2; i pinMode(i, OUTPUT);
}
pinMode(9, INPUT);
}
int räknare = 0;
bool go_by_switch = sant;
int last_input_value = LÅG;
void loop() (
if(go_by_switch) (
int switch_input_value = digitalRead(9);
if(last_input_value == LOW && switch_input_value == HÖG) (

}
last_input_value = switch_input_value;
) annat (
fördröjning(500);
räknare = (räknare + 1) % 10;
}
skrivNumber(räknare);
}

Void writeNumber(int number) (
om (nummer 9) (
lämna tillbaka;
}
byte mask = siffror;
byte currentPinMask = B10000000;
for(int i = 2; i if(mask & currentPinMask) digitalWrite(i,HIGH);
else digitalWrite(i,LOW);
currentPinMask = currentPinMask >> 1;
}
}

Du kan avsevärt utöka potentialen för Arduino-brädor med hjälp av ytterligare moduler, som kan anslutas till PIN-stiften på nästan vilken enhet som helst. Tänk på de mest populära och intressanta expansionsmodulerna, eller sköldar som de också kallas.