ความคิดเห็นที่ 1 -> กระทู้นี้สำหรับเพื่อนร่วม Class เรียน AVR (เพื่อนที่มองไม่เห็น และไม่รู้ว่ามีอยู่จริงหรือเปล่า!!!) <--หุหุ มี มี แต่ตอนนี้ยังไม่ค่อยว่างเล่นเลย ติดโน่นติดนี่อยู่ เดี๋ยวผมค่อยเก็บตกตามหลัง อิอิ จากคุณ : monojo - [ 14 ส.ค. 51 22:18:38 ] : A whole new world

ความคิดเห็นที่ 2 จ้า ๆ รับทราบ  ช่วงนี้ต้นหอมก็ไม่ค่อยว่างเหมือนกัน  วันที่ 25 - 29 นี้ก็ไม่อยู่อ่ะ  กลับมาแล้วคงว่างขึ้นอีกนิด  ว่าจะทำการทดลองให้ดูค่ะ   จากคุณ : ต้นหอม (A whole new world) - [ 14 ส.ค. 51 22:54:31 ]

ความคิดเห็นที่ 3 วิธีเอาไปใช้ ปกติจะทำแบนี้นะครับ โปรเจคเทพ ไฟกระพริบ 1 ดวง (วิธีนี้สามารถ optimize -Os ได้ โดยไม่เพี้ยน) #include <avr.io.h> #include <util/delay.h> void delay_ms(unsigned int time) { while(time-->0) { _delay_ms(1.0); } } int main(void) { DDRB|=0x01; // set PB0 as output while(1) { PORTB^=0x01; // toggle PB0 delay_ms(500); } return 0; } ที่บอกว่าแม่นหรือไม่แม่นเนี่ย ถ้าแกะดูในไฟล์ util/delay.h ดูครับ จะเห็นว่ามันเป็นลูป วนนับไปโดยอาศัย F_CPU มาคำนวณรอบ เลยมีขอบเขตอย่างที่ว่ามา และมันเป็นลูปโปรแกรมหลักเฉยๆ สั่งงานอย่างไรก็ไปตามนั้น คือ ถ้าเราหน่วงเวลา 1 วินาที เป๊ะก็จริง แล้วบรรทัดต่อๆมา ทำโน่นทำนี่ เวลาก็นับต่อไปในแต่ละคำสั่ง พอวนมาใหม่ให้สลับไฟกระพริบอีกครั้ง การกระพริบ จะไม่สลับ 1วินาทีเป๊ะ แต่จะมีเวลาส่วนเกินจากคำสั่งที่ต่อท้ายอีก ซึ่งถ้างานที่ไม่ซีเรียสเรื่องวงรอบการทำงาน ก็หยวนๆ ใช้งานได้ แต่ถ้างานที่ต้องการความแม่นยำของวงรอบจริงๆ ต้องใช้ไทเมอร์มาทำฐานเวลา เพื่อนับแทนอันนี้รับรอง แม่นชัวร์ แต่เทคนิคการเขียนก็จะต่างออกไปครับ จากคุณ : ขาประจำ - [ 14 ส.ค. 51 23:15:31 A:58.8.46.49 X: ]

ความคิดเห็นที่ 4 แก้นิดนึง บรรทัดแรกเป็น #include <avr/io.h> จากคุณ : ขาประจำ - [ 14 ส.ค. 51 23:17:51 A:58.8.46.49 X: ]

