30
1 5.2. Sulautetun järjestelmän C-kielen perusteet 2/8, käsitteet 7.1.2008 pva ”Hän joka ei ota riskejä, ei myöskään juo shampanjaa.” - venäläinen sanalasku Tässä osiossa tärkeää: lisää ohjelmoinnissa tarvittavia peruskäsitteitä, kuten - muuttujat - tietotyypit - perusoperaattorit Sisältö Muuttuja, variable Ohjeita muuttujan nimeämiseen: Miksi muuttuja pitää esitellä? Tieto- eli datatyypit C-kielessä on neljä perustietotyyppiä: Muuttujan tyypin valinta User types Talletusluokat eli muistimääritteet Talletusluokka automaattinen, automatic Talletusluokka Static Talletusluokka Extern Rekisterimuuttujat, Register Variables Volatile Yleinen eli globaali muuttuja, Global Variable Tilde Vakio, constant Miksi käytetään vakioita? 1. Numeeriset vakiot 2. Merkkivakiot 3. Symboliset vakiot 4. Varattu sana const Operaattorit, operators Sijoitusoperaattorit Sijoitus- ja matemaattisten operaattoreiden yhdistäminen Matemaattisten operaattoreiden käyttö-harjoitus Vertailuoperaattorit Unaarioperaattori Lisäys- ja vähennysoperaattorit Varatut sanat

5.2. C-kielen perusteet. 2_8

Embed Size (px)

Citation preview

Page 1: 5.2. C-kielen perusteet. 2_8

1

5.2. Sulautetun järjestelmän C-kielen perusteet 2/8, käsitteet 7.1.2008 pva

”Hän joka ei ota riskejä, ei myöskään juo shampanjaa.” - venäläinen sanalasku Tässä osiossa tärkeää: lisää ohjelmoinnissa tarvittavia peruskäsitteitä, kuten

- muuttujat - tietotyypit - perusoperaattorit

Sisältö Muuttuja, variable Ohjeita muuttujan nimeämiseen: Miksi muuttuja pitää esitellä? Tieto- eli datatyypit C-kielessä on neljä perustietotyyppiä: Muuttujan tyypin valinta User types Talletusluokat eli muistimääritteet Talletusluokka automaattinen, automatic Talletusluokka Static Talletusluokka Extern Rekisterimuuttujat, Register Variables Volatile Yleinen eli globaali muuttuja, Global Variable Tilde Vakio, constant Miksi käytetään vakioita? 1. Numeeriset vakiot 2. Merkkivakiot 3. Symboliset vakiot 4. Varattu sana const Operaattorit, operators Sijoitusoperaattorit Sijoitus- ja matemaattisten operaattoreiden yhdistäminen Matemaattisten operaattoreiden käyttö-harjoitus Vertailuoperaattorit Unaarioperaattori Lisäys- ja vähennysoperaattorit Varatut sanat

Page 2: 5.2. C-kielen perusteet. 2_8

2

Yleistä Tämä luku on hyvin laaja ja perusteellinen. Se sisältää ”kaiken olennaisen ja käytän-nössä tarvittavan” perustiedon. Eli eräänlaiset C-kielen aakkoset, joiden avulla myö-hempi työskentely tapahtuu. Käytä aikaa asioiden omaksumiseen ja harjoitteluun jotta saat ”tartuntapintaa” varsinaisia laiteläheisen ohjelmoinnin opintoja varten. Siispä töihin. Luo uusi projekti, nimi eka_2.c. Kirjoita seuraava koodi. eka_2.c, esimerkkikoodi /************************************************** ******** Project : eka_2.c Hardware: PV-M32 + PV-LEDIT on PORTB Software: WinAVR 20070525 Date : 03.07.2007 Author : pva Comments: ensimmäiset opetuskoodit *************************************************** *******/ #include <avr/io.h> #include <util/delay.h> // prototyyppi void wait(uint16_t time); int main(void) { DDRB = 0xFF; // B-portin suunta ulos unsigned char kuvio = 0x55; // kuvio bitteinä 01 01 0101 while(1) // ikuinen silmukka { // silmukan alku PORTB = 0xF0; // B-porttiin 1111 0000 wait(500); // kulutetaan aikaa PORTB = kuvio; // B-porttiin kuvio-muuttujan arvo wait(500); PORTB = 0x0F; // B-porttiin 0000 1111 wait(500); } // silmukan loppu } // main-funktion loppu // *** Primitive wait() *** void wait(uint16_t time) { volatile uint16_t i; for(i=0;i<2000;i++) _delay_loop_2(time); }

Käännä ja ohjelmoi AVR.

Jatketaan analysointia. Uutta on siis vain rivi:

Page 3: 5.2. C-kielen perusteet. 2_8

3

unsigned char kuvio = 0x55; // kuvio bitteinä 0101 0101

Mikä on ”unsigned char kuvio”? Se on Muuttuja, variable Tietokone tekee monenlaisia asioita ohjelman ohjaamana; esim. se lukee lämpötila-anturin arvoja, muuttaa (laskemalla) sen arvon Celsius-asteiksi, vertaa sitä ennalta annettuun raja-arvoon ja jos arvo ylittää sen, kytkee transistorikytkimen kautta tuulettimen moottorin pyörimään. Näiden tehtävien suorittamiseen mikro-ohjain tarvitsee ohjelmakoodin lisäksi tietoa, dataa eli numeroita ja merkkejä. Osa tiedosta on asetettu pysymään muuttumattomana ohjelman ajon ajan. Ne ovat vakioita, esim. raja-arvo, josta tuuletin käynnistetään. Toiset tiedot muuttuvat ja niitä on voitava muuttaa milloin tahansa ohjelman aikana. Luetaan vaikkapa lämpötilatieto kerran minuutissa. Muutettavat tiedot tallennetaan muuttujiin.

Muuttujan arvo muuttuu, tai saattaa muuttua, ohjelman ajon aikana. Vakion arvo ei muutu ohjelman aikana.

Muuttujat ovat olennaisia asioita kaikissa ohjelmointikielissä. Käsiteltävälle tiedolle pitää olla jokin varastopaikka, oli se sitten vakio tai muuttuja. Muuttujat ovat tiedon tallennukseen varattuja käyttömuistin (SRAM) lokeroita, joihin voi tallettaa ohjelmassa tarvittavia lukuarvoja, numeroita, merkkejä jne. Jokaisella muuttujalla on oma nimi ja tyyppi. Jotta C-käännin tietäisi miten muuttujaa käytetään, se on ensin esiteltävä. Esittely tapahtuu ilmoittamalla funktion alussa muuttujan tyyppi ja muuttujan nimi. Esittely varaa tilaa muuttujalle RAM-muistista ja yhdistää nimen varattuun tilaan. Muistipaikan koko määräytyy tyypin perusteella.

Muuttuja on RAM-muistiin nimetty muistipaikka, jonne voi tallentaa luvun tai merkin.

Oikeasti muistipaikassa on vain ykkösiä (sähkövaraus) ja/tai nollia (ei varausta).

Muuttujalla tulee olla

- nimi, jolla muuttuja tunnistetaan - tyyppi, joka määrää kuinka suuri muistialue varataan, millaista tietoa sinne

voidaan tallettaa ja mitä toimenpiteitä, operaatioita, voidaan muuttujaan kohdistaa

- arvo, joka on muistipaikan sisältö, annetaan heti tai myöhemmin. Muuttujan alkuarvo kannattaa antaa heti määrittelyn yhteydessä. Jos et muuta keksi, anna vaikka nolla.

Muuttujan määrittelyn formaatti:

Page 4: 5.2. C-kielen perusteet. 2_8

4

muuttujan_tyyppi muuttujan_nimi; int x = 0; char merkki = 0; float lampo;

Määrittelyrivi päätetään puolipisteellä (;) Ohjeita muuttujan nimeämiseen: Nimen kelvolliset merkit ovat a - z, numerot ja alaviivat. Et saa käyttää ’öökkösiä’, eli skandinaavisia ä, ö eikä å. Ensimmäinen merkki ei saa olla numero, eikä myöskään alaviiva (sillä se on varattu järjestelmän käyttöön). C-kieli ymmärtää isot ja pienet kirjaimet eri merkeiksi. Ole niissä tarkkana. Käytä muuttujien nimissä vain pieniä kirjaimia. Myöhemmin esiteltävät varatut sanat eivät voi olla muuttujan nimiä. Kokonaislukumuuttujan määrittelyssä kirjoitetaan varattu sana int (integer) ja sitten muuttujan nimi. Voit esitellä useita samaa tyyppiä olevia muuttujia samalla rivillä erottamalla ne toisistaan pilkulla. int virta_1, virta_2, jannite;

