Vaja 0: Razvojno okolje & C
Namen tokratne vaje je, da spoznate delo z razvojnim okoljem, ki ga bomo uporabljali celoten semester. Hkrati bomo še osvežili znanje programskega jezika C s poudarkom na nekaterih sklopih, ki bodo za nas pomembnejši.
Priprava okolja in projekta
Razvojno okolje namestite in ustvarite nov projekt po navodilih v poglavju STM32CubeIDE oziroma VS Code, če ste se odločili za VS Code.
Na tokratni vaji nas bo zanimala predvsem datoteka main.c, ki vsebuje tudi vsem dobro znano funkcijo main().

Razhroščevanje / debuggiranje
Za začetek bomo vsebino datoteke main.c zamenjali s spodnjimi vrsticami:
#include "main.h"
int a = 1;
float b = 3.14;
int main(void)
{
int i = 0;
i++;
a = a + 3;
b = b * 2;
while (1) {
i--;
b += 0.01;
}
}Projekt bomo naložili na razvojno ploščo. Ploščo priključite ter projekt prevedite in zaženite v načinu za razhroščevanje, kot je opisano v razdelku Zagon projekta za STM32CubeIDE oziroma v 7. koraku navodil za VS Code.
Če ste uspešno sledili korakom, boste opazili, da je prva vrstica znotraj funkcije main() obarvana. Program se je uspešno prevedel in naložil na ploščo, debugger pa je program ustavil pred prvo vrstico.

V programu imamo nekaj globalnih in lokalnih spremenljivk, katerih vrednost bomo sedaj skušali spremljati. Če ste vajeni debuggiranja z ukazi printf(), print() in kar še obstaja podobnih funkcij v drugih jezikih, vas moramo na tej točki malo razočarati. Za nadziranje vrednosti bomo primorani uporabiti bolj resne pristope k debuggiranju. Če ste že kdaj debuggirali v kakšnem orodju za poljuben programski jezik, vam bo nekaj naslednjih stavkov že zelo znanih, sicer pa predlagamo, da jim podrobno sledite.
Opis v nadaljevanju se nanaša na STM32CubeIDE. Če uporabljate VS Code, najdete podobne zavihke (Variables, Watch, Breakpoints) v pogledu Run and Debug na levi strani, gumbi za izvajanje programa pa so v plavajoči orodni vrstici na vrhu okna. Nekatere možnosti so drugače poimenovane.
Na desni strani lahko vidite različne možnosti, ki nam jih ponuja orodje (slika spodaj). Zavihek Variables nam prikazuje vrednosti lokalnih spremenljivk, zaenkrat je tam zapisana spremenljivka i. Ker nismo izvedli še nobene vrstice funkcije main(), njena vrednost še ni nastavljena in je lahko poljubna (na sliki je to 0). Zavihek Breakpoints nam izpiše mesta, na katera smo postavili t. i. breakpointe, to so točke, na katerih želimo, da se naš program ustavi. Te dodamo tako, da kliknemo v modro obarvan prostor ob številkah vrstic.

Zavihek Expressions lahko uporabimo za spremljanje globalnih ali lokalnih spremenljivk oz. izrazov, ki uporabljajo spremenljivke. Če izberete Add new expression in dodate a, a + 5 in b, bi morali videti vrednosti, kot so zapisane na sliki spodaj. Vrednosti spremenljivk v zavihkih Variables in Expressions se osvežijo, ko se program ustavi.

Zakaj pri b vrednost ni točno 3.14?
Zavihek Live expressions pa ponuja spremljanje vrednosti globalnih spremenljivk kar med izvajanjem programa. Zavihka Registers in SFRs ponujata spremljanje vrednosti registrov mikrokrmilnika pa tudi spremljanje registrov različnih naprav. Več o tem v naslednjih tednih.
Za izvajanje programa imamo na voljo gumbe, ki se nahajajo nad oknom z izvorno kodo (glej sliko spodaj).