ความคิดเห็นที่ 5 บทเรียนการควบคุม 7 segment แบบสแกนทีละหลัก #include<avr/io.h> #include<compat/deprecated.h> #define F_CPU 8000000UL #include<util/delay.h> const unsigned char display[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f}; unsigned char seg1 = 0,seg2 = 0,seg3 = 0; //หลังจากการแสดงผลเป็น 000 แล้วลองเปลี่ยนค่า seg  //จาก 0 เป็นค่าอื่นๆ เช่น 1,2และ3 unsigned int value=0; void delay_ms(unsigned int i) { for (; i>0;i--)    _delay_us(20); } void multiplx(void) { sbi(PORTB,0); cbi(PORTB,1); cbi(PORTB,2); PORTA=display[seg1]; delay_ms(30); cbi(PORTB,0); sbi(PORTB,1); cbi(PORTB,2); PORTA=display[seg2]; delay_ms(30); cbi(PORTB,0); cbi(PORTB,1); sbi(PORTB,2); PORTA=display[seg3]; delay_ms(30); seg1=(value%10); seg2=(value%100)/10; seg3=(value%1000)/100; } int main(void) {  DDRA=0xFF; PORTA=0x00; DDRB=0x07;   while(1)        {             multiplx();        } return 0; } แก้ไขเมื่อ 15 ส.ค. 51 00:54:31 แก้ไขเมื่อ 15 ส.ค. 51 00:51:51 แก้ไขเมื่อ 15 ส.ค. 51 00:48:53 แก้ไขเมื่อ 15 ส.ค. 51 00:46:39 จากคุณ : oker - [ 15 ส.ค. 51 00:45:02 ]

ความคิดเห็นที่ 6 การเพิ่มค่าตัวแปรในการตรวจสอบการกดสวิทช์แทนการใช้ delay เพื่อแก้การเสียเวลาการสแกนของ 7segและขจัดปัญหา 7segment กระพริบขณะมีการกดสวิทช์ void keyup_down(void) {     if((PINB&(1<<PINB6))==0)         {            if(key++ >30) {    if(value<999)       {          value++;          key=0;       } }           }       else if((PINB&(1<<PINB5))==0)         { if(key++ >30) {   if(value>0)    {       value--;       key=0;   } }      } } จากโปรแกรมจะเห็นได้ว่า เมื่อมีการกดปุ่ม ตัวแปรจะถูกเพิ่มค่าไปจนถึง 30 เราใช้การเพิ่มค่าตัวแปร key เพื่อทำการตรวจสอบการกดสวิทช์  เมื่อตัวแปรมีค่ามากกว่า 30 แล้ว จะเข้าลูปของการตรวจสอบค่า value ถ้าน้อยกว่า 999 ก็ทำการเพิ่มค่า value ขึ้น 1 ค่า และให้ตัวแปร key มีค่าเท่ากับ 0 และจะวนซ้ำไปเรื่อยๆจนกว่าจะมีการปล่อยสวิทช์ จากคุณ : oker - [ 15 ส.ค. 51 01:15:38 ] : A whole new world

ความคิดเห็นที่ 7 ใน Basic compiler ของ AVR (Bascom AVR) ไม่มีคำสั่ง PAUSE ครับ อันนั้นเป็นของ PICBASIC ของ BASCOM AVR จะมี  wait, waitms, waitus ซึ่งเป็นคำสั่งที่พอจะเทียบเคียง delay_ms, delay_us ในภาษา C โปรแกรมไฟกระพริบข้างบนก็จะเขียนประมาณนี้ '--------------------------------- LED Alias Portb.0 Config Pinb.0 = Output Do      Toggle LED      waitms 500 Loop END '--------------------------------- ใน Bascom ยังมีคำสั่ง delay อีกด้วยซึ่งจะไม่เหมือนกับ คำสั่งใน delay ภาษา C จากคุณ : เซียงอี่ - [ 15 ส.ค. 51 03:03:28 ] : A whole new world

ความคิดเห็นที่ 8 แล้วใน Bascom คำสั่ง delay ไม่เหมือนกับ คำสั่ง delay ในภาษา C อย่างไรคะ   ปล. อธิบายเรื่อง PAUSE ของ PICBASIC แตกต่างกับ Delay ในภาษาซี อย่างไรด้วยก็ดีนะคะ   ขอบคุณนะคะ ขอบคุณทุกความคิดเห็น  เดี๋ยวภาพขอบคุณตามมาที่หลังนะคะ   จากคุณ : ต้นหอม (A whole new world) - [ 15 ส.ค. 51 06:17:04 ]

