1

5.11. C-kielen perusteet. Loogiset operaatiot 8.1.2008 pva ”Rahalla saa - hyviä miehiä ja huonoja naisia.” - Mr Benny Mable Oletus Toivottavasti olet oppinut digitaalitekniikassa tärkeimmät loogiset operaatiot, AND, OR ja XOR. Sulautettujen koodauksessa käytetään niitä jatkuvasti. Näistä on lisää toisessa dokumentíssa jossa käsitellään maskausta. Yleistä Bittioperaattoreiden käyttäminen on laiteläheisen C-kielen ohjelmoijalle jokapäiväistä puuhaa. Siksi niiden toiminnan ymmärtäminen on ohjelmoijan ’must’. Sulautetuissa järjestelmissä on varsin tavallista se, että ohjelmalla halutaan käsitellä vain yhtä yksittäistä bittiä. Vain tietty bitti pitää asettaa ykköseksi tai resetoida nollaksi, mutta muihin rekisterin/portin bitteihin ei saa samalla kertaa koskea. Tai kun olemme kiinnostuneet vain portin yhden bitin tilasta, onko se ykkönen, vai nolla. Silloin tarvitaan bittioperaatioita. Aivan kuten elektroniikassa on komponenttittasolla käytössä loogiset operaatiot, samoin ne löytyvät myös C-kielestä. Huom Älä sekoita bittitason loogisia operaatioita (bitti bitiltä) ja loogisia operaatioita (tosi tai epätosi) keskenään.

2

Käytännön esimerkkejä milloin tarvitaan bittioperaatioita • Lähtöporttiin on kytketty FET, jolla ohjataan vesipumpun sähkömoottoria. • Luetaan tuloportista, onko tietty ovikytkin asennossa ON tai EI. • Kun kerrotaan AD-muuntimelle, että nyt on aika aloittaa muunnosprosessi. • Kun pitää asettaa sarjaportin lähetyskeskeytys päälle tai pois päältä. • Asetetaan ajastimen ohjausrekisterin jokin tietty bitti ’päälle’. • Ja paljon muuta

Mikro-ohjaimissa on yleensä joitakin portteja tai rekistereitä jotka ovat bittiosoitettavia, siis käsky vaikuttaa vain yhteen bittiin. C-kääntäjistäkin löytyy bittikomentoja, mutta myös bittioperaattorit tulee tuntea. Bittitason looginen operaattori mahdollistaa kokonaislukumuuttujien (int, char, long) yksittäisen bitin muokkaamisen. Bittioperaatiot ovat tehokkaita, koske ne eivät käytä matemaattisia laskutoimituksia, vaan operoivat bittikuvioita suoraan. Bittitason loogiset operaattorit C:ssä on kuusi operaattoria bittien käsittelyyn. Kukin niistä suorittaa bitti-bitiltä operaation.

Operaatio Symboli Kuvaus AND & Tulos on TRUE jos verrattavat bitit ovat TRUE, tosi OR | Tulos on TRUE jos toinen tai molemmat on TRUE XOR ^ Tulos on TRUE jos vain jompikumpi on TRUE NOT ~ Tulos on TRUE jos tulo on FALSE, epätosi

Sitten on vielä kaksi

- bittien siirto oikealle - bittien siirto vasemmalle

Nehän opeteltiin jo C-kurssin alkuosassa. Kun otamme mitkä tahansa kaksi 8 bitin tavua, muuttujaa tai rekisteriä ja suoritetaan niiden kesken joku em. operaatioista, saamme uuden 8 bittisen tavun, jonka arvo riippuu siitä mitä tavujen kesken tehtiin. Tärkeää tiedostaa, että toiminne tehdään tavujen kunkin bittiparin kesken. Totuustaulukko auttaa asian ymmärtämistä. Muista että 1 on tosi eli true ja 0 on epätosi eli false.

Älä sekoita keskenään: - bittitason loogisia operaatioita (bitti bitiltä) - loogisia operaatioita (tosi tai epätosi)

3

1. Bittitason AND-operaatio. &, JA AND-operaatio asettaa operaation tulosbitin ykköseksi, jos molempien operandien vastaavat bitit ovat ykkösiä, muuten nollaksi. Käytetään nollaamaan joku rekisterin tai muuttujan bitti, tai monta bittiä. AND-operaation formaatti: tulos = luku_1 & luku_2;

tulos-muuttujan arvoksi tulee tavu, jossa ykkönen on niissä kohdissa, missä alunperin ykkönen on molemmissa muuttujissa. Kaikki muut bitit asettuvat nollaksi, katso totuustaulukkoa.

