วันจันทร์ที่ 8 พฤศจิกายน พ.ศ. 2553
ใบงานที่ 1
#define _XTAL_FREQ 20000000
__CONFIG(HS&WDTDIS&LVPDIS);
//====================================
void delay_ms(unsigned int tick)
{
while(tick--)
{
__delay_ms(1);
}
}
//==================== MAIN PROGRAM ======================
void main()
{
TRISC=0x00;
PORTC=00;
while(1)
{
PORTC=~PORTC;
delay_ms(500);
}
}
วันอาทิตย์ที่ 31 ตุลาคม พ.ศ. 2553
โครงสร้างโปรแกรมภาษาซี ของไมโครคอนโทรลเลอร์
โครงสร้างโปรแกรมภาษาซี ของไมโครคอนโทรลเลอร์
#include // header file ของไมโครคอนโทรลเลอร์
#define _XTAL_FREQ 20000000 // กำหนดสัญญาณนาฬิกา
__CONFIG(HS&WDTDIS&LVPDIS); // กำหนดคุณสมบัติทางฮาร์ดแวร์
//===============pototype=======
void shift_data(unsigned char dat); //โปรโตไท
void scan_co();
void send_data(unsigned int);
void delay(unsigned int tick);
/********************************************************** Global variables */
unsigned char const data[44][32] = {
{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xE0,0xF0,0xF8,0x9C,0x0E,0x06,0xE2,0x12,0x16,0x1E,0xFC,0x38,0x00,0x00,};
void main() //ฟังก์ชั่นหลักของโปรแกรม
{
unsigned int i,d=0; //ประกาศตัวแปร
TRISD=0x00;
scan_co(); //เรียกฟังก์ชั่นย่อย
while(1) //
{
for(i=0;i<10;i++)
{
send_data(d);
}
d+=4;
if(d==40)
d=0;
}
}
//=====================โปรแกรมย่อย=========================
//==================shift data====================
void shift_data(unsigned char dat)
{
unsigned char i;
for(i=0;i<8;i++)
{
if(dat & 0x80)
RD0=1; //data
else
RD0=0;
RD1=1; //clk
RD1=0;
dat=dat<<1;
}
}
//======================scan co====================
void scan_co()
{
unsigned char i;
for(i=0;i<8;i++)
{
RD3=1; //DATA
RD4=1; //clk
RD4=0;
}
RD3=0;
RD4=1; //clk co
RD4=0;
RD2=1; //lat
RD2=0;
RD3=1;
}
//====================
//********************************************************
void send_data(unsigned int d)
{
unsigned int r,c;
for(c=0;c<=32;c++)
{
for(r=d;r<4+d;r++)
{
shift_data(data[r][c]);
}
RD3=1;
RD2=1; //lat
RD2=0;
delay(1);
RD4=1; //clk co
RD4=0;
}
RD3=0;
RD4=1; //clk
RD4=0;
RD2=1; //la
RD2=0;
}
//====================================
void delay(unsigned int tick)
{
while(tick--)
{
__delay_ms(1);
}
}
********************************************************************
คอนฟิกูเรชั่น _CONFIG
ทำหน้าที่กำหนดคุณสมบัติการทำงานของไมโครคอนโทรลเลอร์ ก่อนเริ่มการทำงานของไมโครคอนโทรลเลอร์
รูปแบบ
__CONFIG(x)
พารามิเตอร์
x ค่าที่ต้องการกำหนด สามารถกำหนดได้หลากหลาย โดยมี & เป็นตัวคั่น
ตัวอย่าง
__CONFIG(HS&WDTDIS&LVPDIS);
*********************************************************************
ชนิดของข้อมูลและการประกาศตัวแปรในภาษา C
ระบบเลขฐานในภาษาซี
#include
#define _XTAL_FREQ 20000000 // กำหนดสัญญาณนาฬิกา
__CONFIG(HS&WDTDIS&LVPDIS); // กำหนดคุณสมบัติทางฮาร์ดแวร์
//===============pototype=======
void shift_data(unsigned char dat); //โปรโตไท
void scan_co();
void send_data(unsigned int);
void delay(unsigned int tick);
/********************************************************** Global variables */
unsigned char const data[44][32] = {
{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xE0,0xF0,0xF8,0x9C,0x0E,0x06,0xE2,0x12,0x16,0x1E,0xFC,0x38,0x00,0x00,};
void main() //ฟังก์ชั่นหลักของโปรแกรม
{
unsigned int i,d=0; //ประกาศตัวแปร
TRISD=0x00;
scan_co(); //เรียกฟังก์ชั่นย่อย
while(1) //
{
for(i=0;i<10;i++)
{
send_data(d);
}
d+=4;
if(d==40)
d=0;
}
}
//=====================โปรแกรมย่อย=========================
//==================shift data====================
void shift_data(unsigned char dat)
{
unsigned char i;
for(i=0;i<8;i++)
{
if(dat & 0x80)
RD0=1; //data
else
RD0=0;
RD1=1; //clk
RD1=0;
dat=dat<<1;
}
}
//======================scan co====================
void scan_co()
{
unsigned char i;
for(i=0;i<8;i++)
{
RD3=1; //DATA
RD4=1; //clk
RD4=0;
}
RD3=0;
RD4=1; //clk co
RD4=0;
RD2=1; //lat
RD2=0;
RD3=1;
}
//====================
//********************************************************
void send_data(unsigned int d)
{
unsigned int r,c;
for(c=0;c<=32;c++)
{
for(r=d;r<4+d;r++)
{
shift_data(data[r][c]);
}
RD3=1;
RD2=1; //lat
RD2=0;
delay(1);
RD4=1; //clk co
RD4=0;
}
RD3=0;
RD4=1; //clk
RD4=0;
RD2=1; //la
RD2=0;
}
//====================================
void delay(unsigned int tick)
{
while(tick--)
{
__delay_ms(1);
}
}
********************************************************************
คอนฟิกูเรชั่น _CONFIG
ทำหน้าที่กำหนดคุณสมบัติการทำงานของไมโครคอนโทรลเลอร์ ก่อนเริ่มการทำงานของไมโครคอนโทรลเลอร์
รูปแบบ
__CONFIG(x)
พารามิเตอร์
x ค่าที่ต้องการกำหนด สามารถกำหนดได้หลากหลาย โดยมี & เป็นตัวคั่น
ตัวอย่าง
__CONFIG(HS&WDTDIS&LVPDIS);
*********************************************************************
ชนิดของข้อมูลและการประกาศตัวแปรในภาษา C
ชนิดข้อมูลของตัวแปร | ขนาดข้อมูล |
Bit | เป็นข้อมูลขนาด 1 บิตใช้แทนข้อมูลชนิดจำนวนเต็ม มีอยู่ 0 , 1 |
char | เป็นข้อมูลขนาด 8 ของข้บิต ใช้แทนจำนวนเต็ม มีค่า -128 ถึง +127 |
unsigned char | เป็นข้อมูลขนาด 8 บิต ใช้แทนจำนวนเต็ม มีค่าตั้งแต่ 0 ถึง +255 |
int | เป็นข้อมูลขนาด 16 บิต ใช้แทนจำนวนเต็ม มีค่าตั้งแต่ -32,768 ถึง +32,767 |
unsigned int | เป็นข้อมูลขนาด 16 บิต ใช้แทนจำนวนเต็มมีค่าตั้งแต่ 0 ถึง +65535 |
long | เป็นข้อมูลขนาด 32 บิต ใช้แทนจำนวนเต็มมีค่าตั้งแต่ -2,147,483,648 ถึง +2,147,483,647 |
unsigned long | เป็นข้อมูลขนาด 32 บิต ใช้แทนจำนวนเต็มมีค่าตั้งแต่ 0 ถึง +4294967295 |
long long | เป็นข้อมูลขนาด 64 บิต ใช้แทนจำนวนเต็มมีค่าตั้งแต่ -9223372036854775808 ถึง + 9223372036854775807 |
unsigned long long | เป็นข้อมูลขนาด 64 บิต ใช้แทนจำนวนเต็มมีค่าตั้งแต่ 0 ถึง +18446744073709551616 |
float | เป็นข้อมูลขนาด 32 บิต ใช้แทนข้อมูลชนิดจำนวนจริง(เลขทศนิยม) |
double | เป็นชนิดข้อมูลขนาด 32 บิต ใช้แทนข้อมูลชนิดจำนวนจริง(เลขทศนิยม) |
arrays | กลุ่มข้อมูลหรือกลุ่มของตัวแปรที่ถูกประกาศขึ้น ที่มีชนิดข้อมูลเดียวกันและมีแอดเดรสของหน่วยความจำเรียงต่อกัน |
pointers | เป็นชนิดข้อมูลที่ใช้อ้างอิงถึงตำแหน่งแอดเดรสของหน่วยความจำ |
structures | เป็นการจัดกลุ่มข้อมูลที่สามารถมีความแตกต่างชนิดกันได้ |
1. ตัวเลขฐานสิบ สามารถกำหนดค่าเพื่อใช้งานให้กับตัวแปรหรือการคำนวนในโปรแกรมได้ทั่วๆไป
2. ตัวเลขฐานสอง มีรูปแบบการเขียนคือ 0bBBBBBBBB
โดยที่ B คือตัวเลข “0” หรือ “1”
ตัวอย่าง เลขฐานสอง 8 บิตเช่น 0b10010010 เทียบเท่ากับ 146 ฐานสิบ
คำนวณจาก 1*27+0*26+0*25+1*24+0*23+0*22+1*21+0*20 = 14610
3. ตัวเลขฐานสิบหก มีรูปแบบการเขียนคือ 0xHHHHHHHH
โดยที่ H คือตัวเลข 0-9 และ A-F
ตัวอย่าง เลขฐานสิบหก เช่น 0xFF เทียบเท่ากับ 255 ฐานสิบ
คำนวณจาก 15*161+15*160 = 25510
หรือเทียบได้กับเลขฐานสอง 0xFF-> 0b111111112
**************************************************************
!หมายเหตุ ข้อมูลชนิด long สามารถระบุให้ชัดเจนได้โดยใช้อักษร “l” หรือ “L” ต่อท้ายตัวเลขข้อมูลด้วย
การกำหนดค่าข้อมูลเริ่มต้นก็สามารถทำได้เช่น
ตัวแปร Pointers
**************************************************************
การประกาศตัวแปร
การประกาศตัวแปรในโปรแกรมภาษา C ก็จะเหมือนกับการประกาศตัวแปรในภาษา C ทั่วๆไป คือจะมีรูปแบบการประกาศดังนี้
type variable_name;
โดยที่ type คือ ชนิดข้อมูลผลลัพธ์ที่ต้องการกำหนด
variable_name คือ ชื่อตัวแปรที่ประกาศ
เช่น int a; // ประกาศตัวแปรชื่อ a กำหนดชนิดข้อมูลเป็นแบบ int
long result; // ประกาศตัวแปรชื่อ result กำหนดชนิดข้อมูลเป็นแบบ long
float start; // ประกาศตัวแปรชื่อ start กำหนดชนิดข้อมูลเป็นแบบ float
int x,y; // ประกาศตัวแปร 2 ตัวพร้อมกันชื่อ x และ y กำหนดชนิดข้อมูลเป็นแบบ int
float p,q,r; // ประกาศตัวแปร 3 ตัวพร้อมกันชื่อ p,q และ r กำหนดชนิดข้อมูลเป็นแบบ float
นอกจากนี้ถ้าต้องการประกาศตัวแปรพร้อมกับการกำหนดค่าเริ่มต้น(initial value) ก็สามารถทำได้
เช่น
int x=100; // ประกาศตัวแปรชื่อ x กำหนดชนิดข้อมูลเป็นแบบ int และกำหนดค่าเริ่มต้นเป็น 100
int x=15,y=78; // ประกาศตัวแปรชื่อ x และ y กำหนดชนิดข้อมูลเป็นแบบ int และกำหนดค่าเริ่มต้นให้ x
// เป็น 15 และ y เป็น 78
long p=47L,q=31L; // ประกาศตัวแปรชื่อ p และ q กำหนดชนิดข้อมูลเป็นแบบ long และกำหนด
// ค่าเริ่มต้นให้ p เป็น 47 และ q เป็น 31
******************************
ตัวแปร arrays
ตัวแปรชนิดอะเรย์ คือ กลุ่มของตัวแปรที่มีชนิดของข้อมูลเหมือนกัน และมีที่อยู่ในหน่วยความจำ(แอดเดรส)เรียงติดต่อกันไป
อะเรย์ 1 มิติ
รูปแแบบการประกาศใช้ตัวแปรอะเรย์ 1 มิติทำได้ดังนี้
type name[size];
โดยที่ type คือ ชนิดของข้อมูลตัวแปรอะเรย์
name คือ ชื่อของตัวแปรอะเรย์
size คือ ค่าของตัวเลขกำหนดขนาดของอะเรย์ อาจจะไม่กำหนดก็ได้
มีรูปแบบเป็น name[index]โดยที่ index คือ ค่าดัชนีที่ชี้หรือระบุไปยังมาชิกตัวใดๆของอะเรย์ ซึ่งอาจจะเป็นตัวเลข หรือ ค่าตัวแปรใดๆ หรือการกระทำของนิพจน์ ซึ่งทั้งหมดที่กล่าวมาจะต้องมีค่าเป็นจำนวนเต็มเท่านั้น
ตัวอย่าง
ถ้าประกาศเป็น char arr[4]; หมายถึง ตัวแปรอะเรย์ชื่อ arr ซึ่งเป็นตัวแปรที่ประกอบด้วยสมาชิกย่อย 4 ตัว(มองว่าเป็นตัวแปร 4 ตัวก็ได้)แต่เวลาที่จะอ้างอิงถึงสมาชิกจะใช้ดัชนีเป็นตัวบ่งบอกว่ากำลังติดต่อใช้งานสมาชิกตัวไหน ดังนั้น arr จะสามารถแจกแจงสมาชิกได้ดังนี้
arr[0] เป็นสามาชิกตัวที่ 1 แต่มีดัชนีที่ชี้เป็น ‘0’
arr[1] เป็นสามาชิกตัวที่ 2 แต่มีดัชนีที่ชี้เป็น ‘1’
arr[2] เป็นสามาชิกตัวที่ 3 แต่มีดัชนีที่ชี้เป็น ‘2’
arr[3] เป็นสามาชิกตัวที่ 4 แต่มีดัชนีที่ชี้เป็น ‘3’
ซึ่ง arr[0] , arr[1] , arr[2] และ arr[3] ทุกตัวต่างก็เป็นตัวแปรชนิด char มีขนาด 1 ไบต์ ดังนั้นการประกาศตัวแปร arr จึงใช้เนื้อที่ทั้งสิ้น 4 ไบต์
ตัวอย่าง
ถ้าประกาศเป็น int time[10]; หมายถึง ตัวแปรอะเรย์ชื่อ time ซึ่งเป็นตัวแปรที่ประกอบด้วยสมาชิกย่อย 10 ตัว ดังนั้น time จะสามารถแจกแจงสมาชิกได้ดังนี้
time[0] เป็นสมาชิกตัวที่ 1 แต่มีดัชนีที่ชี้เป็น ‘0’
time[1] เป็นสมาชิกตัวที่ 2 แต่มีดัชนีที่ชี้เป็น ‘1’
time[2] เป็นสมาชิกตัวที่ 3 แต่มีดัชนีที่ชี้เป็น ‘2’
time[3] เป็นสมาชิกตัวที่ 4 แต่มีดัชนีที่ชี้เป็น ‘3’
time[4] เป็นสมาชิกตัวที่ 5 แต่มีดัชนีที่ชี้เป็น ‘4’
time[5] เป็นสมาชิกตัวที่ 6 แต่มีดัชนีที่ชี้เป็น ‘5’
time[6] เป็นสมาชิกตัวที่ 7 แต่มีดัชนีที่ชี้เป็น ‘6’
time[7] เป็นสมาชิกตัวที่ 8 แต่มีดัชนีที่ชี้เป็น ‘7’
time[8] เป็นสมาชิกตัวที่ 9 แต่มีดัชนีที่ชี้เป็น ‘8’
time[9] เป็นสมาชิกตัวที่ 10 แต่มีดัชนีที่ชี้เป็น ‘9’
ซึ่ง time[0]… time[9] ทุกตัวต่างก็เป็นตัวแปรชนิด int มีขนาด 2 ไบต์ ดังนั้นการประกาศตัวแปร time จึงใช้เนื้อที่ทั้งสิ้น 20 ไบต์
ตัวอย่าง
การประกาศตัวแปรชนิดอะเรย์พร้อมกับกำหนดค่าข้อมูลให้กับสมาชิก ประกาศเป็น char dat[8] = {1,3,5,7,9,11,13,15} ;
จากตัวอย่างเป็นการประกาศตัวแปรอะเรย์ชื่อ dat และพร้อมกับกำหนดค่าข้อมูลให้กับสมาชิกแต่ละตัว(อาจจะเรียกว่าแต่ละหน่วยก็ได้) ผลลัพธ์ที่ได้คือ
dat[0] = 1;
dat[1] = 3;
dat[2] = 5;
dat[3] = 7;
dat[4] = 9;
dat[5] = 11;
dat[6] = 13;
dat[7] = 15;
· การเรียกใช้สมาชิกอะเรย์ เช่น หลังจากมีประกาศอะเรย์ข้างบน
char i , j ;
i = 3;
j = dat[i]; // j = dat[i] è j = dat[3] è j = 7
/*ผลลัพธ์คือ j = 7 */
ตัวอย่าง
การประกาศตัวแปรชนิดอะเรย์พร้อมกับกำหนดค่าข้อมูลให้กับสมาชิก
ประกาศเป็น char dat[5] = “ abcde” ;
จากตัวอย่างเป็นการประกาศตัวแปรอะเรย์ชื่อ dat และพร้อมกับกำหนดค่าข้อมูลให้กับสมาชิกแต่ละตัว(อาจจะเรียกว่าแต่ละเซลส์ก็ได้) ผลลัพธ์ที่ได้คือ
dat[0] = ‘a’;
dat[1] = ‘b’;
dat[2] = ‘c’;
dat[3] = ‘d’;
dat[4] = ‘e’;
การเรียกใช้ เช่น หลังจากประกาศอะเรย์ข้างบน
char i , j ;
i = 3;
j = dat[i]; // j = dat[i] -> j = dat[3] -> j = ‘d’
/*ผลลัพธ์คือ j = ‘d’ */
โดยในการประกาศตัวแปรชนิดอะเรย์สามารถประกาศใช้งานเป็นแบบ Global หรือ แบบ Local หรือแต่นำไปเป็นตัวแปร parameter เพื่อรับการส่งผ่านค่าของฟังก์ชั่นก็ได้
ตัวอย่าง
การประกาศตัวแปรชนิดอะเรย์ชนิดข้อมูลแบบ float พร้อมกับกำหนดค่าข้อมูลให้กับสมาชิก ประกาศเป็น float cal[5] = {0.85 , 6.23 , 4.7 , 10.8 , 2.14} ;
ดังนั้น
cal[0] = 0.85;
cal[1] = 6.23;
cal[2] = 4.7;
cal[3] = 10.8;
cal[4] = 2.14;
ตัวอย่าง
การประกาศตัวแปรอะเรย์ชนิดข้อมูลแบบ long พร้อมกับกำหนดค่าข้อมูลให้กับสมาชิก ประกาศเป็น long store[4] = {20L , 500L , 49L , 1055L , 412L} ;
การประกาศตัวแปรอะเรย์ชนิดข้อมูลแบบ long พร้อมกับกำหนดค่าข้อมูลให้กับสมาชิก ประกาศเป็น long store[4] = {20L , 500L , 49L , 1055L , 412L} ;
ดังนั้น
store[0] = 20L;
store[1] = 500L;
store[2] = 49L;
store[3] = 1055L;
store[4] = 412L;
!หมายเหตุ ข้อมูลชนิด long สามารถระบุให้ชัดเจนได้โดยใช้อักษร “l” หรือ “L” ต่อท้ายตัวเลขข้อมูลด้วย
นอกจากนี้ยังสามารถใช้ตัวแปรอะเรย์ที่มากกว่า 1 มิติ ได้ด้วย
อะเรย์ 2 มิติ
รูปแแบบการประกาศใช้ตัวแปรอะเรย์ 1 มิติทำได้ดังนี้
type name[x][y];
type name[x][y];
โดยที่ type คือ ชนิดของข้อมูลตัวแปรอะเรย์
name คือ ชื่อของตัวแปรอะเรย์
x คือ ค่าของตัวเลขกำหนดขนาดแถวของอะเรย์
y คือ ค่าของตัวเลขกำหนดขนาดหลักของอะเรย์
เช่น int a[2][5];เป็นการประกาศให้ a เป็นตัวแปรอะเรย์ 2 มิติ ชนิดข้อมูลแบบ int มีจำนวนสมาชิกทั้งหมด 10 ตัว
ได้แก่ a[0][0] , a[0][1] , a[0][2] , a[0][3] , a[0][4] ,
a[1][0] , a[1][1] , a[1][2] , a[1][3] , a[1][4]
การกำหนดค่าข้อมูลเริ่มต้นก็สามารถทำได้เช่น
int menu[3][4] ={{1,3,4,9} , {2,8,0,5}}; เป็นการประกาศให้ menu เป็นตัวแปรอะเรย์ 2 มิติ ชนิดข้อมูลแบบ int มีจำนวนสมาชิกทั้งหมด 12 ตัว และกำหนดค่าข้อมูลเริ่มต้น
ดังนั้น menu[0][0] = 1 menu[0][1] = 3 menu[0][2] = 4 menu[0][3] = 9
menu[1][0] = 2 menu[1][1] = 8 menu[1][2] = 0 menu[1][3] = 5
menu[2][0] = 0 menu[2][1] = 0 menu[2][2] = 0 menu[2][3] = 0
ตัวแปร Pointers
ตัวแปรพอยน์เตอร์ คือ ตัวแปรที่ทำหน้าที่เก็บค่าตำแหน่งที่อยู่หรือแอดเดรสของตัวแปรที่ทำการชี้ หรือแอดเดรสตำแหน่งใดๆ มีรูปแบบการประกาศใช้งานดังนี้
type * name;
โดยที่ type คือ ชนิดข้อมูลของตัวแปรพอยน์เตอร์
name คือ ชื่อตัวแปรพอยน์เตอร์ที่ใช้ประกาศ
เช่น
char *ptr; เป็นการประกาศให้ ptr เป็นตัวแปร Pointers ที่ใช้ชี้ข้อมูลแบบ char
int *a; เป็นการประกาศให้ a เป็นตัวแปร Pointers ที่ใช้ชี้ข้อมูลแบบ int
float *storage_num; เป็นการประกาศให้ storage_num เป็นตัวแปร Pointers ที่ใช้ชี้ข้อมูลแบบ float long *number; เป็นการประกาศให้ number เป็นตัวแปร Pointers ที่ใช้ชี้ข้อมูลแบบ long
การเข้าถึงตำแหน่งแอดเดรสของตัวแปร
การเข้าถึงตำแหน่งแอดเดรสของตัวแปรใดๆด้วยพอยน์เตอร์ สามารถอ้างอิงตำแหน่งด้วยเครื่องหมาย “&” นำหน้าตัวแปร และเมื่อต้องการให้ตัวแปรพอยน์เตอร์กระทำกับข้อมูลที่กำลังชี้อยู่ ณ ขณะนั้นทำได้โดยการใส่เครื่องหมาย “*” นำหน้าตัวแปรพอยน์เตอร์นั้น
เช่นประกาศ
int *ptr; // เป็นการประกาศตัวแปรพอยน์เตอร์ ชื่อ ptr สำหรับเก็บค่าแอดเดรสแบบ int
int x; // เป็นการประกาศตัวแปรชื่อ x ชนิดข้อมูลแบบ int
ptr = &x; // กำหนดให้ ptr เก็บค่าตำแหน่งแอดเดรส x
*ptr = 100; // กำหนดค่าข้อมูลให้กับตำแหน่งแอดเดรส ptrชี้อยู่มีค่าเป็น 100 ซึ่งก็คือค่าของ x ด้วย
lcd(“%d”,x); // ทดสอบเรียกค่าของ x มาแสดงผลที่หน้าจอ LCD ซึ่งจะมีค่าเป็น 100 นั่นเอง
ตัวอย่างที่ 10
ลองทดสอบตัวอย่างโปรแกรมต่อไปนี้
#include // ผนวกไลบรารีหลักที่สนับสนุนบอร์ด IPST
void main() // โปรแกรมหลักของภาษา C
{
long X; // เป็นการประกาศตัวแปรชื่อ X ชนิดข้อมูลแบบ long
long *Xptr; // เป็นการประกาศตัวแปรพอยน์เตอร์ ชื่อ Xptr สำหรับเก็บค่าแอดเดรสแบบ long
X=50L; // กำหนดค่า X เท่ากับ 50 (เนื่องจากเป็นชนิดข้อมูล long ต้องใส่ L ตามหลังด้วย)
Xptr=&X; // กำหนดให้ Xptr เก็บค่าตำแหน่งแอดเดรส X
lcd("*Xptr = %L #c ",*Xptr); // ค่าแรกที่แสดงบนหน้าจอ LCD คือค่าข้อมูลของ X นั่นเอง(X=50L)
// และสั่งเคลียร์ข้อความก่อนแสดงข้อความครั้งถัดไป
sleep(2000); // หน่วงเวลาแสดงค่าผลลัพธ์
X=100L; // โหลดให้ค่า X = 100L
lcd("*Xptr = %L #c ",*Xptr); // ค่าที่สองแสดงบนหน้าจอ LCD คือค่าข้อมูลของ X นั่นเอง(X=100L)
// และสั่งเคลียร์ข้อความก่อนแสดงข้อความครั้งถัดไป
sleep(2000); // หน่วงเวลาแสดงค่าผลลัพธ์
*Xptr=200L; // โหลดให้ค่า X = 200L โดยโหลดผ่านตัวแปรพอยน์เตอร์
lcd("X =%L #c ",X); // แสดงค่าสุดท้ายของค่า X (X=200L)
// และสั่งเคลียร์ข้อความก่อนแสดงข้อความครั้งถัดไป
while(1); // เบรกโปรแกรม
}
********************************************************************
ตัวดำเนินการในภาษา C
ตัวอย่างที่ 1
*******************************************************************************************
ตัวอย่างที่ 2
********************************************************************
ตัวดำเนินการในภาษา C
ในโปรแกรมภาษา C นั้นมีตัวดำเนินการเหมือนกับภาษา C ตามมาตรฐาน ANSI-C(คำสั่งมาตรฐานของภาษา C ที่ใช้พัฒนาบนคอมพิวเตอร์ที่คอมไพเลอร์ในแต่ละผู้ผลิตจะต้องมีเหมือนกันเป็นพื้นฐาน) ทั่วๆไป Operator ของภาษา C นั้นได้ถูกแบ่งเป็นกลุ่มได้ 3 กลุ่ม ใหญ่ๆ ได้แก่ ตัวดำเนินการทางคณิตศาสตร์(Arithmetic Operator), ตัวดำเนินการทางด้านความสัมพันธ์และตรรกะ(Relation & logic Operation)และตัวดำเนินการทางบิต(Bitwise Operation)
1. ตัวดำเนินการทางคณิตศาสตร์(Arithmetic Operator)
การกระทำในกลุ่มนี้ พอสรุปได้เป็นตารางดังนี้
Operator | ความหมาย |
+ | การบวก |
- | การลบ |
* | การคูณ |
/ | การหาร |
% | การหารแบบ modulo(หารเอาเศษ) |
++ | การเพิ่มค่าขึ้นอีกหนึ่งค่า |
- - | การลดค่าลงอีกหนึ่งค่า |
+= | การบวกขึ้นอีกเท่ากับค่าทางขวามือ |
-= | การลดลงอีกเท่ากับค่าทางขวามือ |
*= | การคูณด้วยเท่ากับค่าทางขวามือ |
/= | การหารด้วยเท่ากับค่าทางขวามือ |
%= | การหารด้วยเท่ากับค่าทางขวามือ(modulo) |
· การ + และการ - ที่ควรทราบ
ตัวอย่างที่ 1
int a = 12;
a = a + 3;
ผลลัพธ์คือ a = 15
ซึ่งการทำงานก็คือ เริ่มต้น a มีค่าเป็น 12 ต่อมาสั่งให้ค่า a บวกกับ 3 แล้วเอาผลลัพธ์ที่ได้คือ 15 เก็บไว้ที่ a อีกครั้งหนึ่ง
ตัวอย่างที่ 2
int a = 12;
a = a - 3;
ผลลัพธ์คือ a = 9
ซึ่งการทำงานก็คือ เริ่มต้น a มีค่าเป็น 12 ต่อมาสั่งให้ค่า a ลบกับ 3 แล้วเอาผลลัพธ์ที่ได้คือ 9 เก็บไว้ที่ a อีกครั้งหนึ่ง
· การหารแบบ / และการหารแบบ % จะมีความแตกต่างกันตรงที่
1. การหารแบบ / จะเป็นการหารเก็บค่าจำนวนเต็มที่หารลงตัว
2. การหารแบบ % จะเป็นการหารเก็บค่าเศษที่เหลือจากการหาร
ตัวอย่างที่ 3
int x , y , z;
x = 10;
y = x/3;
z = x%3;
ผลลัพธ์คือ y = 9 และ z = 1
ซึ่งการทำงานก็คือ
y = x/3; è y = 10/3 è y = 3 (จำนวนครั้งที่หารลงตัว)
z = x%3; è z = 10%3 è z = 1 (เศษที่เหลือจากการหาร)
· การเพิ่มค่าแบบ ++ และการลดค่าแบบ - -
ตัวอย่างที่ 4
int y = 5;
y++;
ผลลัพธ์คือ y = 6
ซึ่งการทำงานก็คือ เริ่มต้น y มีค่าเป็น 5 ต่อมาสั่งให้ค่า y บวกกับ 1 แล้วเอาผลลัพธ์ที่ได้คือ 6 เก็บไว้ที่ y อีกครั้งหนึ่ง ดังนั้นคำสั่ง y++; ให้ผลลัพธ์เหมือนกับ y = y + 1;
ตัวอย่างที่ 5
int y = 5;
y- -;
ผลลัพธ์คือ y = 4
ซึ่งการทำงานก็คือ เริ่มต้น y มีค่าเป็น 5 ต่อมาสั่งให้ค่า y ลบกับ 1 แล้วเอาผลลัพธ์ที่ได้คือ 4 เก็บไว้ที่ y อีกครั้งหนึ่ง ดังนั้นคำสั่ง y--; ให้ผลลัพธ์เหมือนกับ y = y - 1;
· การเพิ่มค่าแบบ += และการลดค่าแบบ - =
อธิบายเทียบเคียงได้ว่า
y +=a; ให้ผลลัพธ์เหมือนกับ y = y + a;
y -=a; ให้ผลลัพธ์เหมือนกับ y = y - a;
ตัวอย่างที่ 5
int x = 100;
x += 10;
ผลลัพธ์คือ x = 110
· การคูณค่าแบบ *= , การหารค่าแบบ /= และการหารค่าแบบ %=
อธิบายเทียบเคียงได้ว่า
y *=a; ให้ผลลัพธ์เหมือนกับ y = y * a;
y /=a; ให้ผลลัพธ์เหมือนกับ y = y/a;
y %=a; ให้ผลลัพธ์เหมือนกับ y = y%a;
ตัวอย่างที่ 6
int i , x , y , z;
i = 120;
x *= 4;
y /= 4;
z %= 4;
ผลลัพธ์คือ x = 480 , y = 30 และ z = 0
2. ตัวดำเนินการทางด้านความสัมพันธ์และตรรกะ(Relation & logic Operation)
การกระทำในกลุ่มนี้ ผลลัพธ์จากการตรวจสอบเงื่อนไขจะมีค่าเป็น 1 ถ้าเงื่อนไขนั้นเป็นจริง(true) และจะมีค่าเป็น 0 เมื่อเงื่อนไขเท็จ(false)
ซึ่งการกระทำในกลุ่มนี้พอสรุปได้เป็นตารางดังนี้
Operator | ความหมาย |
== | เท่ากับ |
!= | ไม่เท่ากับ |
> | มากกว่า |
< | น้อยกว่า |
>= | มากกว่าหรือเท่ากับ |
<= | น้อยกว่าหรือเท่ากับ |
! | ไม่ใช่(NOT) |
&& | และ(AND) |
|| | หรือ(OR) |
ตัวอย่างที่ 7
ถ้ากำหนดให้
a = 10
b = 4
c = 0xA0
เงื่อนไข a>b เงื่อนไขเป็นจริง(true) ค่าผลลัพธ์เป็น 1
เงื่อนไข a>c เงื่อนไขเป็นเท็จ(false) ค่าผลลัพธ์เป็น 0
เงื่อนไข a>=c เงื่อนไขเป็นจริง(true) ค่าผลลัพธ์เป็น 1(เพราะ 0xA0 = 10)
เงื่อนไข a != b เงื่อนไขเป็นจริง(true) ค่าผลลัพธ์เป็น 1
เงื่อนไข a != c เงื่อนไขเป็นจริง(false) ค่าผลลัพธ์เป็น 0
· การใช้ ! , && , || เปรียบเทียบประโยคเงื่อนไข
ผลลัพธ์ของการ ! (NOT)พอสรุปได้ดังนี้
ผลลัพธ์กระทำกับผลลัพธ์ | ผลลัพธ์ที่ได้ |
! false | true(1) |
! true | false(0) |
สรุปว่าผลลัพธ์ของการกระทำด้วย NOT จะได้ค่าผลลัพธ์ที่ตรงข้ามนั่นเอง
ผลลัพธ์ของการเปรียบเทียบของประโยค 2 ประโยค ด้วย &&(AND) พอสรุปได้ดังนี้
ผลลัพธ์กระทำกับผลลัพธ์ | ผลลัพธ์ที่ได้ |
false && false | false(0) |
False && true | false(0) |
true && false | false(0) |
true && true | true(1) |
สรุปว่าผลลัพธ์ของการกระทำด้วย AND จะได้ค่าผลลัพธ์เป็น false ทันที หากตัวใดตัวหนึ่ง หรือทั้งคู่เป็น false
ผลลัพธ์ของการเปรียบเทียบของประโยค 2 ประโยค ด้วย ||(OR)พอสรุปได้ดังนี้
ผลลัพธ์กระทำกับผลลัพธ์ | ผลลัพธ์ที่ได้ |
False || false | false(0) |
False || true | true(1) |
True || false | true(1) |
True || true | true(1) |
สรุปว่าผลลัพธ์ของการกระทำด้วย OR จะได้ค่าผลลัพธ์เป็น true ทันที หากตัวใดตัวหนึ่ง หรือทั้งคู่เป็น true
ตัวอย่างที่ 8
ถ้ากำหนดให้
a = 10
b = 4
c = 0xA0
เงื่อนไข a>b เงื่อนไขเป็นจริง(true) ค่าผลลัพธ์เป็น 1
เงื่อนไข a>c เงื่อนไขเป็นเท็จ(false) ค่าผลลัพธ์เป็น 0
เงื่อนไข a>=c เงื่อนไขเป็นจริง(true) ค่าผลลัพธ์เป็น 1(เพราะ 0xA0 = 10)
เงื่อนไข a != b เงื่อนไขเป็นจริง(true) ค่าผลลัพธ์เป็น 1
เงื่อนไข a != c เงื่อนไขเป็นเท็จ(false) ค่าผลลัพธ์เป็น 0
และถ้าเป็น
เงื่อนไข !(a>b) เงื่อนไขเป็นเท็จ(false) ค่าผลลัพธ์เป็น 0
เงื่อนไข !(a>c) เงื่อนไขเป็นจริง(true) ค่าผลลัพธ์เป็น 1
เงื่อนไข !(a>=c) เงื่อนไขเป็นเท็จ(false) ค่าผลลัพธ์เป็น 0
เงื่อนไข !(a != b) เงื่อนไขเป็นเท็จ(false) ค่าผลลัพธ์เป็น 0
เงื่อนไข !(a != c) เงื่อนไขเป็นจริง(true) ค่าผลลัพธ์เป็น 1
และถ้าเป็น
เงื่อนไข !(a>b) && (a>=c) ค่าผลลัพธ์เป็น false(0)
เงื่อนไข (a != b) && (a>=c) ค่าผลลัพธ์เป็น true(1)
เงื่อนไข (a != b) && !(a != b) ค่าผลลัพธ์เป็น false(0)
และถ้าเป็น
เงื่อนไข !(a>b) || (a>=c) ค่าผลลัพธ์เป็น true(1)
เงื่อนไข (a != b) || (a>=c) ค่าผลลัพธ์เป็น true(1)
เงื่อนไข (a != b) || !(a != b) ค่าผลลัพธ์เป็น true(1)
เงื่อนไข !(a>=c) || !(a != b) ค่าผลลัพธ์เป็น false(0)
3. ตัวดำเนินการทางบิต(Bitwise Operation)
การกระทำในกลุ่มนี้ จะเป็นการกระทำที่เข้าถึงในระดับบิตของข้อมูล โดยที่ค่าของแต่ละบิตเป็นได้แค่ 1 หรือ 0 เท่านั้น
ซึ่งการกระทำในกลุ่มนี้พอสรุปได้เป็นตารางดังนี้
Operator | ความหมาย |
~ | กลับค่าของบิตข้อมูล |
& | การ AND แบบบิต |
| | การ OR แบบบิต |
^ | การ exclusive OR แบบบิต |
<< | เลื่อนบิตไปทางซ้าย |
>> | เลื่อนบิตไปทางขวา |
<<= | เลื่อนบิตไปทางซ้ายแล้วให้เท่ากับ |
>>= | เลื่อนบิตไปทางขวาแล้วให้เท่ากับ |
&= | AND แล้วให้เท่ากับ |
|= | OR แล้วให้เท่ากับ |
^= | exclusive OR แล้วให้เท่ากับ |
ผลลัพธ์ของการ ~ พอสรุปได้ดังนี้
การกระทำ | ผลลัพธ์ที่ได้ |
~ 0 | 1 |
~ 1 | 0 |
สรุปว่าผลลัพธ์ของการกระทำด้วย ~ จะได้ค่าผลลัพธ์ของลอจิกที่ตรงข้ามนั่นเอง
ผลลัพธ์ของการ & แบบบิตต่อบิต พอสรุปได้ดังนี้
การกระทำ | ผลลัพธ์ที่ได้ |
0 & 0 | 0 |
0 &1 | 0 |
1 & 0 | 0 |
1 & 1 | 1 |
สรุปว่าผลลัพธ์ของการ & แบบบิตต่อบิต จะได้ค่าผลลัพธ์เป็น 0 ทันที หากตัวใดตัวหนึ่ง หรือทั้งคู่เป็น 0
ผลลัพธ์ของการ | แบบบิตต่อบิต พอสรุปได้ดังนี้
การกระทำ | ผลลัพธ์ที่ได้ |
0 | 0 | 0 |
0 | 1 | 1 |
1 | 0 | 1 |
1 | 1 | 1 |
สรุปว่าผลลัพธ์ของการ | แบบบิตต่อบิต จะได้ค่าผลลัพธ์เป็น 1 ทันที หากตัวใดตัวหนึ่ง หรือทั้งคู่เป็น 1
ผลลัพธ์ของการ ^ แบบบิตต่อบิต พอสรุปได้ดังนี้
การกระทำ | ผลลัพธ์ที่ได้ |
0 ^ 0 | 0 |
0 ^1 | 1 |
1 ^ 0 | 1 |
1 ^ 1 | 0 |
สรุปว่าผลลัพธ์ของการ ^ แบบบิตต่อบิต จะได้ค่าผลลัพธ์เป็น 0 ทันที หากทั้งคู่มีค่าเหมือนกัน
ตัวอย่างที่ 9
int x,y,result1,result2,result3,result4;
x = 0x9C;
y = 0x46;
จงหาผลลัพธ์ของ
1) result1 = x&y;
2) result2 = x|y;
3) result3 = x^y;
4) result4 = ~x;
วิธีคิด
เนื่องจากเป็นการกระทำแบบบิตต่อบิต เพื่อความสะดวกเราจะแปลงจากเลขฐาน 16 ไปเป็นเลขฐาน 2 ซึ่งก็คือ x = 0x9C è 0000000010011100 (ตัวแปร int มีขนาดเป็น 16 บิต)
y = 0x46 è 0000000001000110 (ตัวแปร int มีขนาดเป็น 16 บิต)
1) result1 = (0000000010011100) & (0000000001000110)
0000000010011100
AND
0000000001000110
0000000000000100 è 0x0004 หรือ 0x04
2) result2 = (0000000010011100) | (0000000001000110)
0000000010011100
OR
0000000001000110
0000000011011110 è 0x00DE หรือ 0xDE
3) result3 = (0000000010011100) ^ (0000000001000110)
0000000010011100
XOR
0000000001000110
0000000011011010 è 0x00DA หรือ 0xDA
4) result4 = ~(0000000010011100) กลับบิตข้อมูลทุกบิต
1111111101100011 è 0xFF63
· การเลื่อนบิตข้อมูล
ในการเลื่อนบิตจะต้องบอกจำนวนครั้งการเลื่อนด้วยว่าให้มีการเลื่อนกี่ครั้ง
เช่น dat = dat<<4; หมายถึงให้เลื่อนบิตค่าข้อมูล dat ไปทางซ้าย 4 ครั้ง แล้วผลลัพธ์ที่ได้เก็บไว้ที่ dat เหมือนเดิม ซึ่งจะให้ผลลัพธ์เหมือน dat <<=4;
หรือ dat = dat>>1; หมายถึงให้เลื่อนบิตค่าข้อมูล dat ไปทางขวา 1 ครั้ง แล้วผลลัพธ์ที่ได้เก็บไว้ที่ dat เหมือนเดิม ซึ่งจะให้ผลลัพธ์เหมือน dat >>=1;
ตัวอย่างที่ 10
int dat , x1 , x2;
dat = 0x93;
จงหาผลลัพธ์ของ
1) x1 = dat<<1;
2) x2 = dat<<2;
วิธีคิด
dat = 0x93 è 0000000010010011 (ตัวแปร int มีขนาดเป็น 16 บิต)
dat | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 1 | 0 | 0 | 1 | 1 |
X1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 1 | 0 | 0 | 1 | 1 | 0 |
X2 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 1 | 0 | 0 | 1 | 1 | 0 | 0 |
จากตาราง
1)
x1 คือ ค่าผลลัพธ์จากการเลื่อนบิตข้อมูล dat ไปทางซ้าย 1 ครั้ง ซึ่งจากตาราง
x1 = 0x0126 ตรงกับเลขฐานสิบคือ 294
2)
x2 คือ ค่าผลลัพธ์จากการเลื่อนบิตข้อมูล x1 ไปทางซ้าย 1 ครั้ง หรือเป็นการเลื่อนบิตข้อมูล dat ไปทางซ้าย 2 ครั้งซึ่งจากตาราง
x2 = 0x024C ตรงกับเลขฐานสิบคือ 588
ตัวอย่างที่ 11
int a , b , c;
a = 0x7A;
b = 0x16;
c = 0xFD;
จงหาผลลัพธ์ของ
1) a &= 0x3C;
2) b |= 0x51;
3) c ^= 0xD0;
วิธีคิด
1) จาก a &= 0x3C ก็คือ a = a & 0x3C หมายความว่า นำค่าของ a(คือ 0x7A) ไปAND กับ 0x3C แล้วผลลัพธ์ที่ได้นำไปเก็บที่ a อีกครั้งหนึ่ง เราก็คำนวณหาผลลัพธ์เหมือนที่เคยทำมา
เทียบได้เป็น a = (0000000001111010) & (0000000000111100)
0000000001111010
AND
0000000000111100
0000000000111000 è 0x0038 หรือ 0x38
2) จาก b |= 0x51 ก็คือ b = b & 0x51 หมายความว่า นำค่าของ b(คือ 0x16) ไปOR กับ 0x51 แล้วผลลัพธ์ที่ได้นำไปเก็บที่ b อีกครั้งหนึ่ง
เทียบได้เป็น b = (0000000000010110) & (0000000001010001)
0000000000010110
OR
0000000001010001
0000000001010111 è 0x0057 หรือ 0x57
3) จาก c ^= 0xD0; ก็คือ c = c & 0xD0 หมายความว่า นำค่าของ c(คือ 0xFD) ไปXOR กับ 0xD0 แล้วผลลัพธ์ที่ได้นำไปเก็บที่ c อีกครั้งหนึ่ง
เทียบได้เป็น c = (0000000011111101) & (0000000011010000)
0000000011111101
XOR
0000000011010000
0000000000101101 è 0x002D หรือ 0x2D
คำสั่งควบคุมต่างๆในภาษา C
คำสั่งในภาษา C ที่ใช้ส่วนใหญ่แล้วจะมีลักษณะชุดคำสั่งที่ตรงกับมาตรฐานภาษา C (ANSI-C) เป็นหลัก แต่ก็มีบางส่วนที่เพิ่มเติม และถูกตัดออกไป เพื่อให้เหมาะสมกับทรัพยากรที่มีจำกัดภายในตัวไมโครคอนโทรเลอร์เอง โดยคำสั่งในภาษา C หลักๆก็จะประกอบด้วย คำสั่งแบบตรวจสอบเงื่อนไข และคำสั่งวนลูป ซึ่งจะมีลักษณะคำสั่งดังนี้
1. คำสั่ง if
2. คำสั่ง if-else
3. คำสั่ง switch
4. คำสั่ง for
5. คำสั่ง while
6. คำสั่ง do-while
ซึ่งต่อไปนี้เราจะมาทำความรู้จักกับชุดคำสั่งดังกล่าวกัน
คำสั่ง if
เป็นคำสั่งที่ใช้บ่อยมาก ซึ่งเป็นคำสั่งที่ใช้ในการตรวจสอบเงื่อนไข(Condition) ว่าเป็นจริงหรือเท็จ
รูปแบบ คือ
if(Condition)
{
block
}
block หมายถึงชุดคำสั่งที่อยู่ภายในช่วงวงเล็บปีกกา “{ }” ซึ่งอาจจะมีเพียงแค่ 1 สั่ง หรือ หลายๆคำสั่งก็ได้
ถ้าโปรแกรมมีการตรวจแล้วพบว่า Condition นั้นเป็นจริง ก็จะเข้าไปทำคำสั่งภายใน block แต่ถ้าเป็นเท็จ ก็จะเลยไปทำคำสั่งที่อยู่ต่อไปภายนอก block แต่ถ้าคำสั่งใน block มีเพียงคำสั่งเดียว เราอาจจะไม่ต้องใส่เครื่องหมายปีกกาด้วยก็ได้ เช่น
if(i==4)
{ if(i==4)
y = 46; è y = 46;
}
ตัวอย่างที่ 1
unsigned char i , j ; // ประกาศตัวแปร ให้เป็นแบบ character มีค่าในช่วง(0-255)
i = 5; // กำหนดค่าเริ่มต้นของตัวแปร i
j = 3; // กำหนดค่าเริ่มต้นของตัวแปร j
if(i>=5) // ตรวจสอบเงื่อนไข ถ้า i มากกว่า หรือเท่ากับ 5 ให้ทำคำสั่งใน block
{
j = i +10; // คำสั่งที่ 1
i = 7; // คำสั่งที่ 2
}
/*------------------result----------------------------*/
j = 15
i = 7
/*-----------------------------------------------------*/
จากตัวอย่างที่ 1 จะเห็นว่าผลลัพธ์หลังจากการตรวจสอบเงื่อนไข if พบว่า เงื่อนไขเป็นจริง เพราะ i = 5 (ได้ถูกกำหนดเป็นค่าเริ่มต้น) จึงมีการแวะทำ คำสั่งที่ 1 และ คำสั่งที่ 2 ภายใน block ตามลำดับ
· คำสั่งที่ 1: j = i +10 è j = 5+10 è j = 15
· คำสั่งที่ 2: i = 7 (สั่ง Load ค่าตรงๆ)
ตัวอย่างที่ 2
unsigned char i , j ; // ประกาศตัวแปร ให้เป็นแบบ character มีค่าในช่วง(0-255)
i = j = 2; // กำหนดค่าเริ่มต้นของตัวแปร I และ j ให้มีค่าเท่า 2 ทั้งคู่
if(i==5) // ตรวจสอบเงื่อนไข ถ้า i เท่ากับ 5 ให้ทำคำสั่งใน block
{
j = i +1; // คำสั่งที่ 1
i = 14; // คำสั่งที่ 2
}
if(j==2) // ตรวจสอบเงื่อนไข ถ้า i เท่ากับ 2 ให้ทำคำสั่งใน block
j = j+1; // คำสั่งที่ 3
/*------------------result----------------------------*/
j = 3
i = 2
/*-----------------------------------------------------*/
จากตัวอย่างที่ 2 จะเห็นว่าผลลัพธ์หลังจากการตรวจสอบเงื่อนไข if(i==5) พบว่า เงื่อนไขไม่เป็นจริง ดังนั้นจึงไม่มีการแวะทำ คำสั่งที่ 1 และ คำสั่งที่ 2 ภายใน block แรก ต่อมาเมื่อผ่านมาเจอคำสั่ง if(j==2)จึงมีการตรวจสอบเงื่อนไขดังกล่าวอีกครั้ง และพบว่าเงื่อนไขดังกล่าวเป็นจริง ทำให้ต้องมีการแวะทำคำสั่งที่ 3(เนื่องจากว่าคำสั่ง
if(j==2) มีคำสั่งต่อจากการตรวจสอบเงื่อนไขเพียงคำสั่งเดียว ไม่จำเป็นต้องหุ้มด้วยเครื่องหมาย”{ }” ก็ได้)
· คำสั่งที่ 3: j = j +1 è j = 2+ 1 è j = 3
i = 2 (เพราะไม่พบคำสั่งใด ให้เปลี่ยนแปลงค่า i)
นอกจากนี้ที่ตำแหน่ง Condition นอกจากจะใช้เป็นประโยคเปรียบเทียบด้วยเครื่องหมายทางคณิตศาสตร์และตรรกแล้ว ยังสามารถใช้ในการตรวจสอบค่าคงที่ หรือ ค่าของตัวแปรใดๆที่นำมาเป็นเงื่อนไขได้ด้วย
1. ถ้าหากค่าตัวเลข หรือตัวแปรเงื่อนไขดังกล่าวมีค่าไม่เท่ากับ 0 เงื่อนไขดังกล่าวจะเป็นจริง
จะมีการกระทำคำสั่งภายใน block ของคำสั่ง if นั้นๆ
2. ถ้าหากค่าตัวเลข หรือตัวแปรเงื่อนไขดังกล่าวมีค่าเท่ากับ 0 เงื่อนไขดังกล่าวจะเป็นเท็จ
จะไม่มีการกระทำคำสั่งภายใน block ของคำสั่ง if นั้นๆ
ซึ่งจะยกตัวอย่างดังต่อไปนี้
ตัวอย่างที่ 3
unsigned char a , b; // ประกาศตัวแปร a และ b ให้เป็นแบบ character มีค่าในช่วง(0-255)
a = 10; // กำหนดค่าเริ่มต้นให้ a = 10
b = 20; // กำหนดค่าเริ่มต้นให้ a = 20
if(a>5 && b<=60) // ถ้า a > 5 และ b <= 60 จะทำคำสั่งใน block
{ // จะทำคำสั่งที่ 1 และ 2
a = 100; // คำสั่งที่ 1
b = 200; // คำสั่งที่ 2
}
if(b>100 || b==80) // ถ้า b > 100 หรือ b = 80 จะทำคำสั่งใน block
{ // จะทำคำสั่งที่ 3 และ 4
a = a -10; // คำสั่งที่ 3
b = b -20; // คำสั่งที่ 4
}
/*------------------result----------------------------*/
a = 90
b = 180
/*-----------------------------------------------------*/
จากตัวอย่างที่ 5
การตรวจสอบเงื่อนไข if(a>5 && b<=60) พบว่า เงื่อนไขเป็นจริงเพราะ a = 10 มากกว่า 5 จริง และ b = 20 น้อยกว่า 60 จริง ดังนั้น จึงมีการแวะทำ คำสั่งที่ 1 และ คำสั่งที่ 2 ภายใน block แรก
คำสั่งที่ 1 a = 100;
คำสั่งที่ 2 b = 200;
เงื่อนไขต่อมา if(b>100 || b==80) มีการตรวจสอบเงื่อนไขดังกล่าวอีกครั้ง พบว่าเงื่อนไขดังกล่าวเป็นจริง เพราะ b = 200 มากกว่า 100 จริง (เป็นจริงแค่ประโยคเดียวก็ให้ผลลัพธ์ Condition เป็นจริงแล้ว) ดังนั้น จึงมีการแวะทำ คำสั่งที่ 3 และ คำสั่งที่ 4 ภายใน block
คำสั่งที่ 3 a = a -10; è a = 100 -10 è a = 90
คำสั่งที่ 4 b = b -20; è b = 200 -20 è b = 180
คำสั่ง if-else
เป็นคำสั่งที่ตรวจสอบเงื่อนไข(Condition) ว่าเป็นจริงหรือเท็จ ซึ่งจะมีการเลือกกระทำอย่างใดอย่างหนึ่ง
รูปแบบ คือ
if(Condition)
{
block1 // ทำในส่วนนี้ถ้าเงื่อนไขเป็น”จริง”
}
else
{
block2 // ทำในส่วนนี้ถ้าเงื่อนไขเป็น”เท็จ”
}
จากรูปแบบถ้าโปรแกรมมีการตรวจแล้วพบว่า Condition นั้นเป็นจริง ก็จะเข้าไปทำคำสั่งภายใน block1 แต่ถ้าเป็นเท็จ ก็จะไปทำคำสั่งภายใน block2
ตัวอย่างที่ 4
char m = 2;
int x = 0;
if(m==1) // ตรวจสอบว่า m = 1 จริงหรือไม่
x = 50; // ถ้า”จริง”
else
x = 80; // ถ้า”เท็จ”
/*------------------result----------------------------*/
x = 80
/*-----------------------------------------------------*/
จากตัวอย่างที่ 6
การตรวจสอบเงื่อนไข if(m==1) พบว่า เงื่อนไขเป็นเท็จเพราะ m = 2 ดังนั้น
ทำคำสั่งต่อท้าย else x = 80; è x = 80
ตัวอย่างที่ 5
char z = 10;
if(z>=5) // ตรวจสอบว่า z >= 5 จริงหรือไม่
{ // ตรวจสอบแล้วเงื่อนไขเป็น ”จริง” จะทำคำสั่งที่ 1 และ 2
z += 15; // คำสั่งที่ 1
z = z%10; // คำสั่งที่ 2
}
else
{
z+= 17; // คำสั่งที่ 3
z = z%4 ; // คำสั่งที่ 4
}
/*------------------result----------------------------*/
z = 5
/*-----------------------------------------------------*/
จากตัวอย่างที่ 7
การตรวจสอบเงื่อนไข if(z>=5) พบว่า เงื่อนไขเป็นจริงเพราะ z = 10 มากกว่า 5 จริง ดังนั้น จึงมีการแวะทำ คำสั่งที่ 1 และ คำสั่งที่ 2 ภายใน block แรก
คำสั่งที่ 1 z += 15; èZ = Z + 15 è Z = 10 + 15 è Z = 25
คำสั่งที่ 2 z = Z%10; è z = 25%10 è z = 5 เป็นผลลัพธ์สุดท้าย
ตัวอย่างที่ 6
char z = 10;
if(z<5) // ตรวจสอบว่า z < 5 จริงหรือไม่
{ // ตรวจสอบแล้วเงื่อนไขเป็น ”เท็จ” จะไม่ทำคำสั่งที่ 1 และ 2
z += 15; // คำสั่งที่ 1
z = z%10; // คำสั่งที่ 2
}
else
{
z+= 17; // คำสั่งที่ 3
z = z%4 ; // คำสั่งที่ 4
}
/*------------------result----------------------------*/
z = 3
/*-----------------------------------------------------*/
จากตัวอย่างที่ 8
การตรวจสอบเงื่อนไข if(z<5) พบว่า เงื่อนไขเป็นเท็จเพราะ z = 10 น้อยกว่า 5 จึงเป็นเท็จ ดังนั้น จึงมีการแวะทำ คำสั่งที่ 3 และ คำสั่งที่ 4 ภายใน block ของส่วน else
คำสั่งที่ 3 z += 17; èZ = Z + 17 è Z = 10 + 17 è Z = 27
คำสั่งที่ 4 z = Z%4; è z = 27%4 è z = 3 เป็นผลลัพธ์สุดท้าย
คำสั่ง switch
switch เป็นคำสั่งที่ใช้ในการตรวจสอบตัวแปรหรือค่าคงที่โดยจะทำงานร่วมกับคำสั่ง case เพื่อช่วยในการตัดสินใจว่าตรงกับ case ใด แต่ถ้าหากว่าตัวแปรหรือค่าคงที่ที่นำมาตรวจสอบไม่ตรงกับ case ใดเลย โปรแกรมจะมีการมองหาคำสั่ง default แล้วทำคำสั่งในส่วนของ default แต่ถ้าหากไม่มีการระบุในคำสั่ง default ก็จะทำให้โปรแกรมออกจากการทำงานในส่วน switch ทันที มีรูปแบบที่ใช้บ่อยๆดังนี้
switch(variable)
{
case const1 : block1
break;
case const2 : block2
break;
case const3 : block3
break;
|
|
|
default : blockn
break;
}
variable คือ ตัวแปรที่เรานำมาตรวจสอบเงื่อนไข
const คือ ค่าที่ใช้เทียบกับตัวแปรที่เรานำมาตรวจสอบ ถ้าตรงกับ ตัวใดจะเข้าไปทำงาน block นั้น
default คือ กรณีของการเปรียบแล้วไม่ตรงกับ case ไหนเลย ก็จะเข้ามาทำใน block คำสั่งนี้ ซึ่งไม่จำเป็นต้องมีเสมอไป
ตัวอย่างที่ 7
unsigned char key = 5;
unsigned char j = 10;
switch(key)
{
case 1 : j = j +key;
break;
case 3 : j = j +key;
break;
case 5 : j = j +key; ç ทำคำสั่ง block นี้
break;
}
/*------------------result----------------------------*/
j = 15
/*-----------------------------------------------------*/
ตัวอย่างที่ 8
unsigned char key = ‘b‘ ;
unsigned char j = 0;
switch(key)
{
case ‘a’ : j = key;
break;
case ‘b’ : j = key; ç ทำคำสั่ง block นี้
break;
case ‘c’ : j = key;
break;
default : j = 0x00;
break;
}
/*------------------result----------------------------*/
j = ‘b’
/*-----------------------------------------------------*/
คำสั่ง for
เป็นคำสั่งที่มีการทำงานแบบวนรอบโดยการตรวจสอบจากเงื่อนไข ซึ่งมักจะมีการวนรอบในการทำงานในจำนวนที่แน่นอน โดยมีรูปแบบเป็น
for(initialize ; condition ; incremental)
{
block
}
โดยที่
initialize คือ ค่าเริ่มต้นที่กำหนดจากตัวแปรที่นำมาเป็นเงื่อนไขในการทำงานแบบวนรอบ
condition คือ เงื่อนไขที่ใช้ในการตรวจสอบว่าจะให้โปรแกรมทำคำสั่งภายใน block หรือไม่ ถ้าเป็นจริงจะมีการทำคำสั่งใน block แต่ในทางกลับกันไม่ ถ้าเป็นเท็จจะมีค่าเป็น”0” จะไม่มีการทำคำสั่งใน block
incremental คือ คำสั่งในการกระทำกับตัวแปรที่นำมาเป็นเงื่อนไข
ตัวอย่างที่ 9
unsigned char i = 0 , dat = 3;
for(i=0;i<8;i++)
{
dat++;
}
/*------------------------result----------------------------*/
dat = 11
/*-----------------------------------------------------------*/
จากตัวอย่างที่ 9
ความหมายของ for(i=0;i<8;i++)
หมายถึง ค่าเริ่มต้น คือ i = 0 ใช้ i เป็นตัวแปรในการตรวจสอบเงื่อนไข
เงื่อนไข คือ i<8 ถ้าหาก i น้อยกว่า 8 จะทำคำสั่งใน block ถ้ามากกว่าจะหลุดจาก block นี้
คำสั่ง คือ i++ ถ้าทำคำสั่งใน block เสร็จแล้วจะเพิ่มค่า i ขึ้นทีละ1
นั่นคือ จะมีการทำคำสั่งใน block ทั้งหมด 8 ครั้ง คือ ตั้งแต่ i = 0 ถึง i = 7 แสดงว่ามีการทำคำสั่ง dat++; ทั้งหมด 8 ครั้ง ทำให้หลังจากวนรอบทำคำสั่ง for เสร็จแล้ว ค่าของ dat จะมีค่าเป็น 11 (เพราะมีค่าเริ่มต้นที่ 3)
ตัวอย่างที่ 10
unsigned char i = 0 , dat = 3;
for(i=0;i<8;i+=2)
dat++;
/*------------------------result----------------------------*/
dat = 7
/*-----------------------------------------------------------*/
จากตัวอย่างที่ 10
ความหมายของ for(i=0;i<8;i+=2)
หมายถึง ค่าเริ่มต้น คือ i = 0 ใช้ i เป็นตัวแปรในการตรวจสอบเงื่อนไข
เงื่อนไข คือ i<8 ถ้าหาก i น้อยกว่า 8 จะทำคำสั่งใน block ถ้ามากกว่าจะหลุดจาก block นี้
คำสั่ง คือ i+=2 ถ้าทำคำสั่งใน block เสร็จแล้วจะเพิ่มค่า i ขึ้นทีละ 2
นั่นคือ จะมีการทำคำสั่งใน block ทั้งหมด 4 ครั้ง คือ i = 0 , 2 , 4 , 6 แสดงว่ามีการทำคำสั่ง dat++; ทั้งหมด 4 ครั้ง ทำให้หลังจากวนรอบทำคำสั่ง for เสร็จแล้ว ค่าของ dat จะมีค่าเป็น 7 (เพราะมีค่าเริ่มต้นที่ 3)
ตัวอย่างที่ 11
unsigned char i = 0 , dat = 3;
for(i=10;i>=5;i--)
dat++;
/*------------------------result----------------------------*/
dat = 9
/*-----------------------------------------------------------*/
จากตัวอย่างที่ 11
ความหมายของ for(i=10;i>=5;i--)
หมายถึง ค่าเริ่มต้น คือ i = 10 ใช้ i เป็นตัวแปรในการตรวจสอบเงื่อนไข
เงื่อนไข คือ i>=5 ถ้าหาก i มากกว่าหรือเท่ากับ 5 จะทำคำสั่งใน block ถ้าน้อยกว่าจะหลุดจาก block นี้
คำสั่ง คือ i-- ถ้าทำคำสั่งใน block เสร็จแล้วจะลดค่า i ลงทีละ 1
นั่นคือ จะมีการทำคำสั่งใน block ทั้งหมด 6 ครั้ง คือ i = 10 , 9 , 8 , 7 , 6 , 5 แสดงว่ามีการทำคำสั่ง dat++; ทั้งหมด 6 ครั้ง ทำให้หลังจากวนรอบทำคำสั่ง for เสร็จแล้ว ค่าของ dat จะมีค่าเป็น 9 (เพราะมีค่าเริ่มต้นที่ 3)
คำสั่ง while
เป็นคำสั่งที่มีการทำงานแบบวนรอบโดยการตรวจสอบจากเงื่อนไข โดยจะมีรูปแบบเป็น
while(Condition)
{
block
}
โดยที่ condition คือ เงื่อนไขที่ใช้ในการตรวจสอบว่าจะให้โปรแกรมทำคำสั่งภายใน block หรือไม่ ถ้าเป็นจริง จะมีการทำคำสั่งใน block แต่ในทางกลับกันไม่ ถ้าเป็นเท็จจะไม่มีการทำคำสั่งใน block
เช่น while(1)
{
block
}
เป็น while loop ที่จะมีการทำคำสั่งใน block แบบไม่รู้จบ เพราะสังเกตว่าเงื่อนไขจะเป็นจริงตลอดเวลา เพราะที่ตำแหน่งเงื่อนไข(Condition) มีค่าเป็น “1” ซึ่งก็หมายถึงเงื่อนไขเป็นจริงนั่นเอง
แต่ถ้าเป็น while(0)
{
block
}
จะเป็น while loop ที่จะไม่มีการทำคำสั่งใน block นี้เด็ดขาด เพราะสังเกตว่าเงื่อนไขจะเป็นเท็จตลอดเวลา เพราะที่ตำแหน่งเงื่อนไข(Condition) มีค่าเป็น “0” ซึ่งก็หมายถึงเงื่อนไขเป็นเท็จนั่นเอง
หรือถ้าเป็น while(1); จะเทียบได้กับ while(1)
{
}
ซึ่งทั้งสองรูปแบบจะเหมือนกันคือ เงื่อนไขจะเป็นจริงตลอดเวลา แต่จะวนอยู่กับที่ไม่ยอมไปทำคำสั่งถัดไป เพราะไม่มีคำสั่งอยู่ภายใน block เลย ทำให้วนตรวจสอบเงื่อนไขตัวเองและเป็นจริงตลอดเวลา
ตัวอย่างที่ 12
unsigned char count = 10 , j = 0;
while(count>0) // ถ้า count มากกว่า 0 จริง ทำคำสั่งใน block
{
count- -; // ลดค่า count ลง 1
j++; // เพิ่มค่า j ขึ้น 1
}
/*------------------------result----------------------------*/
j = 10
/*-----------------------------------------------------------*/
จากตัวอย่างที่ 12
ในตัวอย่างนี้ใช้ค่าของ count เป็นตัวตรวจสอบเงื่อนไขว่ามากกว่า 0 อยู่หรือเปล่า ถ้าใช่จะเข้าไปทำคำสั่งใน block และทุกครั้งที่เข้าไปทำคำสั่งใน block ของคำสั่ง while จะลดค่า count ลง 1 ค่า และ เพิ่มค่า j 1 ค่า ดังนั้นจะมีการทำคำสั่งใน block ทั้งหมด 10 ครั้ง คือที่ count = 10 , 9 , 8 , 7 , 6 , 5 , 4 , 3 , 2 , 1
ตัวอย่างที่ 13
unsigned char test = ‘a’, m = 0;
while(test==’a’)
{
test = ‘b’; // คำสั่งที่ 1
m = 25; // คำสั่งที่ 2
}
while(test==’b’)
{
test = ‘a’; // คำสั่งที่ 3
m = 80; // คำสั่งที่ 4
}
/*------------------------result----------------------------*/
test = ‘a’
m = 80
/*-----------------------------------------------------------*/
จากตัวอย่างที่ 13
ในตัวอย่างนี้สำหรับค่าเริ่มต้นของ test = ‘a’ และเมื่อโปรแกรมทำงานจะเจอคำสั่งตรวจสอบเงื่อนไข while(test==’a’) และพบว่าเงื่อนไขเป็นจริง จึงทำคำสั่งใน block คือ คำสั่งที่ 1 และ คำสั่งที่ 2
คำสั่งที่ 1 test = ‘b’;
คำสั่งที่ 2 m = 25;
ต่อจากนั้นเมื่อมีการนำ test ไปตรวจสอบเงื่อนไข while(test==’a’)อีกครั้งพบว่าไม่เป็นจริงอีกต่อไป เพราะเกิดจาการทำคำสั่งที่ 1 จึงหลุดออกจาก loop ซึ่งก็จะไปเจอกับคำสั่งตรวจสอบเงื่อนไข while(test==’b’) และพบว่าเงื่อนไขเป็นจริง จึงทำคำสั่งใน block คือ คำสั่งที่ 3 และ คำสั่งที่ 4
คำสั่งที่ 3 test = ‘a’;
คำสั่งที่ 4 m = 80;
คำสั่ง do-while
เป็นคำสั่งที่มีการทำงานแบบวนรอบโดยการตรวจสอบจากเงื่อนไขเหมือนกับคำสั่ง while แต่แตกต่างกันตรงที่ว่าจะมีการทำคำสั่งใน block ก่อน 1 ครั้งแล้วจึงทำการตรวจสอบในเงื่อนไขในส่วนของ while โดยจะมีรูปแบบเป็น
do
{
block
}while(Condition);
ตัวอย่างที่ 14
unsigned char dat = 0 , j = 0;
do
{
dat++; // เพิ่มค่า dat ขึ้น 1 ค่า
}while(j != 0) // ถ้าหาก j ไม่เท่ากับ 0 จะเข้าไปทำคำสั่งในบล็อก(คำสั่ง dat++;)
/*------------------------result----------------------------*/
dat = 1
/*-----------------------------------------------------------*/
จากตัวอย่างที่ 14
จากตัวอย่างนี้จะเห็นว่าครั้งแรกที่เจอคำสั่ง do-while โปรแกรมจะเข้าไปทำคำสั่งใน block ก่อนทันที ดังนั้นจะทำคำสั่ง dat++; ทำให้ dat มีค่าเป็น 1 ก่อน และจึงไปตรวจสอบดูว่า j ไม่เท่ากับ 0 จริงหรือไม่ ปรากฏว่าไม่จริง จึงทำให้หลุดจากการทำคำสั่ง do-while loop แต่ถ้าเป็น
unsigned char dat = 0 , j = 0;
while(j != 0) // เมื่อตรวจสอบพบว่า j = 0 ก็ไม่ทำคำสั่งใน block แล้ว
{
dat++;
}
/*------------------------result----------------------------*/
dat = 0
/*-----------------------------------------------------------*/
สมัครสมาชิก:
บทความ (Atom)