ความคิดเห็นที่ 9 การหน่วงเวลาของทุกภาษา จะมีหลักการเดียวกัน คือ วนรอบรอเพื่อให้เวลาผ่านไปตามที่กำหนด เพียงแต่อาจมีชื่อเรียกและวิธีการเรียกใช้งานที่แตกต่างกันไปเท่านั้นเอง สำหรับกรณีของ WinAVR นั้นการหน่วงเวลาถือว่าเที่ยงตรงพอสมควรอาจไม่ถึงกับ 100% แต่ก็ใกล้เคียงมาก ผมลองใช้ Scope จับเวลาดูถือว่าตรงครับ ส่วนเปอร์เซ็นต์ความผิดพลาดที่อาจเกิดขึ้นเวลาใช้งานจริงนั้น ไม่ได้อยู่ที่ส่วนของการหน่วงเวลาทั้งหมด แต่อยู่ส่วนของคำสั่งก่อนและหลังคำสั่งหน่วงเวลาด้วย เช่น ถ้ามีการคำนวณหรือสั่งแปลงค่าด้วย เราก็ต้องชดเชยเวลาที่เสียไปกับสิ่งเหล่านี้ด้วย แต่ถ้าต้องการความแม่นยำจริงๆก็ต้องใช้ Timer นับเวลาเอาครับอันนี้เที่ยงตรง 100% สำหรับการเรียกใช้งานฟังก์ชั่น dealy ของ WinAVR นั้น สามารถใช้การเรียกผ่านมาโคร โดยตรงก็ได้ โดยไม่ต้องเสียเวลาไปสร้างฟังก์ชั่นขึ้นมาครอบอีกชั้นหนึ่งก็ได้ อันดับแรกต้องประกาศกำหนดค่าความถี่ XTAL และเรียกใช้ฟังก์ชั่นหน่วงเวลา คือ #include <avr/io.h> #define F_CPU 16000000UL   // 16 MHz #include <util/delay.h> หลังจากนี้ไปในส่วนต่างๆของโปรแกรมเราก็สามารถเรียกใช้คำสั่งหน่วงเวลาได้เลย เช่น _delay_ms(500);  //หน่วงเวลา 500mS (500 milli-Second) _delay_us(100);  // หน่วงเวลา 100uS (100 micro-Second) ตัวอย่างโปรแกรมไฟกระพริบ #include <avr/io.h> #define F_CPU 16000000UL   // 16 MHz #include <util/delay.h> int main(void) { DDRB|=0x01; // set PB0 as output while(1) { PORTB^=0x01; // toggle PB0 _delay_ms(500); } return 0; } จากคุณ : คนไมโคร - [ 15 ส.ค. 51 07:42:01 ] : A whole new world

ความคิดเห็นที่ 10 ไม่แนะนำให้ใช้ Delay function จาก Software เลยครับมันไม่แน่นอน อยากให้ฝึกใช้ Hardware Timer กัน ดีกว่ามากเที่ยงตรงกว่าครับ จากคุณ : INTERRUPT - [ 15 ส.ค. 51 08:52:06 A:58.181.223.3 X: ] Confirmed by : ปลากวน

ความคิดเห็นที่ 11 Hardware Timer  หมายถึง IC555 ใช่ไหมคะ   จากคุณ : ต้นหอม (A whole new world) - [ 15 ส.ค. 51 09:00:46 ]

ความคิดเห็นที่ 12 เห็นใน help ของ PIC บอกว่า การใช้ delay กับ interrupt timer จะเกิดความผิดพลาด  อันนี้หมายถึง function delay ผิดพลาดใช่ไหมค่ะ  แต่ว่า interrupt timer ยังสามารถทำงานได้ถูกต้องใช่ไหมค่ะ  แล้วใน AVR จะเกิดปัญหานี้ไหมคะ แล้วถ้าเราต้องใช้คำสั่ง show ข้อความออก lcd  ซึ่งก็ต้องใช้ function delay  ร่วมด้วยนี้คะ  ไม่งั้นเราก็ดูไม่ทัน  แล้วจะทำอย่างไรคะ  ถ้าต้อง show ข้อความออก lcd และต้องใช้ interrupt timer ด้วยอะค่ะ จากคุณ : ต้นหอม (A whole new world) - [ 15 ส.ค. 51 09:35:18 ]