AND-portti ja sen totuustaulukko. Esimerkkikoodi selvittää toiminnon /************************************************** ******** Project : AND.c Hardware: PV-M32-MOOkit (4 MHz) + PV-LEDIT B-portis sa Software: WinAVR-20071221 Date : 01.01.2008 Author : pva Comments: AND-operaatio kahden muuttujan välillä *************************************************** *******/ #include <avr/io.h> #include <util/delay.h> // *** Primitive wait() *** void wait(uint16_t time) { volatile uint16_t i; for(i=0;i<2000;i++) _delay_loop_2(time); } int main(void) { DDRB = 0xFF; uint8_t tulos = 0; uint8_t luku_1 = 0xF0; // 1111 0000 uint8_t luku_2 = 0x5F; // 0101 1111 while(1) { PORTB = 0x00; wait(500);

4

tulos = luku_1 & luku_2; // AND-operaatio bitt i bitiltä PORTB = tulos; wait(500); } } Analysointi Tehdäään kahden luvn välillä AND-operaatio: uint8_t luku_1 = 0xF0; // 1111 0000 uint8_t luku_2 = 0x5F; // 0101 1111

------------------------------------------------------ AND & 0101 0000

Kuten tuloksesta näkyy, kaikki luku_2:n nolla-bitit nollaavat luku_1:n vastaavat bitit. Selvästi tällä operaatiolla muuttujan (rekisterin) halutut bitit voidaan nollata. AND-Muistisääntö: ”A ja B molemmat ovat 1, tulos on 1, muuten nolla” Jos haluat jonkun tietyn bitin olevan nolla ja muihin bitteihin ei kosketa, käytä AND-operaatiota. 2. Bittitason OR-operaatio, Inklusiivinen TAI, ( |, OR) OR-operaatio asettaa tulosbitin ykköseksi, jos jompikumpi, tai molemmat operandien biteistä ovat ykkösiä. Käytetään kääntämään päälle yksi tai useampia lukuarvon biteistä, tai testaamaan, onko jompikumpi biteistä asetettu ykköseksi. OR-operaation formaatti: tulos = luku_1 | luku_2;

tulos-muuttujan arvoksi tulee tavu, jossa ykkönen on niissä kohdissa, missä alunperin ykkönen on jommassa kummassa tai molemmissa muuttujissa, muut bitit asettuvat nollaksi. Katso totuustaulukkoa.

OR-portti ja totuustaulukko

5

Kun a tai b tai molemmat tulot ovat 1, lähtö L on 1, muuten se on nolla.

OR-portin toiminta OR-operaatio tehdään lukujen bittien kesken, bitti bitiltä. Siis ensin vähiten merkitsevien bittien kesken (äärimmäisenä oikealla), sitten seuraava pari, jne. Huom! Tai-operaattori | on nimeltään ’putki’. Sen saat käyttöön, kun painat Alt Gr ja yhtaikaa suurempi/pienempi kuin. Esimerkkikoodi selvittää toiminnon /************************************************** ******** Project : OR.c Hardware: PV-M32-MOOkit (4 MHz) + PV-LEDIT B-portis sa Software: WinAVR-20071221 Date : 01.01.2008 Author : pva Comments: OR-operaatio kahden muuttujan välillä *************************************************** *******/ #include <avr/io.h> #include <util/delay.h> // *** Primitive wait() *** void wait(uint16_t time) { volatile uint16_t i; for(i=0;i<2000;i++) _delay_loop_2(time); } int main(void) { DDRB = 0xFF; uint8_t tulos = 0; uint8_t luku_1 = 0xF0; // 1111 0000 uint8_t luku_2 = 0x01; // 0000 0001

6

