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:

DECBINHEX
00b00000x0
10b00010x1
20b00100x2
30b00110x3
40b01000x4
50b01010x5
60b01100x6
70b01110x7
80b10000x8
90b10010x9
100b10100xA
110b10110xB
120b11000xC
130b11010xD
140b11100xE
150b11110xF

~ 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

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

This site uses Akismet to reduce spam. Learn how your comment data is processed.