ความคิดเห็นที่ 13 อีกคำถามนะคะ file     avr/io.h  กับ util/delay.h  มันไปซ่อนอยู่ตรงไหนคะ  คือมันอยู่ที่ folder ไหนคะ  แบบว่าหนูหาไม่เจอค่ะ  ใช้คำสั่ง include เข้ามาก็ต้องมี file อยู่ในเครื่องเราแล้วใช่ไหมคะ   #include <avr/io.h> #include <util/delay.h> จากคุณ : ต้นหอม (A whole new world) - [ 15 ส.ค. 51 09:39:36 ]

ความคิดเห็นที่ 14 header file บางส่วนจะเก็บไว้ที่นี่ครับ ลองศึกษาดู c:/winavr/avr/include/avr จากคุณ : เฉื่อยฉ่ำ - [ 15 ส.ค. 51 13:57:40 A:unknown X:203.149.16.34 ]

ความคิดเห็นที่ 15 วิธีจะดูเนื้อหาในไฟล์ header ที่รู้จัก หรือมีคนบอกมา ให้ include แล้ว กด F7 เพื่อ Build ถ้ามี จะไม่ error แล้วสามารถไปดูที่ pane ซ้ายมีอ โดยขยายทรี ตรง External Dependency จะเห็นปรากฏอยู่ แล้ว ดับเบิ้ลคลิก เพื่อดูได้เลย ส่วน ฟังก์ชั่น delay นั่นเข้าใจถูกแล้ว เมื่อมีการใช้ interrupt จะทำให้ ค่าเวลาในการ delay เคลื่อนเพิ่มขึ้น เพราะ interrupt จะแทรกตัวเข้ามาแย่งใช้ซีพียู   เหมือนวิ่งรอบสนามอยู่ แล้วมีคน มาเรียกให้หยุด ดื่มน้ำ มันเลยนานขึ้นกว่าจะครบรอบ จากคุณ : เงาสุริยะ - [ 15 ส.ค. 51 21:00:34 ] : A whole new world

ความคิดเห็นที่ 16 มอบแด่ คุณmonojo  พี่ขาประจำ  พี่oker  พี่เซียงอี่  พี่คนไมโคร  พี่ INTERRUPT  พี่ปลากวน  พี่เฉื่อยฉ่ำ และพี่เงาสุริยะ ค่ะ จากคุณ : ต้นหอม (A whole new world) - [ 15 ส.ค. 51 23:17:18 ]

ความคิดเห็นที่ 17 Hardware timer คือ โมดูล Timer 0/1/2 ในตัว AVR แล้วเขียนโปรแกรมเช็ค flag overflow หรือ ให้มัน interrupt ก็ได้ครับ ไม่ถึงกับต้องใช้ 555 จ้า บอกนิดนึงว่า _delay_ms(500) เอาไปใช้จริงจะไม่ได้เวลา 500ms นะครับ มันเกินขอบเขตการทำงาน ดูในไฟล์ util/delay.h คอมเมนต์ก่อนฟังก์ชั่นเขียนไว้ว่า "The maximal possible delay is 262.14 ms / F_CPU in MHz." ส่วนเรื่อง delay กับ pause ของเบสิก มันก็เหมือนกันครับ เขียนมาคือกัน วนลูปถ่วงเวลาไปเฉยๆ เลยเป็นที่มาว่าทำไมโปรแกรมตัวอย่างที่อยู่ด้านบน ผมต้องเขียนเป็นลูปย่อย 1.0ms นั่นเอง จากคุณ : ขาประจำ - [ 16 ส.ค. 51 00:33:50 A:58.8.46.254 X: ]

ความคิดเห็นที่ 18 ขอบคุณ พี่ขาประจำ พี่เซี่ยงอี่ และพี่คนไมโคร อีกครั้งค่ะ   แก้ไขเมื่อ 16 ส.ค. 51 09:31:40 จากคุณ : ต้นหอม (A whole new world) - [ 16 ส.ค. 51 01:25:20 ]

ความคิดเห็นที่ 19 Delay ในภาษา C จะใส่ค่าการหน่วงเวลาได้ แต่ใน Bascom คำสั่ง delay เราจะใส่ค่าไม่ได้ เมื่อเราใช้คำสั่ง delay มันจะหน่วงเวลาไปประมาณ 1 ms เป็นค่า fix ปกติผมก็ไม่ได้ใช้คำสั่ง delay ใช้แต่ wait ครับ ระหว่าง delay กับ waitms 1 ต่างก็หน่วงเวลา 1ms เท่ากัน แต่ว่าถ้าใช้คำสั่ง delay พอ compile แล้วได้ code สั้นกว่าครับ จากคุณ : เซียงอี่ - [ 16 ส.ค. 51 01:36:50 ] : A whole new world

