รูปปกบทความ

1. 🎯 ตอนที่ 24: ไมโครคอนโทรลเลอร์กับระบบควบคุม (เจาะลึกสมองกลตระกูล STM32)

2. 📖 เปิดฉาก (The Hook)

สวัสดีครับน้องๆ และนักพัฒนาทุกท่าน! ยินดีต้อนรับกลับสู่ซีรีส์ เจาะลึกวิศวกรรมระบบควบคุม (Control Systems) จาก 101 ถึง Advance สไตล์วิศวกรรุ่นพี่ครับ

ในตอนที่ผ่านๆ มา เราได้คุยกันถึงการแปลงสมการแคลคูลัส (Continuous-time) อันสลับซับซ้อน ให้อยู่ในรูปแบบสมการผลต่าง (Discrete-time Difference Equation) เพื่อให้คอมพิวเตอร์สามารถเข้าใจและคำนวณได้แล้วใช่ไหมครับ?

แต่คำถามที่สำคัญมากในโลกแห่งความเป็นจริงก็คือ… “คอมพิวเตอร์แบบไหนล่ะ ที่วิศวกรเขาใช้คุมเครื่องจักรกันจริงๆ?” ในยุคแรกเริ่ม เราอาจจะใช้วงจรออปแอมป์ (Op-amp) ที่ทำงานแบบอนาล็อก แต่ในปัจจุบัน โลกอุตสาหกรรมถูกขับเคลื่อนด้วยชิปซิลิคอนขนาดเล็กที่เรียกว่า “ไมโครคอนโทรลเลอร์ (Microcontroller Unit หรือ MCU)” ครับ!

ลองจินตนาการว่าสมการ PID เป็นเหมือน “จิตวิญญาณ” ตัว MCU ก็คือ “ร่างกาย” ที่จิตวิญญาณนี้ไปสิงสถิตอยู่ หากร่างกายไม่แข็งแรง ประสาทสัมผัสช้า หรือกล้ามเนื้อกระตุก จิตวิญญาณที่เก่งแค่ไหนก็ไม่สามารถขับเคลื่อนหุ่นยนต์ให้สมูทได้ วันนี้พี่จะพาไปเจาะลึกโครงสร้างฮาร์ดแวร์ของไมโครคอนโทรลเลอร์ โดยเฉพาะตระกูลยอดฮิตในวงการอุตสาหกรรมอย่าง STM32 (เช่น STM32F1, F3, F4, G4 และ H7) ว่ามันมีฟังก์ชันลับอะไรที่ช่วยให้ระบบควบคุมของเราทำงานได้อย่างเสถียรและแม่นยำระดับไมโครวินาที!

3. 🧠 แก่นวิชา (Core Concepts)

บทบาทของ MCU ในระบบควบคุม ไม่ใช่แค่การเป็นเครื่องคิดเลขคณิตศาสตร์เท่านั้นครับ แต่มันทำหน้าที่เป็น “Executive Controller” ที่ต้องจัดการจังหวะเวลาและการรับส่งสัญญาณกับโลกภายนอก (Plant) อย่างแม่นยำ,

เพื่อที่จะรันลูปควบคุมดิจิทัล (Digital Feedback Loop) สมองกลจำเป็นต้องพึ่งพา “อวัยวะ” หรือโมดูลฮาร์ดแวร์พื้นฐาน 3 ส่วนหลักๆ ดังนี้ครับ:

  • 1. Timer & Interrupts (หัวใจและชีพจร): การรัน PID ในโลกดิจิทัลตั้งอยู่บนกฎเหล็กที่ว่า “ระยะเวลาการสุ่ม (Sampling Time, $T_s$) ต้องคงที่เป๊ะๆ” เราไม่สามารถเอาสมการไปยัดไว้ใน while(1) ของลูปโปรแกรมหลักได้ เพราะเวลาประมวลผลจะไม่แน่นอน วิศวกรจึงต้องใช้ฮาร์ดแวร์ที่เรียกว่า Timer สร้างสัญญาณขัดจังหวะ Interrupt Service Routine (ISR) เพื่อบังคับให้ CPU หยุดงานทุกอย่าง และหันมาคำนวณสมการ PID ในจังหวะเวลาที่เป๊ะระดับนาโนวินาที,
  • 2. ADC - Analog to Digital Converter (ดวงตาแห่งการรับรู้): โลกภายนอกเป็นสัญญาณอนาล็อกต่อเนื่อง (Continuous) ตัว ADC จะทำหน้าที่รับสัญญาณแรงดันไฟฟ้าจากเซ็นเซอร์ (เช่น ตำแหน่ง, ความเร็ว, หรือกระแสไฟฟ้า) แล้วแปลงให้เป็นข้อมูลตัวเลข 0 และ 1 (Digital code) เก็บไว้ในหน่วยความจำ เพื่อนำไปสร้างค่า Error ในสมการ,
  • 3. PWM - Pulse Width Modulation (กล้ามเนื้อแห่งการขับเคลื่อน): แทนที่เราจะใช้วงจรอนาล็อกตัวใหญ่ๆ เพื่อหรี่ไฟ MCU จะสร้างสัญญาณพัลส์ดิจิทัลแบบเปิด-ปิดสลับกันด้วยความถี่สูง (เช่น 20 kHz ที่หูมนุษย์ไม่ได้ยิน) โดยความกว้างของพัลส์ (Duty Cycle) จะแปรผันตามค่า Control Output ($u(k)$) ที่คำนวณได้จาก PID ส่งไปขับวงจร Power Converter อย่าง H-Bridge เพื่อคุมความเร็วมอเตอร์ได้อย่างมีประสิทธิภาพ,