Muuttujan nimenä kannattaa käyttää jotain sen merkitystä tai tehtävää kuvaavaa nimeä. Jos esim. muuttujaan tallennetaan virta-arvoja, kannattaa antaa muuttujalle nimi virta. Vältä käyttämästä muuttujan nimenä pelkkää kirjainta. Koska globaalin (yleisen) muuttujan nimen tulee olla erityisen kuvaava, (se näkyy kaikille funktioille ja siten käytetään monessa paikassa) se voi toisinaan muodostua kahdesta tai useammasta sanasta. Käytä silloin sanojen välissä alaviivaa, esimerkiksi näin: char ovi_kytkin; int lampo_anturi;

Lokaalille eli paikalliselle muuttujalle, joka on vain väliaikainen, käy lyhyempikin nimi.

i ja j sallitaan silmukoissa, p ja q osoittimissa ja s ja t merkkijonoissa, koska ne ovat niin vakiintuneita käytäntöjä.

Hyvin valittu nimi on kuin ylimääräinen kommenttirivi, se kertoo heti lukijalle mistä on kysymys, mitä ko. ohjelmakohteessa tapahtuu. Miksi muuttuja pitää esitellä? Aina kun kirjoitetaan ohjelmakoodia tarvitaan muuttujia. Käännin tarkistaa joka kerta muuttujan kohdatessaan, onko muuttuja esitelty. Täten säilyy oikea kirjoitusmuoto. Jos näin ei tehtäisi, käännin loisi aina uuden muuttujan virheellisenkin nimen yhteydessä. Tästä seuraisi ongelmia. Isoista ohjelmista ohjelmointivirheiden etsiminen on tosi työlästä.

Page 5: 5.2. C-kielen perusteet. 2_8

5

Käytä ennalta määriteltyjä vakioita, ei lukuja

- sillä ne ovat helpommin muutettavissa esim. #define JANNITE 9

Miksi tarvitaan muuttujaa? Sulautetun järjestelmän työmuistin (SRAM) koko on yleensä vaatimaton, joten kääntimen tulee tietää:

- kuinka iso muistipaikka datalle varataan, varataan vain minimitarve - ja mitä toimenpiteitä ko. datalle voidaan tehdä

Tieto- eli datatyypit C-kieli on 'tyypitetty kieli'. Se tarkoittaa sitä, että kaikilla muuttujilla ja funktioilla on oltava jokin tyyppi. Muuttujan tyyppi määrää, millaisia arvoja muuttuja voi saada ja millaisia operaatioita muuttujaan voidaan kohdistaa, sekä paljonko muistia muuttuja tarvitsee. C-kielessä on neljä perustietotyyppiä: char, character, merkkityyppi, esim. 'a', 'B'. Teknisesti char on 8-bittinen kokonaislukutyyppi, joten sulautetuissa järjestelmissä on tyypillistä käyttää 8-bittisiä heksalukuja tässä yhteydessä, esim. 0xF0. Muuttuja sisältää numeroita, siis vain ykkösiä ja nollia, ei kirjaimia, ne vain tulkitaan sopivassa yhteydessä kirjaimiksi. int , integer, 16-bittinen kokonaislukutyyppi esim. 6, -49, 32736 float, floating point, 32-bittinen reaali- eli liuku- eli desimaalilukutyyppi, esim. 2.46, 3.12E3, Kun liuku-luku tallennetaan muistiin, se jaetaan kahteen osaan, toiseen osaan tallennetaan mantissa ja toiseen eksponentti. Tilaa varataan tietylle määrälle numeroita. Eksponentti ja mantissa voidaan tallettaa muuttujaan eri tavoilla. ANSI-normi ei määrää miten, joten kääntimet tekevät sen ’omalla tavallaan’.

Huom! Muuttujalle varataan tilaa SRAM-muistista, koska sen arvoa on voitava muuttaa ohjelman kuluessa. SRAM-muisti on rakennettu kiikuista, joilla on sähkön kytkemisen jälkeen satunnainen arvo, siis yksi tai nolla. Kiikku voi olla ’kiikun tai kaakun’. Muuttujan esittely varaa vain muistista tilaa, mutta ei ota kantaa muistin sisältöön. Siksi muuttuja on alustettava, initialisoitava eli sille on annettava arvo. Alustamattoman muuttujan käyttö on vaarallista, koska muistipaikka saattaa sisältää mitä tahansa satunnaista dataa.

Page 6: 5.2. C-kielen perusteet. 2_8

6

Pienissä mikro-ohjaimissa ei ole laitteistotukea liukuluvuille (laskentayksikköä, saati matematiikkaprosessoria), joten laskenta on tehtävä ohjelmallisesti. Ongelmaksi tulee silloin suuri muistintarve. Onneksi suurille liukuluvuille on harvoin tarvetta pienissä sulautetuissa järjestelmissä. Liukulukutyypin käytön etuna on se, että sillä voidaan esittää paljon suurempi määrä lukuja, kuin kokonaislukutyypillä. Haittana taas se, että liukulukuoperaatiot ovat paljon hitaampia kuin kokonaislukulaskenta ja pikku systeemeissä laskettaessa luvun tarkkuus vähenee. double, double precision, ’pidempi desimaaliluku’, liukulukumuuttuja, jossa kaksinkertainen tarkkuus. Näitä perustyyppejä voi täsmentää etuliitteellä: unsigned int, etumerkitön (positiivinen) kokonaislukumuuttuja unsigned char, etumerkitön merkkimuuttuja Kokonaisluvut ovat oletuksena etumerkillisiä, ne voivat olla siis joko positiivisia tai negatiivisia. Yleisin tapa esittää negatiivinen numero on kahden komplementti, two's complement. Unsigned on etumerkitön, siis vain positiivisia lukuja sisältävä muuttujatyyppi. Käytä unsigned-tyyppiä, aina jos suinkin voit. Negatiivisten lukujen käsittelyyn liittyy etumerkin testaus ja siihen tarvitaan koodia ja muistitilaa ja siten myös aikaa. Etumerkki varaa yhden bitin paikan rekisteristä, joten lukualue jää pienemmäksi. (void merkitsee tyhjä, ilman tyyppiä) Nimi Koko Lukualue Kommentti Bit 1 bitti 0 tai 1 yksittäinen bitti char 8 bittiä -128…+127 merkki tai etumerkillinen

kokonaisluku unsigned char 8 bittiä 0…255 merkki tai etumerkitön

kokonaisluku int 16 bittiä -32768…+32737 etumerkillinen kokonaisluku short int 16 bittiä -32768…+32737 etumerkillinen kokonaisluku signed int 16 bittiä -32768…+32737 etumerkillinen kokonaisluku unsigned int 16 bittiä 0…65535 etumerkitön kokonaisluku long int 32 bittiä -2147483648…+2147483647 etumerkillinen kokonaisluku unsigned long int

32 bittiä 0…4294967295 etumerkitön kokonaisluku

signed long int

32 bittiä -2147483648…+2147483647 etumerkillinen kokonaisluku

float 32 bittiä +/-1.175e-38…+/-3.402e38 double 32 +/-1.175e-38…+/-3.402e38 Taulukko 5.2.1. C-kielen tietotyypit. Siinä on esitelty C-kielen tavallisimmat tietotyypit, niiden muistista varaama tila ja lukualue.

Page 7: 5.2. C-kielen perusteet. 2_8

7

Ei ole järkevää käyttää liukulukuja AVR:n yhteydessä, koska AVR-ytimessä ei ole liukulukulaskentaa suorittavaa ”rautaa”. Liukuluvut on käsiteltävä ohjelmallisesti ja se syö valtavasti resursseja.

avr-gcc:n kanssa ei voi käyttää double-tarkkuuden muuttujia. Parasta mitä voi tehdä on käyttää 32-bittisiä single precision liukulukuja float.