ความคิดเห็นที่ 20 สรุปความเข้าใจของหนูนะคะ  คือถ้าโปรแกรมมีการใช้งาน interrupt อย่าใช้คำสั่ง delay  ถ้าจำเป็นต้องหน่วงเวลาช่วงเกิดการ interrupt ให้เขียนด้วยใช้ timer แต่ช่วงที่ไม่เกิดการ interrupt อาจจะใช้ delay ได้ ต้องคำนวณเวลาดี ๆ ว่าช่วงนั้นเกิด interrupt หรือไม่  อยากรู้ว่าโปรแกรมที่ใช้ delay มีความแม่นยำหรือไม่ให้เอา Oscilloscope มาวัดดู  ดังนั้นถ้าต้องการ show ข้อมูลออก LCD ควรทำในช่วงไม่เกิด interrupt ใช่ไหมคะ ? ในภาษา C ไม่มีคำสั่ง wait ใช่ไหมคะ?    จากคุณ : ต้นหอม (A whole new world) - [ 16 ส.ค. 51 07:34:36 ]

ความคิดเห็นที่ 21 คำสั่งประเภทหน่วงเวลา โดยใช้การวนรอบอย่าง delay นั้น ถ้ามันไม่ถูกรบกวนจาก Interrupt ค่าเวลามันจะคงที่เสมอ เช่น สมมุติว่าโปรแกรมมันต้องวนรอบ 1000 รอบ การทำงาน 1000 รอบของมันจะใช้เวลาคงที่ไม่เปลี่ยนแปลง แต่พอมีการ Interrupt เข้ามารบกวน โปรแกรมหน่วงเวลามันก็ยังต้องรวนรอบให้ครบ 1000 รอบ เช่นเดิม แต่ถ้าใน 1000 รอบ ที่มันทำงานอยู่นั้น CPU ต้องกระโดดออกไปทำงานในโปรแกรมบริการ Interrupt สัก 100 ครั้ง ค่าเวลาที่ได้จากโปรแกรม delay ก็จะเพิ่มนานขึ้นเท่ากับเวลาที่ใช้ในโปรแกรมบริการ Interrupt 100รอบ บวก กับ ค่าหน่วงเวลาปรกติของโปรแกรม นี่คือสาเหตุของความผิดพลาดครับ   การจะตัดสินใจว่าควรใช้คำสั่ง delay หรือไม่นั้น ต้องดูจากความจำเป็นครับ ว่าซีเรียสกับมันแค่ไหน ถ้าเป็นงานประเภทหน่วงเวลาเพื่อรอคอยธรรมดา อย่างหน่วงเวลาเพื่อแสดงผลไฟกระพริบ หรือแสดงผลข้อความออกที่ LCD ซึ่งถึงแม้ว่าค่ามันอาจจะผิดเพี้ยนเร็วไปหรือช้าไปสัก 1% - 10% ก็คงไม่ทำให้เกิดความผิดพลาดอะไร คนอ่านข้อความอาจไม่เห็นความแตกต่างด้วยซ้ำ อย่างนี้ก็ใช้ได้ไม่มีปัญหาครับ   แต่ถ้างานที่ซีเรียสเรื่องเวลามากๆ เช่น ต้องการจะสร้างสัญญาณความถี่ 1000Hz ถ้าใช้คำสั่ง delay ในการหน่วงเวลา แล้วค่าเวลามันผิดพลาดไปค่าความถี่ที่ได้ก็จะเพี้ยนตามไปด้วย ถ้าเป็นแบบนี้ก็ต้องมองหา Timer ของ CPU มาใช้เป็นตัวนับสร้างความถี่แทนครับ   ส่วนคำสั่ง wait นั้น ในภาษาซีไม่มีครับ ซึ่งกรณีของ WinAVR จะใช้คำสั่ง _delay_ms และ _delay_us แทน จากคุณ : คนไมโคร - [ 16 ส.ค. 51 08:48:33 ] : A whole new world

