En nybörjares guide till Arduino (9 / 15 steg)

Steg 9: Indata från en knapp

Naturligtvis kan du använda I/O stift för Arduino som insatsvaror samt. I det här steget använder vi bara tryckknappar som inmatningsenheter, men naturligtvis kan du använda vilken växel.

Pull-up och pull-down

Arduinoen fungerar med logiska ingångar: 1 = 5v, 0 = 0v. För att göra vår knappen mata dessa spänningar, använder vi en pull-up eller en pull-down motstånd. (bild 1 & 2)
När det gäller en pull-down resistor (bild 1), vi ansluter ett ben av växeln till 5v, och det andra benet genom en resistor (10kΩ i det här fallet) till marken (0v). Benet med resistorn ansluten går till ingångsstiftet på Arduino.

Hitåt, när knappen inte är intryckt (och inte går att ansluta till 2 ben), input är 0v, eftersom den är ansluten till marken genom resistorn. När du trycker på knappen, är indata på 5v, eftersom den är direkt ansluten till 5v via växeln. Resistorn spelar ingen roll när du trycker på knappen, gör det bara till att indata på 0v när knappen inte är intryckt.

En pull-up resistor (bild 2) fungerar på exakt samma sätt, men allt är bytt: den första etappen är ansluten till marken, i stället för 5v, andra är ansluten till 5v, genom en resistor (därav namnet pull-up resistor, eftersom det drar det upp till 5v). Ingångsstiftet fortfarande ansluter till sidan med motståndet, men nu är det hög när knappen inte är intryckt, och går låg när växeln är stängd.

Nu, ansluta en knapp med en pull-down resister till stift 3 av Arduino och en tryckknapp med en pull-up resistor till stift 5. Sedan ansluta två lysdioder (med deras lämpligt motstånd) till stift 10 och 12. (bild 3 & 4)

Öppna exempel button2 och öppna den. Detta program bara läser de två ingångarna och anger utgångarna i samma stat.

Det finns bara två nya saker, och de är verkligen uppenbara: i stället för produktionen konstant, vi använder INPUT att ställa in stiften av våra knappar som insatsvaror, och funktionen digitalRead(pin) returnerar bara tillståndet för det givna ingångsstiftet.

Obs: med pinMode (pin, mata) är egentligen onödigt, eftersom alla stift på Arduino ingångar som standard, men det görs ofta på något sätt, för att göra koden mer läsbar.

När du överför skissen, tryck på knapparna och ser du att tabellen ovan är faktiskt korrekt: LED på stift 12 är alltid på, tills du trycker på knappen på stift 5, detta är eftersom det har en pull-up resistor.

Vill du ljusdioderna till tänds endast när du trycker på knappen, du kan använda boolska inte-operatören: detta ändrar bara en 'sann' till 'false' (eller en 1 till en 0) och vice versa. Den här operatorn är C++ (i Arduino IDE), ett utropstecken (!)

digitalWrite (12,! digitalRead(5));

Inre pull-up motstånd

Det vore verkligen obekvämt om vi var tvungna att använda ett extra motstånd och en extra bit av tråd, varje gång vi vill använda en normal-omkopplaren. Det är därför chip på Arduino har en inbyggd pull-up resistor på varje stift.

Det finns två sätt att aktivera dem:

pinMode(pin,INPUT);
digitalWrite (pin, hög);

pinMode(pin,INPUT_PULLUP);

Båda har samma effekt, men den senare är Rekommenderad, eftersom det är lättare att läsa.

Obs: om du har glömt att använda pinMode (pin, produktion), och du använder digitalWrite (pin, hög) efteråt, du ska bara aktivera pull-up resistor, eftersom alla stift är inställda som insatsvaror som standard.

Nu ansluta tryckknapparna utan motstånd, bara anslutningen till marken (som visas i bild 5)
Du kan se att vi inte behöver använda den 5v pin av Arduino längre, och om vi skulle producera detta i stor skala, de två motstånd vi frälsta skulle göra en betydande skillnad i kostnad.

Öppna exempel button2-b. Som ni ser, använde jag de två sätt att aktivera pull-up motstånd. Observera också att jag använt operatorn "inte", så lamporna är på när knappen trycks.

Sammanfattning

• För att använda knappar och switchar med din Arduino, måste du använda en pull-up eller pull-down motstånd.
• pinMode (stift, INPUT_PULLUP); kan de interna pull-up motstånd av Arduino.
  digitalWrite (pin, hög); på en ingångsstift har samma resultat.
