ท่านใดให้อธิบายการเกิดอินเตอรัพท์สักหน่อย ก็จะอธิบายตามความเข้าใจนะ ถ้าเกิด interrupt อย่างเช่น EXTI0 interrupt, Program Counter จะกระโดดมาที่ Address 0x0000 0058 ก่อน แล้วที่ Address 0x0000 0058 นี้ จะบรรจุคำสั่งให้กระโดดไปที่โปรแกรมย่อย Interrupt Service Routine EXTI0 อีกที เมื่อปฏิบัติตามคำสั่งใน Interrupt Service Routine EXTI0 เสร็จแล้ว ก็จะกระโดกลับไปที่โปรแกรม main(); ในบรรทัดก่อนที่จะเกิดการอินเตอรัพท์ เพื่อปฏิบัติคำสั่งต่อไป
ปล. อ่านแล้วเข้าใจกันไหม พอจะจำได้เคยแปล Atmega328p มาก่อน คงจะเหมือนกัน ท่านมีอะไรเสริมก็ว่ามาได้นะครับ

ใน ARM Cortex M ขั้นตอนตรงนี้มันไม่อยู่ในส่วนที่เราเข้าไป track ดูได้ครับ
ใน Address 0x00000058 จะแค่เก็บ Address ของ Interrupt Service Routine EXTI0 เท่านั้นครับ
ไม่มี Code สำหรับ Jump ไปที่ Interrupt Service Routine ของ EXTI0 แต่อย่างใดครับ
ผมก็ไม่แน่ใจว่ามันมีการ Jump ไปยัง code ส่วนไหนก่อนรึเปล่า ใน Code เราจะเห็นแค่ว่าโปรแกรมทำงานอยู่ใน main
แล้วอยู่ๆ ก็มาโผล่ใน Interrupt Service Routine เลย พอทำงานใน Interrupt Service Routine เสร็จ ก็กลับมาที่ main

บางทีการโหลด Address แล้ว Jump ไป Interrupt Service Routine อาจทำโดย Hardware แต่เราสามารถดูได้ว่า
ทันทีที่มีเข้าสู่ Interrupt Service Routine มันจะมีการ Backup Register R0 - R3, R12, LR, PSR และ Address
ที่จะ Return กลับไป ลง Stack ส่วนเวลา Return กลับไปยัง Main มันไม่ได้ Return ไป Address ที่จะกลับไปใน Main โดยตรง
มันจะ Return ไปส่วนที่เรียกว่า EXC_RETURN code (มี Address อยู่ในช่วง 0xF0000000 - 0xFFFFFFFF) ซึ่งมันจะเป็นการ
execute แบบพิเศษ ไม่ได้เป็น instruction set แบบปกติ

รูปในโพสแรกคือ Register ของ CPU ครับ ปกติเราจะไม่ค่อยได้มายุ่งในส่วนนี้
ถ้าเราไม่ได้เขียน assembly หรือเขียน OS

รายละเอียดก็ตามที่คุณ tha ลงมาในโพสที่ 2 เลยครับ แต่จะเห็นว่ามันมีส่วนแปลกๆ อยู่
เช่น Stack pointer มันมี 2 ตัว ตรงนี้ arm ทำมาเพื่อรองรับการทำงานของ OS ครับ
โดยปกติ CPU จะใช้ MSP เป็น Stack pointer ตัวหลักในการทำงานทั้งหมด แต่เราสามารถ
แยกให้การทำงานปกติใช้ PSP และเวลาอยู่ใน Interrupt จะใช้ MSP ได้ครับ เป็นการแยก
ให้การทำงาน 2 ส่วนใช้ stack memory คนละส่วน โดยเฉพาะพวก RTOS ที่แต่ละ Task
เราจะแบ่ง Stack Memory ไว้ให้แต่ละ Task ไม่เยอะ แล้วระหว่างนั้นถ้ามี Interrupt เกิดขึ้น
มันจะได้ไม่ไปแย่ง Stack Memory ของ Task มาใช้ใน Interrupt

Link Register ถ้าอธิบายง่ายๆ ก็คือเวลา code มีการ Call Function มันก็จะเอา Address
ที่ต้อง Return กลับไปฝากไว้ใน Link Register ถ้ามีการ Call Function ใน Function อีกที
มันก็จะเก็บค่า Address ที่อยู่ใน Link Register ลง Stack Memory ก่อนแล้วค่อยฝาก Address ใหม่ทับลงไป

