» elektronikk » Arduino »Arduino for nybegynnere

Arduino for nybegynnere


Arduino er et mikrokontrollerkort som du kan programmere for å kontrollere eksterne enheter. Det samhandler med omverdenen gjennom sensorer, motorer, LED, høyttalere ... og til og med Internett, noe som gjør det til en fleksibel plattform for forskjellige prosjekter. Det er ganske mange mikrokontrollere, men Arduino er populær på grunn av at forskjellige prosjekter er veldig aktivt lagt ut og diskutert på Internett. Hvis du søker på google eller youtube, vil du finne millioner av ideer og informasjon for å begynne å utforske Arduino selv.
Selv om du ikke har erfaring med å programmere mikrokontrollere - med Arduino vil du raskt lære og lære noe om elektronikk ved hjelp av eksperimenter.

Hva trenger du for å komme i gang?
Arduino Uno- 1 stk
USB-kabel-1stk
Hoppere 1 stk
1stk utviklingsbrett
Rød LED 4 stk
220 ohm motstand 4stk
Motstand 10 rom 1 stk
Knapp uten å fikse
potensiometer
RGB LED med felles katode

Alt dette kan kjøpes i en lokal radiobutikk eller bestilles på Internett.

En online simulator ble brukt til å demonstrere og simulere elektriske kretser.

Denne simulatoren fungerer best i Chrome-nettleseren.
La oss se nærmere på Arduino.

Arduino er ikke en stor datamaskin som eksterne kretser kan koble seg til. 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 hjelp av Arduino IDE. USB-porten gir også strøm til arduino.

Det er en egen strømkontakt. Det er to utganger på brettet, merket 5v og 3.3v, som er nødvendige for å drive forskjellige enheter. Du finner også pinner merket som GND, dette er jordledninger (bakken er 0V). Arduino-plattformen har også 14 digitale utganger (pinner), merket med tall fra 0 til 13, som er koblet til eksterne noder og har to tilstander, høye eller lave (av eller på). 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. Følgende konklusjoner i styret er betegnet A0-A5. Dette er analoge innganger som kan motta data fra forskjellige sensorer. Dette er spesielt praktisk når du måler et område, for eksempel temperatur. De analoge inngangene har tilleggsfunksjoner som kan aktiveres separat.


Slik bruker du en brødbrett.

En brødplate er nødvendig for å midlertidig koble til delene, for å sjekke hvordan enheten fungerer, før du lodder alt sammen.
Alle følgende eksempler er samlet på en brødplate slik at du raskt kan gjøre endringer i kretsen og gjenbruke deler uten å bry deg med lodding.

Brødbrettet har rader med hull der du kan sette inn deler og ledninger. Noen av disse hullene er elektrisk koblet til hverandre.

De to øvre og nedre radene er koblet i serie langs hele brettet. Disse radene brukes til å drive kretsen. Det kan være 5v eller 3.3v, men i alle fall er det første du trenger å gjøre å koble 5v og GND til brødbordet, som vist på figuren. Noen ganger kan disse radtilkoblingene avbrytes på midten av brettet, og hvis du trenger det, kan du koble dem, som vist på figuren.




De resterende hullene som ligger på midten av brettet er gruppert i fem hull. De brukes til å koble til kretsdeler.

Det første vi kobler til mikrokontrolleren vår er LED. Det elektriske tilkoblingsskjemaet er vist på bildet.


Hvorfor trenger jeg en motstand i kretsen? I dette tilfellet begrenser det strømmen som går gjennom lysdioden. Hver LED er designet for en spesifikk strøm, og hvis denne strømmen er større, vil lysdioden feile. Finn ut hvilken verdi motstanden skal ha ved å bruke Ohm-loven. For de som ikke vet eller har glemt, sier Ohms lov at det er en lineær avhengighet av strøm på spenning. Det vil si at jo mer vi bruker spenning 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 er å finne.
Først må vi finne ut spenningen over motstanden. De fleste av 3 mm eller 5 mm LED som du vil bruke har en 3V driftsspenning. Så på motstanden må vi betale 5-3 = 2v.

Deretter beregner vi strømmen som går gjennom motstanden.
De fleste 3 og 5 mm lysdioder lyser med full lysstyrke med en strøm på 20mA. En strøm som er mer enn dette kan deaktivere dem, og en strøm med mindre styrke vil redusere lysstyrken uten å forårsake skade.

