Stap 1: Binaire en bitsgewijze operaties
Voordat we in gegevensbladen duiken moeten we sommige lage basisbegrippen die u wilt gebruiken telkens wanneer u zin voor verrichten iets interessants met een micro.
Laat start op het meest elementaire, het bit.
Een beetje is de kleinste eenheid van gegevens naar een computer, het is een '1' of een '0'.
Met andere woorden is het ofwel in- of uitschakelen.
Ga iets nuttig in een computer een enkele bit is echter niet genoeg, zodat ze worden gecombineerd in bytes.
Een byte is 8 bits samen, en met behulp van binaire tellen een byte kunt ofwel 0-255 (256 nummers) of-128 tot 127 (met dank aan Joel in de commentaren voor het merken van de fout).
Bijvoorbeeld:
00000000 = 0
00000001 = 1
00000010 = 2
00000011 = 3
00000100 = 4
Net als wanneer u rekenen in decimale (grondtal 10, net als in 10 vingers!), wanneer u langs 9, gaat u een 1 vooraan en zet het tweede cijfer 0.
Het is het zelfde met binaire, behalve als er enige 0 of 1, wanneer u voorbij '1 gaat' je een 1 op de voorgrond en een '0' als het tweede cijfer.
De kenmerken van een microcontroller worden gecontroleerd door de registers. In het geval van een 8-bits AVR zijn ze 8 of 16 bits lang.
In plaats van het hele ding die een aantal echter, elke bit wordt gecontroleerd of een bepaalde functie in- of uitschakelen.
We zullen kijken naar een heleboel verschillende registers later, maar voor nu let's make up een denkbeeldige dus we hoe zien kunnen te manipuleren.
Stel je vinden we een register in het gegevensblad dat met 8 LEDs genaamd LEDREG verbindt.
Elke bit in het register is een 1 of een 0, de LED is ofwel op, of het is uitgeschakeld.
We kunnen weer op de eerste LED als volgt:
LEDREG = 1; 00000001
2E LED
LEDREG = 2; 00000010
Maar hoe zit het met de 3de LED?
Als we dit deden:
LEDREG = 3; 00000011
We de 3e LED niet zou krijgen, we 'd get LED 1 & 2 in plaats daarvan verlicht!
Met registers is het niet het aantal dat telt, maar wat de onderliggende stukjes eruit.
De 3e leidde blik zou als volgt:
LEDREG = 4; 00000100
Als u wilden voor zwenking op verschillende patronen van LEDs u alle 256 combinaties kon uitwerken, maar dat zou vervelend.
Er is een betere manier!
Booleaanse logica
Computers op het laagste niveau werk met iets genoemd Booleaanse logica.
Zij logic-poorten gebruiken om binaire getallen combineren.
Bijvoorbeeld een AND-poort zal alleen de uitgang van een 1 als beide ingangen 1.
Een OR-poort een 1 zal output als een van de ingangen zijn 1.
Neem een kijkje hier:
http://www.Electronics-tutorials.WS/Boolean/bool_6.html
Het toont de 'waarheid '-tabellen voor gemeenschappelijke logica poorten.
Dus, wat is dit voor ons?
Kunnen we gebruik van deze logica poorten direct met bitsgewijze operatoren
Bitsgewijze bewerkingen
Laat zeggen we al de 3de LED op:
LEDREG = 4; 00000100
Hoe kunnen we de eerste LED inschakelen?
We kunnen zetten in de waarde van 5 (00000101), maar we willen niet te hebben om erachter te komen welke combinatie telkens.
In plaats daarvan kunnen we gebruik maken van een OR-operator als volgt:
LEDREG = LEDREG | 1;
Wat dit betekent is dit
00000100 of
00000001
--------------
00000101
De operator OR lijnen elke bit en als het brandt in beide byte, zal zij op in de uitvoer.
Een snellere manier te schrijven "LEDREG = LEDREG | 1;"is:
LEDREG | = 1;
U kunt ook uw operators keten als volgt:
LEDREG | = 1 | 2;
Dit zal handig komen wanneer wij operatoren verplaatsen leren.
Wat als je wilde alle van de LEDs in-/ uitschakelen?
U kunt een niet-operator:
LEDREG = ~ LEDREG;
Een operator NOT draait alle bits, zodat u krijgen:
00000101 niet
--------------
11111010
Vervolgens laten we een AND-operator.
EN wordt gebruikt om te maskeren een waarde.
Dat wil zeggen, het wordt gebruikt om leeg uit secties van een bytewaarde maar houden de waarde van de niet-gemaskerde sectie als volgt:
11111010 en
00001111
-------------
00001010
U kunt een en een hele groep van LED's uitschakelen zonder dat de staat van de rest.
In het bovenstaande voorbeeld zou het worden gebruikt als:
LEDREG & = 15; 00001111
Een nuttiger exploitant alvorens verder te gaan is de XOR.
XOR staat voor exclusieve of.
Het is vergelijkbaar met een OR-poort, maar als beide bits zijn op, dan ze zijn uitgeschakeld.
Bijvoorbeeld:
LEDREG ^ = 15;
00001010 XOR
00001111
-------------
00000101
Nu, door zelf de exploitanten zijn beperkt, nog steeds moet u converteren van binair naar de gelijkwaardig decimaal getal.
Dit is waar de operatoren verplaatsen komen
Operatoren voor verplaatsen
De exploitant van een verschuiving verschuift simpelweg alle cijfers links of rechts.
Bijvoorbeeld een linker shift 1:
x = 5 << 1;
geeft u x 10 ==
in het binaire bestand dat zich:
00000101 <<
-------------
00001010
Een juiste verschuiving verplaatst simpelweg de bits naar rechts:
00001010 >>
--------------
00000101
Alle bits aan de uiteinden zijn gewoon verloren (of opgeslagen in een register voeren, maar kunt negeren dat voor nu!)
Een shift-operator kan worden gebruikt als een zeer snelle vermenigvuldiging & divisie, zolang u tevreden bent met alleen te vermenigvuldigen en delen door machten van 2, bijv:
x << 1 == x * 2
x << 2 == x * 4
x << 3 == x * 8
Verschuivingen worden veel gebruikt in de registers van de instelling.
Laten we terugkeren naar ons voorbeeld van LED.
Als we de 6de bit ingesteld willen, in plaats van uit welk getal dat zou worden en vervolgens ORing te werken met het register, kunnen we gebruiken een linker shift als zo:
LEDREG | = (1 << 5);
NB: Het is '5', niet '6' als we slechts hoeven te verplaatsen van de '1' 5 keer.
In de binaire zou kijken als volgt:
00000001 <<
-------------
00100000
Die is dan ORed met het register als volgt:
00000101 OF
00100000
-------------
00100101
In gegevensbladen, de positie van een bepaalde bit meestal krijgt een naam zoals "RXEN", die wordt gebruikt om te schakelen ontvang modus in de seriële perifere en "TXEN" voor zenden.
Samen zij zou als volgt uitzien:
UCSRB | = (1 <
Dit moet genoeg zijn om u begonnen te krijgen, laat gaan naar echte voorbeelden!