• digitalRead(pin) returnerar delstaten ingångsstift 1 = 5v, 0 = 0v.
  Om du använder en knapp med en pull-up resistor (t.ex. den inre en), betyder 1 att knappen inte är intryckt, 0 betyder det trycks.
• Använd inte-operatören (!) att byta 1 och 0. T.ex. ! digitalRead(pin) returnerar 0 när knappen inte är intryckt och 1 när knappen trycks.

Extra: Direkt port manipulation (avancerat)

DigitalRead, digitalWrite och pinMode är bra och enkla funktioner, men de är relativt långsam. Också, du kan inte slå på 2 stift på eller av vid exakt samma tidpunkt och skriva 8 bitar samtidigt för parallell kommunikation går inte heller. Ibland, när du kör kort minne, kan dessa 3 funktioner använda mycket av det tillgängliga utrymmet, också.

Lösningen på dessa problem är direkt port manipulation. Atmel chip har några (3 på de flesta Arduinos) registrerar för I/O pins, detta är bara byte som lagrar information om en PIN-kod är en ingång eller en utgång, oavsett om det är hög eller låg, etc. Varje bit av dessa byte motsvarar en i/o pin på Arduino.

På Arduino Uno innehåller port D stift 0 till 7, port B stift 8 till 13 och port C A0 till A5.

Det finns 3 register att styra I/O (där x är bokstaven port):

• DDRx: Data riktning registrera: det här anger om stiften i hamnen är inputs(1) eller utgångar (0). (pinMode)
• PORTx: Port Data registrera: detta är för att ställa utgångarna höga eller låga, och aktivera eller inaktivera input pull-up motstånd. (digitalWrite)
• PINx: Port Input registrera: detta byte innehåller tillståndet för de digitala ingångarna. Om PIN-koden är en utgång, ger det bara dig utdata staten.

I bilden ovan, kan du se hela pin kartläggning av Arduino Uno, portnumren i de gula fälten bredvid stiften. (bild credit)

Eftersom varje bit av byten som företräder en PIN-kod, är det lättare att skriva värdena i binära notation. Du kan göra detta genom att lägga till ett versalt B före numret, till exempel B111 är 7 i decimal (2² + 2¹ + 2⁰).

Likaså, en ledande 0 kan du använda oktal notation, eller 0 x för hexadecimal form, men i detta fall med dessa två beteckningar riktigt vettigt inte.

När räknar bits, längst till höger (minst signifikanta, LSB) bit är lite 0, så att det motsvarar den första pin av hamnen, medan MSB (mest signifikanta biten) motsvarar den åttonde pin av hamnen.

Några exempel:

Ställa in stift 7 till en utgång och stift 0-6 som indata:

DDRD = B10000000;

Inställningen (output) stift 7 hög:

PORTD = B10000000;

Aktivera den inre pull-up resistorn på (input) stift 6:

PORTD = B01000000;

Läsa delstaten stift 0 till 7:

byte state = PIND;

Däremot använder den som detta kan orsaka vissa problem: e.g. i det andra exemplet, stift 7 ligger högt, men alla andra stift i porten är satt till noll, oavsett deras tidigare tillstånd. För att ändra endast en pin i taget, kan vi använda några bitvis operatörer.

Om du vill ange en lite hög, utan att ändra de andra bitarna, kan vi använda bitvis eller-operator ( | ). Obs: detta är bara en |, boolean eller-operatorn är ||. Bitvis innebär att det tillämpas på varje bit separat. Vi använder en mask för att ange rätt bit hög: den biten vill vi högt är 1, och alla andra bitar är 0.

byte previousPORTD = PORTD; Läs data registret och förvara den i en variabel
PORTD = previousPORTD | B10000000; Set lite sju high

Om lite i masken är en, denna bit sätts till 1 i registret över PORTD, om det är noll, det kommer bara hålla värdet i previousPORTD. Du kan kolla in sanning bordlägger och några exempel i bilderna ovan.

Om du vill ange en bit låg, utan att ändra de andra bitarna, kan vi använda bitvis och-operatorn ( & ). Obs: detta är bara en &, booleska och-operatorn är & &. Nu har vi att Invertera vår mask: den biten vill vi låga är noll, och alla andra bitar en.

