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 utgang. I hoveddelen av programmet sendes først et høyt signal til pinnen, deretter forsinker vi det i 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 5 V, deretter 0.
Du må tydelig forstå at under en pause med forsinkelse, er programmets arbeid suspendert, applikasjonen vil ikke motta 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 vil tillate 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)( // Bytt ut 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. Velg den beste metoden 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.
" presenterer opplæringskurset "Arduino for nybegynnere". Serien består av 10 leksjoner, samt tilleggsmateriell. Leksjonene inkluderer tekstinstruksjoner, bilder og instruksjonsvideoer. I hver leksjon finner du en liste over nødvendige komponenter, en programliste og et koblingsskjema. Når du har fullført disse 10 grunnleggende leksjonene, vil du kunne gå videre til mer interessante modeller og bygging av Arduino-baserte roboter. Kurset er rettet mot nybegynnere; ingen tilleggsinformasjon fra elektroteknikk eller robotikk kreves for å begynne det.
Kort informasjon om Arduino
Hva er Arduino?
Arduino (Arduino) er enrm, hvor hovedkomponentene er et input-output-kort og et utviklingsmiljø. Arduino kan brukes til å lage frittstående interaktive objekter, eller koble til programvare som kjører på en datamaskin. Arduino er en enkeltbordsdatamaskin.
Hvordan er Arduino og roboter koblet sammen?
Svaret er veldig enkelt - Arduino brukes ofte som robothjerne.
Fordelen med Arduino-brett fremfor lignende plattformer er deres relativt lave pris og nesten utbredte distribusjon blant amatører og profesjonelle innen robotikk og elektroteknikk. Når du kommer i gang med Arduino, vil du finne støtte på alle språk og likesinnede som vil svare på spørsmålene dine og diskutere utviklingen din med.
Leksjon 1. Blinkende LED på Arduino
I den første leksjonen lærer du hvordan du kobler en LED til en Arduino og kontrollerer den til å blinke. Dette er den enkleste og mest grunnleggende modellen.
Lysdiode- en halvlederenhet som skaper optisk stråling når en elektrisk strøm føres gjennom den i foroverretningen.
Leksjon 2. Koble til en knapp på Arduino
I denne opplæringen lærer du hvordan du kobler en knapp og en LED til en Arduino.
Når knappen trykkes, vil LED-en lyse, mens når knappen trykkes, vil den ikke lyse. Dette er også basismodellen.
Leksjon 3. Koble til et potensiometer på Arduino
I denne opplæringen lærer du hvordan du kobler et potensiometer til Arduino.
Potensiometer- Dette motstand med justerbar motstand.Potensiometre brukes som regulatorer av forskjellige parametere - lydvolum, kraft, spenning, etc.Dette er også en av grunnordningene. I vår modell fra å vri på potensiometerknappenLysstyrken til LED-en vil avhenge.
Leksjon 4. Servokontroll på Arduino
I denne opplæringen lærer du hvordan du kobler en servo til en Arduino.
Servoer en motor hvis akselposisjon kan kontrolleres ved å stille inn rotasjonsvinkelen.
Servoer brukes til å simulere ulike mekaniske bevegelser av roboter.
Leksjon 5. Trefarget LED på Arduino
I denne opplæringen lærer du hvordan du kobler en trefarget LED til en Arduino.
Trefarget LED(rgb led) - dette er tre lysdioder i forskjellige farger i ett hus. De kommer enten med et lite kretskort som motstander er plassert på, eller uten innebygde motstander. Leksjonen dekker begge alternativene.
Leksjon 6. Piezoelektrisk element på Arduino
I denne leksjonen lærer du hvordan du kobler et piezo-element til en Arduino.
Piezo-element- en elektromekanisk omformer som oversetter elektrisk spenning inn i membranvibrasjoner. Disse vibrasjonene skaper lyd.
I vår modell kan lydfrekvensen justeres ved å stille inn passende parametere i programmet.
Leksjon 7. Fotoresistor på Arduino
I denne leksjonen av kurset vårt vil du lære hvordan du kobler en fotomotstand til Arduino.
Fotomotstand- en motstand hvis motstand avhenger av lysstyrken til lyset som faller på den.
I vår modell lyser LED kun hvis lysstyrken på lyset over fotomotstanden er mindre enn en viss denne lysstyrken kan justeres i programmet.
Leksjon 8. Bevegelsessensor (PIR) på Arduino. Automatisk sending av e-post
I denne leksjonen av kurset vårt lærer du hvordan du kobler en bevegelsessensor (PIR) til Arduino, samt organiserer automatisk sending av e-post. 
Bevegelsessensor (PIR)- infrarød sensor for å oppdage bevegelse eller tilstedeværelse av mennesker eller dyr.
I vår modell, når Arduino mottar et signal om menneskelig bevegelse fra en PIR-sensor, sender Arduino en kommando til datamaskinen om å sende en e-post og brevet sendes automatisk.
Leksjon 9. Koble til en temperatur- og fuktighetssensor DHT11 eller DHT22
I denne leksjonen vår lærer du hvordan du kobler en DHT11 eller DHT22 temperatur- og fuktighetssensor til en Arduino, og også bli kjent med forskjellene i deres egenskaper. 
Temperatur- og fuktighetssensor er en sammensatt digital sensor som består av en kapasitiv fuktighetssensor og en termistor for måling av temperatur.
I vår modell leser Arduino sensoravlesningene og viser avlesningene på dataskjermen.
Leksjon 10. Koble til et matrisetastatur
I denne leksjonen av kurset vårt lærer du hvordan du kobler et matrisetastatur til et Arduino-brett, og også bli kjent med forskjellige interessante kretser.
Matrix tastatur oppfunnet for å forenkle tilkoblingen av et stort antall knapper. Slike enheter finnes overalt - i datamaskintastaturer, kalkulatorer og så videre.
Leksjon 11. Koble til DS3231 sanntidsklokkemodul
I den siste leksjonen av kurset vårt lærer du hvordan du kobler til en sanntidsklokkemodul fra familien 
DS til Arduino-brettet, og bli også kjent med forskjellige interessante kretser.
Sanntidsklokkemodul- dette er en elektronisk krets designet for å registrere kronometriske data (gjeldende tid, dato, ukedag, etc.), og er et system som består av en autonom strømkilde og en opptaksenhet.
Applikasjon. Ferdige rammer og Arduino-roboter
Du kan begynne å lære Arduino ikke bare fra selve brettet, men også ved å kjøpe en ferdig, fullverdig robot basert på dette brettet - en edderkopprobot, en robotbil, en skilpadderobot, etc. Slik vei Den passer også for de som ikke er spesielt tiltrukket av elektriske kretser.
Ved å kjøpe en fungerende robotmodell, dvs. faktisk kan et ferdiglaget høyteknologisk leketøy vekke interessen for uavhengig design og robotikk. Åpenheten til Arduino-plattformen lar deg lage nye leker fra de samme komponentene.
Et annet alternativ er å kjøpe en robotramme eller -kropp: en plattform på hjul eller et spor, en humanoid, en edderkopp, etc. I dette tilfellet må du fylle roboten selv.
Applikasjon. Mobilkatalog
– en assistent for utviklere av algoritmer for Arduino-plattformen, hvis formål er å gi sluttbrukeren muligheten til å ha et mobilsett med kommandoer (referansebok).
Søknaden består av 3 hovedseksjoner:
- Operatører;
- Data;
- Funksjoner.
Hvor kan du kjøpe Arduino
Arduino-sett
Kurset vil bli oppdatert med tilleggstimer. Følg oss
I dag skal vi snakke om bruk av SD- og micro SD-kort i Arduino. Vi vil finne ut hvordan du kobler SD-kort til Arduino, hvordan du skriver og leser informasjon. Å bruke ekstra minne kan være svært nyttig i mange prosjekter. Hvis du ikke vet hva SPI, I2C og analoge pinner er, anbefaler jeg deg å se tidligere leksjoner og forstå disse Arduino-kommunikasjonsgrensesnittene.
I denne opplæringen skal vi snakke om trådløs kommunikasjon mellom to Arduino-kort. Dette kan være veldig nyttig for å overføre kommandoer fra en Arduino til en annen, eller utveksle informasjon mellom DIY-ene dine. Muligheten for trådløs dataoverføring åpner for nye muligheter i å lage dine prosjekter.
I denne opplæringen vil vi lære om I2C-bussen. I2C er en kommunikasjonsbuss som kun bruker to linjer. Ved å bruke dette grensesnittet kan Arduino kommunisere med mange enheter over to ledninger. I dag skal vi finne ut hvordan du kobler sensorer til Arduino via I2C-bussen, hvordan du får tilgang til en spesifikk enhet og hvordan du mottar data fra disse enhetene.
I denne opplæringen vil vi snakke om Arduino Serial kommunikasjonsgrensesnitt. Vi har allerede brukt dette grensesnittet i tidligere leksjoner, da vi viste verdier fra sensorer på dataskjermen. I dag skal vi se nærmere på hvordan denne tilkoblingen fungerer, og vi vil også lære hvordan du bruker dataene som overføres til dataportmonitoren ved hjelp av Processing.
I dag skal vi snakke om transistorer og tilkobling av belastninger til Arduino. Arduino selv kan ikke produsere en spenning høyere enn 5 volt og en strøm høyere enn 40 mA fra en pinne. Dette er nok for sensorer og lysdioder, men skal vi koble til enheter som er mer strømkrevende, må vi bruke transistorer eller releer.
I denne leksjonen vil vi snakke om det grunnleggende om kretsdesign slik det brukes på Arduino. Og la oss starte, selvfølgelig, med Ohms lov, siden dette er grunnlaget for alle kretser. Også i denne leksjonen skal vi snakke om motstand, pull-up og pull-up motstander, beregning av strøm og spenning.
I denne artikkelen bestemte jeg meg for å sette sammen en komplett trinn-for-trinn-guide for Arduino-nybegynnere. 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 et elektronisk byggesett som lar alle lage en rekke elektromekaniske enheter. Arduino består av programvare og maskinvare. Programvaredelen 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.
Fra enkle blinklys, værstasjoner, automasjonssystemer og slutter med smarthussystemer, 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. Dette er et veldig enkelt og praktisk program. På nettstedet mitt har jeg allerede beskrevet prosessen med å laste ned, installere og konfigurere utviklingsmiljøet. Derfor vil jeg her bare legge igjen lenker til den nyeste versjonen av programmet og til
| 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 ) return current ) 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 ) ( ledPå = ! ledPå; lastButton = currentButton ; digitalWrite(ledPin, ledOn); |
I denne skissen opprettet jeg en ekstra debounse-funksjon 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 pinnene 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% fyll 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 -- ) ( |
Denne simulatoren fungerer best i Chrome-nettleseren
La oss se nærmere på Arduino.
Arduino er ikke en stor datamaskin som kan kobles til eksterne kretser. Arduino Uno bruker Atmega 328P
Dette er den største brikken på brettet. Denne brikken kjører programmer som er lagret i minnet. Du kan laste ned programmet via usb ved å bruke Arduino IDE. USB-porten gir også strøm til arduinoen.
Det er en separat strømkontakt. Brettet har to pinner merket 5v og 3.3v, som er nødvendig for å drive ulike enheter. Du finner også pinner merket GND, dette er jordpinnene (jord er 0V). Arduino-plattformen har også 14 digitale pinner, merket 0 til 13, som kobles til eksterne noder og har to tilstander, høy eller lav (på eller av). Disse kontaktene kan fungere som utganger eller som innganger, dvs. de kan enten overføre noen data og kontrollere eksterne enheter, eller motta data fra enheter. De neste pinnene på brettet er merket A0-A5. Dette er analoge innganger som kan motta data fra ulike sensorer. Dette er spesielt praktisk når du trenger å måle et bestemt område, for eksempel temperatur. De analoge inngangene har tilleggsfunksjoner som kan aktiveres separat.
Hvordan bruke en utviklingstavle.
Brødbrettet er nødvendig for å koble sammen delene midlertidig, sjekke hvordan enheten fungerer, før du lodder alt sammen.
Alle de følgende eksemplene er satt sammen på et brødbrett slik at du raskt kan gjøre endringer i kretsen og gjenbruke deler uten å bry deg med lodding.
Brødbrettet har rader med hull som du kan sette inn deler og ledninger i. Noen av disse hullene er elektrisk koblet til hverandre.
De to øverste og nederste radene er koblet sammen i rader langs hele brettet. Disse radene brukes til å levere strøm til kretsen. Det kan være 5V eller 3,3V, men uansett, det første du må gjøre er å koble 5V og GND til breadboard som vist på bildet. Noen ganger kan disse radforbindelsene være brutt på midten av brettet, så hvis du trenger det, kan du koble dem som vist på bildet.
De resterende hullene, plassert i midten av brettet, er gruppert i grupper på fem hull. De brukes til å koble kretsdeler.
Det første vi skal koble til mikrokontrolleren vår er en LED. Det elektriske koblingsskjemaet er vist på bildet.
Hvorfor trengs en motstand i en krets? I dette tilfellet begrenser den strømmen som går gjennom LED-en. Hver LED er designet for en viss strøm, og hvis denne strømmen er høyere, vil LED svikte. Du kan finne ut hvilken verdi motstanden skal ha ved å bruke Ohms lov. For de som ikke vet eller har glemt, sier Ohms lov at det er et lineært forhold mellom strøm og spenning. Det vil si at jo mer spenning vi legger på motstanden, jo mer strøm vil strømme gjennom den.
V=I*R
Hvor V- spenning over motstanden
Jeg- strøm gjennom motstanden
R- motstand som må finnes.
Først må vi finne ut spenningen over motstanden. De fleste 3mm eller 5mm LED du vil bruke har en driftsspenning på 3V. Dette betyr at vi må slukke 5-3 = 2V ved motstanden.
Vi vil da beregne strømmen som går gjennom motstanden.
De fleste 3 mm og 5 mm LED lyser med full lysstyrke ved 20 mA. En strøm som er større enn dette kan deaktivere dem, mens en strøm med mindre intensitet vil redusere lysstyrken uten å forårsake skade.
Så vi ønsker å koble LED-en til 5V-kretsen slik at den har en strøm på 20mA. Siden alle delene er inkludert i én krets, vil motstanden også ha en strøm på 20mA.
Vi får
2V = 20 mA * R
2V = 0,02A * R
R = 100 Ohm
100 Ohm er minimumsmotstanden, det er bedre å bruke litt mer, fordi lysdioder har en viss variasjon i egenskaper.
I dette eksemplet brukes en 220 ohm motstand. Bare fordi forfatteren har mange av dem: blunk: .
Sett lysdioden inn i hullene i midten av brettet slik at den lange ledningen er koblet til en av motstandsledningene. Koble den andre enden av motstanden til 5V, og koble den andre ledningen til LED-en til GND. LED-en skal lyse.
Vær oppmerksom på at det er forskjell på hvordan du kobler til LED-en. Strøm flyter fra den lengre terminalen til den kortere. I diagrammet kan du tenke deg at strømmen går i den retningen trekanten er rettet. Prøv å snu LED-en opp ned og du vil se at den ikke vil lyse.
Men hvordan du kobler til motstanden spiller ingen rolle i det hele tatt. Du kan snu den eller prøve å koble den til en annen pinne på LED-en, dette vil ikke påvirke driften av kretsen. Det vil fortsatt begrense strømmen gjennom LED-en.
Anatomy of Arduino Sketch.
Programmer for Arduino kalles skisse. De består av to hovedfunksjoner. Funksjon oppsett og funksjon Løkke
Inne i denne funksjonen vil du stille inn alle grunnleggende innstillinger. Hvilke pinner vil fungere som inngang eller utgang, hvilke biblioteker som skal kobles til, initialiserer variabler. Funksjon Oppsett() kjører kun én gang under skissen, når programkjøringen starter.
dette er hovedfunksjonen som utføres etter oppsett(). Faktisk er det selve programmet. Denne funksjonen vil kjøre på ubestemt tid til du slår av strømmen.
Arduino blinkende LED
I dette eksempelet skal vi koble en LED-krets til en av Arduinoens digitale pinner og skru den av og på ved hjelp av et program, og du vil også lære flere nyttige funksjoner.
Denne funksjonen brukes i oppsett() del av programmet og tjener til å initialisere pinnene du vil bruke som input (INNGANG) eller gå ut (PRODUKSJON). Du vil ikke kunne lese eller skrive data fra pinnen før du setter den til hhv pinMode. Denne funksjonen har to argumenter: PIN-kode er pin-nummeret du skal bruke.
Modus- angir hvordan pinnen skal fungere. Ved inngangen (INNGANG) eller gå ut (PRODUKSJON). For å tenne LED-en må vi gi et signal FRA Arduino. For å gjøre dette konfigurerer vi utgangspinnen.
- denne funksjonen brukes til å stille inn tilstanden (stat) pina (PIN-kode). Det er to hovedtilstander (faktisk 3 av dem), en er HØY, vil det være 5V på pinnen, det er noe annet Lav og pinnen vil være 0v. Dette betyr at for å tenne LED-en må vi sette pinnen koblet til LED-en til et høyt nivå HØY.
Forsinkelse. Tjener til å utsette driften av programmet i en periode spesifisert i msek.
Nedenfor er koden som får LED-en til å blinke.
//LED Blink int ledPin = 7;//Arduino pin som LED er koblet til void setup() ( pinMode(ledPin, OUTPUT);// setter pinnen som OUTPUT) void loop() ( digitalWrite(ledPin, HIGH) ;// slå på LED-forsinkelsen(1000);// delay 1000 ms (1 sek) digitalWrite(ledPin, LOW);//Slå av LED-forsinkelsen(1000);//vent 1 sek.)
Små forklaringer på koden.
Linjer som starter med "//" er kommentarer og ignoreres av Arduino.
Alle kommandoer slutter med semikolon hvis du glemmer dem, vil du motta en feilmelding.
ledPin er en variabel. Variabler brukes i programmer for å lagre verdier. I dette eksemplet er variabelen ledPin verdien er tilordnet 7, dette er Arduino-pinnummeret. Når Arduino-programmet møter en linje med en variabel ledPin, vil den bruke verdien vi spesifiserte tidligere.
Så rekord pinMode(ledPin, OUTPUT) ligner på opptak pinMode(7, OUTPUT).
Men i det første tilfellet trenger du bare å endre variabelen, og den vil endres på hver linje der den brukes, og i det andre tilfellet, for å endre variabelen, må du gjøre endringer manuelt i hver kommando.
Den første linjen angir typen av variabelen. Når du programmerer Arduino, er det viktig å alltid deklarere typen variabler. For nå er det nok for deg å vite det INT kunngjør negative og positive tall.
Nedenfor er en simulering av skissen. Klikk på start for å se kretsen i aksjon.
Som forventet slukkes LED-en og tennes igjen etter ett sekund. Prøv å endre forsinkelsen for å se hvordan det fungerer.
Kontroll av flere lysdioder.
I dette eksemplet lærer du hvordan du kontrollerer flere lysdioder. For å gjøre dette, installer 3 flere LED-er på brettet og koble dem til motstander og Arduino-pinner som vist nedenfor.
For å slå lysdiodene av og på én etter én, må du skrive et program som ligner på dette:
//Multi LED Blink int led1Pin = 4; int led2Pin = 5; int led3Pin = 6; int led4Pin = 7; void setup() ( //sett pinner som OUTPUT pinMode(led1Pin, OUTPUT); pinMode(led2Pin, OUTPUT); pinMode(led3Pin, OUTPUT); pinMode(led4Pin, OUTPUT); ) void loop() ( digitalWrite(led1Pin, HIGH );//skru på LED-forsinkelsen(1000);//delay 1 sek digitalWrite(led1Pin, LOW);//slå av LED-forsinkelsen(1000);//delay 1 sek //gjør det samme for de andre 3 LED digitalWrite(led2Pin , HIGH);//lyser LED-forsinkelsen(1000);//forsinkelse 1 sek digitalWrite(led2Pin, LOW);//slukker LED-forsinkelsen(1000);//forsinkelse 1 sek digitalWrite(led3Pin, HIGH) );//lys LED-forsinkelsen(1000);// delay 1 sek digitalWrite(led3Pin, LOW);//slukk LED-forsinkelsen(1000);//delay 1 sek digitalWrite(led4Pin, HIGH);//slå på LED-forsinkelsen(1000);// forsinkelse 1 sek digitalWrite(led4Pin, LOW);//slukk LED-forsinkelsen(1000);//forsinkelse 1 sek.)
Dette programmet vil fungere utmerket, men det er ikke den mest rasjonelle løsningen. Koden må endres. For at programmet skal fungere om og om igjen, vil vi bruke en konstruksjon som heter .
Løkker er nyttige når du må gjenta den samme handlingen flere ganger. I koden ovenfor gjentar vi linjene
DigitalWrite(led4Pin, HIGH); forsinkelse(1000); digitalWrite(led4Pin, LOW); forsinkelse(1000);
full skissekode i vedlegg (nedlastinger: 1260)
LED lysstyrkejustering
Noen ganger må du endre lysstyrken på lysdiodene i programmet. Dette kan gjøres ved å bruke kommandoen analogWrite()
. Denne kommandoen slår LED-en av og på så raskt at øyet ikke kan se flimringen. Hvis LED-en er slått på halve tiden og av halve tiden, vil det visuelt se ut til at den lyser med halve lysstyrken. Dette kalles pulsbreddemodulasjon (PWM eller PWM på engelsk). Shim brukes ganske ofte, siden den kan brukes til å kontrollere en "analog" komponent ved hjelp av en digital kode. Ikke alle Arduino-pinner er egnet for disse formålene. Bare de konklusjonene som en slik betegnelse trekkes nær " ~
". Du vil se den ved siden av pinnene 3,5,6,9,10,11.
Koble en av LED-ene til en av PWM-pinnene (for forfatteren er dette pinne 9). Kjør nå LED-blinkskissen, men endre først kommandoen digitalWrite() på analogWrite(). analogWrite() har to argumenter: det første er pin-nummeret, og det andre er PWM-verdien (0-255), i forhold til lysdioder vil dette være deres lysstyrke, og for elektriske motorer rotasjonshastigheten. Nedenfor er en eksempelkode for forskjellige LED-lysstyrker.
//Endre lysstyrken til LED int ledPin = 9;//en LED er koblet til dette pin void oppsettet() ( pinMode(ledPin, OUTPUT);// initialiserer pinnen til utgangen ) void loop() ( analogWrite( ledPin, 255);// full lysstyrke (255/255 = 1) delay(1000);//pause 1 sek digitalWrite(ledPin, LOW);//slå av LED-forsinkelse(1000);//pause 1 sek analogWrite( ledPin, 191);//lysstyrke med 3/4 (191/255 ~= 0,75) delay(1000);//pause 1 sek digitalWrite(ledPin, LOW);//slå av LED-forsinkelsen(1000);// pause 1 sek analogWrite(ledPin, 127); //halv lysstyrke (127/255 ~= 0,5) delay(1000);//pause 1 sek digitalWrite(ledPin, LOW);//slå av LED-forsinkelse(1000);/ /pause 1 sek analogWrite(ledPin, 63); //kvart lysstyrke (63/255 ~= 0,25) delay(1000);//pause 1 sek digitalWrite(ledPin, LOW);//slå av LED-forsinkelsen(1000) ;//pause 1 sek)
Prøv å endre PWM-verdien i kommandoen analogWrite() for å se hvordan dette påvirker lysstyrken.
Deretter lærer du hvordan du justerer lysstyrken jevnt fra full til null. Du kan selvfølgelig kopiere et kodestykke 255 ganger
analogWrite(ledPin, lysstyrke); delay(5);//short delay lysstyrke = lysstyrke + 1;
Men du forstår, dette vil ikke være praktisk. Den beste måten å gjøre dette på er å bruke FOR-løkken vi brukte tidligere.
Følgende eksempel bruker to løkker, en for å redusere lysstyrken fra 255 til 0
for (int lysstyrke=0; lysstyrke=0; lysstyrke--)( analogWrite(ledPin, lysstyrke); delay(5); )
forsinkelse (5) brukes til å redusere lysstyrkens inntoningshastighet 5*256=1280ms=1,28s)
Den første linjen bruker " lysstyrke-" for å få lysstyrkeverdien til å reduseres med 1 hver gang sløyfen gjentas. Merk at sløyfen vil løpe til lysstyrke >=0.Bytter ut skiltet >
på skiltet >=
vi inkluderte 0 i lysstyrkeområdet. Denne skissen er modellert nedenfor. //endre lysstyrken jevnt int ledPin = 9;//en LED er koblet til dette pin void oppsettet() ( pinMode(ledPin, OUTPUT);// initialisering av utgangspinnen) void loop() ( //øk jevnt lysstyrke (0 til 255 ) for (int lysstyrke=0; lysstyrke=0; lysstyrke--)( analogWrite(ledPin, lysstyrke); delay(5); ) delay(1000);//vent 1 sek //reduser lysstyrken jevnt (255 til 0) for (int lysstyrke=255;lysstyrke>=0;lysstyrke--)( analogWrite(ledPin,lysstyrke); delay(5); ) delay(1000);//vent 1 sek ) )
Det er lite synlig, men tanken er klar.
RGB LED og Arduino
En RGB LED er faktisk tre forskjellige fargede LED-er i en pakke.
Ved å inkludere forskjellige lysdioder med forskjellige lysstyrker, kan du kombinere dem for å lage forskjellige farger. For Arduino, hvor antall lysstyrkenivåer er 256, vil du få 256^3=16581375 mulige farger. I virkeligheten blir det selvfølgelig færre av dem.
LED-en vi skal bruke er den vanlige katoden. De. alle tre lysdiodene er strukturelt forbundet med katoder til en terminal. Vi kobler denne pinnen til GND-pinnen. De resterende pinnene, gjennom begrensende motstander, må kobles til PWM-pinnene. Forfatteren brukte pinnene 9-11 På denne måten vil det være mulig å styre hver LED separat. Den første skissen viser hvordan du slår på hver LED individuelt.
//RGB LED - test //pin tilkoblinger int rød = 9; int grønn = 10; int blå = 11; void oppsett())( pinMode(rød, OUTPUT); pinMode(blå, OUTPUT); pinMode(grønn, OUTPUT); ) void loop())( //slå på/av den røde LED digitalWrite(rød, HIGH); delay(500) digitalWrite(rød, LAV) //slå på/av den grønne LED digitalWrite(grønn, LAV) HØY); digitalWrite(blå, LAV);
Følgende eksempel bruker kommandoene analogWrite() og for å få forskjellige tilfeldige lysstyrkeverdier for LED-ene. Du vil se forskjellige farger endres tilfeldig.
//RGB LED - tilfeldige farger //pin tilkoblinger int rød = 9; int grønn = 10; int blå = 11; void oppsett())( pinMode(rød, OUTPUT); pinMode(blå, OUTPUT); pinMode(grønn, OUTPUT); ) void loop())( //velg en tilfeldig farge analogWrite(rød, tilfeldig(256)); analogWrite(blå, tilfeldig(256));
Tilfeldig(256)-returnerer et tilfeldig tall i området fra 0 til 255.
I den vedlagte filen er en skisse som vil demonstrere jevne fargeoverganger fra rød til grønn, deretter til blå, rød, grønn, etc. (nedlastinger: 348)
Eksempelskissen fungerer, men det er mye duplikatkode. Du kan forenkle koden ved å skrive din egen hjelpefunksjon som jevnt vil skifte fra en farge til en annen.
Slik vil det se ut: (nedlastinger: 385)
La oss se på funksjonsdefinisjonen stykke for stykke. Funksjonen kalles fader og har to argumenter. Hvert argument er atskilt med komma og har en type deklarert på den første linjen i funksjonsdefinisjonen: void fader (int farge1, int farge2). Du ser at begge argumentene er erklært som int, og de får navn farge1 Og farge 2 som betingelsesvariabler for å definere en funksjon. Tomrom betyr at funksjonen ikke returnerer noen verdier, den utfører bare kommandoer. Hvis du måtte skrive en funksjon som returnerte resultatet av multiplikasjon, ville det sett slik ut:
int multiplikator(int tall1, int tall2)( int produkt = tall1*nummer2; returprodukt; )
Legg merke til hvordan vi erklærte Type int som returtype i stedet
tomrom.
Inne i funksjonen er det kommandoer som du allerede har brukt i forrige skisse, kun pin-numrene er erstattet med farge1 Og farge 2. Funksjonen kalles fader, dens argumenter beregnes som farge1 = rød Og farge2 = grønn. Arkivet inneholder en komplett skisse ved hjelp av funksjoner (nedlastinger: 288)
Knapp
Den neste skissen vil bruke en knapp med normalt åpne kontakter, uten låsing.
Dette betyr at mens knappen ikke trykkes inn, flyter det ingen strøm gjennom den, og etter å ha sluppet den går knappen tilbake til sin opprinnelige posisjon.
I tillegg til knappen bruker kretsen en motstand. I dette tilfellet begrenser den ikke strømmen, men "trekker" knappen til 0V (GND). De. Inntil knappen trykkes, vil Arduino-pinnen den er koblet til gå lavt. Motstanden som brukes i kretsen er 10 kOhm.
//bestem når knappen trykkes int buttonPin = 7; void setup())( pinMode(buttonPin, INPUT);//initialiser pinnen til inngangen Serial.begin(9600);//initialiser den serielle porten) void loop())( if (digitalRead(buttonPin)==HIGH )(//hvis knappen trykkes Serial.println("pressed"); // vis inskripsjonen "pressed" ) else ( Serial.println("unpressed");// ellers "unpressed" ) )
Det er flere nye kommandoer i denne skissen.
-Denne kommandoen tar de høye og lave verdiene for utgangen vi tester. Denne utgangen må først konfigureres som en inngang i setup().
; //hvor knappPin er pin-nummeret der knappen er koblet til.
Serieporten lar Arduino sende meldinger til datamaskinen mens kontrolleren selv kjører programmet. Dette er nyttig for å feilsøke et program, sende meldinger til andre enheter eller applikasjoner. For å aktivere dataoverføring via en seriell port (også kalt UART eller USART), må du initialisere den i setup()
Serial.begin() har bare ett argument - dette er dataoverføringshastigheten mellom Arduino og datamaskinen.
Skissen bruker en kommando for å vise en melding på skjermen i Arduino IDE (Verktøy >> Serial Monitor).
- Designet lar deg kontrollere fremdriften av programkjøringen ved å kombinere flere kontroller på ett sted.
Hvis digitalRead returnerer HIGH, vises ordet "trykket" på skjermen. Ellers (ellers) vises ordet "frigitt" på skjermen. Nå kan du prøve å slå lysdioden av og på ved å trykke på en knapp.
//knapptrykkdeteksjon med LED-utgang int-knappPin = 7; int ledPin = 8; void setup())( pinMode(buttonPin, INPUT);//denne gangen vil vi sette knappen pin som INPUT pinMode(ledPin, OUTPUT); Serial.begin(9600); ) void loop())( if (digitalRead(buttonPin) )= =HIGH)( digitalWrite(ledPin,HIGH); Serial.println("presset"); ) else ( digitalWrite(ledPin,LOW); Serial.println("unpressed"); ) )
Analog inngang.
analogLes lar deg lese data fra en av Arduino analoge pinner og viser en verdi i området fra 0 (0V) til 1023 (5V). Hvis spenningen på den analoge inngangen er 2,5V, vil 2,5 / 5 * 1023 = 512 bli skrevet ut
analogLes har bare ett argument - Dette er det analoge inngangsnummeret (A0-A5). Følgende skisse viser koden for å lese spenningen fra potensiometeret. For å gjøre dette, koble en variabel motstand, de ytre terminalene til 5V- og GND-pinnene, og den midtre terminalen til A0-inngangen.
Kjør følgende kode og se i seriemonitoren hvordan verdiene endres avhengig av rotasjonen av motstandsknappen.
//analog inngang int potPin = A0;//den sentrale pinne til potensiometeret er koblet til denne pin void oppsettet())( //analog pin er inkludert som en inngang som standard, så initialisering er ikke nødvendig Serial.begin(9600 ); ) void loop())( int potVal = analogRead(potPin);//potVal er et tall mellom 0 og 1023 Serial.println(potVal)
Følgende skisse kombinerer knappeklikkskissen og LED-lysstyrkekontrollskissen. LED-en vil tennes fra knappen, og lysstyrken vil bli kontrollert av et potensiometer.
//knapptrykkdeteksjon med LED-utgang og variabel intensitet int-knappPin = 7; int ledPin = 9; int potPin = A0; void setup())( pinMode(buttonPin, INPUT); pinMode(ledPin, OUTPUT); Serial.begin(9600); ) void loop())( if (digitalRead(buttonPin)==HIGH)(//hvis knappen trykkes inn int analogVal = analogRead(potPin); int scaledVal = map(analogVal, 0, 1023, 0, 255); ( digitalWrite(ledPin, LOW);//slå av hvis knappen ikke er trykket Serial.println("unpressed"); ) )
Levering av nye hjemmelagde produkter til postkontoret
Motta et utvalg av nye hjemmelagde produkter på e-post. Ingen spam, bare nyttige ideer!