Så vi ønsker å slå på LED-en i 5v-kretsen slik at den har en strøm på 20mA. Siden alle delene er inkludert i en krets, vil motstanden også ha en strøm på 20 mA.
Vi får
2V = 20 mA * R
2V = 0,02A * R
R = 100 ohm

100 Ohms er minste motstand, det er bedre å bruke litt mer, fordi lysdiodene har en viss variasjon i egenskaper.
I dette eksemplet brukes en 220 ohm-motstand. Bare fordi forfatteren har mange av dem: blink:.

Sett LED i hullene på midten av brettet slik at den lange terminalen er koblet til en av polene på motstanden. Koble den andre enden av motstanden til 5V, og koble den andre utgangen av LED-en til GND. Lysdioden skal lyse opp.

Vær oppmerksom på at det er en forskjell i hvordan du kobler til LED-en. Strøm flyter fra en lengre terminal til en kortere. I diagrammet kan man forestille seg at strømmen flyter i retningen der trekanten er rettet. Prøv å snu LED-en, så ser du at den ikke vil lyse.

Men hvordan du kobler motstanden, det er ingen forskjell i det hele tatt. Du kan snu den eller prøve å koble den til den andre utgangen på lysdioden, dette vil ikke påvirke driften av kretsen. Det vil fortsatt begrense strømmen gjennom LED.

Anatomy of an Arduino Sketch.

Programmer for Arduino kalles skisse. De består av to hovedfunksjoner. funksjon oppsett og funksjon sløyfe
i denne funksjonen vil du angi alle grunnleggende innstillinger. Hvilke konklusjoner vil fungere med input eller output, hvilke biblioteker som skal kobles til, initialiseres variabler. funksjon Oppsett () Det starter bare en gang under skissen, når programmet starter.
dette er hovedfunksjonen som utføres etter oppsett (). Faktisk er dette selve programmet. Denne funksjonen kjører på ubestemt tid til du slår av strømmen.

Arduino blinkende LED




I dette eksemplet vil vi koble en krets med en LED til en av Arduino digitale pinner og slå den av og på ved hjelp av programmet, så lærer du også flere nyttige funksjoner.



- denne funksjonen brukes i oppsett () deler av programmet og tjener til å initialisere konklusjonene som du vil bruke som innspill (INPUT) eller avslutte (OUTPUT). Du kan ikke lese eller skrive data fra pinnen før du angir den tilsvarende pinMode. Denne funksjonen har to argumenter: pinNumber- Dette er pinnetallet du vil bruke.

Mode- angir hvordan tappen skal fungere. Ved inngangen (INPUT) eller avslutte (OUTPUT). For å tenne på LED må vi gi et signal FRA Arduino. For å gjøre dette konfigurerer vi pinnen slik at den går ut.
- denne funksjonen tjener til å stille inn tilstanden (State) tapp (PinNumber). Det er to hovedtilstander (generelt er det 3), det ene er HIGH, pinnen vil være 5v, en annen er lav og tappen vil være 0v. Så for å lyse opp LED må vi stille et høyt nivå på pinnen som er koblet til LED HIGH.

- forsinkelse. Tjener å utsette programmet i en spesifisert periode i ms.
Nedenfor er koden som får LED til å blinke.
// LED Blink

int ledPin = 7; // Arduino pin som LED er koblet til

ugyldig oppsett () {
  pinMode (ledPin, OUTPUT); // angi pinnen som EXIT
}

void loop () {
  digitalWrite (ledPin, HIGH); // lyser LED
  forsinkelse (1000); // forsinkelse 1000 ms (1 sek)
  digitalWrite (ledPin, LOW); // Slå av LED-en
  forsinkelse (1000); // vent 1 sek
}


En liten forklaring på koden.
Linjer som begynner med "//" er kommentarer fra Arduino som ignorerer dem.
Alle kommandoer slutter med en semikolon; hvis du glemmer dem, vil du motta en feilmelding.

ledPiner en variabel. Variabler brukes i programmer for å lagre verdier. I dette eksemplet er variabelen ledPin tildelt en verdi av 7, dette er pin-nummeret til Arduino. Når Arduino i programmet møter en streng med en variabel ledPin , vil den bruke verdien som vi spesifiserte tidligere.
Så ta opp pinMode (ledPin, OUTPUT) lik rekord pinMode (7, OUTPUT).
Men i det første tilfellet er det nok for deg å endre variabelen, og den vil endres i hver linje der den brukes, og i det andre tilfellet, for å endre variabelen, må du gjøre endringer i håndtakene i hver kommando.

