Kiem Tra gtc082018 PDF

AN<nnnnnnnn>
Embedded C Language Review
Rev 1.0 25-12-2009 Application Note

KHT AN<nnnnnnnn>
Revision History
Revision Date Description Author
Rev <nn.nn> + 1 <dd-mm-yyyy><Revision Description – Delete if not required> <Author>
Rev <nn.nn> <dd-mm-yyyy><Revision Description> <Author>
Nguyen Trung Hieu 25-12-2009 Page 2 of 27

KHT AN<nnnnnnnn>
1. Cấu trúc chương trình C - C Program Structure

Cấu trúc 1 chương trình C cơ bản như sau:
/* Included header files */
#include <header_file.h>
/* User definitions */
#define user_definition
/* Global variable declarations */
/* Function prototypes */
/* Function declarations */
return_type function_name (parameter_list)
{
/* body of the function */
/* return expression */
}
/* Main program */
int main(void)
{
/* Body of main function */
/* Main Loop – Forever */

/* Do not return in main() */
while(1);
}
2. Kiểu dữ liệu - Data types

Bao gồm các kiểu như sau:

KHT AN<nnnnnnnn>
3. Ghi chú – Comment

Ví dụ:
/* This is a comment */
/* This is a
multiple line comment */
// This is also a comment
4. Từ khóa - Reserved keyword

Cần tránh sử dụng để đặt tên cho biến, hằng, định nghĩa… trong chương trình C.
break else int static
bit enum interrupt struct
case extern long switch
char flash register typedef
const float return union
continue for short unsigned
default funcused signed void
do goto sizeof volatile
double if sfrb while
eeprom inline sfrw
5. Cách đặt tên - Identifier Naming

• Sử dụng trong biến (variable), hàm (function), nhãn (label) hay các đối tượng khác.
• Có thể chứa các kí tự chữ a Æ z, A Æ Z, số 0 Æ 9 hoặc dấu underscore (_)
• Chỉ có thể bắt đầu bằng kí tự chữ hoặc underscore (không bắt đầu bằng chữ số)
• Phân biệt hoa/thường (UPPER CASE/lower case)
• Dài nhất là 32 kí tự.

KHT AN<nnnnnnnn>
6. Biến số và hằng số
6.1. Biến số - Variable
6.1.1. Kiểu biến - Variable Types
• Được khai báo cú pháp sau:
• [<storage modifier>] <type definition> <identifier>;
• [<lớp lưu trữ>] <định nghĩa kiểu dữ liệu> <tên biến>;
• Có thể khai báo dưới dạng mảng, tối đa 8 chiều.
• Phần tử đầu tiên lúc nào cũng được định vị trí bằng 0.
• Giá trị khởi tạo biến sẽ được xóa về 0 nếu không có giá trị khởi tạo cụ thể nào cho nó.
• Lưu trên RAM vì nội dung có thể thay đổi trong quá trình chạy.
Biến kiểu bit - Bit variable
• Các biến kiểu bit toàn cục (global bit variable) có thể nằm phân bổ trong các thanh ghi
GPIOR từ R2 Æ R14.
• Cú pháp: bit <identifier>
Ví dụ:
/* declaration and initialization for an ATtiny2313 chip
which has GPIOR0, GPIOR1 and GPIOR2 registers */
bit alfa=1; /* bit0 of GPIOR0 */
bit beta; /* bit1 of GPIOR0 */
void main(void)
{
if (alfa) beta=!beta;
/* ........ */
}
• Các biến kiểu bit cục bộ (local bit variable) có thể khai báo tối đa 8 biến và được phân bổ
trong thanh ghi R15.
Ví dụ:
void main(void)
{
bit alfa; /* bit 0 of R15 */
bit beta; /* bit 1 of R15 */
/* ........ */
}
6.1.2. Phạm vi của biến

Biến cục bộ - Local Variable
• Nằm trong hàm (function) khi chương trình thực thi hàm đó.
• Không thể truy xuất bởi các hàm khác.
• Một biến cục bộ có tên đặt giống nhau có thể sử dụng trong nhiều hàm khác nhau mà
không sợ bị trùng lặp nhau.

KHT AN<nnnnnnnn>
Biến toàn cục - Global Variable

• Thường được khai báo trước hàm main() và không nằm trong hàm nào.
• Bất kì hàm nào cũng có thể truy xuất đến.
Ví dụ 1:
/* Global variables declaration */
unsigned char globey;
/* And Initialization */
long c = 1111111;
/* This is function may be called from main() */