Huom. Muuttujien koot vaihtelevat kääntimittäin ja varsinkin sulautettujen järjestelmien C-kääntimet eivät välttämättä sisällä kaikki niitä tietotyyppejä, mitä ANSI-normi edellyttää. Käytä näitä: ANSI C99 määrittelee muuttujien koot, esim. int16_t, int8_t, uint8_t, jne. Numeroarvo kertoo muuttujan koon, bittimäärän. C99 tietotyyppejä kannattaa käyttää porttaamisen (koodin siirto toiseen käännin- tai MCU-ympäristöön) helpottamiseksi. Siis silloin, jos tietotyypin koolla on merkitystä ohjelman toimintaan. int8_t (signed char) int16_t (signed int) int32_t (signed long int) int64_t (signed long long int) Vastaavasti etumerkittömät muuttujat: uint8_t (unsigned char) uint16_t (unsigned int) uint32_t (unsigned long int) uint64_t (unsigned long long int) esim. typedef signed char int8_t; se ja muut määritykset löytyvät stdint.h-headerista ja polku on C:\WinAVR-20070525\avr\include

Mitä tarkoittaa UL numeron perässä?

esim. 100000UL. Se on Unsigned long.

Merkintä ei ole case sensitive, joten voit käyttää u tai U ja l tai L.

C-kielen boolean-muuttuja varaa yhden tavun. Se on joko

0 (== false), or non-zero (== true).

Voit käyttää Boolean-muuttujaa lippuna, flag, se selviää myöhemmin.

Page 8: 5.2. C-kielen perusteet. 2_8

8

Muuttujan tyypin valinta Oikean datatyypin valinta on tärkeää (säästyy muistia ja koodi nopeutuu). 8-bittisissä sulautetuissa järjestelmissä manipuloimme tavallisimmin 8-bittisiä rekistereitä, tai I/O-liitäntöinä ulkoiseen maailmaan toimivia portteja. Silloin luonnollinen valinta on 8-bittinen tyyppi eli char. Valitse etumerkitön char, koska todennäköisemmin käytämme positiivisia lukuja ja voimme käsitellä suurempia lukuja (2 potenssiin 8 = 256) ja etumerkin testi jää pois. Jos tarvitaan suurempia lukuja kuin 255, niin silloin luonnollinen valinta on int ja taas etumerkitön, ellei toisin tarvita. Palataan koodiin. unsigned char kuvio; kuvio = 0x55;

Määritimme siis funktion alussa kuvio-nimisen muuttujan, jonka tyyppi on unsigned char eli etumerkitön merkkimuuttuja. Seuraavalla rivillä sijoitamme kuvio-muuttujaan heksa-luvun 0x55. Muistanet, että = -merkki on C-kielessä sijoitusoperaattori. PORTB = kuvio; // B-porttiin sijoitetaan kuvio-muut tujan arvo

Seuraavaksi B-porttiin sijoitetaan kuvio-muuttujan sisältö eli siis 0x55. Se on binäärisenä 0101 0101, joten joka toinen LED loistaa ja joka toinen ei. Viive kuten ennenkin, jotta ehdimme nähdä mitä tapahtuu. Käännä tämä koodi, samalla nimellä ja ohjelmoi mikro-ohjain saman tien. Nyt kuvioita on kaksi erilaista, tai oikeastaan kolme, jos ’pimeät’ lasketaan. TIETOTYYPIT

Yksinkertaiset määrittelyt perustyypit - char, unsigned char, void, int, float, double

Yksinkertaiset käyttäjän määrittämät tyypit

- typedef, enum Rakenteiset, perustyypeistä johdetut

- taulukko-vector, - tietue-structure, - yhdiste-union, - osoitin-pointer, - tiedosto, typedef struct,

Vinkki: Miten kokonaislukumuuttujasta liukulukumuuttuja? int i; double d; d = i; parempi tapa: d = (double)i;

Page 9: 5.2. C-kielen perusteet. 2_8

9

Käyttäjän itse määrittämät tyypit C-kielessä koodaaja voi luoda omia tyyppejä. Se tehdään typedef-määreellä ja apuna käytetään kirjaston standardityyppejä. Formaatti on: typedef standardi_tyyppi omatekema_tyyppi;

typedef unsigned char tavu; // luo tavu-tyypin, etu merkitön char typedef unsigned int sana; // luo sana-tyypin, etum erkitön int

Näistä myöhemmin lisää. Talletusluokat eli muistimääritteet Talletusluokalla määritetään mitkä funktiot pääsevät käsittelemään muuttujaa. Puhu-taan ns. vaikutusalueesta. Toiseksi talletusluokka määrää, miten kauan muuttuja pysyy muistissa. Talletusluokat määräytyvät sen perusteella, missä muuttuja määri-tellään ja mitä avainsanaa käytetään. Talletusluokka automaattinen, automatic Kaikki funktion sisällä esitellyt muuttujat, paikalliset muuttujat, kuten myös funktion parametrit kuuluvat oletusarvoisesti auto-luokkaan, ellei ole toisin esitelty. Automaattiset muuttujat ovat voimassa vain siinä funktiossa, missä se on määritelty. Automaattinen muuttuja ’syntyy automaattisesti’ aina kun funktiota kutsutaan ja kun funktiosta poistutaan, se myös automaattisesti häviää. SRAM-muistipaikka voidaan ottaa muuhun käyttöön. Teknisesti ajatellen; järjestelmä varaa auto-tyyppiselle muuttujalle tilaa ajonaikaisesta pinosta, run time stack, silloin, kun funktion suoritus alkaa ja vapauttaa niiden tilanvarauksen, kun funktion suoritus loppuu. Tässä on nyt ’fundeeraamisen’ paikka! Asiaan vihkiytymätön ihmettelee usein, miten mikro-ohjaimessa voi olla vain 128 tavua SRAM-muistia, siis työmuistia? (Joissakin ohjaimissa ei ole laisinkaan RAM-muistia). Edellisen perusteella ymmärrät, miksi sulautetun järjestelmän ohjelma tulee jakaa pieniin funktioihin ja käyttää vain paikallisia muuttujia. Funktio muuttujineen ’elää’ vain oman aikansa ja ’kuolee’ pois. Sitten uusi funktio omine muuttujineen ’elää’ samassa muistitilassa ja käyttää samaa pinomuistia. Teemme samalla, hyvin pienellä, pöydällä kaikki työt. Jos entiset työvälineet poistetaan aina uuden työn tullessa ja uusitaan vain työkalut, ei tarvita isoa pöytätilaa.

Auto-muuttujalla on määrittämätön (’mitä sattuu’) alkuarvo. Siksi se on aina ensiksi alustettava, eli sille on annettava jokin arvo.

Jos hieman saivarrellaan, niin oikeasti muuttujat pitäisi esitellä näin: auto int luku; Mutta kun kaikki muuttujat ovat oletusarvoisesti automaattisia, niin tyyppi auto voidaan jättää pois.

Page 10: 5.2. C-kielen perusteet. 2_8

10

Talletusluokka Static Jo haluamme käyttää funktion laskemaa muuttujan arvoa seuraavan kerran funktioon tullessamme, on meidän tehtävä muuttujasta pysyvä. Se tapahtuu lisäämällä avainsana, varattu sana, static, muuttujan tietotyypin eteen: static unsigned char kuvio; static uint8_t alku = 0x01;

Static-määrityksellä kuvattu muuttuja alustetaan kerran (ensimmäisellä käyttökerralla) ja se varaa SRAM-muistia pysyvästi eli tuhlaa muistia). Ellei sitä tehdä, käännin alustaa muuttujan nollalla. Uudelleen alustamista ei seuraavalla käyttökerralla tehdä, kuten tapahtuu muilla automaattisilla muuttujilla. Static-muuttuja säilyttää arvonsa funktion kutsukertojen välillä. Tämä on tarpeellinen ominaisuus esim. kierroslaskuria käytettäessä. Mutta huomaa, static muuttuja ei ole näkyvä muissa funktioissa, joten sitä ei voi niissä käyttää. Static-määre muuttaa muuttujan elinikää (jatkuva) ja tallennuspaikkaa (pinosta tav. käyttömuistiin). Tästä on ohjelmaesimerkki merkkitaulukoiden esittelyn yhteydessä.

Miksi ei main-funktiossa käytetä static-määrittelyä? Koska main-funktiossa määritelty muuttuja on voimassa koko ohjelman ajan, mutta se näkyy vain main-funktiolle.