på den første linjen indikerer variabeltypen. Når du programmerer Arduino, er det viktig å alltid oppgi typen variabler. Foreløpig er det nok for deg å vite det INT kunngjør negative og positive tall.
Nedenfor presenteres modellering skisse. Trykk på start for å se driften av kretsen.



Som forventet slås LED av og lyser etter ett sekund. Prøv å endre forsinkelsen for å se hvordan det fungerer.

Styring av flere lysdioder.

I dette eksemplet lærer du hvordan du kontrollerer flere LED-er. For å gjøre dette må du installere ytterligere 3 LED på brettet og koble dem til Arduino-motstandene og pinnene, som vist nedenfor.



For å slå av og på LED-ene i sving, må du skrive et program som dette:
// Multi LED blink

int led1Pin = 4;
int led2Pin = 5;
int led3Pin = 6;
int led4Pin = 7;

ugyldig oppsett () {
  // sett pinner som EXIT
  pinMode (led1Pin, OUTPUT);
  pinMode (led2Pin, OUTPUT);
  pinMode (led3Pin, OUTPUT);
  pinMode (led4Pin, OUTPUT);
}

void loop () {
  digitalWrite (led1Pin, HIGH); // tenner LED-en
  forsinkelse (1000); // forsinkelse 1 sek
  digitalWrite (led1Pin, LOW); // sett ut LED
  forsinkelse (1000); // forsinkelse 1 sek

  // gjør det samme for de andre 3 LED-ene
  digitalWrite (led2Pin, HIGH); // lyser LED
  forsinkelse (1000); // forsinkelse 1 sek
  digitalWrite (led2Pin, LOW); // sett ut LED
  forsinkelse (1000); // forsinkelse 1 sek

  digitalWrite (led3Pin, HIGH); // lyser LED
  forsinkelse (1000); // forsinkelse 1 sek
  digitalWrite (led3Pin, LOW); // sett ut LED
  forsinkelse (1000); // forsinkelse 1 sek

  digitalWrite (led4Pin, HIGH); // tenner LED-en
  forsinkelse (1000); // forsinkelse 1 sek
  digitalWrite (led4Pin, LOW); // sett ut LED
  forsinkelse (1000); // forsinkelse 1 sek
}


Dette programmet vil fungere fint, men dette er ikke den mest rasjonelle løsningen. Koden må endres. For at programmet skal fungere om og om igjen, vil vi bruke konstruksjonen som heter.
Syklus er praktisk når du trenger å gjenta den samme handlingen flere ganger. I koden over gjentar vi linjene

digitalWrite (led4Pin, HIGH);
forsinkelse (1000);
digitalWrite (led4Pin, LOW);
forsinkelse (1000); 

full skissekode i vedlegget for.zip [720 b] (nedlastinger: 1410)

LED lysstyrkejustering

Noen ganger må du endre lysstyrken på lysdiodene i programmet. Dette kan gjøres ved hjelp av kommandoen analogWrite (). Denne kommandoen slår LED og av så raskt at øyet ikke ser denne flimmeren. Hvis lysdioden slås på halvparten av tiden og halvparten av, vil det visuelt se ut som om den lyser på halvparten av lysstyrken. Dette kalles pulsbreddemodulasjon (PWM eller PWM på engelsk). Shim brukes ganske ofte, siden den kan brukes til å kontrollere den "analoge" komponenten ved hjelp av en digital kode. Ikke alle Arduino-pinner er egnet for disse formålene. Bare de konklusjoner som en slik betegnelse trekkes rundt "~".Du vil se den ved siden av pinner 3,5,6,9,10,11.
Koble en av LED-ene til en av PWM-utgangene (for forfatteren er dette pin 9). Kjør nå skissen blinkende LED, men bytt først kommandoen digitalWrite ()analogWrite (). analogWrite () Det har to argumenter: det første er pinnetallet, og det andre er PWM-verdien (0-255), som brukt på lysdioder, vil dette være lysstyrken, og for elektriske motorer, rotasjonshastigheten. Nedenfor er en eksempelkode for forskjellig LED-lysstyrke.
// Endre lysstyrken på LED

int ledPin = 9; // LED koblet til denne pinnen
ugyldig oppsett () {
  pinMode (ledPin, OUTPUT); // initialiser pinnen til utdata
}