void function_z(void) {
/* A local variable to function_z */
unsigned int tween;
long a = 1000;
tween = 12; // OK
globey = 47; // OK
main_loc = 12; // Error
}
/* Main program */
void main(void)
{
/* A local variable to main */
unsigned char main_loc;
char b = 99;
main_loc = 1; // OK
globey = 20; // OK
tween = 30; // Error
/* Main Loop – Forever */

while(1);
}
Ví dụ 2:
/* All the elements of the array will be 0 */
int global_array1[32];
/* Array is automatically initialized */

int global_array2[]={1,2,3};
int global_array3[4]={1,2,3,4};

KHT AN<nnnnnnnn>
char global_array4[]=”This is a string”;
/* Only the first 3 elements of the array are

initialized, the rest 29 will be 0 */
int global_array5[32]={1,2,3};
/* Multidimensional array */
int multidim_array[2][3]={{1,2,3},{4,5,6}};
void main(void) {
/* local array declaration */
int local_array1[10];
/* local array declaration and initialization */

int local_array2[3]={11,22,33};
char local_array3[7]="Hello";
}
6.1.3. Ép kiểu cho biến - Type Casting

Sử dụng đế gán kiểu tạm thời cho biến nào đó trong các phép tính toán.
Ví dụ:
void calc(void)
{
unsigned char a;
unsinged int b;
a = 255;
b = (unsigned int)a + 100;
}
6.2. Hằng số - Constant

