AVR: Binaartehted

Inglise keeles: Bitwise Logical Operators

Registrisse binaarväärtuse kirjutamine:

PORTB = 0b01100001;

Registri lugemine muutujasse:

unsigned char reg = PORTB;

Üksikute bittide muutmiseks registris (arvus jne) kasutatakse binaartehteid. Binaartehe on tehe binaararvude vahel, kus nende arvude iga biti vahel toimub omaette loogikatehe.

Binaararvude ette kirjutatakse 0b ja heksatestimaalarvud 0x. Binaararve kirjutatakse paremalt vasakule. Näiteks: 1 == 0b0001, 2 == 0b0010. Binaararve teisendatakse heksadetsimaalarvudeks lugedes bitte nelja kaupa paremalt vasakule. Näiteks 0b0110 0001 == 0x61.

Allpool on tabel, kus on kirjas kümnendarvud ja neile vastavad binaar- ja heksadetsimaalarvud:

DEC	BIN	HEX
0	0b0000	0x0
1	0b0001	0x1
2	0b0010	0x2
3	0b0011	0x3
4	0b0100	0x4
5	0b0101	0x5
6	0b0110	0x6
7	0b0111	0x7
8	0b1000	0x8
9	0b1001	0x9
10	0b1010	0xA
11	0b1011	0xB
12	0b1100	0xC
13	0b1101	0xD
14	0b1110	0xE
15	0b1111	0xF

~ Eitus