while(1) { PORTB = 0x00; wait(500); tulos = luku_1 | luku_2; // OR-operaatio bitti bitiltä PORTB = tulos; wait(500); } } Analysointi Tehdäään kahden luvun välillä OR-operaatio: uint8_t luku_1 = 0xF0; // 1111 0000 uint8_t luku_2 = 0x01; // 0000 0001 ----------------------------------- OR tulos 1111 0001

Kuten tuloksesta näkyy, kaikki luku_2:n ykkösbitit asettavat luku_1:n vastaavat bitit. Muut jää ennalleen. Selvästi tällä operaatiolla muuttujan (rekisterin) halutut bitit voidaan asettaa ykköseksi. OR-Muistisääntö: ”A tai B tai molemmat on 1, tulos on 1, muuten nolla” Jos haluat jonkun tietyn bitin olevan yksi ja muihin bitteihin ei kosketa, käytä OR-operaatiota. 3. Bittitason ehdoton-TAI-operaatio, Ekslusiivinen-TAI, (^, EXOR) Ehdoton-TAI-operaatio, XOR tai EXOR, asettaa tulosbitit ykkösiksi niiltä osin, kun bitit operandeilla ovat erilaisia ja nollaksi, kun ne ovat samanlaisia. Toisin sanoen: jos vain jompikumpi on 1, niin tulos on 1, muuten aina 0. exclusive, sulkea pois, jättää ulos Bittitason ehdoton-TAI-operaation formaatti: tulos = luku_1 ^ luku_2;

tulos-muuttujan arvoksi tulee tavu, jossa ykkönen on niissä kohdissa, missä alunperin ykkönen on vain toisessa muuttujassa, muut bitit asettuvat nollaksi. Katso totuustaulukkoa.

7

Operaatio Tulos 1 ^1 0 1 ^ 0 1 0 ^ 1 1 0 ^ 0 0 EXOR-operaation totuustaulukko. Huom! ^ eli OR-operaation saat kun painat alas oikea Shift ja samaan aikaan nappia, jossa on ^merkki, ja vielä tämän jälkeen painat’ pitkulaa’ eli väli-merkkiä. Esimerkkikoodi selvittää toiminnon /************************************************** ******** Project : XOR.c Hardware: PV-M32-MOOkit (4 MHz) + PV-LEDIT B-portis sa Software: WinAVR-20071221 Date : 01.01.2008 Author : pva Comments: XOR-operaatio kahden muuttujan välillä *************************************************** *******/ #include <avr/io.h> #include <util/delay.h> // *** Primitive wait() *** void wait(uint16_t time) { volatile uint16_t i; for(i=0;i<2000;i++) _delay_loop_2(time); } int main(void) { DDRB = 0xFF; uint8_t tulos = 0; uint8_t luku_1 = 0x01; // 0000 0001 while(1) { PORTB = tulos; wait(500); PORTB = PORTB ^ luku_1; // XOR-operaatio bitt i bitiltä wait(500); } } Analysointi Tehdään kahden luvun välillä XOR-operaatio:

8

Eka kierros PORTB = 0000 0000 luku_1 = 0000 0001 ------------------ XOR PORTB = 0000 0001

Toka kierros PORTB = 0000 0001 luku_1 = 0000 0001 ------------------ XOR PORTB = 0000 0000 Kuten tuloksesta näkyy XOR kahden luvun välillä aikaansaa tuloksen, jossa kaikki ne bitit, joissa molemmat ovat ykkösiä, nollataan. Jos muuttujissa vain toisessa bitti on 1, se siirtyy myös lopputulokseen. Tämä ohjelma kääntelee vähiten merkitsevää bittiä. Yksittäisen bitin tila voidaan kääntää päinvastaiseksi XOR-operaation avulla. Kun OR-operaatio on ”A tai B tai molemmat on 1, tulos on 1” niin XOR on poissulkeva OR, exclusive-OR.

XOR-Muistisääntö: ”A tai B on 1, tulos on 1, muuten nolla”

Bittioperaatioiden käytöstä | putki operaatiota käytetään bittien päälle laittamiseen ^ xor operaatiota käytetään bittien tilan vaihtamiseen & operaatiolla voidaan nollata halutut bitit

9

4. Bittitason NOT-operaatio, Bitwise Complement, (EI, NOT, ~) NOT-operaatio tuottaa kokonaisluvun yhden komplementin, eli se invertoi jokaisen muuttujan 1-bitin nollaksi ja päinvastoin. NOT-operaattori toimii yhdellä operandilla, siksi toisinaan puhutaan unaarioperaattorista, joskus myös komplementaarioperaattorista. NOT-operaation formaatti: tulos = ~luku;

tulos-muuttujan arvoksi tulee tavu, jossa ykkönen on niissä kohdissa, missä luku-muuttujassa on nolla ja nolla, missä luku-muuttujassa on ykkönen. Operaatio Tulos ~1 0 ~0 1 NOT-operaation totuustaulukko. Esimerkkikoodi selvittää toiminnon /************************************************** ******** Project : NOT.c Hardware: PV-M32-MOOkit (4 MHz) + PV-LEDIT B-portis sa Software: WinAVR-20071221 Date : 01.01.2008 Author : pva Comments: NOT-operaatio *************************************************** *******/ #include <avr/io.h> #include <util/delay.h> // *** Primitive wait() *** void wait(uint16_t time) { volatile uint16_t i; for(i=0;i<2000;i++) _delay_loop_2(time); } int main(void) { DDRB = 0xFF; uint8_t luku_1 = 0x01; // 0000 0001 while(1) { PORTB = luku_1; wait(500); PORTB = ~luku_1; // NOT-operaatio bitti bitil tä wait(500); } } Analysointi Koodi ei kommentteja enempää kaipaa.