Computer Organization & Cortex-M Architecture

ผลการเรียนรู้ (Learning Outcomes)

• อธิบายลำดับภาษา (high→assembly→machine) และ toolchain (compiler/assembler/linker/loader)
• อธิบาย program memory layout: Flash(code), RAM(Data/BSS, Stack, Heap) และ stack/heap ชนกัน
• อธิบายทำไม global address คงที่จึง watch real-time ได้ แต่ local ไม่ได้
• อธิบาย register Cortex-M (13 GPR + SP/LR/PC + PSR N Z C V)
• เปรียบเทียบ Von Neumann vs Harvard; Cortex-M=Harvard
• จำแนก Cortex-A/R/M และ M0/M3/M4/M7
• เปรียบเทียบ SRAM/DRAM, ROM/PROM/EPROM/EEPROM/Flash

§2.1 ระดับภาษาและ Toolchain

ภาษาโปรแกรมมีหลายระดับไล่จากใกล้คนไปใกล้เครื่อง. ระดับบนสุดคือ High-level language (ภาษาระดับสูง เช่น C/C++) ที่เขียนใกล้ตัวปัญหาและคนอ่านเข้าใจง่าย. ถัดลงมาคือ Assembly ซึ่งเป็นรูปข้อความของคำสั่งเครื่องแต่ละคำสั่ง. ล่างสุดคือ Machine code ที่เป็นเลขฐานสอง จัดเป็น word ขนาด 8/16/32/64 บิต โดยแต่ละบิตแทนด้วยระดับแรงดันไฟฟ้า.

Toolchain คือชุดเครื่องมือที่แปลงภาษาระดับสูงให้เป็นไฟล์ที่ชิปรันได้. Compiler แปลงไฟล์ .c/.h เป็น assembly (.s). Assembler แปลง assembly เป็น object file โดยตั้งชื่อ symbol เป็นเลขลำดับภายใน. Linker รวม object หลายไฟล์เข้ากับ libraries แล้วจัด address ใหม่ให้เป็น executable (ELF/.bin/.hex) ซึ่ง loader ต้องรู้รูปแบบไฟล์จึงจะโหลดได้.

บนบอร์ด Nucleo เราข้ามขั้น loader ที่ซับซ้อนได้ เพราะลากไฟล์ .bin ไปวางลงไดรฟ์ของ ST-LINK ได้โดยตรง ไม่ต้องมี loader แยกต่างหาก.

§2.2 Program Memory Layout

โค้ดโปรแกรมถูกเก็บใน Flash ซึ่งเป็นหน่วยความจำแบบ non-volatile (ข้อมูลไม่หายเมื่อปิดไฟ). ส่วนตัวแปรทั้งหลายอยู่ใน RAM ซึ่งถูกแบ่งเป็นหลายส่วน.

RAM แบ่งเป็นส่วนหลัก ๆ ดังนี้. Data segment เก็บตัวแปร global ที่มีค่าเริ่มต้น เช่น int A=5. BSS เก็บตัวแปร global ที่ไม่ได้กำหนดค่า ซึ่ง compiler จะตั้งค่าเริ่มต้นเป็น 0 ให้. Stack เก็บตัวแปร local และข้อมูลการเรียกฟังก์ชัน. Heap เก็บหน่วยความจำที่จองแบบ dynamic ด้วย malloc.

Stack มีพฤติกรรมพิเศษคือโตจาก address สูงลงไปหา address ต่ำ. เมื่อเข้าฟังก์ชันจะลดค่า SP (Stack Pointer) ลงเพื่อจองพื้นที่ เมื่อออกจากฟังก์ชันก็บวกค่า SP คืน ทั้งหมดนี้ compiler จัดการให้เอง. ส่วน Heap ใช้เมื่อเราไม่รู้ขนาดข้อมูลตอน compile เช่นการสร้าง linked list.

จุดที่ต้องระวังคือ Stack (โตลง) กับ Heap (โตขึ้น) โตเข้าหากัน ถ้าทั้งคู่ใช้พื้นที่มากจนมาชนกันโปรแกรมจะพัง จึงอาจต้องกำหนดขนาด stack/heap ใน linker. ค่าคงที่เล็ก ๆ เก็บฝังไว้ในโค้ด (Flash) ได้ แต่ตัวแปรที่ต้องเปลี่ยนค่าต้องจองพื้นที่ใน RAM.

addr สูง ┌──────────┐
         │  Stack   │ ↓ โตลง (local, ฟังก์ชัน)
         │    ↓     │
         │  (ว่าง)  │ ← เสี่ยงชนกัน
         │    ↑     │
         │  Heap    │ ↑ โตขึ้น (malloc)
         ├──────────┤
         │ BSS (=0) │
         │Data(init)│
addr ต่ำ └──────────┘  (RAM)
Flash: [ code + ค่าคงที่ ] non-volatile

§2.3 Global vs Local Address