void loop () {
  analogWrite (ledPin, 255); // full lysstyrke (255/255 = 1)
  forsinkelse (1000); // pause 1 sek
  digitalWrite (ledPin, LOW); // slå av LED-en
  forsinkelse (1000); // pause 1 sek

  analogWrite (ledPin, 191); // lysstyrke ved 3/4 (191/255 ~ = 0,75)
  forsinkelse (1000); // pause 1 sek
  digitalWrite (ledPin, LOW); // slå av LED-en
  forsinkelse (1000); // pause 1 sek

  analogWrite (ledPin, 127); // halv lysstyrke (127/255 ~ = 0,5)
  forsinkelse (1000); // pause 1 sek
  digitalWrite (ledPin, LOW); // slå av LED-en
  forsinkelse (1000); // pause 1 sek

  analogWrite (ledPin, 63); // kvart lysstyrke (63/255 ~ = 0,25)
  forsinkelse (1000); // pause 1 sek
  digitalWrite (ledPin, LOW); // slå av LED-en
  forsinkelse (1000); // pause 1 sek
}


Prøv å endre PWM-verdien i kommandoen analogWrite ()for å se hvordan det påvirker lysstyrken.
Deretter lærer du hvordan du justerer lysstyrken jevnt fra full til null. Du kan selvfølgelig kopiere et stykke kode 255 ganger
analogWrite (ledPin, lysstyrke);
forsinkelse (5); // kort forsinkelse
lysstyrke = lysstyrke + 1;

Men du forstår - det vil ikke være praktisk. For dette er det best å bruke FOR-loopen som ble brukt før.
Følgende eksempel bruker to sykluser, en for å redusere lysstyrken fra 255 til 0
for (int lysstyrke = 0; lysstyrke = 0; lysstyrke -) {

analogWrite (ledPin, lysstyrke);
forsinkelse (5);

}

forsinkelse (5) brukes til å bremse hastigheten på stigning og fall av lysstyrke 5 * 256 = 1280 ms = 1,28 sek.)
Den første linjen bruker "Skarphet-"slik at lysstyrkeverdien synker med 1, hver gang syklusen gjentas. Vær oppmerksom på at syklusen vil fungere så lenge lysstyrke> = 0Bytte ut skiltet > på skiltet >= vi inkluderte 0 i lysstyrkeområdet. Denne skissen er modellert nedenfor.
// jevn lysstyrke

int ledPin = 9; // LED er koblet til denne pinnen

ugyldig oppsett () {
  pinMode (ledPin, OUTPUT); // initialiser pinnen for å gå ut
}

void loop () {
  // øke lysstyrken gradvis (0 til 255)
  for (int lysstyrke = 0; lysstyrke = 0; lysstyrke -) {
    analogWrite (ledPin, lysstyrke);
    forsinkelse (5);
  }

  forsinkelse (1000); // vent 1 sek
 // reduser lysstyrken jevnt (255 til 0)
  for (int lysstyrke = 255; lysstyrke> = 0; lysstyrke -) {
    analogWrite (ledPin, lysstyrke);
    forsinkelse (5);
  }

  forsinkelse (1000); // vent 1 sek
}
}

Dette er lite synlig, men ideen er klar.



RGB LED og Arduino

RGB LED er faktisk tre lysdioder i forskjellige farger i ett hus.



Inkludert forskjellige lysdioder med forskjellig lysstyrke, kan du kombinere og få forskjellige farger. For Arduino, der antall graderinger av lysstyrke er 256, får du 256 ^ 3 = 16581375 mulige farger. I virkeligheten vil det selvfølgelig være mindre av dem.
LED-en som vi skal bruke er den vanlige katoden. dvs. alle tre lysdioder er strukturelt koblet av katoder til en terminal. Vi vil koble denne pinnen til GND-pinnen. De resterende terminalene, gjennom begrensningsmotstandene, må kobles til PWM-terminalene. Forfatteren brukte konklusjoner 9-11. Dermed vil det være mulig å kontrollere hver LED separat. Den første skissen viser hvordan du slår på hver LED separat.



// RGB LED - test

// pin-tilkoblinger
int rød = 9;
int grønn = 10;
int blå = 11;

ugyldig oppsett () {
  pinMode (rød, UTGANG);
  pinMode (blå, UTGANG);
  pinMode (grønn, UTGANG);
}

void loop () {
  // slå av / på den røde lysdioden
  digitalWrite (rød, HØY);
  forsinkelse (500);
  digitalWrite (rød, LAV);
  forsinkelse (500);
  
  // slå av / på den grønne lysdioden
  digitalWrite (grønn, HØY);
  forsinkelse (500);
  digitalWrite (grønn, LAV);
  forsinkelse (500);

  // slå av / på den blå lysdioden
  digitalWrite (blå, HØY);
  forsinkelse (500);
  digitalWrite (blå, LAV);
  forsinkelse (500);
}


