I denne artikkelen bestemte jeg meg for å samle en komplett trinn for trinn guide for nybegynnere i Arduino. Vi vil se på hva Arduino er, hva du trenger for å begynne å lære, hvor du kan laste ned og hvordan du installerer og konfigurerer programmeringsmiljøet, hvordan det fungerer og hvordan du bruker programmeringsspråket, og mye mer som er nødvendig for å lage fullverdig komplekse enheter basert på familien til disse mikrokontrollerne.

Her vil jeg prøve å gi et fortettet minimum slik at du forstår prinsippene for å jobbe med Arduino. For en mer fullstendig fordypning i verden av programmerbare mikrokontrollere, ta hensyn til andre seksjoner og artikler på dette nettstedet. Jeg vil legge igjen lenker til annet materiale på denne siden for en mer detaljert studie av noen aspekter.

Hva er Arduino og hva er det for?

Arduino er elektronisk designer, som lar hvem som helst lage en rekke elektromekaniske enheter. Arduino består av programvare og maskinvare. Programvare del inkluderer et utviklingsmiljø (et program for å skrive og feilsøke fastvare), mange ferdige og praktiske biblioteker og et forenklet programmeringsspråk. Maskinvaren inkluderer en stor serie med mikrokontrollere og ferdige moduler for dem. Takket være dette er det veldig enkelt å jobbe med Arduino!

Ved hjelp av Arduino kan du lære programmering, elektroteknikk og mekanikk. Men dette er ikke bare en pedagogisk konstruktør. Basert på det kan du lage virkelig nyttige enheter.
Starter fra enkle blinklys, værstasjoner, automasjonssystemer og slutter med smart hjem, CNC-maskiner og ubemannede luftfartøyer. Mulighetene er ikke engang begrenset av fantasien din, fordi det er et stort antall instruksjoner og ideer for implementering.

Arduino startsett

For å begynne å lære Arduino, må du anskaffe selve mikrokontrollerkortet og tilleggsdeler. Det er best å kjøpe et Arduino startsett, men du kan velge alt du trenger selv. Jeg anbefaler å velge et sett fordi det er enklere og ofte billigere. Her er lenker til de beste settene og individuelle delene som du definitivt trenger å studere:

Grunnleggende Arduino-sett for nybegynnere:	Kjøpe
Stort sett for trening og første prosjekter:	Kjøpe
Sett med ekstra sensorer og moduler:	Kjøpe
Arduino Uno er den mest grunnleggende og praktiske modellen fra linjen:	Kjøpe
Loddefri brødbrett for enkel læring og prototyping:	Kjøpe
Sett med ledninger med praktiske kontakter:	Kjøpe
LED-sett:	Kjøpe
Motstandssett:	Kjøpe
Knapper:	Kjøpe
Potensiometre:	Kjøpe

Arduino IDE utviklingsmiljø

For å skrive, feilsøke og laste ned fastvare må du laste ned og installere Arduino IDE. Det er veldig enkelt og praktisk program. På nettstedet mitt har jeg allerede beskrevet prosessen med å laste ned, installere og konfigurere utviklingsmiljøet. Så her vil jeg bare legge igjen linker til siste versjon programmer og

Versjon	Windows	Mac OS X	Linux
1.8.2

Arduino programmeringsspråk

Når du har et mikrokontrollerkort i hendene og et utviklingsmiljø installert på datamaskinen, kan du begynne å skrive dine første skisser (fastvare). For å gjøre dette, må du bli kjent med programmeringsspråket.

Arduino-programmering bruker en forenklet versjon av C++-språket med forhåndsdefinerte funksjoner. Som i andre C-lignende programmeringsspråk finnes det en rekke regler for å skrive kode. Her er de mest grunnleggende:

• Hver instruksjon må følges av et semikolon (;)
• Før du erklærer en funksjon, må du spesifisere datatypen som returneres av funksjonen, eller ugyldig hvis funksjonen ikke returnerer en verdi.
• Det er også nødvendig å angi datatypen før du deklarerer en variabel.
• Kommentarer er utpekt: ​​// Inline og /* blokk */

Du kan lære mer om datatyper, funksjoner, variabler, operatorer og språkkonstruksjoner på siden på Du trenger ikke å huske og huske all denne informasjonen. Du kan alltid gå til oppslagsboken og se på syntaksen til en bestemt funksjon.

All Arduino-fastvare må inneholde minst 2 funksjoner. Disse er setup() og loop().

oppsett funksjon

For at alt skal fungere, må vi skrive en skisse. La oss få LED-en til å lyse etter å ha trykket på knappen, og slukke etter neste trykk. Her er vår første skisse:

// variabler med pinner til tilkoblede enheter int switchPin = 8; int ledPin = 11; // variabler for å lagre statusen til knappen og LED boolean lastButton = LOW; boolsk strømknapp = LAV; boolsk ledOn = falsk; void setup() ( pinMode(switchPin, INPUT); pinMode(ledPin, OUTPUT); ) // funksjon for 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 pinner til tilkoblede enheter int switchPin = 8 ; int ledPin = 11 ; // variabler for å lagre statusen til knappen og LED boolean lastButton = LAV ; boolean currentButton = LAV ; boolsk ledPå = falsk; void oppsett() ( pinMode(switchPin, INPUT); pinMode(ledPin, OUTPUT); // funksjon for avhopping boolsk debounse (boolsk siste ) ( boolsk strøm = digitalRead(switchPin); if (siste != gjeldende ) ( forsinkelse(5); gjeldende = digitalRead(switchPin); returstrøm ; void loop() ( currentButton = debounse(lastButton); if (lastButton == LOW && currentButton == HIGH ) ( ledOn = ! ledPå ; lastButton = currentButton ; digitalWrite(ledPin, ledOn);

I denne skissen jeg laget tilleggsfunksjon debounse for å undertrykke kontaktsprett. Det er informasjon om kontaktsprett på nettsiden min. Sørg for å sjekke ut dette materialet.

PWM Arduino