ตัวแปร global มี address ที่ compiler รู้แน่นอนตั้งแต่ตอน compile จึงอยู่ตำแหน่งคงที่. เพราะ address ไม่เปลี่ยน เราจึงอ่านค่าจาก address นั้นได้ตลอดเวลา ทำให้ watch หรือ monitor ค่าแบบ real-time ได้.

ตัวแปร local อยู่บน stack ซึ่ง address ขึ้นกับเส้นทางการเรียกฟังก์ชัน (call path) จึงไม่คงที่ แต่ละครั้งที่เรียกอาจอยู่คนละที่ จึง watch ค่าแบบ real-time ไม่ได้.

§2.4 Registers ใน Cortex-M

Register คือหน่วยเก็บบิตชั่วคราวความเร็วสูงที่อยู่ภายใน CPU สร้างขึ้นจากวงจร D flip-flop. Cortex-M มี register ทั้งหมด 16 ตัว แบ่งเป็น general-purpose 13 ตัว (R0–R12) และ special register 3 ตัว.

special register 3 ตัวได้แก่ SP (Stack Pointer) ที่ชี้ยอด stack, LR (Link Register) ที่เก็บ address สำหรับกลับจากฟังก์ชัน, และ PC (Program Counter) ที่ชี้คำสั่งถัดไป. นอกจากนี้ยังมี PSR ที่เก็บ flag สถานะ 4 ตัว ได้แก่ N (Negative), Z (Zero), C (Carry) และ V (oVerflow).

ขั้นตอนการคำนวณของ ALU: โหลด operand จาก memory เข้า register → ให้ ALU คำนวณ → เก็บผลลัพธ์กลับ register แล้วจึงเขียนกลับ memory (หรือส่งตรงออก I/O).

คำสั่ง (instruction) ของ ARM ขนาด 32 บิต แบ่งบิตเป็นสองส่วน: บิตแรก ๆ เป็น opcode (บอกว่าทำอะไร) ส่วนที่เหลือเป็น operand (บอกว่าทำกับข้อมูลตัวไหน). วงจร decoder จะแปลง opcode ให้กลายเป็นสัญญาณควบคุมภายใน.

LDR  R0, [x]      ; โหลด x เข้า R0
LDR  R1, [y]      ; โหลด y เข้า R1
ADD  R2, R0, R1   ; ALU: R2 = R0 + R1
STR  R2, [z]      ; เก็บผลกลับตัวแปร z

§2.5 Von Neumann vs Harvard

สถาปัตยกรรมแบบ Von Neumann ใช้บัสเส้นเดียวร่วมกันทั้งการดึงคำสั่งและการเข้าถึงข้อมูล จึงดึงคำสั่งกับข้อมูลพร้อมกันไม่ได้.

สถาปัตยกรรมแบบ Harvard แยกบัสคำสั่งออกจากบัสข้อมูล จึงดึงทั้งสองอย่างพร้อมกันได้และทำงานเร็วกว่า แลกกับวงจรที่ซับซ้อนกว่า. Cortex-M เป็นแบบ Harvard (ภายใต้ ARMv7-M).

นอกจากนี้บัสยังแบ่งตามหน้าที่เป็น address bus, data bus และ control bus (ส่งสัญญาณ enable/read/write). สำหรับงานที่ต้องการราคาถูกและใช้พื้นที่น้อยก็มี ARMv6-M เป็นทางเลือก.

§2.6 ตระกูล Cortex: A/R/M และ M0–M7

ARM แบ่งตระกูล Cortex เป็น 3 โปรไฟล์ตามลักษณะงาน: Cortex-A สำหรับงานสมรรถนะสูงที่รัน OS, Cortex-R สำหรับงาน real-time ที่ต้องตอบสนองแน่นอน และ Cortex-M สำหรับงานฝังตัวที่เน้นประหยัดพลังงาน. ภายในตระกูล M ยังแบ่งย่อยเป็นรุ่น M0, M3, M4, M7 ตามตารางด้านล่าง.

§2.7 เทคโนโลยีหน่วยความจำ

หน่วยความจำแบ่งเป็นสองกลุ่มใหญ่ตามการเก็บข้อมูล. RAM เป็นแบบ volatile เก็บข้อมูลชั่วคราว ข้อมูลหายเมื่อปิดไฟ. ส่วน ROM หรือหน่วยความจำ non-volatile เก็บ code และค่าคงที่ไว้ได้แม้ปิดไฟ.

ตัวอย่างการใช้งานจริง: DRAM ใช้เป็น main store หรือหน่วยความจำหลัก, SRAM ใช้เป็น cache ที่เร็วแต่แพง, ส่วน Flash ใช้เก็บ BIOS, firmware หรือเพลง MP3.

int main(void) {
    HAL_Init();
    SystemClock_Config();
    MX_GPIO_Init();            // เปิด clock GPIOB, ตั้ง PB0 output push-pull
    while (1) {
        HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_SET);   // LD1 ติด (3.3V)
        HAL_Delay(500);
        HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_RESET); // LD1 ดับ (0V)
        HAL_Delay(500);
    }
}