PSR หรือ Program Status Registers ตัวนี้ประหลาดดี ตรงมี Register จริงๆ ตัวเดียว แต่เวลาเรียกใช้จะแยกเป็น 3 ตัวตือ
- APSR - Application Program Status Registers ตัวนี้เหมือนเป็น Flags เวลาเราบวกลบคูณหารเลข
มันจะมี Bit คอยบอกว่าผลลัพทํมีค่าติดลบนะ ผลลัพท์มีค่าเป้น 0 ผลลัพท์มีการทดเลข ผลลัพท์ Overflow อะไรพวกนี้
- IPSR - Interrupt Program Status Registers ตัวนี้จะบอกว่า Interrupt ที่รันอยู่นี่คือ Interrupt อะไร
มันจะมีค่าเป็นเลข Number ของ Interrupt อยู่
- EPSR - Execution Program Status Registers อันนี้ไม่เคยใช้ครับ ไม่รู้เหมือนกัน

PRIMASK คือ Interrupt mask register มีให้เซ็ตแค่บิตเดียว ถ้าเซ็ตคือ Block Interrupt ทั้งหมดยกเว้น
NMI กับพวก fault Handler ทั้งหลาย

FAULTMASK เหมือน PRIMASK แต่เอาไว้ Block พวก NMI กับพวก fault Handler ทั้งหลาย

BASEPRI มันนี้พิเศษหน่อย คือให้เรา Block Interrupt โดยการระบุ Priority เช่น Interrupt จะมี
Priority ได้ตั้งแต่ 15 - 0 (0 คือสูงที่สุด) ถ้าเซ็ต BASEPRI = 5 Interrupt ที่มี Priority ตั้งแต่ 15 ถึง 5 จะถูก Block
แต่ถ้า BASEPRI = 0 จะหมายถึงการเลิกใช้งาน BASEPRI เพราะฉะนั้น BASEPRI จะใช้ Block Interrupt ที่มี Priority 0 ไม่ได้

สุดท้ายคือ CONTROL Register อันนี้เอาไว้คุม Stack pointer ว่าจะให้ใช้ MSP หรือ PSP นั่นแหละครับ
แล้วก็ยังกำหนดให้ Thread ทำงานแบบ Privileged หรือ Unprivileged ได้ด้วย (แทรกนิดนึง ปกติเวลา
CPU ทำงานใน function main เราจะเรียกว่ามันทำงานใน Thread mode ส่วนเวลาที่ทำงานอยู่ใน Interrupt
เราจะเรียกว่า Handler mode ครับ) ปกติ CPU จะรัน Thread แบบ Privileged คือเข้าถึง Register หรือ
Config ค่า Register ได้ทุกอย่าง แต่ถ้าเราปรับเป็นแบบ Unprivileged จะทำให้ Thread เข้าถึง Register
บางตัวไม่ได้ มีปะรโยชน์คือเป็นการจำกัดสิทธิ์ของโปรแกรมที่ทำงานใน MCU ครับ ถ้าเราซีเรียสเรื่องความปลอดภัยมากๆ

ปล. เอาแค่นี้ก่อน ช่วงนี้ผมไม่ค่อยว่างเท่าไหร่ครับ ถ้าสนใจเรื่องสถาปัตยกรรมของ ARM Cortex M ผมแนะนำหนังสือ
The Definitive Guide to ARM® Cortex®-M3 and Cortex®-M4 Processors ของ โจเซฟ ยู ครับ เขียนได้ละเอียดดีครับ

volatile เป็นการนิยามว่า memory หรือตัวแปรส่วนนี้มีความแปรปรวนครับ
จะมีผลก็ต่อเมื่อเราเปิด optimizer ครับ compiler จะไม่ optimize ตัวแปรหรือ memory ที่เป็น volatile
จะจัดการอย่างตรงไปตรงมา

โดยปกติ compiler จะมองว่า memory หรือตัวแปรจะเปลี่ยนค่าก็ต่อเมื่อถูกเซ็ตค่า

เช่น
a = 1;

แต่ compiler จะพิจารณาแค่ไฟล์ต่อไฟล์เท่านั้น เช่น

ในไฟล์ main.c มีการประกาศตัวแปร global
int a = 1;

แล้วก็มีการใช้งาน
while(a);