Følgende eksempel bruker kommandoene analogWrite () og for å få forskjellige tilfeldige lysstyrkeverdier for lysdioder. Du vil se forskjellige farger endres tilfeldig.
// RGB LED - tilfeldige farger

// pin-tilkoblinger
int rød = 9;
int grønn = 10;
int blå = 11;
ugyldig oppsett () {
  pinMode (rød, UTGANG);
  pinMode (blå, UTGANG);
  pinMode (grønn, UTGANG);
}
void loop () {
  // velg en tilfeldig farge
  analogWrite (rød, tilfeldig (256));
  analogWrite (blå, tilfeldig (256));
  analogWrite (grønn, tilfeldig (256));
  forsinkelse (1000); // vent ett sekund
}


Tilfeldig (256)-Vendrer et tilfeldig tall i området fra 0 til 255.
I den vedlagte filen er det en skisse som viser jevne overganger av farger fra rødt til grønt, deretter til blått, rødt, grønt, etc. perehody.zip [373 b] (nedlastinger: 386)
Et eksempel skisse fungerer, men det er mye duplikatkode. Du kan forenkle koden ved å skrive din egen hjelperfunksjon, som enkelt vil endre en farge til en annen.
Slik ser det ut: funktsiya.zip [263 b] (nedlastinger: 420)
La oss se på definisjonen av en funksjon i deler. Funksjon kalt fader og har to argumenter. Hvert argument er atskilt med komma og har en type deklarert i den første linjen i funksjonsdefinisjonen: void fader (int color1, int color2). Du ser at begge argumentene er erklært som int, og de får navn farger1 og COLOR2 som betingede variabler for å definere en funksjon. Void betyr at funksjonen ikke returnerer noen verdier, den kjører bare kommandoer. Hvis det var nødvendig å skrive en funksjon som returnerte resultatet av multiplikasjonen, ville det sett slik ut:
int multiplikator (int nummer1, int nummer2) {

int produkt = nummer1 * antall2;
retur produkt;

} 

Legg merke til hvordan vi erklærte Type int som returtype i stedet
ugyldig.
Inne i funksjonen er det kommandoer som du allerede brukte i forrige skisse, bare pin-numrene ble erstattet av farger1 og COLOR2. Funksjon kalt fader, er dens argumenter beregnet som farge1 = rød og farge2 = grønn. Arkivets fullskisse ved bruk av funksjoner funktsii.zip [392 b] (nedlastinger: 320)

knapp

I neste skisse vil en knapp med normalt åpne kontakter bli brukt, uten å fikse.

Arduino for nybegynnere

Dette betyr at mens knappen ikke er trykket, strømmer ikke strømmen gjennom den, og etter å ha sluppet, går knappen tilbake til sin opprinnelige posisjon.
I kretsen, i tillegg til knappen, brukes en motstand. I dette tilfellet begrenser det ikke strømmen, men "drar" knappen til 0v (GND). dvs. til knappen er trykket på pinnen på Arduino som den er koblet til, vil nivået være lavt. Motstanden som brukes i 10 kΩ kretsen.

// definere knappeklikk
int-knappPin = 7;
ugyldig oppsett () {
  pinMode (buttonPin, INPUT); // initialisere inngangsnålen
  Serial.begin (9600); // initialisere serieporten
}
void loop () {
  if (digitalRead (buttonPin) == HIGH) {// hvis du trykker på knappen
    Serial.println ("presset"); // skriv ut "presset"
  } annet {
    Serial.println ("unpressed"); // ellers "unpressed"
  }
}

Det er flere nye lag i denne skissen.
-Denne kommandoen tar verdien Høyt (høyt nivå) og lavt (lavt nivå) på utdataene som vi sjekker. Tidligere, i oppsett (), må denne utgangen konfigureres for input.
; // hvor buttonPin er pinnetallet der knappen er koblet til.
Seriell port lar deg sende Arduino-meldinger til datamaskinen, mens kontrolleren selv kjører programmet. Dette er nyttig for feilsøking av et program, sending av meldinger til andre enheter eller applikasjoner. For å aktivere dataoverføring via serieporten (også kjent som UART eller USART), må du initialisere den under oppsett ()