ความคิดเห็นที่ 22 น้องต้นหอมครับ เวลาที่ MCU มันทำงานอยู่แล้วเราออกแบบให้มันใช้งาน interrupt ด้วย บางครั้งเราไม่สามารถรู้ว่า interrupt มันจะเกิดขึ้นมาช่วงไหน หากเรากำลังใช้ software delay อยู่แล้วเกิด interrupt ขึ้น CPU จะหยุดการทำงานของ software delay ไว้แล้วก็กระโดดไปทำงานข้างใน ISR (interrupt service routine) ก่อนจนเสร็จแล้วจึงจะสามารถไปทำงาน software delay ต่อได้ ดังนั้นสิ่งสำคัญก็คือหากเราเขียน program ให้ข้างใน ISR ทำงานข้อนข้างเยอะผลที่ได้ก็คือ software delay ของเรามันจะไม่เที่ยงตรงมันจะนานกว่าเดิม ซึ่งเราทำให้มันเที่ยงตรงได้ยากมากๆครับ ในกรณีที่เกิดการ interrupt ขึ้นบ่อยครั้ง แต่ถ้าเราเปลี่ยนมาใช้ timer ในการนับถึงแม้จะมี interrupt บ่อยขนาดไหนก็ตามแต่ hardware timer ของ MCU มันก็ยังคงนับต่อไปเรื่อยๆจนกว่าจะ overflow หรือเราสั่งให้มันหยุดนับ แต่มี technics อยู่ครับคือถ้าเรา design ให้ software มี base time ตัวเดียวกันมันจะง่ายยิ่งขึ้นในกรณีที่เราต้องการ delay ครับ คือเราสามารถใช้ base time เป็นตัวนับในการ delay ได้เลย ลองใช้วิธีนี้ดูครับ จากคุณ : INTERRUPT - [ 16 ส.ค. 51 09:59:51 A:58.181.223.3 X: ]