รูปประกอบบล็อกไดอะแกรมแสดงการทำงานร่วมกันของ Timer, ADC, CPU และ PWM ในไมโครคอนโทรลเลอร์

4. 🧮 ร่ายมนต์สมการและโค้ดควบคุม (The Math & Implementation)

มาดูโครงสร้างการเขียนโปรแกรมควบคุม PID บนชิป STM32 กันครับ โครงสร้างนี้สามารถพอร์ตข้ามตระกูลต่างๆ (Cross-series portability) ได้ง่ายมาก หากเราแยกส่วนคณิตศาสตร์ออกจากส่วนที่เรียกใช้ฮาร์ดแวร์เฉพาะ

สมการ PID แบบมาตรฐานในโลกดิจิทัลที่เราคุ้นเคย: $$ u[k] = K_p e[k] + K_i \sum_{j=0}^{k} e[j] + K_d (e[k] - e[k-1]) $$

ตัวอย่างโครงสร้าง C Code ใน STM32 (ผ่าน HAL Library): การคำนวณ PID จะถูกเรียกใช้อยู่ภายในฟังก์ชัน Callback ของ Timer Interrupt (TISR) เพื่อรับประกันว่า $T_s$ คงที่

// 1. ฟังก์ชันคำนวณ PID (แยกเป็นอิสระจาก Hardware)
float PID_Compute(PID_Controller *pid, float setpoint, float measured_value) {
    float error = setpoint - measured_value;
    
    float Pout = pid->Kp * error;                // Proportional term
    
    pid->integral += error;                      // Integral term (ควรมี Anti-windup ด้วย)
    float Iout = pid->Ki * pid->integral;
    
    float derivative = error - pid->prev_error;  // Derivative term
    float Dout = pid->Kd * derivative;
    
    float output = Pout + Iout + Dout;           // Total output
    
    // Limit output (Saturation)
    if (output > pid->output_limit) output = pid->output_limit;
    else if (output < -pid->output_limit) output = -pid->output_limit;
    
    pid->prev_error = error;
    return output;
}

// 2. Hardware Timer Interrupt (หัวใจของระบบ)
// ฟังก์ชันนี้จะถูกฮาร์ดแวร์ STM32 เรียกโดยอัตโนมัติตามคาบเวลาที่ตั้งไว้ (เช่น 10 kHz)
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim) {
    if (htim->Instance == TIM3) {
        // ก. อ่านค่าเซ็นเซอร์จาก ADC
        uint32_t adc_raw = HAL_ADC_GetValue(&hadc1); 
        float pv = Convert_ADC_to_Physical(adc_raw);
        
        // ข. คำนวณ PID
        float control_signal = PID_Compute(&myPID, setpoint, pv);
        
        // ค. ส่งสัญญาณไปขับกล้ามเนื้อ PWM 
        // แปลงสัญญาณควบคุม (0-100%) ให้เป็นค่า Duty Cycle ของ Timer
        uint32_t pwm_duty = Convert_Signal_to_Duty(control_signal);
        __HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_1, pwm_duty); 
    }
}

5. 🛡️ เคล็ดลับจากคัมภีร์ลับ (Under the Hood / Pro-Tips)