Static-muuttuja on ikäänkuin ”private global variable”, omassa käytössä oleva globaali muuttuja. Vain se funktio jossa se on määritetty, ”näkee” sen ja voi sitä manipuloida. Static tyyppinen muuttuja alustetaan AINA käännösvaiheessa, eli jos sille ei anneta arvoa, c-käännin laittaa arvon nollaksi.

Globaalit ja staattiset muuttujat alustetaan systeemin puolesta nollaksi ellei ohjelmoija anna niille alkuarvoja. Automaattisia ja rekisterimuuttujia ei alusteta automaattisesti.

Talletusluokka Extern Funktiot ja globaalit muuttujat ovat ohjelmassa ’kaikkien käytössä’. Jos haluamme funktion käyttävän muuttujia, jotka on määritetty jossain toisessa tiedostossa, on kääntimelle kerrottava tämä varatulla sanalla extern. (Isoissa ohjelmissa on kymmenittäin erilaisia tiedostoja). Extern-määrittely kertoo kääntimelle, että tämän muuttujan määrittely löytyy tiedoston ulkopuolelta. Se siis viittaa olemassa olevaan ulkoiseen määrittelyyn. Extern antaa käyttää ulkoista muuttujaa, vaikka se olisi määritelty myöhemmin samassa tai eri tiedostossa. Ellei muuttujalle ole tyyppimääritystä, käännin tulkitse muuttujan tyypiksi extern int.

Page 11: 5.2. C-kielen perusteet. 2_8

11

Extern esimerkki Kirjoita seuraava koodi ja käännä se normaalisti. /************************************************** ******** Project : extern_1.c Hardware: PV-M32 + PV-LEDIT on PORTB Software: WinAVR-20081221 Date : 05.01.2008 Author : pva Comments: extern-määritys, demo *************************************************** *******/ #include <avr/io.h> #include <util/delay.h> #include "apu.h" // kerrotaan kääntimelle, että tämä tiedosto on käy tettävissä // prototyyppi void wait(uint16_t time); int main(void) { DDRB = 0xFF; // extern unsigned char luku, luku_2; // esittely, ei ole määrittely, vaan käsky etsiä mu uttujaa muualta unsigned char luku, luku_2; // aloita tällä, extern rivi kommentoitu = ei toimi // toinen ajo, kommentoi unsigned rivi // ja poista kommenttimerkit extern-rivin alusta while(1) { PORTB = 0x00; wait(200); PORTB = luku; wait(200); PORTB = 0x00; PORTB = luku_2; wait(200); } } // *** Primitive wait() *** void wait(uint16_t time) { volatile uint16_t i; for(i=0;i<2000;i++) _delay_loop_2(time); } Sitten, avaa New File = valkoinen tyhjä ”sheetti” ja kirjoita siihen seuraavat rivit: uint8_t luku = 0x01; uint8_t luku_2 = 0x80;

// määrittelyt, muistia on varattu muuttujia varten

ja talleta se projektikansioon (se on sama, missä on käännettävä lähdekoodi) nimellä apu.h

Page 12: 5.2. C-kielen perusteet. 2_8

12

Analysointi 1.) Käännä koodi ensin siten, että luku-muuttujat ovat esitelty ilman asetettua arvoa. Ohjelma kääntyy (pari varoitusta) ja kun ajat sen, niin tulostus on ”mitä sattuu” = LEDit ovat pimeitä, koska muuttujat ovat määrittämättömiä (0). 2.) Lisää sitten muuttujamääritykseen varattu sana extern poistamalla kommenttimerkit rivin alusta. Se kertoo kääntimelle, että muuttujat on määritetty jossain muualla. Käännin löytää määritykset uint8_t luku = 0x01; uint8_t luku_2 = 0x80;

apu.h-tiedostosta, joka on liitetty mukaan käännösympäristöön direktiivillä #include "apu.h"

Kun nyt käännät ja ajat koodin, tulostus toimii oikein. Extern-määritystä käytetään aina, jos ohjelma koostuu useasta eri tiedostosta. Se on hyvin yleistä sulautetuissa järjestelmissä. Rekisterimuuttujat, Register Variables Kuten AVR-mikro-ohjaimien tekniikkaa käsittelevässä luvussa kerrottiin, SRAM-muistialueeseen kuuluu erityinen rekisterialue, jossa ovat I/O-rekisterit, ajastimet ja muita erityisrekistereitä. Osa näistä rekistereistä on yleiskäyttöisiä, General Purposes Registers. CPU:n sisäisen rekisterin käyttö on huomattavasti nopeampaa kuin (ulkoisen) muistin. Rekisterin käyttö tapahtuu laittamalla avainsana register muuttujan määrittelyn eteen, esim. register char virta;

Tämä on vain ehdotus kääntimelle, sillä se saattaa tehdä sen itsekin. Käännin joko huomioi ohjeen eli register-määreen, tai jättää sen huomiotta. Riippuu tilanteesta. Sulautetuissa järjestelmissä on toisinaan tärkeää, että käännin ei käytä CPU:n rekisteriä muuttujan tallentamiseen, vaan käyttää siihen SRAM-muistipaikkaa, mutta siitä tarkemmin rekisteritason ohjelmoinnin yhteydessä.

Huomaa! register-esittelyä voidaan käyttää vain automaattisiin muuttujiin ja funktioiden muodollisiin parametreihin.

Huom!

Älä käytä register-määrittelyä c-koodin yhteydessä!!!

avr-gcc-käännin osaa itse käyttää yleisrekistereitä parhaiten.

Ainoastaan jos opiskelet assembly-koodin käyttöä, silloin voit itse määrätä mitä yleisrekistereitä käytät.

Page 13: 5.2. C-kielen perusteet. 2_8

13

Volatile Jos sulautetun systeemin koodin toiminta muuttuu oudoksi kun kytket kääntimen optimoinnin päälle tai otat keskeytyksen käyttöön, on syytä opetella tuntemaan volatile. Kun käännin saa sijoittaa haluamiaan muuttujia rekistereihin, nopeuttaa se ohjelmaa (optimointi). Mutta kun käännin on siirtänyt jonkun muuttujan CPU:n rekisteriin ja kesken kaiken tulee keskeytys joka käsittelee juuri tuota muuttujaa - siis sen muistissa olevaa versiota - on tuloksena ongelmia.

Volatile on muuttujan lisämääre joka kieltää käännintä muokkaamasta ohjelmoijan tarkoittamaa koodin toimintaa. Siis käännin ei suorita tälle muuttujalle minkäänlaista optimointia tai muuta järjestelyä.

Käyttö:

Muuttuja on määritettävä volatileksi, jos sen arvo voi muuttua koodista huolimatta.

- kun muuttujan arvo voi muuttua asynkronisesti, siis esim. kun globaalia muuttujaa muokataan keskeytysfunktiossa ja jota arvoa testataan pääkoodissa

- samoin jos käytät muistiavaruudessa olevaa oheislaitteen rekisteriä jonka arvo voi muuttua koodista huolimatta

- odotat loopissa jossa luetaan I/O-pinnin muuttumista

- tai luet timeria

- jos yleensä odotat, että jotain tapahtuu, kuten while(!jotain);

Syntaksi: volatile int arvo; int volatile arvo;

Ihan miten päin vaan. Tutki tarkemmin mallikoodia. Tässä mallikoodissa käytetään timeria, johon tuskin olet vielä perehtynyt. Mutta älä välitä siitä vaan ota koodi käyttöön, niin havaiset volatile-määrityksen merkityksen.

1. kokeile ensin ilman volatile-määritystä, ledit ova pimeitä. 2. sitten ota volatile-määre käyttöön, laskuri toimii ja ledit tulostaa.

/************************************************** ******** Project : volatile.c Hardware: PV-M322 + PV-LEDIT Software: WinAVR-20071221 Date : 7.01.2008 Author : pva Comments: volatile-demo, käyttää Timer1 overflow in terrupt Ellet määritä laskuri-muuttujaa volatileksi, käännin ei "ymmärrä" että laskuri inkrementoidaan keskeytysrutiinissa, vaan se "luulee", että muuttujan arvo pysyy vakiona . ja LEDit pysyvät pimeänä Kun määritys on volatile, koodi toimii *************************************************** *******/

Page 14: 5.2. C-kielen perusteet. 2_8

14