• Khai báo với từ khóa “const” hoặc “flash”
• Là các kí tự, các chữ số, chuỗi v.v… với giá trị cố định không thể thay đổi.
• Được trình dịch (compiler) phân bổ trong ROM/Flash.
• Có thể khai báo dưới dạng mảng (array), tối đa 8 chiều.
• Không khai báo trong chương trình.
Ví dụ 1:
/* A constant - stored in FLASH/ROM and can not be modified */
const char c = 57;
/* Main program */
void main()
{

KHT AN<nnnnnnnn>
/* Variable */
unsigned char x, y;
x = y + c;
/* “3” is stored in FLASH/ROM and can not be modified */
x = 3 + y;
/* Letter ‘B’ is stored in FLASH/ROM and can not be modified */
x = ‘B’;
/* String “Hello world!” stored in FLASH/ROM
and can not be modified */
printf(“Hello world!”);
/* Main loop */
while(1);
}
Ví dụ 2:
/ * this function displays a string located in SRAM */
void display_ram(char *s) {
/* ....... */
/ * this function displays a string located in FLASH */
void display_flash(char flash *s) {
/* ....... */
void main(void) {
/* this will not work !!! */
/* because the function addresses the string as */
/* it is located in SRAM, but the string "Hello world" */
/* is constant and is placed in FLASH */
display_ram("Hello world");
/* this will work !!! */

/* the function addresses the string as it is located in FLASH */
display_flash("Hello world");
}

KHT AN<nnnnnnnn>
Hằng số kiểu số - Numeric Constant

• Kiểu decimal: không có tiền tố. Ex: 1234.
• Kiểu binary: bắt đầu bằng 0b. Ex: 0b101010
• Kiểu Hexadecimal: bắt đầu bằng 0x. Ex: 0xff
• Kiểu Octal: bắt đầu bằng 0. Ex: 0777.
Ngoài ra:
• Hằng số kiểu unsigned integer: kết thúc bằng U. Ex: 10000U
• Hằng số kiểu long integer: kết thúc bằng L. Ex: 99L
• Hằng số kiểu unsigned long integer: kết thúc bằng UL. Ex: 99UL
• Hằng số kiểu dấu chấm động (Float): kết thúc bằng F. Ex: 1.234F
Hằng số kiểu kí tự - Charater Constant
• Hằng kiểu kí tự có thể “in” được (printable) như các số từ 0-9 và A-Z, a-z hay không “in”
được (non-printable) như kí tự bắt đầu dòng mới (newline), kí tự xuống dòng (carriage
return) hoặc dấu tab.
• Đặt trong dấu nháy đơn ‘’.
• Hoặc đặt trong cặp dấu nháy đơn và đi sau dấu xổ ngược (back slash)
‘t’ can be represented by ‘\164’ (octal)
or
‘t’ can be represented by ‘\x74’ (hexadecimal)
Lưu ý:
Để hiển thị dấu nháy đơn (‘) hay dấu xổ ngược trong dạng printable, chúng phải đặt trong cặp
dấu nháy đơn và theo sau dấu xổ ngược.
‘\’’ represented for a single quote.
‘\\’ represented for a back slash.
Các kiểu non-printable trong C

Character Representation Equivalent hex value
BEL ‘\a’ ‘\0x07’
Back Space ‘\b’ ‘\0x08’
TAB ‘\t’ ‘\0x09’
LF (New line) ‘\n’ ‘\0x0a’
VT ‘\v’ ‘\0x0b’
FF ‘\f’ ‘\0x0c’
CR ‘\r’ ‘\0x0d’
Ví dụ:
flash int integer_constant=1234+5;
flash char char_constant=’a’;
flash long long_int_constant1=99L;
flash long long_int_constant2=0x10000000;
flash int integer_array1[]={1,2,3};

KHT AN<nnnnnnnn>
/* The first two elements will be 1 and 2,

the rest will be 0 */
flash int integer_array2[10]={1,2};
flash int multidim_array[2][3]={{1,2,3},{4,5,6}};
flash char string_constant1[]=”This is a string constant”;
const char string_constant2[]=”This is also a string constant”;
6.3. Lớp lưu trữ - Storage Class

Tất cả các biến có thể khai báo trong 3 lớp: auto, static và register.
Ngoài ra còn có 2 kiểu: extern và volatile.
Automatic
• Kiểu mặc định của các biến được khai báo.
• Biến khai báo với kiểu auto trong hàm sẽ bị hủy giá trị khi thoát ra khỏi hàm đó, nghĩa là
giá trị của biến này không được lưu lại nếu thực thi hàm này lần nữa.
auto int value;
or
int value; // This is the common, default form
Static
• Biến kiểu này mặc dù chỉ có thể được truy xuất từ hàm mà nó được khai báo trong đó
(không thể truy xuất từ các hàm khác), nhưng được compiler phân bổ trong vùng nhớ
toàn cục (global memory space).
• Biến này sẽ được khởi tạo giá trị một lần duy nhất khi hàm được gọi lần đầu tiên và giá
trị nó vẫn được lưu lại khi thoát khỏi hàm và gọi lại hàm đó vào lần tiếp theo.
static int value;
Ví dụ:
int alfa(void) {
/* declare and initialize the static variable */
static int n=1;
return n++;
}
void main(void) {
int i;
/* the function will return the value 1 */

i=alfa();
/* the function will return the value 2 */

i=alfa();
}
Register
• Tương tự như biến auto.

KHT AN<nnnnnnnn>
• Chỉ khác là được compiler phân bỏ trong thanh ghi thực sự của vi điều khiển để giảm tối
đa chu kỳ truy xuất dữ liệu từ các biến đó.
register char value;
Extern
• Nếu biến đó khai báo ở source file khác, trước khi tham chiếu tới biến cần phải khai báo
biến với kiểu extern.
extern int xyz;
/* now include the file which contains

the variable xyz definition */
#include <file_xyz.h>
Volatile
• Sử dụng để tránh compiler phân bổ biến đó vào vùng nhớ các thanh ghi của vi điều
khiển và lưu ý compiler rằng nội dung của biến có thể bị thay đổi khi chương trình kiểm
tra.
volatile int abc;
7. Liệt kê và Định nghĩa

Có thể sử dụng 2 loại này để thay thế số với tên tự đặt hoặc trong nhiều trường hợp khác.
7.1. Liệt kê - Enumeration

• Gán các giá trị số liên tục nhau cho danh sách các indentifier.
• Giá trị cho identifier đầu tiên mặc định bằng 0 (trừ khi gán cho nó một giá trị xác định
khác)
Ví dụ:
int value;
enum {first_val = 10, second_val, third_val};
void main()
{
value = third_val; // value = 12
value = first_val; // value = 10
}
7.2. Định nghĩa - Definition

Dùng để gán tên cho đối tượng khác.
Ví dụ:
enum { red_led_on = 1, green_led_on, both_leds_on}
#define leds PORTA
void main()

KHT AN<nnnnnnnn>
{
// All following lead to the same result
PORTA = 1;
PORTA = red_led_on;
leds = 1;
leds = red_led_on;
}
8. Các phép tính toán và biểu thức

8.1. Toán tử gán – Assignment Operator
Toán tử gán (=) được sử dụng để gán biểu thức đến biến với dạng tổng quát:
Variable_name = expression;
8.2. Toán tử số học – Arithmetic Operator
Ví dụ 1:
// Following is the same
x = x + 1;
// Or
x++; // Post-Increasement
// Or
++x; // Pre-Increasement
Ví dụ 2: Về Pre-Increasement và Post-Increasement
i = 1;
k = 2*i++; // at complettion, k = 2, i = 2.
i = 1;
k = 2*++i; // at completion, k = 4, i = 2.
8.3. Toán tử với bit – Bitwise Operator

Chức năng của toán tử Kí hiệu toán tử
Lấy bù (Ones Complement) ~

KHT AN<nnnnnnnn>
Dịch trái (Left Shift) <<

Dịch phải (Right Shift) >>
AND &
Loại trừ (Exclusive OR) ^
OR (Inclusive OR) |
Ví dụ:
unsigned char y = 0xC9;
x = ~y; // x = 0x36
x = y << 3; // x = 0x48
x = y >> 4; // x = 0x0C
x = y & 0x3F; // x = 0x09
x = y ^ 1; // x = 0xC8
x = y | 0x10;
8.4. Toán tử quan hệ và logic – Logical and Relational Operator
Ví dụ:
unsigned char x = 5;
unsigned char y = 2;
(x && y); // TRUE – Both are non-zero

(x & y); // FALSE – 0b101 & 0b010 = 0b000
(x || y); // TRUE – Either value is non-zero
(x | y); // TRUE – 0b101 | 0b010 = 0b111

KHT AN<nnnnnnnn>
8.5. Toán tử gán kép – Compound Assignment Operator

Ví dụ:
a += 3; // a = a + 3
a |= 3; // a = a | 3 (OR Operation)
PORTC &= 3; // PORTC = PORTC & 3 (AND Operation)
8.6. Biểu thức chứa điều kiện – Conditional Expression

if (expression_A)
expression_B;
else
expression_C;
Có thể rút gọn bằng biểu thức
expression_A ? expression_B : expression_C;
* Xem thêm trong cấu trúc điều khiển if-else
8.7. Độ ưu tiên của các toán tử - Operator Precedence

* Tham khảo P.18
9. Các cấu trúc điều khiển – Control Statement

9.1. While loop
while (expression)
{
statement;
}
Hoặc
while (expression)
statement;
* Tham khảo ví dụ P.20
9.2. Do/While loop

do
{
statement;
} while (expression)
Hoặc
do
statement;
while (expression);

KHT AN<nnnnnnnn>
9.3. For loop

for (exp1; exp2; exp3)
{
statement;
}
Hoặc
for (exp1; exp2; exp3)
statement;
9.4. If-else
if (expression)
{
statement;
} else if (exression)
{
statement;
} else
{
statement;
}
Hoặc
if (expression)
statement;
else if (exression)
statement;
else
statement;
* Xem thêm biểu thức chứa điều kiện.
* Tham khảo ví dụ P.23 Æ P.26
9.5. Switch/Case
switch (expression)
{
case const_1:
statement;
break;
case const_2:
statement;
break;
case const_3:
statement;

KHT AN<nnnnnnnn>
break;
default:
statement;
break;
}
9.6. Break, Continue và Goto

Các lệnh trên sử dụng trong các cấu trúc for, while, do/while, switch
* Tham khảo ví dụ P.28 Æ P.30
10. Hàm - Function

type function_name (type param_1, type param_2, …)
{
statement_1;
statement_2;
statement_3;
}
10.1. Bố cục của hàm và tiền khai báo hàm – Prototyping and Function
Organization
// Declaration of global variables
int var1, var2, var3;
// Declaration of function
int function_1 (int x, int y)
{
// statement
}
void function_2 (void)

{
// statement
}
// main() would be last

void main(void)
{
var3 = function_1(var1, var2);
function_2();
}

KHT AN<nnnnnnnn>
10.2. Hàm trả về giá trị - Functions return value

float cube(float v)
{
return (v*v*v); // This returns a type float value.
}
void main(void)
{
float a, b, c;
a = 12.9;
b = 13.3;
c = cube(a,b); // assign c to return value of cube() function
while(1);
}
10.3. Đệ quy
// Calculate Factorials
// n! = n * (n – 1)
int fact(int n)
{
if (n == 0) return n;
else return (n * fact(n - 1));
}
11. Con trỏ và mảng

11.1. Con trỏ
Con trỏ là loại biến chứa địa chỉ của biến, hằng, hàm hay đối tượng data nào đó.
Khai báo với (*) liền trước tên biến.
Ví dụ
char *p; // p is a pointer to a charater
int *fp; // fp is a pointer to an integer
Cách truy xuất nội dung con trỏ: phải khởi tạo giá trị con trỏ đến địa chỉ của biến nào đó cần
truy xuất (tức là cho con trỏ trỏ đến địa chỉ của biến đó).
Ví dụ:
char *p;
char a = 10;
char b;
p = &a; // p is now pointing to a

KHT AN<nnnnnnnn>
b = *p; // b = a = 10 now
Ví dụ 2:
char *p;
char a;
char b = 20;
p = &a; // p is now pointing to a

*p = b; // a = b = 10 now
Ví dụ 3:
int *p1; // A pointer to an integer
int **p2; // A pointer to a pointer to an integer
int ***p3; // A pointer to a pointer to a pointer to an integer
int i, j;
p1 = &i;
p2 = &p1;
p3 = &p2;
j = ***p3; // the same result as j = i;

Ví dụ 4:
int *ptr;
long *lptr;
ptr = ptr + 1; // move pointer to next integer (2 bytes)

// The same as ptr++;
lptr = ptr + 1; // move pointer to next long integer (4 bytes)
// The same as lptr++;
Ví dụ 5:
char c;
char *p;
c = *p++; // assign c the value pointed to by p, then increase p

c = *++p; // increase p, then assign c the value pointed to by p
c = ++*p; // increase value pointed to by p, then assign c to that value.
c = (*p)++; // assign c the value pointed to by p, then increase value
// pointed to by p
11.2. Hàm với tham số vào là con trỏ

Trong trường hợp này, khi gọi hàm phải truyền tham số vào là địa chỉ của biến.
Ví dụ:
int var1 = 10;
int var2 = 20;

KHT AN<nnnnnnnn>
void swap(int *a, int *b)

{
int temp;
temp = *b;
*b = *a;
*a = temp;
}
void main(void)
{
swap(&var1, &var2);
}
Ví dụ 2: Với hàm scanf
int x, y z;
scanf(“ %d %d %d”, &x, &y, &z);
11.3. Con trỏ hàm

Khai báo với dạng: (*function_pointer_name)(type var1, type var2...)
Trỏ con trỏ hàm vào hàm trước khi sử dụng.
Ví dụ:
#include <stdio.h>
void task_0(void)
{
printf("This is task 0 \n\r");
}
void task_1(void)
{
printf("This is task 1 \n\r");
}
void main (void)

{
void (*task_ptr)(void);
task_ptr = task_0;
(*task_ptr)();
task_ptr = task_1;
(*task_ptr)();
while(1);

KHT AN<nnnnnnnn>
11.4. Mảng
Mảng là tập dữ liệu với kiểu được khai báo trước, sắp xếp theo thứ tự.
Khai báo mảng cũng tương tự như khai báo biến, hằng và số lượng phần tử trong mảng trong
dấu [] ngay sau tên mảng.
Ví dụ:
int digit[10];
char str[20];
char str2[]=”Testing…\n\r”;
Cách truy xuất giá trị của phần tử trong mảng: các phần tử trong mảng được định vị từ 0 Æ
lượng phần tử - 1.
Ví dụ 2:
char digit[10]={0, 1, 2, 3, 4, 5 ,6 , 7, 8, 9};
char b;
b = digit[0]; // b = 0
b = digit[5]; // b = 5
b = digit[9]; // b = 9
Truy xuất phần tử trong mảng với con trỏ: giá trị của mảng cũng chính là địa chỉ của phần tử
đầu tiên trong mảng.
Ví dụ 3:
char digit[10]={0, 1, 2, 3, 4, 5 ,6 , 7, 8, 9};
char *p;
p = digit;
// Or
p = &digit[0];
11.5. Mảng nhiều chiều

Mảng nhiều chiều có thể cấu trúc bởi 2, 3 hay nhiều chiều hơn. Cách phân bố các phần tử của
mảng trong bộ nhớ như sau:
Ví dụ:
int two_d[5][10];
// In memory, the element of the array would be stored in sequense rows

like this:
// two_d[0][0], two_d[0][1], two_d[0][2]... two_d[0][9],
// ...
Ví dụ 2: một số cách khai báo khác với phần tử là mã ASCII
const char keycode[4][3] = { ‘1’, ‘2’, ‘3’,

KHT AN<nnnnnnnn>
‘4’, ‘5’, ‘6’,

‘7’, ‘8’, ‘9’,
‘*’, ‘0’, ‘#’};
Ví dụ 3: phần tử dạng chuỗi
char day_of_week[7][10] = {
“Sunday”,
“Tueday”,
“Wednesday”,
“Thursday”,
“Friday”,
“Saturday”,
“Sunday”};
// Use with printf()
printf(“%s”, &day_of_the_week[3][0]; // Print Wednesday
// Or
printf(“%s”, day_of_the_week[3]; // Print Wednesday
12. Structure và Union

12.1. Structure – Dữ liệu kiểu cấu trúc
Khai báo và cách truy xuất
Dữ liệu là một đối tượng trong đó chứa nhiều phần tử, các phần tử này không nhất thiết phải
cùng kiểu với nhau.
Ví dụ:
struct structure_tag_name {
type member_1;
type member_2;
type member_3;
//...
type member_n;
} structure_var_name;
structure structure_tag_name var_1, var_2; // Structure variable

structure structure_tag_name var_3[5]; // Array of structure
Cách truy xuất: phần tử trong structure truy cập bằng tên biến sử dụng structure và toán tử
phần tử (.)
Ví dụ 2:
struct structure_tag_name P
type member_1;
type member_2;
type member_3;
//...

KHT AN<nnnnnnnn>
type member_n;
} structure_var_name;
// Access to member 1
structure_var_name.member_1;
Ví dụ 3:
struct DATE {
int month;
int day;
int year;
}
// Initialize structure variables

structure DATE date_of_birth = { 2, 21, 1999};
// The same as
date_of_birth.month = 2;
date_of_birth.day = 21;
date_of_birth.year = 1999;
Các phần tử trong structure có thể sử dụng kiểu là các structure khác.
Ví dụ 4:
struct LOCATION {
int x;
int y;
}
struct PART {
char part_name[20];
long int sku;
struct LOCATION bin;
} widget;
// Access to member
int x_location, y_location;
x_location = widget.bin.x;
y_location = widget.bin.y;
Hàm với kiểu cấu trúc

Ví dụ 1:
struct PART new_location(int x, int y)
{
struct PART temp;
temp.part_name = “”;

KHT AN<nnnnnnnn>
temp.sku = 0;
temp,bin.x = x;
temp.bin.y = y;
return temp;
}
widget = new_location(10, 12);

// the result will be
// widget.part_name = “”
// widget.sku = 0
// widget.bin.x = 10
// widget.bin.y = 12
Mảng cấu trúc – Array of Structure

Ví dụ:
struct PART {
char part_name[20];
long int sku;
} widget[100];
int x_location, y_location;
// Access to x and y location of widget[0]

x_location = widget[0].bin.x;
y_location = widget[0].bin.y;
Ví dụ 2:
struct DATE {
int month;
int day;
int year;
}
struct DATE birthday[3] = {

2, 21, 1985,
8, 8, 1999,
12, 10, 2000};
Con trỏ tới cấu trúc – Pointer to Structure

Khai báo dưới dạng:
struct structure_tag_name *structure_var_name;
Khi sử dụng con trỏ cấu trúc, dấu -> được dùng để truy cập đến nội dung của phần tử trong
biến cấu trúc mà con trỏ đang trỏ tới.
Ví dụ:
struct LOCATION {

KHT AN<nnnnnnnn>
int x;
int y;
}
struct PART {
char part_name[20];
long int sku;
};
struct PART widget, *this_widget;
this_widget = &widget; // Assign the pointer to address of the structure

this_widget->sku = 1234; // assign widget.sku = 1234
// Or
(*this_widget).sku = 1234;
Ví dụ 2:
struct LIST_ITEM {
char *string;
int position;
struct LIST_ITEM *next_item;
} item, item2;
int pos;
item.next_item = &item2;
pos = item.next_item->position;
// The same as
pos = item2.postion;
Sử dụng trong LINKED-LISTS và QUICK-SORTS.
12.2. Union
Cách khai báo của union cũng tương tự như của structure
Ví dụ:
struct union_tag_name {
type member_1;
type member_2;
type member_3;
//...
type member_n;
} union_var_name;
Chỉ khác biệt ở chỗ cách phân bổ bộ nhớ, các thành phần trong union chia sẻ với nhau vùng
nhớ chung là vùng nhớ chứa thành phần có kích thước lớn nhất của union đó.
Ví dụ 2:
union SOME_TYPES {

KHT AN<nnnnnnnn>
char character;
int integer;
long int long_one;
} my_space;
// Assign value for the largest member

my_space.long_one = 0x12345678UL;
// Then the remaining member will be equal to
// my_space.character = 0x12;
// my_space.integer = 0x1234;
Ví dụ 3:
void main(void)
{
union {
unsigned char port_byte[2];
unsigned int port_word;
} value;
while(1)
{
value.port_byte[0] = PINA;
value.port_byte[1] = PINB;
printf(“16-bit = %04x \n”, value.port_word);
}
}

KHT AN<nnnnnnnn>
12.3. Kiểu định nghĩa bởi người dùng – Typedef

12.4. Bits và Bitfields
12.5. Hàm sizeof
13. Kiểu bộ nhớ - Memory types

13.1. Biến và hằng – Constants and Variables
13.2. Con trỏ - Pointer
13.3. Thanh ghi và biến – Register and Variables
14. Phương pháp lập trình thời gian thực – Realtime methods
14.1. Sử dụng ngắt – Using Interrupt
14.2. Thực thi thời gian thực – Realtime Executive
14.3. State Machines

KHT AN<nnnnnnnn>
Table Of Content
1. Cấu trúc chương trình C - C Program Structure............................................................................................................. 3
2. Kiểu dữ liệu - Data types................................................................................................................................................. 3
3. Ghi chú – Comment ........................................................................................................................................................ 4
4. Từ khóa - Reserved keyword.......................................................................................................................................... 4
5. Cách đặt tên - Identifier Naming ..................................................................................................................................... 4
6. Biến số và hằng số.......................................................................................................................................................... 5
6.1. Biến số - Variable .................................................................................................................................................... 5
6.1.1. Kiểu biến - Variable Types ................................................................................................................................ 5
6.1.2. Phạm vi của biến ............................................................................................................................................... 5
6.1.3. Ép kiểu cho biến - Type Casting ....................................................................................................................... 7
6.2. Hằng số - Constant ................................................................................................................................................. 7
6.3. Lớp lưu trữ - Storage Class .................................................................................................................................. 10
7. Liệt kê và Định nghĩa .................................................................................................................................................... 11
7.1. Liệt kê - Enumeration ............................................................................................................................................ 11
7.2. Định nghĩa - Definition........................................................................................................................................... 11
8. Các phép tính toán và biểu thức ................................................................................................................................... 12
8.1. Toán tử gán – Assignment Operator..................................................................................................................... 12
8.2. Toán tử số học – Arithmetic Operator................................................................................................................... 12
8.3. Toán tử với bit – Bitwise Operator ........................................................................................................................ 12
8.4. Toán tử quan hệ và logic – Logical and Relational Operator ............................................................................... 13
8.5. Toán tử gán kép – Compound Assignment Operator ........................................................................................... 14
8.6. Biểu thức chứa điều kiện – Conditional Expression ............................................................................................. 14
8.7. Độ ưu tiên của các toán tử - Operator Precedence.............................................................................................. 14
9. Các cấu trúc điều khiển – Control Statement ............................................................................................................... 14
9.1. While loop.............................................................................................................................................................. 14
9.2. Do/While loop ........................................................................................................................................................ 14
9.3. For loop ................................................................................................................................................................. 15
9.4. If-else..................................................................................................................................................................... 15
9.5. Switch/Case .......................................................................................................................................................... 15
9.6. Break, Continue và Goto....................................................................................................................................... 16
10. Hàm - Function.......................................................................................................................................................... 16
10.1. Bố cục của hàm và tiền khai báo hàm – Prototyping and Function Organization .......................................... 16
10.2. Hàm trả về giá trị - Functions return value ...................................................................................................... 17
10.3. Đệ quy ............................................................................................................................................................. 17
11. Con trỏ và mảng........................................................................................................................................................ 17
11.1. Con trỏ............................................................................................................................................................. 17
11.2. Hàm với tham số vào là con trỏ ...................................................................................................................... 18

KHT AN<nnnnnnnn>
11.3. Con trỏ hàm..................................................................................................................................................... 19

11.4. Mảng................................................................................................................................................................ 20
11.5. Mảng nhiều chiều ............................................................................................................................................ 20
12. Structure và Union..................................................................................................................................................... 21
12.1. Structure – Dữ liệu kiểu cấu trúc..................................................................................................................... 21
12.2. Union ............................................................................................................................................................... 24
12.3. Kiểu định nghĩa bởi người dùng – Typedef..................................................................................................... 26
12.4. Bits và Bitfields ................................................................................................................................................ 26
12.5. Hàm sizeof....................................................................................................................................................... 26
13. Kiểu bộ nhớ - Memory types..................................................................................................................................... 26
13.1. Biến và hằng – Constants and Variables ........................................................................................................ 26
13.2. Con trỏ - Pointer .............................................................................................................................................. 26
13.3. Thanh ghi và biến – Register and Variables ................................................................................................... 26
14. Phương pháp lập trình thời gian thực – Realtime methods...................................................................................... 26
14.1. Sử dụng ngắt – Using Interrupt ....................................................................................................................... 26
14.2. Thực thi thời gian thực – Realtime Executive ................................................................................................. 26
14.3. State Machines................................................................................................................................................ 26

KHT AN<nnnnnnnn>
Appendix

Kiem Tra gtc082018 PDF

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Kiem Tra gtc082018 PDF

Uploaded by

Copyright:

Available Formats

AN<nnnnnnnn>

Embedded C Language Review

Rev 1.0 25-12-2009 Application Note

Nguyen Trung Hieu 25-12-2009 Page 2 of 27

1. Cấu trúc chương trình C - C Program Structure

/* Global variable declarations */

/* Main Loop – Forever */

2. Kiểu dữ liệu - Data types

Nguyen Trung Hieu 25-12-2009 Page 3 of 27

3. Ghi chú – Comment

4. Từ khóa - Reserved keyword

5. Cách đặt tên - Identifier Naming

Nguyen Trung Hieu 25-12-2009 Page 4 of 27

6.1.2. Phạm vi của biến

Nguyen Trung Hieu 25-12-2009 Page 5 of 27

Biến toàn cục - Global Variable

/* This is function may be called from main() */

/* Main Loop – Forever */

/* Array is automatically initialized */

Nguyen Trung Hieu 25-12-2009 Page 6 of 27

char global_array4[]=”This is a string”;

/* Only the first 3 elements of the array are

/* local array declaration and initialization */

6.1.3. Ép kiểu cho biến - Type Casting

6.2. Hằng số - Constant

Nguyen Trung Hieu 25-12-2009 Page 7 of 27

/ * this function displays a string located in FLASH */

void display_flash(char flash *s) {

/* this will work !!! */

Nguyen Trung Hieu 25-12-2009 Page 8 of 27

Hằng số kiểu số - Numeric Constant

Các kiểu non-printable trong C

Nguyen Trung Hieu 25-12-2009 Page 9 of 27

/* The first two elements will be 1 and 2,

6.3. Lớp lưu trữ - Storage Class

/* the function will return the value 1 */

/* the function will return the value 2 */

Nguyen Trung Hieu 25-12-2009 Page 10 of 27

/* now include the file which contains

7. Liệt kê và Định nghĩa

7.1. Liệt kê - Enumeration

enum {first_val = 10, second_val, third_val};

7.2. Định nghĩa - Definition

Nguyen Trung Hieu 25-12-2009 Page 11 of 27

8. Các phép tính toán và biểu thức

8.2. Toán tử số học – Arithmetic Operator

8.3. Toán tử với bit – Bitwise Operator

Nguyen Trung Hieu 25-12-2009 Page 12 of 27

Dịch trái (Left Shift) <<

8.4. Toán tử quan hệ và logic – Logical and Relational Operator

(x && y); // TRUE – Both are non-zero

Nguyen Trung Hieu 25-12-2009 Page 13 of 27

8.5. Toán tử gán kép – Compound Assignment Operator

8.6. Biểu thức chứa điều kiện – Conditional Expression

8.7. Độ ưu tiên của các toán tử - Operator Precedence

9. Các cấu trúc điều khiển – Control Statement

9.2. Do/While loop

Nguyen Trung Hieu 25-12-2009 Page 14 of 27

9.3. For loop

Nguyen Trung Hieu 25-12-2009 Page 15 of 27

9.6. Break, Continue và Goto

10. Hàm - Function

void function_2 (void)

void swap(int a, int b)