แต่ไม่มีการเปลี่ยนค่า a ใน main.c อีก

ส่วนในไฟล์ interrupt.c มีการเปลี่ยนค่าตัวแปร a
a = 0;

ถ้าเราเปิด optimizer ขณะที่ compiler ทำการ compile ไฟล์ main.c compiler ก็จะมองแค่ไฟล์ main.c ไฟล์เดียว
ไม่ได้สนใจว่า interrupt.c จะมี code อะไร ทำให้ compile เข้าใจว่า a มีค่าเป็น 1 แล้วก็ไม่มีการเปลี่ยนค่าอีก
compiler เลยทำการแทนที่ a ใน code main.c ด้วยค่า 1 เลยทั้งหมด แม้โปรแกรมจะทำงานมาถึงไฟล์ interrupt.c
และเปลี่ยนค่าตัวแปร a ไป ก็ไม่สามารถทำให้หลุดจาก while ได้

อีกกรณีก็พวก register ที่จะถูกเซ็ตค่าโดย hardware ตอน compile ตัว compiler จะมองว่ามันเป็นแค่
memory ตำแหน่งหนึ่ง แล้วก็มีการอ่านค่ามาอย่างเดียว ไม่มีการเซ็ตค่า ก็เสี่ยงที่จะถูก optimize ได้
เราจึงมักจะนิยาม register ให้เป็น volatile เพื่อป้องกันไม่ให้ compiler optimize ครับ

ส่วนใน function delay นั่น ถ้าตัวแปร nCount ไม่ใช่ volatile optimizer มันจะมองว่า while มันเป็น loop เปล่าๆ
และ nCount หลังจากหลุด while ไปแล้วมันก็ไม่ได้ใช้งานอะไร มันจะลบ loop ทิ้งเอาดื้อๆ เพราะมองว่ามันเสียเวลาโดยเปล่าประโยชน์
แต่ถ้า nCount เป็นตัวแปร volatile มันก็จะตัด loop ออกไม่ได้ เพราะ compiler จะไม่ optimize แต่แปร nCount และตัวแปร nCount
ต้องถูกนับลดและอ่านค่าอย่างตรงไปตรงมา ทำให้ loop ยังอยู่ครับ

ใช่ครับ STM32CubeMX ตัวใหม่ๆ รวมถึง CubIDE ด้วย ต้องใช้ OS 64bit ครับ

OpenOCD เป็น Open Source On-Chip Debugging ครับ มันจะทำหน้าที่เป็น GDB Server ให้ และรันอยู่บนคอมเรานี่แหละ
ไม่ต้องใช้เน็ตแต่อย่างใดครับ

ในปัจจุบันการ Debug ภาษา C เราแทบจะใช้ GDB แทบทั้งสิ้นครับ (ย่อมาจาก GNU Debugger) แต่ก็จะมีการ Custom โปรแกรม
ให้เหมาะกับ environment ต่างๆ กันไป สำหรับใน MCU แล้ว GDB Server จะคอยรับคำสั่งจาก GDB Client แล้วไปสั่งการ MCU ให้หยุด
หรือทำงาน หรืออ่านค่าจาก Memory และ Register ผ่าน JTAG Communication Protocol



ในตอนที่เราสั่งให้ Eclipse เข้า Debug Mode ตัว Eclipse มันก็จะไปเรียก GDB Server (OpenOCD) ขึ้นมาทำงาน
แล้วก็จะเรียก GDB Client (arm-none-eabi-gdb.exe) ขึ้นมาเพื่อสั่งการ GDB Server แล้วก็จะเอา Response ต่างๆ
ที่ GDB Client ได้รับมาแสดงผลให้เราดูบนโปรแกรม Eclipse IDE ครับ

OpenOCD มันก็มีข้อดีตรงที่มันฟรี และมันก็รองรับ MCU กับ JTAG Adapter หลายชนิดมาก
แต่ประสิทธิภาพมันยังเป็นรองพวก GDB Server จากผู้ผลิต JTAG Adapter โดยตรงอย่างมากครับ
ถ้าไม่มีทางเลือกจริงๆ หรือโปรแกรมที่จะ Debug ไม่ซับซ้อนมันก็ใช้ได้ครับ ผมเคยต้อง Debug MicroPython
บน STM32 ด้วย OpenOCD บอกตามตรงว่าอารมณ์เสียมาก