byte previousPORTD = PORTD; Läs data registret och förvara den i en variabel
PORTD = previousPORTD & B01111111; Set lite sju låg

Denna notation fungerar alldeles utmärkt, men vi kan göra det lite mer lättläst. Istället för att skriva ett helt binärt tal för vår mask, kan vi använda operatorn vänster bitshift (<<). det skiftar bara alla siffror till vänster för ett visst antal platser. Till exempel: 1 << 2 = B100, B101 << 1 = B1010 och så vidare. Detta är också ett enkelt sätt att beräkna två: 1 << 7 = B10000000 = 128 = 2⁷

Men vi kommer att skapa vår mask: till exempel masken B10000000 kan skrivas som 1 << 7, nu kan du lätt se att det är det åttonde stiftet i registret, utan att behöva räkna nollorna.

Att skapa inverterad mask, för den och notation, bitvis inte-operatör ( ~ ) kan användas för att Invertera varje bit: B01111111 kan skrivas som ~ (1 << 7). (se bild)

Om du vill bara vända en eller flera bitar, kan du använda exklusiv eller-operator. (xor, ^ ). Detta returnerar 1 om en av de ingående bitarna är en, och 0 om båda ingångarna är desamma.

byte previousPORTD = PORTD; Läs data registret och förvara den i en variabel
PORTD = previousPORTD ^ B10000000; knäppa lite sju

Vi kan använda sammansatta operatörer för att krympa koden: x = x + 1. kan skrivas som x += 1. till exempel. Detsamma gäller för bitvisa operatorer. Vi behöver inte den tillfälliga variabeln längre.

PORTD | = 1 << 7; ställa in stycke 7 hög

PORTD & = ~ (1 << 7); ställa in stycke 7 låg

PORTD ^ = 1 << 7; Flip bit 7

För att få en viss bit från input register, exempelvis kan du använda funktionen bitRead (byte, bit) :

booleska state = bitRead (PIND, 6); Läs tillståndet i den 6: e pin av port D

Du kan använda några grundläggande matematik för att uppnå samma resultat:

booleska state = (PIND >> 6) %2; Läs tillståndet i den 6: e pin av port D

Här används en rätt bitshift (>>) och en modulooperatorn (%): >> gör samma som <<, men i den andra riktningen. Om PIND är B10101010, till exempel PIND >> 6 = B10, i grund och botten det kotletter av de 6 sista siffrorna (binära). Den biten vi ville kolla nu är längst till höger lite. Modulo ger dig resten av en division, t.ex. 10 %3 = 1, eftersom 3 * 3 + 1 = 10, 5 %6 = 5, eftersom 0 * 6 + 5 = 5, 23 %8 = 7, eftersom 2 * 8 + 7 = 23. x %2 ger dig en 0 om x är även, och 1 om x är udda. Den sista siffran (längst till höger bitar) i ett jämnt antal är 0 i binära notation, och den sista siffran i ett udda tal är 1. Så om vi vill bara veta den sista siffran i ett binärt tal, vi kan bara använda x %2.

Ett annat sätt att få bara en bit av ett tal med hjälp av villkorliga operatorn ( ?: ):

booleska state = (PIND & (1 << 6)) == 0? 0: 1; Läs tillståndet i den 6: e pin av port D

PIND & (1 << 6) kommer bara hålla den 6: e lite på PIND, alla andra siffror blir 0. Om PIND är B10101010, till exempel PIND & (1 << 6) = B00000000, och om PIND är B01010101, PIND & (1 << 6) = B01000000. Från dessa exempel, kan du se att resultatet är noll om bit 6 var 0. Så om vi testa om detta resultat == 0, vi vet statligt av bit 6. Vi använda villkorliga operatorn: skick? resultIfTrue: resultIfFalse. Om villkoret är sant, operatören kommer tillbaka resultIfTrue, om det är FALSKT returneras resultIfFalse.

Obs om kompatibilitet: port-till-stifts mappningen beror på chip. Detta innebär att du måste ändra ditt program om du vill använda en annan Arduino. För personligt bruk, detta är inte så mycket av ett problem, men om du skriver program eller bibliotek för gemenskapen eller för att dela online, du bör ta hänsyn till detta.

Arduino referens: heltal konstanter

Han dödade min tråd: direkt port manipulation tutorial

Arduino referens: Port Manipulation

The Atmel ATmega 328 p datablad p.91 14,4

Arduino referens: bitRead