Pulsbreddemodulasjon (PWM) er prosessen med å kontrollere spenning ved bruk av driftssyklusen til et signal. Det vil si at ved hjelp av PWM kan vi jevnt kontrollere belastningen. For eksempel kan du jevnt endre lysstyrken til en LED, men denne endringen i lysstyrke oppnås ikke ved å redusere spenningen, men ved å øke intervallene til det lave signalet. Driftsprinsippet til PWM er vist i dette diagrammet:

Når vi bruker PWM på LED-en, begynner den å lyse raskt og slukke. Det menneskelige øyet er ikke i stand til å se dette fordi frekvensen er for høy. Men når du tar opp video, vil du mest sannsynlig se øyeblikk når LED-en ikke lyser. Dette vil skje forutsatt at kameraets bildefrekvens ikke er et multiplum av PWM-frekvensen.

Arduino har en innebygd pulsbreddemodulator. Du kan bare bruke PWM på de pinnene som støttes av mikrokontrolleren. For eksempel har Arduino Uno og Nano 6 PWM-pinner: disse er pinner D3, D5, D6, D9, D10 og D11. Pinnene kan variere på andre brett. Du kan finne en beskrivelse av styret du er interessert i

For å bruke PWM i Arduino er det en funksjon.Den tar som argumenter pin-nummeret og PWM-verdien fra 0 til 255. 0 er 0% fylling med et høyt signal, og 255 er 100%. La oss skrive en enkel skisse som et eksempel. La oss få LED-en til å lyse jevnt, vente ett sekund og tone ut like jevnt, og så videre i det uendelige. Her er et eksempel på bruk av denne funksjonen:

// LED-en er koblet til pin 11 int ledPin = 11; void setup() ( pinMode(ledPin, OUTPUT); ) void loop() ( for (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 koblet til pinne 11 int ledPin = 11 ; void oppsett() ( pinMode(ledPin, OUTPUT); void loop() ( for (int i = 0 ; i< 255 ; i ++ ) { analogWrite(ledPin, i); forsinkelse(5); forsinkelse(1000); for (int i = 255; i > 0; i -- ) (

Hvordan velge Arduino′ Dette spørsmålet oppstår for alle som bestemte seg for å lage et prosjekt med Arduino for første gang. Vi bestemte oss for de nødvendige detaljene: sensorer, sensorer, moduler, etc., og ble møtt med et betydelig utvalg av Arduino-brett, i tillegg har hvert brett også to eller tre analoger. Noen mennesker tror at jo dyrere og kraftigere jo bedre, de kjøper seriøse løsninger, for eksempel Arduino Due, og så innser de at ikke alle skisser fungerer på det, og det er vanskelig for dem å takle den fulle kraften til denne enheten på egen hånd. Andre tar den motsatte veien og møter ressursbegrensninger (minne, pinner, porter, klokkefrekvens, ernæring). Hvordan finner jeg den gyldne middelvei? La oss prøve å finne ut av det...

Betale	proffer	Minuser
Arduino Uno funksjonalitet som ProMini og Nano	Brettet er det vanligste i Arduino-familien; det største antallet leksjoner er laget for det. Takket være tilstedeværelsen av et DIP-panel kan du endre mikrokontrolleren	Med samme funksjonalitet som Arduino ProMini, Nano og Micro, er brettet mange ganger større i størrelse
Arduino Mega 2560	Skjold laget for Arduino UNO er ​​egnet Maksimalt antall pinner Utvidet kapasitet for alle typer minne	Kan ikke installeres på Breadboard uten å bruke ledninger
Arduino Leonardo funksjonalitet som MICRO	Skjold laget for Arduino UNO er ​​egnet Brettet er en forbedret versjon av Arduino UNO og fungerer med de fleste skissene	Kan ikke installeres på Breadboard uten å bruke ledninger Noen skisser laget for Arduino Uno fungerer ikke på Leonardo, fordi... forskjellige mikrokontrollere brukes
Arduino Due	Antall pinner som Arduino Mega To analoge utganger er implementert Bruker en kraftig 32-bits mikrokontroller med en klokkefrekvens på 84 MHz	Kan ikke installeres på Breadboard uten å bruke ledninger Største brettstørrelse i hele Arduino-familien Ikke alle skisser gir så høy klokkefrekvens Ikke alt er skjold sørge for overføring av signaler med en grensespenning på 3,3V Forsyningsspenning 3,3V
Arduino ProMini 3.3V funksjonalitet som Nano og UNO		Den laveste klokkefrekvensen til en mikrokontroller, kun 8 MHz Forsyningsspenning 3,3V
Arduino ProMini 5V funksjonalitet som Nano og UNO	Kan brukes til å designe diagrammer på Breadboard Det minste brettet i Arduino-familien Leveres uten loddede stiftkontakter, muliggjør overflatemontering	Skjold laget for Arduino UNO er ​​ikke egnet Det er ingen USB-kontroller, som krever en ekstern programmerer
Arduino NANO V3.0 funksjonalitet som ProMini og UNO	Kan brukes til å designe diagrammer på Breadboard Brettet er litt større enn Arduino ProMini, men har en USB-port og krever ikke bruk av en ekstern programmerer	Skjold laget for Arduino UNO er ​​ikke egnet Innføringen av en USB-port med en kontroller førte til en økning i mengden flashminne som ble tildelt for oppstartslasteren (sammenlignet med Arduino ProMini)
Arduino MICRO funksjonalitet som Leonardo	Kan brukes til å designe diagrammer på Breadboard Brettet er litt større enn Arduino Nano, men har all funksjonaliteten til Arduino Leonardo Det er mulig å simulere ulike USB-enheter når det er koblet til en PC (kortet vil bli oppdaget som en mus, tastatur osv.)	Skjold laget for Arduino UNO er ​​ikke egnet Overføring av USB-kontrollerfunksjonen til mikrokontrolleren førte til en økning i mengden flashminne som ble tildelt for oppstartslasteren

Det første spørsmålet som påvirker valget av Arduino– hvilket prosjekt ønsker du å gjennomføre?