#include <avr/io.h> #include <avr/interrupt.h> // volatile uint16_t laskuri = 0; // globaali muutt uja uint16_t laskuri = 0; // poista volatile-määritys ja kokeile toiminta // timer_1 overflow interrupt routine ISR(TIMER1_OVF_vect) { laskuri++; // inkrementoidaan laskuria timerin yl ivuodon tapahtuessa } int main(void) { DDRB = 0xFF; TCCR1B |= 1<<CS11; // kellon jakoluku; clk/8, m uuta tätä TIMSK |= 1<<TOIE1; // T/C1 Overflow interrupt en able sei(); // globaali keskeytysten sallinta for(;;) // ikuinen silmukka { PORTB = laskuri; } } Volatile sanoo C-kääntimelle: ”Älä päästä optimoijaa muuttamaan tätä muuttujaa pitämällä sitä pelkästään AVR:n rekisterissä, koska sen arvo voi muuttua (esim. keskeytysfunktiossa). Jos pidät muuttujaa pelkästään rekisterissä, et huomaa sen muuttumista. Joten aina kun tätä muuttujaa käytetään, se on haettava SRAMmista ja palautettava sinne takaisin.

Yleinen eli globaali muuttuja, Global Variable Muuttuja voi olla myös ns. yleinen eli globaali. Globaalit muuttujat määritetään lähdekoodin alussa ennen funktioita, siis kaikkien funktioiden ulkopuolella. Huomaa, myös main-funktion ulkopuolella. Siksi globaalit muuttujat ovat voimassa (näkyviä) kaikkialla ohjelmassa. Siis käytettävissä koko koodin alueella. Jos globaalin muuttujan arvoa muutetaan, niin sen uusi arvo on siitä lähtien voimassa kaikissa ohjelman funktioissa. Ellet alusta globaalia muuttujaa, käännin tekee sen itse ja asettaa arvoksi nollan. Isoissa ohjelmissa globaalit muuttujat määritetään yhdessä erityisessä header-tiedostossa ja esitellään siellä missä niitä käytetään määreellä extern. extern int jannite;

Kun määre on extern, sillä kerrotaan kääntimelle, että muuttuja on määritetty jossain muussa moduulissa.

Page 15: 5.2. C-kielen perusteet. 2_8

15

Lisää ’fundeeraamista’! Globaali muuttuja asetetaan datamuistiin pysyvästi. Se siis varaa muistia koko ohjelman ajan. Tämä on tärkeää tietää, koska mikro-ohjaimissa on pieni SRAM-muistitila. Yleensä on syytä välttää globaalien muuttujien käyttöä. Iso ongelma saattaa syntyä siitä, että muuttujan arvoa voidaan muuttaa monesta paikkaa. Isoissa ohjelmissa ne saattavat aiheuttaa hyvinkin vaikeasti selvitettäviä virheitä. Paha kauneusvirhe on se, että funktiot eivät tällöin enää ole itsenäisiä, riippumattomia. Pienissä sovelluksissa, kuten meidän 8-bittisen mikro-ohjaimen yhteydessä, pieni SRAM-muistitila rajoittaa globaalien muuttujien käyttöä. Siksi kannattaa opetella heti alkuun oikea ohjelmointityyli ja välttää globaaleja. Jos se suinkin on mahdollista.

Globaali muuttuja - on voimassa koko ohjelman ajan ja siten se varaa

muistia kaikenaikaa - sen arvoa voi mikä tahansa funktio muuttaa,

milloin tahansa. Muuttujan ominaisuuksia Muuttujan määrittelypaikka määrää muuttujan ominaisuudet, ellei sitä ole lisämääreillä toisin kerrottu. Elinikä

- aika minkä aikana muuttujan tilanvaraus on voimassa, eli muuttuja on käytettävissä. Funktion (aliohjelma) sisällä määritelty muuttuja ”elää” vain sen ajan kuin funktion käsittely kestää. Lohkojen ulkopuolella määritetty muuttuja on globaali ja se on pysyvä (varaa muistia koko ohjelman ajan).

näkyvyys

- koodialue mistä muuttujaan voidaan viitata. Funktion sisällä määritetty muuttuja näkyy vain ko. funktion sisällä. Se on paikallinen, lokaali.

- Funktioiden ulkopuolella määritetty muuttuja on käytettävissä kaikkialla, se näkyy jokaiselle funktiolle. Se on globaali muuttuja.

- kukin funktio eli aliohjelma muodostaa oman näkyvyysalueensa. Kun kutsutaan funktiota, hypätään tämän aliohjelman näkyvyysalueelle.

tallennuspaikka

- datasegmentti SRAM-muistissa - pinomuisti (SRAM-muistissa) - rekisteri

tyyppi

- C-kielessä valmiina primitiivisiä tyyppejä, kuten int, char, float - joista voi rakentaa uusia tyyppejä, kuten taulukko, tietue

Page 16: 5.2. C-kielen perusteet. 2_8

16

Määrite Tarkoitus auto(matic) muuttujat ovat oletusarvoisesti tällaisia

määritys on voimassa vain siinä funktiossa missä se on määritelty, se on siis paikallinen - local

const muuttujan arvo on vakio register määrittelee muuttujan paikalliseksi ja määritys kehottaa käännintä

pitämään muuttujan rekisterissä. Tämä on lähinnä isojen koneitten ominaisuus, pienissä sulautetuissa järjestelmissä tätä ei tarvita, (rekisterien käyttö on oletuksena). Älä käytä sulautetuissa.

extern muuttuja tai funktio on määritelty toisessa tiedostossa static muuttuja on olemassa ohjelman suorituksen ajan

muuttuja alustetaan funktiossa kerran ja sen arvo säilyy vaikka funktiosta välillä poistutaankin käyttö: laskurit yms.

typedef tyyppimäärittely volatile arvo voi muuttua ulkoisista syistä Seuraavassa harjaannutaan edelleen käänninympäristön käyttöön ja opitaan lisää C-kielen käsitteitä, kuten * vakion määritys * operaattori * operandi

Vakio, constant Vakio on myös ohjelman käyttämä muistipaikka, mutta sen sisältöä ei voi muuttaa ohjelman ajon aikana. Vakion sisältö on, kuten nimikin sanoo, muuttumaton, staattinen. Se täytyy alustaa esittelyn yhteydessä. Miksi käytetään vakioita? Kun ryhdyt kirjoittamaan isoja ohjelmia, joissa voi olla satoja (tuhansia?) koodirivejä, niin silloin huomaat vakion määrityksen merkityksen. Sama lukuarvo saattaa esiintyä useita kertoja koodin sisällä. Jos jostain syystä em. lukuarvoa on myöhemmin muutettava, jokaisen ilmenemispaikan etsintä on työlästä. Käyttämällä vakion määritystä kerran ohjelman alussa ja sen jälkeen käytetään koodissa vain sitä. Jos myöhemmin vakion arvo täytyy jostain syystä muuttaa, riittää arvon korjaus vain yhdessä kohdassa ohjelmaa.

Page 17: 5.2. C-kielen perusteet. 2_8

17

1. Numeeriset vakiot Numeerinen vakio on arvo, joka kirjoitetaan suoraan lähdekoodiin aina tarvittaessa. Se voidaan tarpeen mukaan kirjoittaa eri muodossa. Kokonaislukuvakiot voidaan kirjoittaa: desimaaliluku, ilman etuliitettä esim. 1234 heksaluku, etuliite on 0x esim. 0xF0 oktaaliluku, etuliite on 0 esim. 0567 int kierrosluku = 12; PORTB = 0xA6; float alv_vero = 0.22; Kierrosluku ja alv_vero ovat muuttujia, porttimääritys on ns. makro. (selviää myöhemmin). Sijoitusoperaattorin (=-merkin) oikealla puolella olevat arvot ovat numeerisia vakioita. Desimaalipiste erottaa liukulukuvakion kokonaislukuvakiosta. 2. Merkkivakiot Merkkivakio voi olla tulostettava (kuten aakkoset), tai ei-tulostettava (kuten rivin vaihto new line, tabulaattori tab). Tulostettavat merkkivakiot kirjoitetaan ympäröimällä merkki heittomerkeillä, esim. ’A’, joka on heksamuodossa 0x41. Ei-tulostettavat merkkivakiot ovat ns. ohjausmerkkejä, kuten ’\n’, new line, ’\x0a’ heksalukuna, jolla siirretään kursori seuraavalle riville, tai tabulointimerkki ’\t’, heksana ’\x09’. 3. Symboliset vakiot on vakioita, joita ohjelmassa esittää nimi, symboli. Sitä ei voi ohjelman ajon aikana muuttaa. Käytön etuna on koodin selkeys. Ne otetaan esikääntimen käsittelyyn samoin kuin header-tiedostot, eli risuaitamerkillä #. #define VAKIONIMI arvo - #define, määritä, on, kuten muistanet, esikääntimen komento - käännin korvaa VAKIONIMI-tekstin arvolla arvo - define-rivi ei pääty puolipisteeseen #define JANNITE 10 - esikäännin suorittaa yksinkertaisen tekstikorvauksen, aina kun se näkee sanan JANNITE, se korvaa sen luvulla 10. Itse käännin ei näe koskaan JANNITE nimeä, vaan ainoastaan arvon 10.

