Procesory DSP do sterowania
Procesory DSP do sterowania
urządzeń przemysłowych
urządzeń przemysłowych
Język C
Język C
WYKA
AD III
dr inż. Adam Penczek
dr inż. Adam Penczek
mgr inż. Marcin Baszyński
mgr inż. Marcin Baszyński
[e-mail]
[e-mail]
AGH KANiUP budynek B1 p. 16
Plan prezentacji
Plan prezentacji
º% Podstawy jÄ™zyka C.
º% Podstawy jÄ™zyka C.
Podstawowe informacje o kodzie z
ródłowym
Podstawowe informacje o kodzie z
ródłowym
Składnia języka
Składnia języka
Definicje zmiennych
Definicje zmiennych
Definicje własnych typów zmiennych
Definicje własnych typów zmiennych
Operacje arytmetyczne i logiczne
Operacje arytmetyczne i logiczne
Instrukcje
Instrukcje
Definicje funkcji
Definicje funkcji
Podstawowe informacje o kodzie
Podstawowe informacje o kodzie
z
ródłowym
z
ródłowym
1. int
2. Liczba
int Liczba;
3. ;
char Znak;
4. char
5. Znak
6. ;
Przejrzystość programu
int Licznik; // Licznik pozycji
int Licznik; /*
Licznik pozycji
*/
Liczba= (a*b)/\
Liczba= (a*b)/c;
c;
Jednostki leksykalne
Jednostki leksykalne
º%SÅ‚owa kluczowe
º%SÅ‚owa kluczowe
º%Identyfikatory
º%Identyfikatory
º%StaÅ‚e
º%StaÅ‚e
º%LiteraÅ‚y Å‚aÅ„cuchowe
º%LiteraÅ‚y Å‚aÅ„cuchowe
º%Operatory
º%Operatory
º%Znaki przystankowe
º%Znaki przystankowe
SÅ‚owa kluczowe
SÅ‚owa kluczowe
Specjalne identyfikatory zarezerwowane dla ściśle określonych celów i
Specjalne identyfikatory zarezerwowane dla ściśle określonych celów i
mogą być wykorzystywane tylko zgodnie z ich przeznaczeniem
mogą być wykorzystywane tylko zgodnie z ich przeznaczeniem
ustalonym przez definicję języka C.
ustalonym przez definicję języka C.
NIE mogą być redefiniowane przez programistę.
NIE mogą być redefiniowane przez programistę.
asm(" mov SP, #0x400");
asm(" mov SP, #0x400");
for (i= 0; i< k; ++i)
for (i= 0; i< k; ++i)
{
{
&
&
if (n> 100) continue;
if (n> 100) continue;
&
&
};
};
Identyfikatory
Identyfikatory
Identyfikator składa się z małych lub/i z dużych liter, cyfr, znaku
Identyfikator składa się z małych lub/i z dużych liter, cyfr, znaku
podkreślenia. Pierwszy znak nie może być cyfrą.
podkreślenia. Pierwszy znak nie może być cyfrą.
np.
np.
_DSP
_DSP
dsp_0
dsp_0
Dsp_0
Dsp_0
Znaki przystankowe
Znaki przystankowe
1. [] nawiasy kwadratowe
6. : dwukropek
char str[20];
start:
int tab[10][5];
a= c* y;
tab[10][2]= 10;
7. & wielokropek
funkcja(int x, & );
2. () nawiasy okrągłe
p= 0.5* (a+ b);
8. * znak gwiazdki
funkcja();
int *w
3. {} nawiasy klamrowe
a= c* y
if (x!= y)
9. = znak równości
{p= x;
int tab[2]= {1, 2, 3};
d= a+ x;}
a= c* y;
4. , przecinek
funkcja(x, y, z);
10. # dyrektywy preprocesora
#include
5. ; średnik
#define True 1
a= c* y;
Struktura programu C
Struktura programu C
Modułowa budowa programu
//najprostszy moduł w języku C
int n;
Dołączanie modułu do programu
#include
#include  nazwa_modulu
Najprostszy wykonywalny program C
main ()
{
}
Typy i zmienne całkowite
Typy i zmienne całkowite
º% SÅ‚owa kluczowe okreÅ›lajÄ…ce typy caÅ‚kowite
º% SÅ‚owa kluczowe okreÅ›lajÄ…ce typy caÅ‚kowite
char - typ znakowy
char - typ znakowy
int - typ całkowity
int - typ całkowity
long - typ całkowity, tzw. długich liczb
long - typ całkowity, tzw. długich liczb
signed - liczby ze znakiem
signed - liczby ze znakiem
short - typ krótkich liczb całkowitych
short - typ krótkich liczb całkowitych
unsigned - liczby bez znaku
unsigned - liczby bez znaku
º% Deklaracje zmiennych
º% Deklaracje zmiennych
char a; // zmienna a typu signed lub unsigned
char a; // zmienna a typu signed lub unsigned
signed char c; // znak reprezentowany jako liczba z znakiem
signed char c; // znak reprezentowany jako liczba z znakiem
short d; //krótka liczba całkowita
short d; //krótka liczba całkowita
long int e; // długa liczba całkowita z znakiem
long int e; // długa liczba całkowita z znakiem
long unsigned int f; //długa liczba całkowita bez znaku
long unsigned int f; //długa liczba całkowita bez znaku
º% Deklaracja zmiennych z wartoÅ›ciÄ… poczÄ…tkowÄ…
º% Deklaracja zmiennych z wartoÅ›ciÄ… poczÄ…tkowÄ…
char a= 65; // równoważne przypisaniu a=  A ;
char a= 65; // równoważne przypisaniu a=  A ;
Typy rzeczywiste
Typy rzeczywiste
º% SÅ‚owa kluczowe okreÅ›lajÄ…ce typy rzeczywiste
º% SÅ‚owa kluczowe okreÅ›lajÄ…ce typy rzeczywiste
float - typ rzeczywisty pojedynczej precyzji
float - typ rzeczywisty pojedynczej precyzji
double - typ rzeczywisty podwójnej precyzji
double - typ rzeczywisty podwójnej precyzji
º% Deklaracje zmiennych
º% Deklaracje zmiennych
float x= 29.16e10; //wartość 29.16*1010
float x= 29.16e10; //wartość 29.16*1010
double y= .22-10; // wartość 0.22*10-10
double y= .22-10; // wartość 0.22*10-10
long double z= -0.77e-200L; //wartość -0.77*10-200
long double z= -0.77e-200L; //wartość -0.77*10-200
Typy i zmienne wskaz
nikowe
Typy i zmienne wskaz
nikowe
Deklaracja zmiennej wskaz
nikowej
Deklaracja zmiennej wskaz
nikowej
int *wsk_liczby; //wskaz
nik na liczbę całkowitą
int *wsk_liczby; //wskaz
nik na liczbę całkowitą
Zmienna
wskazywana
Wskaz
nik
char (*wsk_tablicy)[2][2]; // wskaz
nik na dwuwymiarowÄ…
char (*wsk_tablicy)[2][2]; // wskaz
nik na dwuwymiarowÄ…
// tablicÄ™ typu char
// tablicÄ™ typu char
Char
Wskaz
nik
s
e
r
d
A
s
e
r
d
A
char *wsk_tablicy[2][2]; // dwuwymiarowa tablica
char *wsk_tablicy[2][2]; // dwuwymiarowa tablica
//wskaz
ników na typ char
//wskaz
ników na typ char
Zmienna
Zmienna
wskazywana
wskazywana
Zmienna
Zmienna
wskazywana
wskazywana
wskaz
nik
int **wks_wsk; // zmienna wskazujÄ…ca wskaz
nik
// liczby typu int
Zmienna
wskazywana
Wskaz
nik
Wskaz
nik
A
s
d
e
r
r
e
d
s
A
A
s
d
e
r
r
es
d
A
s
e
r
d
A
s
e
r
d
A
Dostęp do elementów tablicy
Dostęp do elementów tablicy
º%Deklaracja tablicy
º%Deklaracja tablicy
int tab[20]; // tablica 20 elementów typu int
int tab[20]; // tablica 20 elementów typu int
º%DostÄ™p do tablicy
º%DostÄ™p do tablicy
przez indeksowanie
przez indeksowanie
º%tab[10]= 100;
º%tab[10]= 100;
przez wskaz
nik
przez wskaz
nik
º%*(tab+ 10)= 100;
º%*(tab+ 10)= 100;
Stałe
Stałe
º%Definiowanie staÅ‚ych,
º%Definiowanie staÅ‚ych,
słowo kluczowe CONST
słowo kluczowe CONST
const int C= 100;
const int C= 100;
int * const p = &x;
int * const p = &x;
const int * q = &x;
const int * q = &x;
Deklaracja struktur
Deklaracja struktur
º% Schemat deklaracji struktury
º% Schemat deklaracji struktury
struct identyfikator-typu-struktury
struct identyfikator-typu-struktury
{
{
deklaracja składowych //pola struktury
deklaracja składowych //pola struktury
} [identyfikator-struktury= [inicjator, & ]];
} [identyfikator-struktury= [inicjator, & ]];
Przykład:
Przykład:
struct point
struct point
{
{
int x, y;
int x, y;
} s1={4, 5}; // koniec deklaracji struktury
} s1={4, 5}; // koniec deklaracji struktury
struct point WSP0= {1, 2}; // deklaracja zmiennej
struct point WSP0= {1, 2}; // deklaracja zmiennej
struct point *WSP1; // deklaracja wskaz
nika do struktury
struct point *WSP1; // deklaracja wskaz
nika do struktury
Dostęp do pól struktury:
Dostęp do pól struktury:
s1.x= 250;
s1.x= 250;
WSP0.y= 250;
WSP0.y= 250;
WSP1->y= 250;
WSP1->y= 250;
Deklaracja unii
Deklaracja unii
º% Schemat deklaracji unii
º% Schemat deklaracji unii
union identyfikator-typu-unii
union identyfikator-typu-unii
{
{
deklaracja składowych //pola unii
deklaracja składowych //pola unii
} [identyfikator-struktury= [inicjator, & ]];
} [identyfikator-struktury= [inicjator, & ]];
Przykład:
Przykład:
union ex_union
union ex_union
{
{
double x;
double x;
long y;
long y;
} s1={4.55}; // koniec deklaracji unii
} s1={4.55}; // koniec deklaracji unii
union ex_union WSP0= {1.01}; // deklaracja zmiennej
union ex_union WSP0= {1.01}; // deklaracja zmiennej
union ex_union *WSP1; // deklaracja wskaz
nika do unii
union ex_union *WSP1; // deklaracja wskaz
nika do unii
Pola bitowe
Pola bitowe
º%PrzykÅ‚ad deklaracji pól bitowych
º%PrzykÅ‚ad deklaracji pól bitowych
struct status
struct status
{
{
signed a:5;
signed a:5;
signed :3;
signed :3;
unsigned b:4;
unsigned b:4;
unsigned c:2;
unsigned c:2;
unsigned d:2;
unsigned d:2;
} st_0;
} st_0;
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
dc b a
º%Zadanie:
º%Zadanie:
Wpisać do pola  d (bity 15 i 14) wartość 0b01;
Wpisać do pola  d (bity 15 i 14) wartość 0b01;
załączyć bit 14 i wyłączyć bit 15;
załączyć bit 14 i wyłączyć bit 15;
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
dc b a
RozwiÄ…zanie
RozwiÄ…zanie
st_0.d= 1;
st_0.d= 1;
Konwersja typów
Konwersja typów
º%Konwersja niejawna
º%Konwersja niejawna
int x= 65000, z=65000;
int x= 65000, z=65000;
long int y;
long int y;
y= x; // wyrażenie poprawne
y= x; // wyrażenie poprawne
º%Konwersja jawna
º%Konwersja jawna
y= (long int) x* z;
y= (long int) x* z;
Operatory arytmetyczne
Operatory arytmetyczne
º% Operatory addytywne
º% Operatory addytywne
op1 + op2 // dodawanie
op1 + op2 // dodawanie
op1  op2 // odejmowanie
op1  op2 // odejmowanie
º% Operatory inkrementacji i dekrementacji
º% Operatory inkrementacji i dekrementacji
Przedrostkowy --op ++op
Przedrostkowy --op ++op
Przyrostkowy op-- op++
Przyrostkowy op-- op++
Przykład
Przykład
int m=3, n=1, r;
int m=3, n=1, r;
r= (m++)+ (++n);
r= (m++)+ (++n);
int m=3, n=1, r;
int m=3, n=1, r;
r= (++m)+ (++n);
r= (++m)+ (++n);
º% Operatory multiplikatywne
º% Operatory multiplikatywne
op1 * op2 // mnożeni
op1 * op2 // mnożeni
op1 / op2 // dzielenie
op1 / op2 // dzielenie
op1 % op2 // reszta z dzielenia
op1 % op2 // reszta z dzielenia
Operatory bitowe
Operatory bitowe
º%Operatory funkcji binarnych
º%Operatory funkcji binarnych
op1 & op2 //op1 AND op2
op1 & op2 //op1 AND op2
op1 ^ op2 //op1 EXOR op2
op1 ^ op2 //op1 EXOR op2
op1 | op2 //op1 OR op2
op1 | op2 //op1 OR op2
~op1 //NOT op1
~op1 //NOT op1
Przykład
Przykład
int x= 2, y=1; //x= 0b010; y=0b001
int x= 2, y=1; //x= 0b010; y=0b001
x= x & y; // x = 0;
x= x & y; // x = 0;
Operatory logiczne
Operatory logiczne
º% Operatory i wyrażenia logiczne
º% Operatory i wyrażenia logiczne
Op1 && op2 // koniunkcja
Op1 && op2 // koniunkcja
Op1 || op2 // alternatywa
Op1 || op2 // alternatywa
!op1 // negacja
!op1 // negacja
Przykład:
Przykład:
if (x< t && x> s && !z) || (z)
if (x< t && x> s && !z) || (z)
return 1 // True
return 1 // True
else
else
return 0 // False
return 0 // False
Uwaga:
Uwaga:
int c, x= 1, y= 2; // binarnie x= 0b001; y= 0b010;
int c, x= 1, y= 2; // binarnie x= 0b001; y= 0b010;
c= x & y; // c= 0
c= x & y; // c= 0
c= x && y; // c= 1
c= x && y; // c= 1
Operatory przesunięcia
Operatory przesunięcia
º%Wyrażenie z operatorami przesuniÄ™cia
º%Wyrażenie z operatorami przesuniÄ™cia
Op1 << op2 // przesuń op1 w lewo o op2 bitów
Op1 << op2 // przesuń op1 w lewo o op2 bitów
Op1 >> op2 // przesuń op1 w prawo o op2 bitów
Op1 >> op2 // przesuń op1 w prawo o op2 bitów
Przykład:
Przykład:
int a, b;
int a, b;
a= 2; // a= 2; 0b00000010
a= 2; // a= 2; 0b00000010
b= a << 2; // b= 8; 0b00001000
b= a << 2; // b= 8; 0b00001000
a= 45; // a= 45; 0b00101101
a= 45; // a= 45; 0b00101101
b= a >> 1; // b= 22; 0b00010110
b= a >> 1; // b= 22; 0b00010110
Instrukcje warunkowe
Instrukcje warunkowe
º% Instrukcja  jeÅ›li
º% Instrukcja  jeÅ›li
if (wyrażenie-warunkowe) instrukcje [else instrukcje]
if (wyrażenie-warunkowe) instrukcje [else instrukcje]
przykład:
przykład:
Czy
A<>10
if (a!= 10)
if (a!= 10)
if (b<10)
if (b<10)
c+= a+ b;
c+= a+ b;
else c= 0;
else c= 0;
Czy
C=10
B<10
if (a!= 10)
if (a!= 10)
{
{
C= C+ a+ b
if (b<10)
if (b<10)
c+= a+ b;
c+= a+ b;
} else c= 0;
} else c= 0;
BÅ‚Ä…d !!!
TAK
NI
K
E
A
T
N
I
E
º% Instrukcja wyboru
º% Instrukcja wyboru
switch (wyrażenie sterujące)
switch (wyrażenie sterujące)
{
{
etykieta- wyboru: instrukcja
etykieta- wyboru: instrukcja
&
&
etykieta- wyboru: instrukcja
etykieta- wyboru: instrukcja
};
};
etykieta- wyboru może przyjąć postać:
etykieta- wyboru może przyjąć postać:
case wyrażenie typu całkowitego
case wyrażenie typu całkowitego
default:
default:
przykład:
przykład:
swtch (znak_z_portu_RS) // znak_z_portu_RS - typu char
swtch (znak_z_portu_RS) // znak_z_portu_RS - typu char
{ case  1 : instrukcja_0;
{ case  1 : instrukcja_0;
break;
break;
case  2 : instrukcja_1;
case  2 : instrukcja_1;
break;
break;
default: instrukcja_2;
default: instrukcja_2;
};
};
Instrukcje iteracyjne
Instrukcje iteracyjne
º%Instrukcja  dla for
º%Instrukcja  dla for
for(wyrażenie- inicjujące; wyrażenie- warunkowe;
for(wyrażenie- inicjujące; wyrażenie- warunkowe;
wyrażenie- zwiększające)
wyrażenie- zwiększające)
{instrukcje;}
{instrukcje;}
Przykład:
Przykład:
for(;;); // pętla nieskończona
for(;;); // pętla nieskończona
for(double y, t= 0; t< 2*PI; t+= krok)
for(double y, t= 0; t< 2*PI; t+= krok)
{ y= sin(t);
{ y= sin(t);
rysuj_punkt(t, y);}
rysuj_punkt(t, y);}
º%Instrukcja  dopóki while
º%Instrukcja  dopóki while
while (wyrażenie- warunkowe)
while (wyrażenie- warunkowe)
{instrukcja;}
{instrukcja;}
Przykład:
Przykład:
while (1); // pętla nieskończona
while (1); // pętla nieskończona
while(znak!= EOF)
while(znak!= EOF)
{znak= read_UART();}
{znak= read_UART();}
º% Instrukcja  wykonuj dopóki do & while
º% Instrukcja  wykonuj dopóki do & while
do
do
{instrukcje;}
{instrukcje;}
while (wyrażenie- warunkowe)
while (wyrażenie- warunkowe)
Przykład:
Przykład:
do
do
{instrukcje;}
{instrukcje;}
while (1); // pętla nieskończona
while (1); // pętla nieskończona
do
do
{znak= read_UART();}
{znak= read_UART();}
while (znak!= EOF);
while (znak!= EOF);
Deklaracja funkcji
Deklaracja funkcji
º% Ogólna postać deklaracji
º% Ogólna postać deklaracji
identyfikator-funkcji( lista- parametrów)
identyfikator-funkcji( lista- parametrów)
º% Prototypy funkcji
º% Prototypy funkcji
void funkcja (void);
void funkcja (void);
funkcja (void);
funkcja (void);
void funkcja (int);
void funkcja (int);
double funkcja (float l1, float L1);
double funkcja (float l1, float L1);
int funkcja (const char *);
int funkcja (const char *);
int funkcja (char *str, & );
int funkcja (char *str, & );
Przykład:
Przykład:
char read_UART(void)
char read_UART(void)
{
{
char read_data;
char read_data;
&
&
return read_data;
return read_data;
}
}
Wywołanie zdefiniowanej funkcji:
Wywołanie zdefiniowanej funkcji:
znak= read_UART();
znak= read_UART();
DZI
KUJ
ZA UWAG