Hvis du ønsker å lage et ferdig prosjekt, vennligst levert av andre utviklere, så ville det logiske kjøpet være Arduinoen som prosjektet opprinnelig ble opprettet på. Det er verdt å merke seg her det faktum at nå, i den russiske føderasjonen, distribueres Arduino-brett under merkevaren Geduino . Det vil si, som du riktig har forstått, skiller Arduino Micro seg fra Geduino Micro i navn og logo (dette er ikke en analog), som skrevet på den offisielle nettsiden. Og siden sistnevnte er billigere, er valget åpenbart.

Hvis du ikke har bestemt deg for et prosjekt, men ønsker å kjøpe en Arduino for dine egne eksperimenter, så er en viktig faktor kvantiteten ulike eksempler på nettverket, under en eller annen Arduino. Den utvilsomme lederen her er Arduino UNO , dette forklares med det faktum at dette brettet er det eldste i Arduino-linjen, men er ikke utdatert, siden det har gjennomgått en del endringer siden det ble opprettet.

Hvis du planlegger å gjennomføre ditt eget prosjekt, da bør valget av Arduino tilnærmes med metode for eliminering. Hvis prosjektet ditt har moduler med pinner for Arduino Uno, ekskluder Arduino ProMini 3.3V, Arduino ProMini 5V, en analog av Arduino Nano), men kan ha en annen type USB-kontakt, være litt forskjellig i størrelse, ha en annen USB-kontroller, en annen type mikrokontrollerdeksel, kortfarge osv. Her må du forstå at disse brettene gjentar funksjonaliteten til originalen (som de ligner i navn), siden de bruker den samme ATmega-mikrokontrolleren i samme serie. Kortdimensjoner, mikrokontrollerhus og type USB-port, kan bestemmes fra bildet. Og tilstedeværelsen av "CH340G" i navnet betyr at USB-kontrolleren ikke er en standard FTDI-brikke for Arduino, men dens analoge CH340G, derfor, for å koble en slik Arduino til en datamaskin, må du installere en driver for CH340G-brikken . Disse brettene passer for de som mener at en engangsdriverinstallasjon ikke er noen ulempe, og den reduserte prisen er en fordel fremfor det opprinnelige navnet.

Arduino er veldig populær blant alle designentusiaster. De som aldri har hørt om det bør også introduseres for det.

Hva er Arduino?

Hvordan kan du kort beskrive Arduino? Med optimale ord vil være: Arduino er et verktøy som du kan lage ulike elektroniske enheter. I hovedsak er dette en ekte maskinvareplattform for generell bruk. Den kan brukes til å bygge enkle kretser, og for gjennomføring av ganske komplekse prosjekter.

Designeren er basert på maskinvaren, som er et input-output-kort. For å programmere brettet brukes språk som er basert på C/C++. De kalles henholdsvis Processing/Wiring. Fra gruppe C arvet de ekstrem enkelhet, takket være hvilken de kan mestres veldig raskt av enhver person, og å bruke kunnskap i praksis er ikke et ganske betydelig problem. For at du skal forstå hvor enkelt det er å jobbe, sies det ofte at Arduino er for nybegynnere av veiviserdesignere. Selv barn kan forstå Arduino-brett.

Hva kan du samle på den?

Applikasjonene til Arduino er ganske forskjellige; den kan brukes både for de enkleste eksemplene, som vil bli anbefalt på slutten av artikkelen, og for ganske komplekse mekanismer, inkludert manipulatorer, roboter eller produksjonsmaskiner. Noen håndverkere klarer å bruke slike systemer til å lage nettbrett, telefoner, hjemmeovervåkings- og sikkerhetssystemer, smarthussystemer eller rett og slett datamaskiner. Arduino-prosjekter for nybegynnere, som selv de uten erfaring kan komme i gang med, er på slutten av artikkelen. De kan til og med brukes til å lage primitive systemer virtuell virkelighet. Alt takket være den ganske allsidige maskinvaren og egenskapene som Arduino-programmering gir.

Hvor kan jeg kjøpe komponentene?

Komponenter laget i Italia regnes som originale. Men prisen på slike sett er ikke lav. Derfor lager en rekke selskaper eller til og med enkeltpersoner håndverksmetoder av Arduino-kompatible enheter og komponenter, som spøkefullt kalles produksjonskloner. Ved kjøp av slike kloner kan man ikke si med sikkerhet at de vil fungere, men ønsket om å spare penger tar sitt toll.

Komponenter kan kjøpes enten som en del av sett eller separat. Det finnes til og med ferdige sett til å sette sammen biler, helikoptre med forskjellige typer kontroller eller skip. Et sett som det som er avbildet ovenfor, laget i Kina, koster $49.

Mer om utstyret

Arduino-brett er enkelt AVR mikrokontroller, som ble flashet med en bootloader og har minimum nødvendig USB-UART-port. Det er andre viktige komponenter, men innenfor rammen av artikkelen ville det være bedre å kun fokusere på disse to komponentene.

Først, om mikrokontrolleren, en mekanisme bygget på en enkelt krets der det utviklede programmet er plassert. Programmet kan påvirkes ved å trykke på knapper, motta signaler fra komponentene i skapelsen (motstander, transistorer, sensorer, etc.), etc. Dessuten kan sensorene være svært forskjellige i deres formål: belysning, akselerasjon, temperatur, avstand, trykk, hindringer etc. Enkle deler kan brukes som displayenheter, fra LED og diskanthøyttalere til komplekse enheter, som grafiske displayer. Kvaliteten som vurderes er motorer, ventiler, releer, servoer, elektromagneter og mange andre, som vil ta veldig, veldig lang tid å liste opp. MK arbeider direkte med noen av disse listene, ved hjelp av tilkoblingsledninger. Noen mekanismer krever adaptere. Men når du først begynner å designe, vil det være vanskelig for deg å rive deg løs. La oss nå snakke om Arduino-programmering.

Lær mer om styreprogrammeringsprosessen