Makro on esikääntimen komento. Makron nimi korvataan koodilla, joka suorittaa varsinaisen toiminnon: #define NIMI korvaus_teksti Makro kirjoitetaan tavallisesti isoilla kirjaimilla, jotta se erottuisi muista määrityksistä ja sen loppuun ei tule puolipistettä. Tässä esitetty makro on ns. yksinkertainen makro, siis pelkkä tekstikorvaus. Se voi olla myös monimutkaisempi, jolloin makro sisältää parametreja.

Page 18: 5.2. C-kielen perusteet. 2_8

18

4. Varattu sana const Varattu sana const on muunnin, jolla muuttuja määritellään const-tyyppiseksi vakioksi, sitä ei voi enää sen jälkeen ohjelmassa muuttaa. Vakiolla on myös tyyppi ja käännin tarkistaa, että sitä käytetään oikein. C-kielessä vakioita on kolme perustyyppiä: int, float ja char const int VIRTA = 9; const int KIERROSLUKU = 100; const char MERKKI = ‘U’; Const ei talleta oliota flash-muistiin vaan SRAMmiin. Se on oikeasti muuttuja jonka arvoa ei voi ohjelmassa muuttaa. Se on eräänlainen suojamekanismi. Const on hyödyllinen määre funktioiden parametrien määrityksessä, se estää funktiota muuttamasta arvoa. Globaalit vakiot tulisi tallettaa flash-muistiin käyttämällä PROGMEM-määritystä.

Globaalit vakiot tulee tallettaa ohjelmamuistiin (flash). Se tehdään komennolla: const char luku PROGMEM = 3; /* Store variable in F LASH */

Mutta näistä myöhemmin oman esimerkkikoodin avulla lisää. Palataan takaisin koodiin. Kirjoita seuraava lähdekoodi ja ennen kääntämistä analysoidaan se rivi riviltä eli selvitetään mitä ohjelma tekee. vakio.c esimerkki /************************************************** ******** Project : vakio.c HW: PV-M32 + PV-LEDIT SW: WinAVR-20070525 Date : 02.12.2007 Author : pva Comments: vakion käyttö-demo *************************************************** *******/ #include <avr/io.h> #include <util/delay.h> #define VAKIO 0x81 // vakion määritys // *** Primitive wait() *** void wait(uint16_t time) { volatile uint16_t i; for(i=0;i<2000;i++) _delay_loop_2(time); }

Page 19: 5.2. C-kielen perusteet. 2_8

19