ในฐานะวิศวกรที่ต้องไปสู้รบกับชิปหน้างาน นี่คือเคล็ดลับวิชา (Pro-Tips) ที่มือโปรมักจะใช้กับไมโครคอนโทรลเลอร์ตระกูล STM32 ครับ:

  1. การซิงโครไนซ์ PWM และ ADC (PWM/ADC Synchronization): ในงานคุมมอเตอร์ (Motor Control) สัญญาณ PWM มักจะสร้างคลื่นรบกวน (Switching Noise) สูงมาก! ถ้าน้องปล่อยให้ ADC สุ่มค่าไปเรื่อยเปื่อยแบบไม่ดูจังหวะ ค่าที่อ่านได้จะแกว่งมหาศาล วิศวกรจึงนิยมตั้งค่าให้ ฮาร์ดแวร์ Timer ของ PWM เป็นตัวเหนี่ยวไก (Trigger) สั่งให้ ADC ทำงาน ณ ตำแหน่ง “จุดกึ่งกลางของช่วงที่ PWM ปิด (Off-time)” พอดีเป๊ะ เพื่อหลีกเลี่ยง Noise จากการสวิตชิ่งของทรานซิสเตอร์ครับ!,
  2. ขุมพลังซ่อนเร้น FMAC และ HRTIM: ถ้าเราต้องทำระบบจ่ายไฟดิจิทัล (Digital SMPS) หรือคุมมอเตอร์ความเร็วสูง การใช้ CPU รันโค้ดธรรมดาอาจจะไม่ทันกิน ชิปตระกูล STM32G4 มีฮาร์ดแวร์เฉพาะทางที่เรียกว่า HRTIM (High-Resolution Timer) ที่ซอยความละเอียดของ PWM ได้ลึกถึงระดับ “พิโควินาที (Sub-nanosecond)” นอกจากนี้ยังมี FMAC (Filter Math Accelerator) ซึ่งเป็นฮาร์ดแวร์คำนวณคณิตศาสตร์แยกต่างหาก ที่สามารถนำมารันสมการตัวกรองแบบ IIR หรือ PID ได้เร็วกว่า CPU หลายเท่า ทำให้ CPU ว่างไปทำอย่างอื่นได้สบายๆ ครับ,
  3. อย่าลืมหนีออกมาจาก Interrupt!: กฎเหล็กของการเขียนโค้ดระบบควบคุมใน Microcontroller คือ “จงทำให้อยู่ใน Interrupt สั้นที่สุด!” โค้ดคำนวณลูปควบคุมหลักต้องกระชับ (อย่างเช่น 6-Step Loop หรือลูปกระแสที่ต้องการความถี่สูงระดับ PWM) งานอื่นๆ ที่ไม่รีบด่วน เช่น การคำนวณการเคลื่อนที่ (Reference Computation), การสื่อสาร UART หรืออัปเดตหน้าจอ LCD ควรถูกเตะออกไปรันใน main() while(1) หรือใช้ SysTick Interrupt ที่ความถี่ต่ำกว่าแทนครับ

6. 🏁 บทสรุป (To be continued…)

ไมโครคอนโทรลเลอร์ (MCU) ไม่ใช่แค่กล่องดำลึกลับ แต่มันคือผืนผ้าใบที่รวมเอาหน่วยประมวลผล (CPU), เครื่องจับเวลา (Timer), ดวงตารับรู้ (ADC) และกล้ามเนื้อ (PWM) เข้าไว้ด้วยกัน การเข้าใจสถาปัตยกรรมของชิปอย่าง STM32 ช่วยให้เราสามารถออกแบบระบบควบคุมที่แม่นยำ ตอบสนองไว และรีดประสิทธิภาพออกมาได้สูงสุดตามทฤษฎีที่เราวาดฝันไว้ครับ

เมื่อเรามีฮาร์ดแวร์ที่ทรงพลัง และมีโค้ดที่รันสมการ PID ได้อย่างสมบูรณ์แบบแล้ว ก็ถึงเวลาที่เราจะเข้าสู่สุดยอดวิชาที่ทุกคนรอคอย ในตอนต่อไปเราจะมาดู “วิธีการปรับจูนพารามิเตอร์ PID ด้วยเทคนิคระดับตำนาน Ziegler-Nichols” ว่าเราจะหาค่า $K_p, K_i, K_d$ ที่เข้าเป้าที่สุดโดยไม่ต้องเดาสุ่มได้อย่างไร รอติดตามกันนะครับ!

ต้องการที่ปรึกษาด้านการออกแบบระบบควบคุม (Control Systems), หุ่นยนต์อัตโนมัติ (Robotics) หรือพัฒนาระบบ Automation ขั้นสูงให้กับโรงงานของคุณ? ทีมงาน WP Solution พร้อมให้บริการออกแบบและติดตั้งระบบแบบครบวงจร ดูรายละเอียดบริการของเราได้ที่: www.wpsolution2017.com หรือพูดคุยปรึกษาเบื้องต้นได้ที่ Line: wisit.p