Prvi gumb z leve Terminate and Relaunch bo ustavil debug način in ponovno naložil program. Sledi mu gumb Resume, ki bo sprožil izvajanje programa. Program se bo ustavil le v primeru, da naleti na breakpoint ali kliknemo gumb Pause, ki se nahaja desno od gumba Resume. Naslednja gumba Terminate in Disconnect na različna načina ustavita debug način. Preostali gumbi so namenjeni koračnemu pomikanju po programu. Step Into bo izvedel eno vrstico in se ustavil pred naslednjo. Če je v tej vrstici klic funkcije, se bo debuggiranje naprej izvedlo znotraj funkcije. Step Over bo ravno tako izvedel naslednjo vrstico, le da se debuggiranje nadaljuje v funkciji, v kateri se trenutno nahajamo. Morebiten klic funkcije se bo izvedel v celoti. Step Return, ki je zadnji gumb na voljo v orodni vrstici, pa bo izvedel preostanek funkcije, v kateri se nahajamo, ter se ustavil v vrstici za klicem funkcije, v kateri smo se pred tem nahajali.
S kliki gumba Step Over izvedite vrstice 8 do 11. Preglejte zavihka Variables in Expressions, kjer boste sedaj našli nove vrednosti za spremenljivke. V zavihek Live expressions dodajte spremenljivko b in nato kliknite gumb Resume. Vrednost spremenljivke b se bo hitro osveževala, medtem ko vrednosti v ostalih zavihkih med izvajanjem niso dostopne. Čez nekaj časa z gumbom Pause ustavite program in preglejte še vrednosti v ostalih zavihkih. Če kliknete na katerokoli spremenljivko v oknih za spremljanje njihove vrednosti, boste lahko videli tudi njihov zapis v različnih številskih sistemih in oblikah zapisov.
Pod Default je vidna dejanska vrednost števila s plavajočo vejico. Zakaj je vrednost pod Decimal tako drugačna? Kako je to program “izračunal” oz. kaj predstavlja?
Preostanek gradiva je namenjen ponovitvi programskega jezika C.
Podatkovni tipi, definirani v stdint.h
Pri tej vaji in v nadaljevanju semestra bomo veliko uporabljali t. i. standardne celoštevilske podatkovne tipe (angl. Standard Integer Types), ki so definirani po standardu C99. Njihove definicije se nahajajo v zaglavni datoteki (angl. header file) <stdint.h>. Tipi imajo obliko intN_t (za predznačena cela števila) in uintN_t (za nepredznačena/unsigned cela števila), kjer je N lahko 8, 16, 32 in ponekod tudi 64.
Na voljo imamo torej tipe uint8_t, int8_t, uint16_t, int16_t, uint32_t, int32_t in na določenih sistemih tudi uint64_t, int64_t.
Uporabljali jih bomo vedno, kadar bo pomembno, koliko bitov ima spremenljivka, s katero operiramo. Na primer pri delu z registri naprav. Za osnovne podatkovne tipe, kot je int, namreč nimamo zagotovila o številu bitov, ki jih za njih uporabimo na ciljnem sistemu. Večinoma sicer spremenljivke tipa int zasedejo 32 bitov, vendar ne nujno vedno. Zaglavna datoteka pa bo poskrbela, da imajo zgoraj našteti tipi vedno toliko bitov, kot je zapisano v imenu tipa.
V funkcijo main() dodajte spodnje vrstice in preglejte, kakšne so njihove vrednosti. Ne pozabite dodati #include <stdint.h>. Če vas je kakšna vrednost presenetila, si skušajte razjasniti, zakaj je drugačna od pričakovanj.
int8_t v = 50;
int8_t w = 129;
uint8_t p = 1;
int16_t t = -1;
int32_t k = -1;
int16_t r = 0b1001;
uint32_t x = 0x12345678;Kazalci
Kazalci v jeziku C so pogosto trn v peti vsakega študenta. Pri predmetu Organizacija računalniških sistemov s kazalci ne bomo ustvarjali kompleksnih podatkovnih struktur, ampak bomo uporabljali njihov primarni namen – kazanje na specifični naslov. Kazalec je namreč zgolj spremenljivka, katere vrednost ni neka poljubna številka, ampak predstavlja naslov. Tip kazalca nam pove, kakšnega tipa je spremenljivka, ki se nahaja na naslovu, ki je “shranjen” v kazalcu.
Kazalec definiramo tako, da poleg tipa dodamo zvezdico. int* predstavlja kazalec na spremenljivko tipa int. Naslov torej kaže na 4 bajte, katerih vrednost predstavlja predznačeno celo število. Če imamo spremenljivko a definirano kot int a = 4;, kazalec na spremenljivko dobimo z ukazom int *p = &a;. Znak & pred imenom spremenljivke namreč vrača njen naslov. Spodaj je podana koda običajnih ukazov, ki jih izvajamo s kazalci. Razlaga je podana v komentarjih:
// definiramo kazalec
int *p;
// definiramo spremenljivko
int a = 26;
p = &a; // kazalec kaze na a, recimo, da se nahaja na naslovu 0x200
*p = 12; // vrednost na naslovu 0x200 nastavimo na 12, kar pomeni, da je vrednost a 12
*(p+1) = 7; // vrednost na naslovu 0x204 nastavi na 7
// v zgornjem primeru s povecavo kazalca za 1 pridemo do naslova 0x204 (0x200 + 0x4), do stirice pridemo, ker je na naslovu 0x200 spremenljivka tipa int, ki zaseda 4 bajte
// pozor: na naslovu 0x204 ni nase spremenljivke, zato s tem vpisom lahko povozimo kaj drugegaKazalce bomo pri ORS uporabljali predvsem takrat, ko bomo želeli pisati na točno določene naslove. Ali pa, ko bomo želeli, da funkcija spreminja vrednost podanega argumenta. Primer takšne uporabe je prikazan spodaj. Funkciji fun_value podamo vrednost spremenljivke x, ki jo potem v funkciji spremenimo. Ker je bila spremenljivka podana kot vrednost, se ta sprememba ne pozna v funkciji, ki kliče fun_value. V primeru, da si želimo takšnega obnašanja, moramo argument x podati kot kazalec, v funkciji pa spreminjati vrednost na naslovu, na katerega kaže ta kazalec. Tak primer je prikazan v funkciji fun_reference.
void fun_value(int a) {
// ...
a = 4;
// ...
}
void fun_reference(int* a) {
// ...
*a = 7;
// ...
}
int main() {
int x = 1;
fun_value(x);
// x je tu se vedno 1
fun_reference(&x);
// x je sedaj 7 tudi v main funkciji
}Strukture
Struktura v jeziku C je zbirka spremenljivk (elementov), ki so lahko različnih tipov.
struct circle {
int x;
int y;
uint32_t z;
uint16_t a;
uint16_t b;
double c;
};
struct circle a;
a.x = 4;
a.y = 6;
struct circle *b;
b = &a;
b->x = 3;
b->y = 7;Posebnost struktur, ki jo bomo s pridom izkoriščali tekom semestra, je ta, da se elementi strukture v pomnilniku nahajajo zaporedno, v vrstnem redu, v katerem so deklarirani. Če se zgornja struktura začne na naslovu 0x200, potem vemo, da se element x nahaja na naslovu 0x200, element y na naslovu 0x204, element z na naslovu 0x208, element a na naslovu 0x20C, element b na naslovu 0x20E ter element c na naslovu 0x210.
Pri tem moramo biti previdni, saj mora biti vsak element poravnan na naslov, ki je večkratnik njegove velikosti. Če temu ni tako, prevajalnik med elemente vstavi neuporabljene bajte (angl. padding). V zgornjem primeru se to ne zgodi, saj je element c (8 bajtov) ravno na naslovu 0x210, ki je deljiv z 8. Če bi element b izpustili, bi bil c na naslovu 0x210 in ne 0x20E.
Druga posebnost struktur je njihova uporaba v kombinaciji s kazalci. Kazalec na strukturo definiramo enako kot vsak drug kazalec, kar lahko vidite v zgornjem primeru. Naivno bi tako lahko pričakovali, da bomo do posameznih elementov dostopali z *b.x = 3;. Težava nastopi, ker ima pika višjo prioriteto od operatorja *, zato bi to morali zapisati kot (*b).x, kar pa je precej neberljivo in zoprno za pisati. Namesto tega uporabimo bolj pregledno obliko s puščico: b->x.
Bitne operacije
C omogoča naslednje operacije nad biti: - bitni in: x & y - bitni ali: x | y - bitni xor: x ^ y - bitna negacija: ~x - pomik bitov v desno: x >> 2 - pomik bitov v levo: x << 3
Pri pomiku bitov v levo se izpraznjeni bit vedno postavi na vrednost 0. Pri pomiku v desno se na izpraznjeno mesto pri nepredznačenih številih vpiše ničla, pri predznačenih pa se na izpraznjeno mesto vpiše vrednost najvišjega bita (predznaka). Slednje velja za prevajalnik GCC, ki ga uporabljamo; standard jezika C pomik negativnih predznačenih števil v desno prepušča prevajalniku. Bitne operacije so pri delu z mikrokrmilniki nepogrešljive. Z njimi bomo izvajali predvsem naslednje operacije:
Postavi bit (Set Bits)
Pogosto bomo želeli bit b_i v n-bitni spremenljivki spremeniti v enico, pri tem pa ostale bite ohraniti v istem stanju. Na ta način bomo na primer prižgali LED, zagnali motorček itd. To najlažje dosežemo z operacijo ali a = a | x;, kjer je x konstanta, v kateri je zgolj bit b_i nastavljen na 1. Takšno število najlažje ustvarimo tako, da enico pomaknemo za i mest v levo. Ukaz, ki v spremenljivki a nastavi bit b_i, je tako:
a = a | (1 << i);Pobriši bit (Reset Bits)
Seveda bomo želeli na enak način bite tudi pobrisati oz. ponastaviti, torej vrednost bita b_i v n-bitnem številu spremeniti v ničlo, ostale bite pa ohraniti v istem stanju. Najenostavneje to dosežemo z operacijo in – a = a & x;, kjer je x konstanta, v kateri je zgolj bit b_i nastavljen na 0, ostali biti pa na 1. Takšno konstanto najlažje ustvarimo tako, da enico pomaknemo za i mest v levo, kot v prejšnjem primeru, nato pa dobljeno konstanto negiramo. Ukaz, ki spremenljivki a pobriše bit b_i, je tako:
a = a & ~(1 << i);Negiraj bit (Toggle Bits)
Z operacijo negacije obrnemo vrednost posameznega bita, pri čemer stanje ostalih bitov ohranimo. To dosežemo na enak način kot pri postavljanju bita, le da namesto operacije ali uporabimo operacijo ekskluzivni ali xor:
a = a ^ (1 << i);Testiraj bit (Test Bits)
Velikokrat nas bo zanimala vrednost bita b_i v n-bitni spremenljivki. Na ta način bomo na primer ugotavljali, ali je gumb pritisnjen ali spuščen. Najenostavnejši postopek za testiranje vrednosti bita b_i je:
// testiraj bit i
a & (1 << i);
// primer testiranja bita j
if (a & (1 << j)) {
// ce je j-ti bit enica
} else {
// ce je j-ti bit nicla
}Naloga 0
Implementirajte naslednje funkcije:
uint32_t reset_bit(uint32_t x, uint8_t p)– resetiraj p-ti bit spremenljivke x.uint32_t reset_two_bits(uint32_t x, uint8_t p)– resetiraj bita p in p+1 spremenljivke x.uint32_t set_bit(uint32_t x, uint8_t p)– postavi p-ti bit spremenljivke x.uint32_t set_two_bits_to(uint32_t x, uint8_t p, uint8_t n)– bita p in p+1 spremenljivke x nastavi na vrednost n – možne vrednosti so od 0 do 3.void set_vector_length(struct vector *a), ki prejme kazalec na strukturostruct vectors tremi elementi:x,y,length. Prva dva elementa sta predznačeni celi števili,lengthpa število v plavajoči vejici. Funkcijaset_vector_lengthna podlagi vrednostixinyizračuna dolžino vektorjalength = sqrt(x^2+y^2)in jo zapiše vlength. Funkcija nič ne vrača.
uint32_t a;
uint32_t b;
a = 0xf;
b = reset_bit(a, 2); // 0xB
a = 0xA;
b = reset_bit(a, 0); // 0xA
a = 0xFF;
b = reset_two_bits(a, 3); // 0xE7
a = 0xB7;
b = reset_two_bits(a, 3); // 0xA7
a = 0xB;
b = set_bit(a, 0); // 0xB
a = 0xE;
b = set_bit(a, 2); // 0xE
a = 0xEF;
b = set_two_bits_to(a, 3, 1); // 0xEF
a = 0xB7;
b = set_two_bits_to(a, 3, 2); // 0xB7
struct vector c;
c.x = 4;
c.y = -2;
set_vector_length(&c);
// c.length = 4.47