Serial.begin () har bare ett argument er dataoverføringshastigheten mellom Arduino og datamaskinen.
skisse, en kommando brukes til å vise en melding på skjermen i Arduino IDE (Tools >> Serial Monitor).
- designen lar deg kontrollere fremdriften til programmet ved å kombinere flere kontroller på ett sted.
Hvis (hvis) digitalRead returnerer HØY, vises ordet "presset" på skjermen. Ellers (ellers) vises ordet "klemt" på skjermen. Nå kan du prøve å slå LED av og på ved å trykke på en knapp.
// knappetrykkdeteksjon med LED-utgang
int-knappPin = 7;
int ledPin = 8;
ugyldig oppsett () {
  pinMode (buttonPin, INPUT); // denne gangen vil vi sette knappestiften som INPUT
  pinMode (ledPin, OUTPUT);
  Serial.begin (9600);
}
void loop () {
  if (digitalRead (buttonPin) == HØY) {
    digitalWrite (ledPin, HIGH);
    Serial.println ("presset");
  } annet {
    digitalWrite (ledPin, LOW);
    Serial.println ("unpressed");
  }
}


Analog inngang.

analogRead 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 skrives ut
analogRead har bare ett argument - Dette er det analoge inngangsnummeret (A0-A5). Følgende skisse gir en kode for lesespenning fra et potensiometer. For å gjøre dette, koble en variabel motstand, de ekstreme pinnene til pinnene 5V og GND, og ​​den midterste pinnen til inngang A0.


Kjør følgende kode og se på seriemonitoren hvordan verdiene endres avhengig av rotasjonen av motstandsknappen.
// analog inngang

int potPin = A0; // potensiometerets sentrale utgang er koblet til denne pinnen

ugyldig oppsett () {
  // den analoge stiften er aktivert som standard, slik at initialisering ikke er nødvendig
  Serial.begin (9600);
}

void loop () {
  int potVal = analogRead (potPin); // potVal er et tall mellom 0 og 1023
  Serial.println (potVal);
}

Den neste skissen kombinerer en knapp-klikk-skisse og en LED-lysstyrke-kontrollskisse. Lysdioden slås på fra knappen, og potensiometeret vil kontrollere glødens lysstyrke.
// knappen trykkdeteksjon med LED-utgang og variabel intensitet
int-knappPin = 7;
int ledPin = 9;
int potPin = A0;
ugyldig oppsett () {
  pinMode (buttonPin, INPUT);
  pinMode (ledPin, OUTPUT);
  Serial.begin (9600);
}
void loop () {
  if (digitalRead (buttonPin) == HIGH) {// hvis knappen er trykket
    int analogVal = analogRead (potPin);
    int skalertVal = kart (analogVal, 0, 1023, 0, 255);
    analogWrite (ledPin, scaledVal); // slå på ledning med intensitet satt av potten
    Serial.println ("presset");
  } annet {
    digitalWrite (ledPin, LOW); // slå av hvis ikke knappen er trykket
    Serial.println ("unpressed");
  }
}
8.7
9
9

Legg til en kommentar

    • smilersmilerxaxaokdontknowyahoonea
      sjefscratchlurejaja-jaaggressivhemmelighet
      beklagerdansedance2dance3benådninghjelpdrikkevarer
      stoppvennergodgoodgoodfløytebesvimelsetunge
      røykklappingCrayerklærehånligdon-t_mentionnedlasting
      heteirefullaugh1MDAmøtemoskingnegative
      not_ipopcornstraffeleseskremmeskremmersøk
      spydighetthank_youdetteto_clueumnikakuttenig
      dårligbeeeblack_eyeblum3rødmeskrytekjedsomhet
      sensurertpleasantrysecret2trueseieryusun_bespectacled
      ShokRespektlolPrevedvelkommenKrutoyya_za
      ya_dobryihelperne_huliganne_othodiFLUDforbudnær
4 kommentarer
Slik fungerer det som det skal - // øker lysstyrken gradvis (0 til 255)
for (int lysstyrke = 0; lysstyrke <= 255; lysstyrke ++) {
analogWrite (ledPin, lysstyrke);
forsinkelse (5);
ved samlingen gir en feil Arduino: 1.6.5 (Windows 7), brettet "Arduino Nano, ATmega328"

sketch_sep20a: 25: feil: forventet erklæring før '}' -token
forventet erklæring før '}' -token
Jeg kopierte skissen av glatt tenning.
LED-en min lyser skarpt, men den går greit ut.

Forklar vær så snill.
Jeg kopierte skissen av glatt tenning.
LED-en min lyser skarpt, men den går greit ut.

Forklar vær så snill.

Vi anbefaler deg å lese:

Gi den til smarttelefonen ...