Et program som allerede er klart til å kjøre på en mikrokontroller kalles firmware. Det kan være enten ett prosjekt eller Arduino-prosjekter, så det vil være tilrådelig å lagre hver fastvare i en egen mappe for å fremskynde prosessen med å finne nødvendige filer. Den blinkes på MK-krystallen ved hjelp av spesialiserte enheter: programmerere. Og her har Arduino én fordel - den trenger ikke en programmerer. Alt er gjort slik at programmering av Arduino for nybegynnere ikke skal være vanskelig. Den skrevne koden kan lastes inn i MK via en USB-kabel. Denne fordelen oppnås ikke av en forhåndsbygd programmerer, men av spesiell firmware - en bootloader. Bootloaderen er et spesialprogram som starter umiddelbart etter tilkobling og lytter til om det er noen kommandoer, om man skal flashe krystallen, om det er Arduino-prosjekter eller ikke. Det er flere svært attraktive fordeler ved å bruke en bootloader:

1. Bruker kun én kommunikasjonskanal, som ikke krever ekstra tidskostnader. Så Arduino-prosjekter krever ikke at du kobler til mange forskjellige ledninger, og det vil være forvirring når du bruker dem. Én USB-kabel er nok for vellykket drift.
2. Beskyttelse mot skjeve hender. Det er ganske enkelt å bringe mikrokontrolleren til en mursteinstilstand ved å bruke direkte fastvare; du trenger ikke å jobbe hardt. Når du arbeider med en bootloader, vil du ikke kunne få tilgang til potensielt farlige innstillinger (ved hjelp av et utviklingsprogram, selvfølgelig, ellers kan alt bli ødelagt). Derfor er Arduino for nybegynnere ment ikke bare fra det synspunkt at det er forståelig og praktisk, det vil også tillate deg å unngå uønskede økonomiske utgifter forbundet med uerfarenhet til personen som jobber med dem.

Prosjekter for å komme i gang

Når du har skaffet deg et sett, en loddebolt, kolofonium og loddemetall, bør du ikke umiddelbart forme veldig komplekse strukturer. Selvfølgelig kan du lage dem, men sjansen for suksess i Arduino for nybegynnere er ganske lav med komplekse prosjekter. For å trene og forbedre ferdighetene dine, kan du prøve å implementere noen få enklere ideer som vil hjelpe deg å forstå samspillet og driften av Arduino. Som slike første trinn i arbeidet med Arduino for nybegynnere, kan vi råde deg til å vurdere:

1. Lag en som vil fungere takket være Arduino.
2. Koble en egen knapp til Arduino. I dette tilfellet kan du gjøre det slik at knappen kan justere lyset på LED-en fra punkt nr. 1.
3. Potensiometertilkobling.
4. Servodriftskontroll.
5. Koble til og arbeide med en trefarget LED.
6. Koble til det piezoelektriske elementet.
7. Koble til en fotomotstand.
8. Koble til en bevegelsessensor og signaler om driften.
9. Koble til en fuktighets- eller temperatursensor.

Prosjekter for fremtiden

Det er usannsynlig at du er interessert i Arduino for å koble til individuelle lysdioder. Mest sannsynlig er du tiltrukket av muligheten til å lage din egen bil, eller flygende platespiller. Disse prosjektene er vanskelige å implementere og vil kreve mye tid og utholdenhet, men når de er fullført, vil du få det du ønsker: verdifull Arduino-designopplevelse for nybegynnere.

Forsinkelser i Arduino spiller en veldig stor rolle. Uten dem kan ikke selv det enkleste eksemplet på Blink, som blinker en LED etter en spesifisert tidsperiode, fungere. Men de fleste nybegynnere programmerere vet lite om tidsforsinkelser og bruker bare Arduino-forsinkelse uten å vite bivirkningene av denne kommandoen. I denne artikkelen vil jeg snakke i detalj om tidsfunksjoner og hvordan du bruker dem i Arduino IDE.

Det er flere forskjellige kommandoer i Arduino som er ansvarlige for å jobbe med tid og pauser:

• forsinkelse()
• delayMicroseconds()
• millis()
• mikros()

De er forskjellige i nøyaktighet og har sine egne egenskaper som bør tas i betraktning når du skriver kode.

Bruker arduino forsinkelsesfunksjonen

Syntaks

Arduino delay er den enkleste kommandoen og brukes oftest av nybegynnere. I hovedsak er det en forsinkelse som setter programmet på pause i antall millisekunder som er angitt i parentes. (Det er 1000 millisekunder i ett sekund.) Maksimumsverdien kan være 4294967295 ms, som er omtrent lik 50 dager. La oss se på et enkelt eksempel som tydelig viser hvordan denne kommandoen fungerer.