ความคิดเห็นที่ 23 สมมุติว่าต้องการให้ LED1 ON/OFF ทุกๆ 50ms แล้วก็ LED2 ON/OFF ทุกๆ 100ms แล้วก็ MCU ต้องทำ functio_1(), functio_2(), function_n(); อีกหลาย function ให้เสร็จภายใน 50ms จากข้อกำหนดข้างต้นนี้ถ้าเราใช้ software delay จะไม่สามารถทำได้ หรือทำได้ก็ข้อนข้างยากมาก แต่ถ้าใชวิธี base time ละก็ง่ายมากครับเหลือเวลาไปทำอย่างอื่นอีกตั้งมากมายเลยทีเดียว volatile unsigned char FLAG_50ms; unsigned char counter; int main () { for(;;) { if(FLAG_50ms) { FLAG_50ms = 0; ON_OFF_LED1; // LED1 control every 50ms if(++counter == 2) { counter = 0; ON_OFF_LED2; // LED1 control every 100ms } functio_1(); functio_2(); functio_n(); } } return 0; } ISR(Timer0_overflow) // overflow ทุกๆ 50ms { FLAG_50ms = 1; } ข้อสำคัญก็คือเวลาการทำงานรวมของ function_1(), function_2() และ function_n() ต้องไม่เกิน เวลาของ base time ถ้าเกินก็ต้อง adjust base time เอาหรือไม่ก็ใช้ technic อื่นเข้ามาช่วยเช่นอาจจะใช้ state machine เข้ามาเป็นตัวแยก การทำงานใน function การออกแบบในลักษณะนี้ทำให้ง่าย แล้วก็มีข้อดีอีกหลายอย่างเช่น ไม่ต้องไปทำงานใน ISR มากนักทำให้ลดความเสี่ยงในการใช้ share variable ระหว่าง main กับ ISR หวังว่าน้องต้นหอมคงเกิด idea ที่จะทำการ delay อย่างมีประสิทธิภาพบ้างนะครับ ผมก็อาศัยว่าเคยททดลองมาแยอะเลยรู้ว่าวิธีไหนน่าจะดีที่สุด แต่อาจจะไม่ใช่วิธีที่ดีที่สุดสำหรับคนอื่นๆ Embedded มันพลิกแพลงได้มากมายหลายวิธีทั้งนี้ทั้นนั้นสิ่งที่สำคัญก็คือผลการ test ครับว่าออกมาดีหรือไม่ จากคุณ : INTERRUPT - [ 16 ส.ค. 51 11:43:40 A:58.181.223.3 X: ] Confirmed by : ปลากวน

ความคิดเห็นที่ 24 ขอบคุณค่ะ พี่ INTERRUPT  หนูพอจะเข้าใจการใช้ Timer ในการถ่วงเวลาแทนคำสั่ง delay แล้วค่ะ แต่ขอถามอีกนิดนะคะ พี่ ๆ ช่วยอธิบายหรือยกตัวอย่างให้หน่อยสิคะ 1. "state machine เข้ามาเป็นตัวแยก " 2. "ลดความเสี่ยงในการใช้ share variable ระหว่าง main กับ ISR" อย่างข้อ 2  หนูเข้าใจว่า ถ้าเรามีตัวแปรซึ่งมีการเปลี่ยนแปลงค่าเมื่อเกิด ISR และเราใช้ตัวแปรตัวนี้ใน main มันอาจเกิดความผิดพลาดขึ้นเพราะเราไม่ทราบแน่ ๆ ว่า ISR จะเกิดขึ้นเมื่อไรแน่ใช่ไหมคะ  แบบว่าขณะที่อยู่ใน main ก็อาจเกิด ISR ทำให้ตัวแปรตัวนั้นเปลี่ยนไปอีกใช่ไหมคะ แก้ไขเมื่อ 16 ส.ค. 51 12:57:54 จากคุณ : ต้นหอม (A whole new world) - [ 16 ส.ค. 51 12:48:51 ]

ความคิดเห็นที่ 25 State Machine เราสามารถ implement ได้โดยใช้ switch case ครับยกต่ออย่างของการแบ่ง job ในหนึ่ง function ได้แบบนี้ครับ enum state_type { INIT, JOB1, JOB2, JOB3 }; void function_n(void) { static unsigned char stste; state += 1; switch(state) { case JOB1 : job1(); break; case JOB2 : job2(); break; case JOB3 : job3(); state = INIT; break; } } ความเสี่ยงในการใช้ share variable ระหว่าง main กับ ISR ก็คือเวลาที่ main function กำลังกระทำกับ variable ตัวนั้นอยู่แล้วในขณะที่ยังกระทำไม่เสร็จนั้นเกิดการ interrupt ขึ้น CPU ก็จะกระโดดไปทำงานใน ISR ถ้าหากว่าข้างใน ISR เรากระทำกับ variable ตัวเดียวกับ main ที่กำลังทำอยู่นั้น บางครั้งมันจะทำให้เกิด bug ขึ้นใน program ครับ ซึ่ง bug ในลักษณะนี้หาข้อนข้างยากเพราะมันเกิดขึ้นเป็นบางครั้งในช่วงเวลาที่ main กับ ISR access share variable ตัวเดียวกันพร้อมกัน ดั้งนั้นถ้าหลีกเลี่ยงการใช้ share variable ระหว่าง main กับ ISR ได้เป็นดีที่สุด แต่ถ้าหลีกเลี่ยงไม่ได้จริงๆก็มีอีกหลายวิธีที่จะแก้ไขได้แต่วิธีที่นิยมใช้กันก็คือการ Disable interrupt ก่อนที่ main จะกระทำกับ variable ตัวนั้น หลังจากกระทำเสร็จแล้วก็ทำการ Enable interrupt กลับคืนครับ จากคุณ : INTERRUPT - [ 16 ส.ค. 51 13:13:15 A:192.168.0.16 X:58.181.223.3 ]

ความคิดเห็นที่ 26 ขอบคุณ พี่ INTERRUPT มาก ๆ เลยค่ะ  หนูได้ idea เยอะเลย   มอบแด่พี่ ๆ อีกรอบ..... 5555  แบบว่ากระทู้นี้หนูชอบมาก............... จากคุณ : ต้นหอม (A whole new world) - [ 16 ส.ค. 51 13:36:44 ]