En komplett starter guide till AVRs (1 / 10 steg)

Steg 1: Binära och bitvis operationer

Innan vi dyker in i datablad måste vi förstå några låga begrepp som ska användas varje gång du vill göra något intressant med en mikro.

Låter start på den mest grundläggande, lite.
En bit är den minsta enheten av data till en dator, det är antingen en '1' eller en '0'.
Med andra ord är det antingen på eller av.

För att göra något användbart i en dator, en enda bit räcker inte, så de är kombinerade i byte.
En byte är 8 bitar tillsammans med binära räknar en byte kan antingen lagra 0-255 (256 nummer) eller nummer -128 till 127 (tack till Joel i kommentarerna för märker felet).
Till exempel:
00000000 = 0
00000001 = 1
00000010 = 2
00000011 = 3
00000100 = 4

Precis som när du räknar i decimal (bas 10, som i 10 fingrar!), när du går förbi 9, du sätta en 1 framme och sätta den andra siffran som 0.
Det är samma med binär, förutom eftersom det enda 0 eller 1, när du går förbi '1' du sätta en 1 framför och en '0' som den andra siffran.

Dragen av en mikrokontroller styrs av register. För en 8-bitars AVR är de antingen 8 eller 16 bitar långa.
I stället för det hela som representerar flera emellertid, avgör varje bit om en viss funktion är på eller av.

Vi kommer att titta på en massa olika register senare, men för nu Låt oss göra upp en imaginära så vi kan se hur man manipulera dem.

Tänk dig finner vi ett register i databladet som ansluter till 8 lysdioder kallas LEDREG.
Varje bit i registret är antingen en 1 eller 0, LED är antingen på eller den är avstängd.

Vi kunde vända på den första lysdioden som så:
LEDREG = 1; 00000001
2. LED
LEDREG = 2; 00000010

Men hur är den 3: e LED?
Om vi gjorde detta:
LEDREG = 3; 00000011
Vi skulle inte få den 3: e LED, skulle vi få LED 1 & 2 lyste upp istället!

Med register det inte hur många som är viktigt, men vad de underliggande bitarna ser ut.
3: e LED skulle utseende vara så här:
LEDREG = 4; 00000100

Om du ville vända på olika mönster av lysdioder kan du träna alla 256 kombinationer, men det skulle vara tråkiga.
Det finns ett bättre sätt!

Boolesk logik
Datorer på lägsta nivå arbetet med något som heter boolesk logik.
De använder logik gates för att kombinera binära tal.
Till exempel kommer en AND-gate bara ut en 1 om båda ingångarna är 1.
En eller-grind kommer ut en 1 om något av det är insatsvaror är 1.

Ta en titt här:
http://www.Electronics-tutorials.ws/Boolean/bool_6.html

Det visar "sanning tabeller" för gemensamma logik gates.

Så, vad är allt detta för oss?
Kan vi använda dessa logiska grindar direkt med bitvisa operatorer

Bitvis operationer

Kan säga att vi redan har den 3: e LED på:
LEDREG = 4; 00000100

Hur kan vi vända på första LED?
Vi skulle kunna sätta i värdet av 5 (00000101) men vi vill inte behöva räkna ut vilken kombination varje gång.
Vi kan i stället använda en OR-operator som så:
LEDREG = LEDREG | 1.
Vad detta innebär är detta
00000100 eller
00000001
--------------
00000101

Operatorn eller ställer upp varje bit och om det är på antingen byte, det kommer att vara på i utdata.
Ett snabbare sätt att skriva "LEDREG = LEDREG | 1."är:
LEDREG | = 1;

Du kan också länka din operatörer som så:
LEDREG | = 1 | 2.
Detta kommer komma till hands när vi lär oss SKIFT operatörer.

Vad händer om du ville växla alla lysdioder?
Du kan använda en inte operatör:
LEDREG = ~ LEDREG;

En inte operatören vänder alla bitar, så att du får:
00000101 inte
--------------
11111010

Nästa låt oss titta på en AND-operatorn.
OCH används för att maskera ett värde.
Det vill säga den används att tomma ut delar av en byte men behålla värdet av avsnittet omaskerade som så:

11111010 och
00001111
-------------
00001010

Du kan använda en och för att stänga av en hel grupp av lysdioder utan ändrar läget för resten.
I exemplet ovan skulle det användas som:
LEDREG & = 15. 00001111

En mer användbar operatör innan vi går vidare är XOR.
XOR står för exklusiv eller.
Det liknar en eller-grind, men om båda bitar på, då de är avstängda.
Till exempel:

LEDREG ^ = 15.

00001010 XOR
00001111
-------------
00000101

Nu, själva operatörerna är begränsade, du fortfarande behöva konvertera från binär till motsvarande decimaltal.
Det är där SKIFT aktörer kommer

Shift operatörer
Ett skift operatör skiftar helt enkelt alla siffror åt vänster eller höger.

Till exempel en vänster SKIFT 1:
x = 5 << 1.
ger dig x == 10
i binär som är:
00000101 <<
-------------
00001010

En höger SKIFT flyttas helt enkelt bitarna till höger:
00001010 >>
--------------
00000101

Några bitar i ändarna förloras helt enkelt (eller lagras i ett register som bär, men kan ignorera att för nu!)
Ett skift operatör kan användas som en mycket snabb multiplikation och division, så länge du är nöjd med bara att multiplicera / dividera med befogenheter 2, t.ex.:

x << 1 == x * 2
x << 2 == x * 4
x << 3 == x * 8

Skiften används mycket i inställningen register.
Kan återgå till vårt LED exempel.

Om vi vill ange den 6: e lite, istället för att arbeta ut vad som skulle vara och sedan ORing det med registret, kan vi använda en vänster SKIFT som så:
LEDREG | = (1 << 5);

Obs: Det är '5', inte '6' så behöver vi bara flytta den '1' 5 gånger.
I binär det skulle se ut som så:

00000001 <<
-------------
00100000

Vilket är då ORed med registret som så:

00000101 ELLER
00100000
-------------
00100101

I datablad ges vissa lite ställning vanligtvis ett namn som "RXEN" som används för att aktivera få mode i det seriella perifera och "TXEN" för sändnings.
Tillsammans skulle de se ut så här:
UCSRB | = (1 <

Detta bör vara tillräckligt för att komma igång, kan gå in på några riktiga exempel!