Void setup() ( pinMode(13, OUTPUT); ) void loop() ( digitalWrite(13, HIGH); // send et høyt signal til pin 13 delay(10000); // pause 10000ms eller 10 sekunder digitalWrite13, LOW) ; // send et lavt signal til pin 13 delay(10000); // pause 10000ms eller 10 sekunder)

I metode oppsett Vi spesifiserer at pinne 13 skal brukes som en utgang. I hoveddelen av programmet sendes først et høyt signal til pinnen, deretter gjør vi en forsinkelse på 10 sekunder. I løpet av denne tiden ser det ut til at programmet er suspendert. Så gis et lavt signal og igjen er det en forsinkelse og alt starter på nytt. Som et resultat får vi at pinnen vekselvis forsynes med enten 5 V eller 0.

Du må tydelig forstå at under en pause med forsinkelse, er programmets arbeid suspendert, applikasjonen vil ikke motta noen data fra sensorene. Dette er den største ulempen ved å bruke Arduino-forsinkelsesfunksjonen. Du kan omgå denne begrensningen ved å bruke avbrudd, men vi vil snakke om dette i en egen artikkel.

Eksempel på forsinkelse med blinkende LED

Et eksempel på krets for å illustrere hvordan forsinkelsesfunksjonen fungerer.
Du kan bygge en krets med en LED og en motstand. Da vil vi ha et standard eksempel - blinkende en LED. For å gjøre dette må du koble en LED med en positiv kontakt til pinnen, som vi utpekte som utgang. Vi kobler det ledige benet til LED-en til jord gjennom en motstand på omtrent 220 Ohm (litt mer er mulig). Du kan bestemme polariteten ved å se på innsiden. Den store koppen inni er koblet til minus, og den lille leggen til pluss. Hvis LED-en din er ny, kan du bestemme polariteten etter lengden på ledningene: det lange benet er pluss, det korte benet er minus.

delayMicroseconds funksjon

Denne funksjonen er en komplett analog av forsinkelse, bortsett fra at dens måleenheter ikke er millisekunder, men mikrosekunder (på 1 sekund er det 1 000 000 mikrosekunder). Maksimalverdien vil være 16383, som er lik 16 millisekunder. Oppløsningen er 4, det vil si at tallet alltid vil være et multiplum av fire. Et eksempelutdrag vil se slik ut:

DigitalWrite(2, HØY); // send et høyt signal til pin 2 delayMicroseconds(16383); // pause 16383 µs digitalWrite(2, LOW); // send et lavt signal til pin 2 delayMicroseconds(16383); // pause 16383 µs

Problemet med delayMicroseconds er nøyaktig det samme som med forsinkelse - disse funksjonene "henger" programmet fullstendig, og det fryser bokstavelig talt en stund. På dette tidspunktet er det umulig å jobbe med porter, lese informasjon fra sensorer og utføre matematiske operasjoner. Dette alternativet er egnet for blinkende lys, men erfarne brukere bruker det ikke til store prosjekter, siden slike feil ikke er nødvendige der. Derfor er det mye bedre å bruke funksjonene beskrevet nedenfor.

Millis-funksjon i stedet for forsinkelse

Millis()-funksjonen lar deg utføre en forsinkelse uten forsinkelse på Arduino, og dermed omgå manglene ved de tidligere metodene. Maksimalverdien for millis-parameteren er den samme som for forsinkelsesfunksjonen (4294967295ms eller 50 dager).

Ved å bruke millis stopper vi ikke utførelsen av hele skissen, men indikerer bare hvor lenge Arduinoen ganske enkelt skal "omgå" den eksakte kodeblokken som vi vil sette på pause. I motsetning til delay millis, stopper det ikke noe av seg selv. Denne kommandoen returnerer ganske enkelt til oss fra mikrokontrollerens innebygde timer antall millisekunder som har gått siden starten. Med hvert kall til loop måler vi selv tiden som har gått siden siste oppkall av koden vår, og hvis tidsforskjellen er mindre enn ønsket pause, så ignorerer vi koden. Så snart forskjellen blir større enn den nødvendige pausen, kjører vi koden, får gjeldende tid med samme millis og husker det - denne gangen vil være det nye utgangspunktet. I neste syklus vil nedtellingen allerede være fra det nye punktet og vi vil igjen ignorere koden til den nye forskjellen mellom millis og vår tidligere lagrede verdi når ønsket pause igjen.

Forsinkelse uten forsinkelse ved bruk av millis krever mer kode, men med dens hjelp kan du blinke en LED og pause en skisse uten å stoppe systemet.

Her er et eksempel som tydelig illustrerer teamets arbeid:

Usignert lang timing; // Variabel for lagring av referansepunktet void setup() ( Serial.begin(9600); ) void loop() ( /* På dette tidspunktet begynner utførelsen av delay()-analogen. Beregn forskjellen mellom gjeldende øyeblikk og tidligere lagret referansepunkt. Hvis forskjellen er større enn ønsket verdi, utfør koden. Hvis ikke, gjør ingenting */ if (millis() - timing > 10000)( // I stedet for 10000, erstatte pauseverdien du trenger timing = millis(); Serial.println ("10 sekunder") ; ) )

Først introduserer vi tidsvariabelen, som vil lagre antall millisekunder. Som standard er verdien av variabelen 0. I hoveddelen av programmet sjekker vi betingelsen: hvis antall millisekunder fra starten av mikrokontrolleren minus tallet skrevet i tidsvariabelen er større enn 10000, så handlingen for å sende ut en melding til portmonitoren utføres og gjeldende tidsverdi skrives til variabelen. Som et resultat av programmets drift vil meldingen 10 sekunder vises på portmonitoren hvert 10. sekund. Denne metoden lar deg blinke LED-en uten forsinkelse.

Mikrofunksjoner i stedet for forsinkelse

Denne funksjonen kan også utføre en forsinkelse uten å bruke forsinkelseskommandoen. Det fungerer nøyaktig det samme som millis, men det teller mikrosekunder i stedet for millisekunder med en oppløsning på 4 μs. Dens maksimale verdi er 4294967295 mikrosekunder eller 70 minutter. Hvis det renner over, tilbakestilles verdien ganske enkelt til 0, ikke glem det.

Sammendrag

Arduino-plattformen gir oss flere måter å implementere en forsinkelse i prosjektet vårt. Ved å bruke forsinkelse kan du raskt pause utførelsen av en skisse, men samtidig blokkerer du operasjonen til mikrokontrolleren. Ved å bruke millis-kommandoen kan du gjøre det uten forsinkelser i Arduino, men dette vil kreve litt mer programmering. Velge Den beste måten avhengig av kompleksiteten til prosjektet ditt. Som regel, i enkle skisser og med en forsinkelse på mindre enn 10 sekunder, brukes forsinkelse. Hvis driftslogikken er mer kompleks og det kreves en stor forsinkelse, er det bedre å bruke millis i stedet for forsinkelse.

En serie artikler og treningsdiagrammer med amatørradioeksperimenter på Arduino for nybegynnere. Dette er en slags amatørradiokonstruksjon leketøy, hvorfra, uten loddebolt, etsning trykte kretskort og lignende, enhver elektronikkamatør kan sette sammen en fullverdig arbeidsenhet, egnet for både profesjonell prototyping og amatøreksperimenter i studiet av elektronikk.

Arduino-kortet er først og fremst ment for å lære nybegynnere radioamatører det grunnleggende om programmering av mikrokontrollere og lage mikrokontrollerenheter med egne hender uten seriøs teoretisk trening. Arduinos utviklingsmiljø lar deg kompilere og laste ferdig programkode inn i kortets minne. Dessuten er det ekstremt enkelt å laste koden.

Arduino hvor du skal begynne for en nybegynner

Først av alt, for å jobbe med Arduino-kortet, må en nybegynner elektronikkingeniør laste ned Arduino-utviklingsprogrammet; det består av en innebygd tekstredigerer der vi jobber med programkode, et meldingsområde, et tekstutdatavindu (konsoll) ), en verktøylinje med knapper for ofte brukte kommandoer og flere menyer. For å laste ned programmene og kommunisere, er dette programmet koblet til Arduino-kortet via en standard USB-kabel.