int main(void) { uint8_t kuvio; const uint8_t LUKU = 3; // vakion määritys DDRB = 0xFF; // B-portin suunta ulos while(1) // ikuinen silmukka { kuvio = 0x02; PORTB = kuvio; // B-porttiin 0000 0010 bin wait(3000); // kulutetaan aikaa kuvio = kuvio + 5; // kuvio on 2 + 5 eli 7 PORTB = kuvio; // B-porttiin 0000 0111, eli 7 des wait(3000); kuvio = LUKU * 2; // kuvio on 3 * 2 eli 6 des PORTB = kuvio; // B-porttiin 0000 0110 wait(3000); PORTB = VAKIO; // B-porttiin 1000 0001 wait(2000); } } Main-funktiossa määritetään muuttuja, jonka nimi on kuvio ja tyyppi unsigned char. Char on lyhenne sanasta character ja se tarkoittaa merkkimuuttujaa. Char-muuttujalle käännin varaa 8 bittiä muistitilaa, jossa voi esittää 256 eri merkkiä tai lukua. Jos määritetään muuttuja pelkästään tyypiksi char kuvio , niin merkkitavun eniten merkitsevä bitti, vasemmanpuoleisin, on tällöin ns. merkkibitti. Se kertoo, onko luku positiivinen tai negatiivinen. Silloin varsinaista merkkiä varten jää vain 7 bittiä, siis 128 eri dataa, jotka voivat olla negatiivisia tai positiivisia. Rivillä const unsigned int LUKU = 3; määritetään vakio LUKU ja sille arvoksi sijoitetaan 3. Määritetään char-muuttuja kuvio unsigned char kuvio; ja while-silmukassa sijoitetaan sille arvo: kuvio = 0x02; Niin kauan kuin olemme main-funktion sisällä, kuvio-muuttujalla on määritetty arvo, ellemme sitä ohjelmassa muuta. Palataan koodiin. While-silmukassa ensiksi kuvio-muuttuja saa arvon 0x02, sitten se kirjoitetaan B-porttiin. Kolmen sekunnin viiveen jälkeen kuvio-muuttujaan lisätään luku 5 ja summa sijoitetaan kuvio-muuttujan uudeksi arvoksi. Seuraavalla rivillä kuvio-muuttujan uusi arvo sijoitetaan B-porttiin ja se näkyy loistavina LEDeinä. kuvio = LUKU * 2; // kuvio on 3 * 2 eli 6 des PORTB = kuvio; // B-porttiin 0000 0110

Page 20: 5.2. C-kielen perusteet. 2_8

20

Sitten luku-vakion arvo, joka on 3, kerrotaan luvulla 2 ja tulo sijoitetaan kuvio-muuttujan uudeksi arvoksi. Välittömästi tämän jälkeen kuvio sijoitetaan B-porttiin.

VAKIOT Arvoa ei voi muuttaa. Kirjoitusasu määrittää vakioiden tyypin: kokonaisluku on int tai long int, esim 1, 1234 desimaaliluku on float (esim 5.67) ’a’ merkit ovat char tyyppiä, hipsut ”a” ja ”abc” ovat merkkijonoja, sitaatit const int Portti=23;

Bitti ja tavu Pienin tiedon yksikkö on bitti. Se arvo voi olla nolla tai yksi, 0 tai 1. Tavu on kahdeksan bittiä. Jokainen tavun bitti voi olla 0 tai 1, joten erilaisia tavuja voi olla kaikkiaan 2 potenssin 8 eli 256 kappaletta.

Operaattorit, operators Mikro-ohjaimessa tietoa voidaan käsitellä monella eri tavalla. Ensin data pitää sijoittaa SRAM-muistiin muuttujan arvoksi ja siirtää sitten itse prosessorin tiedon käsittely-yksikköön, akkuun, tms. rekisteriin. Se tehdään sijoitusoperaattorilla. Oikeastaan sijoitus on tiedon kopiointia paikasta toiseen. Tiedon työstämiseen tarvitaan siihen tarkoitetut toimijat, operaattorit. Koska prosessori käsittelee lukuja, luonnollisesti operaattorit, jotka osaavat perusmatemaattiset toiminnot, ovat tarpeen. Kun vertaillaan kahta muuttujaa keskenään, sitäkin varten tarvitaan oma operaattori. Operaattori on nimi tai symboli toiminnolle, joka panee ohjelman tekemään jotain operandille, esimerkiksi muuttujalle. Operaattoreita on hyvin monenlaisia. Niiden tunteminen on yhtä tärkeää kuin muuttuja-käsitteen hahmottaminen. Operandi on se olio, jota operaattori operoi, käsittelee. Kaikki C-kielen operaatiot ovat lausekkeita.

- sijoitusoperaattorit - matemaattiset operaattorit - vertailuoperaattorit - loogiset operaattorit

Page 21: 5.2. C-kielen perusteet. 2_8

21

Sijoitusoperaattorit, Assignment Operators Sijoitusoperaattorilla annetaan muuttujalle arvo. C-kielen sijoitusoperaattori on matematiikan yhtäsuuruusmerkki (=)-merkki. C-kielen yhtäsuuruus on kaksi on-merkkiä yhdessä eli ( ==). Sijoitusoperaattorin formaatti: tunniste = arvo;

HUOM! Yllä oleva lauseke ei tarkoita sitä, että tunniste ja arvo olisivat yhtä suuria, vaan, että arvo sijoitetaan tunniste-muuttujan arvoksi. Sijoitusoperaattorin oikealla puolella oleva arvo, (rvalue, right value) sijoitetaan sen vasemmalla puolella olevan muuttujan arvoksi (lvalue, left value). Operaattori, operator Merkitys, Meaning Esimerkki, Example = sijoitus x = 3; Taulukko 5.2.2. Sijoitusoperaattori Esimerkki sijoitusoperaattorin käytöstä unsigned int muuttuja; /* esitellään etumerkitön kokonaislukumuuttuja nimeltä muuttuja, sen arvo on tässä vaiheessa epämääräinen, ’mitä sattuu’ */ muuttuja = 5; // sijoitus, nyt muuttujassa on arvo 5 Aritmeettiset operaattorit, Arithmetic Operators Aritmeettisilla operaattoreilla suoritetaan laskutoimituksia. Jos osaa peruslasku-toimitukset, siis yhteen-, vähennys-, jako- ja kertolaskut, niin osaa käyttää C-kielen aritmeettisia operaattoreitakin. Operaattorien suoritusjärjestys on sama kuin matematiikassa. Aritmeettiset operaattorit on esitelty taulukossa 5.2.3 Operaattori, Operator Merkitys, Meaning Esimerkki, Example + yhteenlasku, addition a = x + y; - vähennyslasku, subtraction a = x – y; * kertominen, multiplication a = x * y; / jakaminen, division a = x / y; % jakojäännös, modulus a = x % y; Taulukko 5.2.3. Aritmeettiset operaattorit Operandien (taulukon esimerkin x ja y), joita aritmeettiset operaattorit käsittelevät, täytyy olla numeerisia arvoja. Operandi on siis joko kokonaisluku, liukuluku tai merkki.

Page 22: 5.2. C-kielen perusteet. 2_8

22

Modulus- eli jakojäännösoperaattori. Jakojäännös jää, kun kokonaisluku jaetaan toisella kokonaisluvulla. Modulusoperaattori palauttaa kokonaislukujakolaskun jakojäännöksen. unsigned int jako, jaettava = 8, jakaja = 3; jako = jaettava % jakaja; // jako = 8 % 3, eli jako saa arvon 2, joka on jak ojäännös

Sijoitus- ja matemaattisten operaattoreiden yhdistäminen Ohjelmoitaessa tulee usein eteen tapaus, jossa muuttujaan lisätään jokin arvo ja tulos sijoitetaan takaisin muuttujaan. esim. virta = virta + 2;

Lisätään luku 2 muuttujaan virta ja sijoitetaan summa virta-muuttujan uudeksi arvoksi. Toinen tapa esittää sama asia: virta += 2;

Näin koodi yksinkertaistuu, mutta samalla se tulee vaikealukuisemmaksi. Operaattori Merkitys Esim. yhtä kuin += summaus ja sijoitus, addition update x += 2; x = x + 2; -= erotus ja sijoitus, subtration update x -= 2 x = x - 2; *= kertolasku ja sijoitus, multiplication

update x *= 2 x= x * 2;

/= jakolasku ja sijoitus, division update

x /= 2 x = x / 2;

%= muistinumerojako ja sijoitus, modulus update

x %= 2

x = x % 2;

<<= siirto vasemmalle ja sijoitus, left shift update

x <<= 2 kaikki bitit 2 askelta vasemmalle

>>= siirto oikealle ja sijoitus, rigth shift update

x >>= 3 kaikki bitit 3 askelta oikealle

&= bitti bitiltä AND ja sijoitus, bitwise AND update

x &= 2

|= bitti bitiltä OR ja sijoitus, bitwise OR update

x |= 2

^= bitti bitiltä XOR ja sijoitus, bitwise XOR update

x ^= 2

Taulukko. 5.2.4. Yhdistetyt sijoitusoperaattorit. Aluksi kannattaa käyttää vain yksinkertaista sijoitusoperaattoria (=). Käytä yhdistettyjä sijoitusoperaattoreita vasta, kun olet opinnoissa alkeita pidemmällä.

Page 23: 5.2. C-kielen perusteet. 2_8

23

Matemaattisten operaattoreiden käyttö Harjoituksia

1. Anna muuttujille uusia, pieniä arvoja (jotta voit seurata koodia) ja totea ohjelman eteneminen ja aritmeettisten operaattorien toiminta. Viive suuremmaksi?

2. Lisää kaksi laskutoimitusta peräkkäin samalle käskyriville. - esim. luku = luku + 3 – 2;

Vertailuoperaattorit, Relational Operators Vertailuoperaattorit vertaavat kahta arvoa keskenään, kuten ”Onko luku suurempi kuin 10?” , ”Ovatko luku_1 ja luku_2 yhtä suuria?”, ”Onko a pienempi kuin b?”. Jos vertailun tulos on tosi, lausekkeen arvo on 1, muussa tapauksessa lausekkeen arvo on nolla eli epätosi. C-kielen vertailuoperaattorit on esitelty taulukossa 5.2.5. Operaattori Merkitys Esimerkki < pienempi kuin, less than x < y <= pienempi tai yhtä suuri kuin, less than or equal to x <= y > suurempi kuin, greater than x > y >= suurempi tai yhtä suuri kuin, greater than or equal to x >= y == yhtä suuri kuin, equals x == y != erisuuri kuin, not equals x != y Taulukko 5.2.5. Vertailuoperaattorit. esim. x < y on tosi, true, jos x on pienempi kuin y, muuten se on epätosi, false. 5 < 6 on tosi. 6 > 8 on epätosi. Harjoitukset tehdään ohjausrakenteiden yhteydessä.

Page 24: 5.2. C-kielen perusteet. 2_8

24

Unaarioperaattori, Single Operand C-kieleen kuuluu ns. unaarioperaattori, se operoi vain yhtä arvoa. Niitä ovat jo edellä opittu tilde (invertoi bitit) ja tässä esiteltävät lisäys- ja vähennysoperaattorit. Lisäys- ja vähennysoperaattorit, Increment and Decrement Operators Yleisin sulautetun systeemin muuttujaan lisättävä tai siitä vähennettävä arvo on 1. C-kielessä on tähän tarkoitukseen omat operaattorit; lisäys- eli inkrementointi-operaattori (++) ja vähennys- eli dekrementointioperaattori (--). Lisäysoperaattori lisää ykkösen operandiinsa ja vastaavasti vähennysoperaattori vähentää ykkösen. Operaattori Merkitys Esimerkki ++ etuoperaattori, inkrementointi, pre increment ++x; jälkioperaattori, inkrementointi, post

increment x++;

-- etuoperaattori, dekrementointi, pre decrement

--x;

jälkioperaattori, dekrementointi, post decrement

x--;

Taulukko 5.2.6. Lisäys- ja vähennysoperaattorit. Esim. unsigned int i = 2; i++; // tarkoittaa: i = i + 1; eli i saa arvon 2 + 1 eli on 3 toinen tapa esittää sama toiminto: i += 1; i--; // tarkoittaa: i = i - 1; eli jos i on 3, niin nyt saa arvon 3-1 eli 2 toinen tapa esittää sama toiminto: i -= 1; Lisäys - ja vähennysoperaattoreita voidaan käyttää kahdella eri tavalla, ennen tai jälkeen operandin. Voidaan kirjoittaa siis joko ++i, tai i++. Etuoperaattori Jos operaattori on ennen operandia, siis kuten ++i, puhutaan etuoperaattorista. Käsky toimii niin, että ensin i-muuttujaan lisätään yksi ja vasta sitten sitä käytetään. int a, b, x = 5; a = ++x; - ensin x inkrementoidaan eli x on yhtä kuin 5+1 eli 6 ja sitten tämä 6 sijoitetaan a:n arvoksi. toinen esimerkki: kierrosluku = 2* ++i;

- ensin i = i + 1 - sitten i = i * 2 - ja sitten kierrosluku = i

Page 25: 5.2. C-kielen perusteet. 2_8

25

Jälkioperaattori Jos operaattori on operandin jälkeen, siis kuten i++, puhutaan jälkioperaattorista. Käsky toimii niin, että ensin operandia käytetään ja sitten vasta kasvatetaan sitä. int b = 5, x = 6; b = x++; - ensin arvo x sijoitetaan b:n arvoksi eli b on 6 ja sitten x inkrementoidaan eli x on 7. toinen esimerkki: kierrosluku = 2 * i++;

- ensin kierrosluku = 2 * i - sitten i = i + 1

* etuoperaattori suoritetaan ennen sijoitusta ja * jälkioperaattori suoritetaan sijoituksen jälkeen.

Yksinkertaisissa lauseissa, joissa halutaan vain muuttaa muuttujan arvoa, ei merkintätavoilla ole eroa. Mutta monimutkaisissa lauseissa järjestyksellä on merkitystä. Jos esim. yhteenlasku ja sijoitus suoritetaan samassa lauseessa, toimintojen suoritusjärjestyksellä on todella merkitystä. Joten ole tarkkana. Tässä esimerkkikoodi incrementoinnista, olen jättänyt ylimääräiset rivit pois. Täydennä ja aja koodi. int main(void) { DDRB = 0xFF; uint8_t luku = 0; while (1) { luku++; PORTB = luku; wait(50); } } Analyysi: 1. Mitä tapahtuu kun muuttuja saa arvon 0xFF?

Page 26: 5.2. C-kielen perusteet. 2_8

26

Otetaan seuraavaksi siirto-operaattori, koska sillä saadaan edelliseen liittyviä opettavaisia pikku harjoituksia. Ja toisaalta, ’pienuudestaan’ huolimatta, siirto-operaattorit tekevät sulautetuissa järjestelmissä useasti hyvinkin tarpeellisia toimintoja. Bittikohtaiset siirto-operaattorit Siirto-operaattorikäskyt siirtävät rekisterin bittejä vasemmalle tai oikealle, niin monta askelta kuin ohjausnumero edellyttää. Jos esim. siirretään bittejä yhden askeleen vasemmalle, niin äärimmäisenä vasemmalla oleva bitti 'putoaa roskakoriin' ja oikeanpuolimaiseksi bitiksi nousee 'hatusta’ nolla.

Kuva 5.2.2. Bittien siirto. Bittikohtainen siirto vasemmalle x << 1; Rekisterin bitit siirtyvät yhden askeleen vasemmalle. x << 2; Rekisterin bitit siirtyvät kahden askeleen verran vasemmalle. x = x << 1; Muuttujan x bitit siirtyvät yhden pykälän vasemmalle, oikeanpuolimaiseksi bitiksi tulee 0. Tämä on käytännössä sama kuin kertominen kahdella.

Huom! siirto-operaatio ei muuta muuttujan arvoa, ellet käytä sijoitusoperaatiota x = x >> 3;

Page 27: 5.2. C-kielen perusteet. 2_8

27

Bittikohtainen siirto oikealle x >> 1; Rekisterin bitit siirtyvät yhden askeleen oikealle. x >> 3; Rekisterin bitit siirtyvät kolme askelta oikealle. x = x >> 1; Muuttujan x bitit siirtyvät yhden pykälän oikealle, vasemmanpuolimaiseksi bitiksi tulee 0. Tämä on käytännössä sama kuin jakaminen kahdella. Käskyn toiminta selviää parhaiten tutkimalla ja ajamalla ohjelmia. Bittien siirto oikealle, esimerkki /************************************************** ******** Project : siirto_1.c Hardware: PV-M32 + PV-LEDIT on PORTB Software: WinAVR-20071221 Date : 05.01.2008 Author : pva Comments: bittien siirto oikealle *************************************************** *******/ #include <avr/io.h> #include <util/delay.h> #define WAIT(time) for(uint16_t i=0;i<2000;i++)_del ay_loop_2(time); int main(void) { DDRB = 0xFF; uint8_t bitti = 0x80; // 1000 0000 bin PORTB = bitti; WAIT(1000); while (1) { bitti = bitti >> 1; // siirretään bittejä 1 as kel oikealle // tulos asetetaan bitti-muuttujan uudeksi arv oksi PORTB = bitti; WAIT(300); } } Analysointi Kommentit ohjelmassa kertovat kaiken muun, paitsi ei vastausta kysymykseen: Miksi ensimmäisen kierroksen jälkeen LEDit pysyvät pimeinä? Muuta koodia niin, että loistava LEDi siirtyy vasemmalta oikealle uudestaan ja uudestaan.

Page 28: 5.2. C-kielen perusteet. 2_8

28

Operaattoreiden suoritusjärjestys Operaattoreilla on evaluointijärjestys, precedence, joka määrää operaattoreiden kutsujärjestyksen lausekkeessa. Jos lausekkeessa on useita samanarvoisia operaattoreita, käytetään ns. assosioituvuutta, associativity:

- yksioperandiset ja sijoitusoperaattorit evaluoidaan oikealta vasemmalle - muut vasemmalta oikealle - järjestystä voidaan muuttaa käyttämällä sulkeita

Operaattori Order of evaluation Remarks [] () -> vasemmalta oikealle Array subscript, function call - + sizeof() ! ++ -- & * ~ (cast) oikealta vasemmalle unary * / % vasemmalta oikealle binary multiplicative + - vasemmalta oikealle binary additive >> << vasemmalta oikealle siirto-operaatiot < <= > >= vasemmalta oikealle relational operators == != vasemmalta oikealle yhtäsuuruus, erisuuruus & vasemmalta oikealle bitwise AND operator ^ vasemmalta oikealle bitwise XOR | vasemmalta oikealle bitwise OR && vasemmalta oikealle Logical And operator || vasemmalta oikealle Logical Or ?: vasemmalta oikealle conditional operator = += -= *= /= %= &= -= |= <<= >>= oikealta vasemmalle assignment , oikealta vasemmalle comma, pilkku Taulukko 5.2.7. Operaattoreiden suoritusjärjestys.

Page 29: 5.2. C-kielen perusteet. 2_8

29

Sulautettujen systeemien operaattorit, yhteenveto Useimmin käytetyt operaatiot ovat:

- summaus - vähentäminen - kertominen - jakaminen

Sijoitus = PORTB = 0x55; käytetään lauseissa, joissa muuttujaan sijoitetaan lukuarvo taikka suoritetaan muu lauseke

Aritmetiikka summa + Rtot = R1 + R1; erotus - Rtot = R1 – R2; tulo * Rtot = 2*R1; osamäärä / Rtot = R1/2; jakojäännös % taajuus_ero = f%50;

* operaatiota käytetään tavallisimmissa matemaattisissa lauseissa

Vertailu

yhtäsuuri == pienempi < if (jann < vert)

suurempi > if (virta1 > virta2) yhtä suuri tai suurempi >= yhtä suuri tai pienempi <= if (x <= y)

eri suuri != if (virta1 != virta2)

vertailuoperaatioita käytetään yleensä ns haarautuvissa ohjausrakenteissa, joissa ohjelma etenee vertailun tuloksen perusteella, kuten if-ehtolause ja while-toistosilmukka

Lisäys ja vähennys lisäys, inkrementointi ++ tavu++; vähennys, dekrementointi -- teho--; askeltaa yhdellä ylös- tai alaspäin esim. rekisterin sisältöä tai muuttujan sisältöä

Loogiset operaatiot JA, AND & TAI, OR | ehdoton tai, XOR ^ invertointi ~ siirto vasemmalle << siirto oikealle >> Esim. 8 bit tavujen , rekisterien tai muuttujien sisällön muokkaaminen tavallisilla digitaalitekniikan operaatioilla. Näitä operaatioita käytetään sulautettujen järjestelmien ohjelmoinnissa.

Loogiset JA-operaatio && TAI-operaatio || EI, NOT ! operaatioita käytetään yhdistämään vertailuoperaatioita. Älä sekoita näitä edellisiin operaattoreihin.

Page 30: 5.2. C-kielen perusteet. 2_8

30

Varatut sanat Varattuja sanoja C-kielessä on 32 kpl. Joku niistä määrää CPU:n tekemään jotain erikoista, toisia yhdessä muiden kanssa kertomaan ohjelmalle mitä tehdä, joitakin et tule käyttämään milloinkaan. Varatut sanat kirjoitetaan pienellä. Niitä ei saa käyttää muuhun kuin varattuun tarkoitukseen. Vältä varattuja sanoja muistuttavia muuttujanimiä. auto break case char const continue default do double else enum extern float for goto if int long register return short signed sizeof static struct switch typedef union unsigned void volatile while