Inglise keeles: one`s complement

Eitus muudab biti väärtuse vastupidiseks. 0 muutub 1 ja 1 muutub 0. C-keeles on eituse märk ~

Kasutakase kogu registri korraga vastupidiseks muutmiseks.

Näide 1: Oletame, et PORTB == 0b00001111; // 0x0F

PORTB = ~PORTB;

Nüüd on PORTB väärtus 0b11110000; // 0xF0

& Loogiline korrutamine

Inglise keeles: AND

Kahte bitti korrutades on vastus 1, kui mõlemad bitid olid 1. Muuljuhul on vastus 0. C-keeles on korrutamise märk &

AND võrdleb kahte biti ja tagastab 1, kui mõlemad bitid on 1.

Kasutatakse ühe või enama bitti madalaks (0) seadmiseks. Tehte üks osapool on register ja teine bitimask, kus madalaks on seatud vaid see bitt, mida ka registris soovitaks madalaks seada.

Näide 1: Oletame, et PORTB == 0b00001111; // Heksadetsimaalarvuna 0x0F

PORTB = PORTB & 0b11111110;

Või lühemalt:

PORTB &= 0b11111110; // 0xFE

Veel lühemalt:

PORTB &= 0xFE;

Nüüd on PORTB väärtus 0b00001110; // 0x0E

Loogilist korrutamist kasutatakse ka ühe või enama biti väärtuse lugemiseks registrist. Tehte osapoolteks on register ja bitimask, kus kõrge on vaid see bitt, mille väärtust soovitakse lugeda.

Näide 1: Oletame, et PORTB == 0b00001111;

unsigned char x = PORTB & 0b00000001; // 0x01

Nüüd x == 0b00000001;

Bittide nullimine

Tihti kasutatakse loogilist korrutamist & koos eitustega ~, et bitte panna nulli.

Näide 1: Oletame, et PORTB == 0b11000111; ~(1<<2) on sama, mis 0b11111011;

PORTB = PORTB & ~(1<<2);

Sama tehe lühemalt:

PORTB &= ~(1<<2);

Näide 2: Mitme bitti korraga nullimine:

PORTB &= ~( (1<<2) | (1<<4) );

| Loogiline liitmine

Inglise keeles: OR

Kahe biti liitmisel on vastus 1, kui vähemalt ühe biti väärtus on 1. C-keeles on liitmise märk |

OR tagastab 1, kui üks võrreldavatest bittidest on 1.

Loogilist liitmist kasutatakse üksiku biti kõrgeks seadmiseks. Liitmis tehte üks osapool on register, teine bitimask , kus kõrge (1) on ainult see bitt, mida registris soovitakse kõrgeks seada.

Bitimaski (Bitmask) kasutatakse, et muuta ühte bitti, teisi bitte mõjutamatta.

Näide 1: Oletame, et PORTB == 0b00001111; // Heksadetsimaalarvuna 0x0F

// Kahe kaldkriipsuga tähistatakse c-keeles ühe realisi kommentaare.

PORTB = PORTB | 0b00010001; // 0x11

Seda saab kirjutada ka lühemalt:

PORTB |= 0b0001001;

Päris lühikeselt:

PORTB |= 0x11;

Nüüd on PORTB väärtus 0b0001 1111; // ehk 0x1F

Näide 2: Oletame, et PORTB == 0b11000011 ja me tahame kolmanda biti määrata kõrgeks:

PORTB = PORTB | 0b00000100;

Enamasti kirjutatakse see lühemalt:

PORTB = PORTB | (1<<2);

Või tegelikult veel lühemalt:

PORTB |= (1<<2);

(1<<2) on biitnihke tehe ja on sama mis 0b00000100. Kõige pealt seame null järgu biti 1 ja siis nihutame seda kaks kohta vasakule (<<).

PORTB on nüüd 0b11000111;

Näide 3: Mitteme biti kõrgeks seadmine. Oletame, et PORTB == 0b11000011

PORTB = PORTB | ( (1<<2)|(1<<4) );

PORTB |= ( (1<<2)|(1<<4) );

( (1<<2)|(1<<4) ) on sama mis 0b00010100;

PORTB on nüüd 0b11010111;

^ Mittesamaväärsus

Inglise keeles: XOR

Kui bittide väärtused teineteisest erinevad on vastus 1. Muuljuhul 0. C-keeles on mittesamaväärsuse märk ^

Tagastab 1 ainult siis, kui üks võrreldavast bitist on 1.

Kasutatakse ühe või mitme bitti vastupidiseks muutmiseks ehk inverteerimiseks. Tehte osapoolteks on register ja bitimask , kus kõrgeks (1) on seatud vaid need bitid, mida registris soovitakse muuta.

Näide 1: Oletame, et PORTB == 0b00001111; // ehk 0x0F

PORTB = PORTB ^ 0b00010001;

Lühemalt:

PORTB ^= 0b00010001;

Veel lühemalt:

PORTB ^= 0x11;

Nüüd on PORTB väärtus 0b00011110; // ehk 0x1E

Näide 2: Ühe biti ümberlülitamine. Oletame, et PORTB == 0b11000111;

PORTB = PORTB ^ (1<<2);

(1<<2) == 0b00000100; Sama tehe lühemalt:

PORTB ^= (1<<2);

Nüüd on PORTB väärtus 0b11000011;

Näide 3: Mitme biti ümberlülitamine.

PORTB ^=( (1<<2) | (1<<4) );

<< Bitinihe vasakule

Inglise keeles: Left Shift

Nihet vasakule kasutatakse bitijärgu bitimaskiks teisendamiseks.

Näide 1:

REG = 0b00000001 << 5;

Sama tulemuse saab ka:

REG = 1<<5;

Nüüd REG == 0b00100000;

Näide 2: Oletame, et PORTB == 0b00001111;

PORTB = PORTB << 3;

Nüd on PORTB väärtus 0b01111000. Kõik bitid liikusid 3 kohta edasi (vasakule).

>> Bitinihe paremale

Inglise keeles: Right Shift

Nihet paremale kasutatakse bitimaskist biti loogilise väärtuse leidmiseks. Näieks me tahame teda kas viies bitt on 1 või 0. (Bitti järgu lugemine hakkab peale nullist. Paremalt vasakule.)

Näide 1: Oletame, et REG = 0b00100000;

unsigned char x = REG >>5;

Nüüd teame, et x == 0x01; ehk 1 ehk 0b00000001