Kode skrevet inn Arduino miljø, kalt skisse. Det er skrevet i tekstredigerer, som har spesialverktøy for å sette inn/klippe ut, erstatte/søke etter tekst. Under lagring og eksport vises forklaringer i meldingsområdet (se bildet i første leksjon for nybegynnere, rett nedenfor), og feil kan også vises. Konsollen viser Arduino-meldinger inkludert fullstendige feilrapporter og annet nyttig informasjon. Verktøylinjeknapper lar deg sjekke og ta opp en skisse, åpne, opprette og lagre den, åpne seriell bussovervåking og mye mer.

Så la oss gå videre til den første. Arduino leksjon kretsskjemaer for nybegynnere elektronikkingeniører.

For enkelhets skyld for nybegynnere har Arduino UNO-kontrolleren allerede en motstand og en LED koblet til pin 13 på kontakten, så vi trenger ingen eksterne radioelementer i det første eksperimentet.

Ved å laste inn koden lar Arduino programmet vårt delta i systeminitialisering. For å gjøre dette, indikerer vi til mikrokontrollerkommandoene at den vil utføres ved første oppstart og deretter helt glemme dem (dvs. disse kommandoene vil bli utført av Arduino bare én gang ved oppstart). Og det er for dette formålet at vi i koden vår velger en blokk der disse kommandoene er lagret. ugyldig oppsett(), eller rettere sagt i rommet innenfor de krøllete klammeparentesene til denne funksjonen, se programskissen.

Ikke glem de krøllete tannreguleringene! Tapet av minst en av dem vil gjøre hele skissen helt ubrukelig. Men ikke sett ekstra parenteser heller, da dette også vil føre til en feil.

Last ned kode:

Skisse med kommentarer og forklaringer i filen 001-1_mig-led.ino

Funksjon void loop() det er her vi legger kommandoene som vil bli utført så lenge Arduino er slått på. Etter å ha startet kjøringen fra den første kommandoen, vil Arduino nå helt til slutten og umiddelbart gå til begynnelsen for å gjenta den samme sekvensen. Og så videre et uendelig antall ganger, så lenge brettet får strøm. I kjernen er en void loop hovedfunksjonen, inngangspunktet til Arduino.

Funksjon forsinkelse(1000) forsinker programbehandlingen med 1000 millisekunder. Det hele foregår i en evig syklus Løkke().

Hovedkonklusjonen etter å ha forstått vårt første program på Arduino: Ved å bruke void loop og void setup-funksjonene sender vi instruksjonene våre til mikrokontrolleren. Alt som er inne i oppsettblokken vil kun bli utført én gang. Innholdet i loop-modulen vil bli gjentatt i en loop så lenge Arduino forblir slått på.

I forrige program var det en ny forsinkelse mellom å slå av og på lysdioden. Det var ett stort minus i den enkleste koden til en nybegynner Arduino-operatør som ble brukt ovenfor. For å opprettholde en pause mellom å slå på og av lysdioden i ett sekund, brukte vi funksjonen forsinkelse() og derfor for øyeblikket er ikke kontrolleren i stand til å utføre andre kommandoer i hovedfunksjonen Løkke(). Korrigere kode i en funksjon Løkke(), presentert nedenfor løser dette problemet.

I stedet for å sette verdien til HIGH og deretter til LOW, vil vi få verdien til ledPin og invertere den. La oss si at hvis den var HØY, vil den bli LAV osv.

Sekund Arduino-kodealternativ for LED-kontroll Her:

Da kan du erstatte funksjonen forsinkelse(). I stedet er det bedre å bruke funksjonen millis(). Den returnerer antall millisekunder som har gått siden programmet startet. Funksjonen vil flyte over etter omtrent 50 dager med kjøring av programkoden.

En lignende funksjon er mikros(), som returnerer antall mikrosekunder som har gått siden programkoden ble lansert. Funksjonen går tilbake til null etter 70 minutters programdrift.

Selvfølgelig vil dette legge til noen få linjer med kode til skissen vår, men det vil garantert gjøre deg mer erfaren programmerer og vil øke potensialet til din Arduino. For å gjøre dette trenger du bare å lære hvordan du bruker millis-funksjonen.

Det skal være klart forstått at den enkleste forsinkelsesfunksjonen stopper utførelsen av hele Arduino-programmet, noe som gjør det ikke i stand til å utføre noen oppgaver i løpet av denne tidsperioden. I stedet for å sette hele programmet på pause, kan vi telle hvor lang tid som har gått før handlingen fullføres. Dette er fint implementert ved hjelp av millis()-funksjonen. For å gjøre alt lett å forstå, vil vi vurdere følgende alternativ for å blinke en LED uten tidsforsinkelse.

Begynnelsen av dette programmet er den samme som enhver annen standard Arduino-skisse.

I i dette eksemplet to Arduino digitale I/O-pinner brukes. LED-en er koblet til pinne 8, som er konfigurert som OUTPUT. En knapp er koblet til 9 via, som er konfigurert som INPUT. Når vi trykker på knappen settes pinne 9 til HØY, og programmet bytter pin 8 til HØY, og slår dermed på LED. Å slippe knappen tilbakestiller pinne 9 til LAV. Koden bytter deretter pin 8 til LAV, og slår av indikatorlyset.

For å kontrollere fem lysdioder vil vi bruke forskjellige manipulasjoner med Arduino-porter. For å gjøre dette skriver vi dataene direkte til Arduino-porter, vil dette tillate deg å stille inn verdiene for lysdiodene ved hjelp av bare én funksjon.

Arduino UNO har tre porter: B(digitale innganger/utganger fra 8 til 13); C(analoge innganger); D(digitale innganger/utganger 0 til 7)

Hver port kontrollerer tre registre. Den første DDR spesifiserer om pinnen skal være en inngang eller utgang. Ved å bruke det andre PORT-registeret kan du sette pin til HIGH eller LOW. Ved å bruke den tredje kan du lese informasjon om tilstanden til Arduino-benene, hvis de fungerer som en inngang.

For å betjene kretsen bruker vi port B. For å gjøre dette, sett alle portpinner som digitale utganger. Port B har bare 6 ben. DDRB-registerbitene må settes til "1" , hvis pinnen skal brukes som en utgang (OUTPUT), og inn "0" , hvis vi planlegger å bruke pinnen som en inngang (INPUT). Portbiter er nummerert 0 til 7, men har ikke alltid alle 8 pinnene

La oss si: DDRB = B00111110;// sett port B pinner 1 til 5 som utgang og 0 som inngang.

I kjørelyskretsen vår bruker vi fem utganger: DDRB = B00011111; // sett port B pinner 0 til 4 som utganger.

For å skrive data til port B, må du bruke PORTB-registeret. Du kan tenne den første LED-en ved å bruke kontrollkommandoen: PORTB = B00000001;, første og fjerde LED: PORTB = B00001001 og så videre

Det er to binære skiftoperatorer: venstre og høyre. Venstre skiftoperatør får alle databiter til å flytte til venstre, mens høyre skiftoperatør flytter dem til høyre.

Eksempel:

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

La oss nå gå tilbake til kildekoden til programmet vårt. Vi må legge inn to variabler: opp ned vil inkludere verdiene for hvor du skal flytte - opp eller ned, og den andre cylon vil indikere hvilke lysdioder som skal tennes.

Strukturelt sett har en slik LED én felles terminal og tre terminaler for hver farge. Nedenfor er et diagram over tilkobling av en RGB LED til et Arduino-kort med en felles katode. Alle motstander som brukes i koblingskretsen må ha samme verdi fra 220-270 Ohm.

For en tilkobling med en felles katode vil koblingsskjemaet for en trefarget LED være nesten det samme, bortsett fra at den vanlige pinnen ikke kobles til jord (gnd på enheten), men til +5 volt-pinnen. Pinner Rød, grønn og blå er i begge tilfeller koblet til kontrollerens digitale utganger 9, 10 og 11.

Vi vil koble en ekstern LED til den niende pinnen til Arduino UNO gjennom en motstand på 220 Ohm. For å jevnt kontrollere lysstyrken til sistnevnte, bruk funksjonen analogWrite(). Den gir utgang av et PWM-signal til kontrollerbenet. Dessuten laget pinMode() ikke nødvendig å ringe. Fordi analogWrite(pin, verdi) inkluderer to parametere: pinne - pinnenummer for utgang, verdi - verdi fra 0 til 255.

Kode:
/*
Et opplæringseksempel for en nybegynner Arduino-utvikler som avslører egenskapene til analogWrite()-kommandoen for å implementere Fade-effekten til en LED
*/
int lysstyrke = 0; // LED-lysstyrke
int fadeAmount = 5; // lysstyrke endre trinn
unsigned long currentTime;
usignert lang loopTime;

Ugyldig oppsett() (
pinMode(9, OUTPUT); // sett pin 9 som utgang
gjeldendeTid = millis();
loopTime = currentTime;
}

Void loop() (
gjeldendeTid = millis();
if(currentTime >= (loopTime + 20))(
analogWrite(9, lysstyrke); // sett verdien på pinne 9

Lysstyrke = lysstyrke + fadeAmount; // legg til et trinn for å endre lysstyrken, som vil bli etablert i neste syklus

// hvis nådd min. eller maks. verdier, så går vi i motsatt retning (revers):
if (lysstyrke == 0 || lysstyrke == 255) (
fadeAmount = -fadeAmount ;
}
loopTime = currentTime;
}
}

Arduino operasjon med koder

Enkoderen er designet for å konvertere rotasjonsvinkelen til et elektrisk signal. Fra den mottar vi to signaler (A og B), som er motsatt i fase. I denne opplæringen vil vi bruke SparkFun COM-09117-koderen, som har tolv posisjoner per omdreining (hver posisjon er nøyaktig 30°). Figuren nedenfor viser tydelig hvordan utgang A og B avhenger av hverandre når koderen beveger seg med eller mot klokken.

Hvis signal A går fra et positivt nivå til null, leser vi verdien av utgang B. Hvis utgang B er i positiv tilstand på dette tidspunktet, beveger koderen seg i retning med klokken, hvis B gir ut et nullnivå, så koderen beveger seg i motsatt retning. Ved å lese begge utgangene er vi i stand til å beregne rotasjonsretningen ved hjelp av en mikrokontroller, og ved å telle pulser fra A-utgangen til koderen, rotasjonsvinkelen.

Om nødvendig kan du bruke frekvensberegninger for å bestemme hvor raskt koderen roterer.

Ved å bruke en koder i opplæringseksemplet vårt vil vi justere lysstyrken på LED-en ved å bruke PWM-utgangen. For å lese data fra koderen vil vi bruke en metode basert på programvaretidtakere, som vi allerede har dekket.

Med tanke på det faktum at vi i det raskeste tilfellet kan rotere koderknappen 180° på 1/10 av et sekund, vil dette være 6 pulser på 1/10 av et sekund eller 60 pulser på ett sekund.

I realiteten er det ikke mulig å rotere raskere. Siden vi trenger å spore alle halvsykluser, bør frekvensen være omtrent 120 Hertz. For å være helt sikker, la oss ta 200 Hz.

Siden vi i dette tilfellet bruker en mekanisk koder, er kontaktsprett mulig, og lav frekvens filtrerer perfekt bort slik skravling.

Basert på programtidsursignalene er det nødvendig å hele tiden sammenligne gjeldende verdi av koderutgangen A med forrige verdi. Hvis tilstanden endres fra positiv til null, spør vi tilstanden til utgang B. Avhengig av resultatet av tilstandsmålingen øker eller reduserer vi verditelleren LED lysstyrke LED. Programkoden med et tidsintervall på ca. 5 ms (200 Hz) er presentert nedenfor:

Arduino nybegynnerkode:
/*
** Enkoder
** For å kontrollere lysstyrken på LED-en brukes en koder fra Sparkfun
*/

Int lysstyrke = 120; // LED-lysstyrke, start på halvparten
int fadeAmount = 10; // lysstyrke endre trinn
unsigned long currentTime;
usignert lang loopTime;
const int pin_A = 12; // pinne 12
const int pin_B = 11; // pinne 11
usignert char encoder_A;
usignert char encoder_B;
usignert char encoder_A_prev=0;
void oppsett() (
// erklærer pin 9 for å være en utgang:
pinMode(9, OUTPUT); // sett pin 9 som utgang
pinMode(pin_A, INPUT);
pinMode(pin_B, INPUT);
gjeldendeTid = millis();
loopTime = currentTime;
}
void loop() (
gjeldendeTid = millis();
if(currentTime >= (loopTime + 5))( // sjekk tilstander hver 5ms (frekvens 200 Hz)
encoder_A = digitalRead(pin_A); // les tilstanden til utgang A til koderen
encoder_B = digitalRead(pin_B); // koderutgang B
if((!encoder_A) && (encoder_A_prev))( // hvis tilstanden endres fra positiv til null
if(koder_B) (
// utgang B er i positiv tilstand, som betyr at rotasjonen er med klokken
// øke lysstyrken til gløden, ikke mer enn 255
if(lysstyrke + fadeAmount )
ellers(
// utgang B er i nulltilstand, som betyr at rotasjonen er mot klokken
// reduser lysstyrken, men ikke under null
if(lysstyrke - fadeAmount >= 0) lysstyrke -= fadeAmount;
}

}
encoder_A_prev = encoder_A; // lagre verdien av A for neste sløyfe

AnalogWrite(9, lysstyrke); // sett lysstyrken til den niende pinne

LoopTime = gjeldende tid;
}
}

I dette nybegynnereksemplet skal vi se på å jobbe med en piezo-emitter for å generere lyder. For å gjøre dette, la oss ta en piezoelektrisk sensor som lar oss generere lydbølger i frekvensområdet 20 Hz - 20 kHz.

Dette er et amatørradiodesign hvor LED-er er plassert over hele volumet. Ved å bruke dette opplegget kan du generere forskjellige lys- og animasjonseffekter. Komplekse kretsløp er til og med i stand til å vise forskjellige tredimensjonale ord. Dette er med andre ord en elementær surroundmonitor

Servodrevet er hovedelementet i utformingen av ulike radiostyrte modeller, og styringen ved hjelp av en kontroller er enkel og praktisk.

Kontrollprogrammet er enkelt og intuitivt. Det starter med å koble til en fil som inneholder alle nødvendige kommandoer for å kontrollere servostasjonen. Deretter lager vi et servoobjekt, for eksempel servoMain. Den neste funksjonen er setup(), der vi spesifiserer at servoen er koblet til den niende pinnen på kontrolleren.

Kode:
/*
Arduino Servo
*/
#inkludere
Servo servoMain; // Servoobjekt

Ugyldig oppsett()
{
servoMain.attach(9); // Servo koblet til pin 9
}

void loop()
{
servoMain.write(45); // Roter servo til venstre 45°
delay(2000); // Vent 2000 millisekunder (2 sekunder)
servoMain.write(0); // Roter servo til venstre med 0°
forsinkelse(1000); // Pause 1 s.

forsinkelse(1500); // Vent 1,5 s.
servoMain.write(135); // Roter servo høyre 135°
forsinkelse(3000); // Pause 3 s.
servoMain.write(180); // Roter servo høyre 180°
forsinkelse(1000); // Vent 1 s.
servoMain.write(90); // Roter servoen 90°. Sentral posisjon
forsinkelse(5000); // Pause 5 s.
}

I hovedfunksjonen Løkke(), gir vi kommandoer til servomotoren, med pauser mellom dem.

Arduino tellerkrets på en 7-segment indikator

Dette enkle Arduino-prosjektet for nybegynnere innebærer å lage en tellerkrets ved å bruke en vanlig 7-segments felles katodeskjerm. Programkode, gitt nedenfor, lar deg begynne å telle fra 0 til 9 når du trykker på en knapp.

Syv-segmentindikator - er en kombinasjon av 8 lysdioder (den siste er ansvarlig for punktet) med en felles katode, som kan slås på i ønsket rekkefølge slik at de lager tall. Det skal bemerkes at i denne kretsen, se figuren nedenfor, er pinnene 3 og 8 tildelt katoden.

Korrespondansetabellen vises til høyre Arduino pinner og LED-indikatorpinner.

Kode for dette prosjektet:

byte tall = (
B11111100, B01100000, B11011010, B11110010, B01100110,
B10110110, B10111110, B11100000, B11111110, B11100110
};
void oppsett() (
for(int i = 2; i pinMode(i, OUTPUT);
}
pinMode(9, INPUT);
}
int teller = 0;
bool go_by_switch = sant;
int siste_inndataverdi = LAV;
void loop() (
if(go_by_switch) (
int switch_input_value = digitalRead(9);
if(last_input_value == LOW && switch_input_value == HØY) (

}
siste_inndataverdi = bytte_inndataverdi;
) annet (
forsinkelse(500);
teller = (teller + 1) % 10;
}
skrivTall(teller);
}

Void writeNumber(int number) (
if(nummer 9) (
komme tilbake;
}
byte maske = tall;
byte currentPinMask = B10000000;
for(int i = 2; i if(mask & currentPinMask) digitalWrite(i,HIGH);
else digitalWrite(i,LOW);
currentPinMask = currentPinMask >> 1;
}
}

Du kan betydelig utvide potensialet til Arduino-brett ved å bruke tilleggsmoduler, som kan kobles til PIN-pinnene til nesten alle enheter. Tenk på de mest populære og interessante utvidelsesmodulene, eller skjoldene som de også kalles.