Có. Và thực ra phần mềm nhúng của nồi cơm điện tử/nồi cơm cao tần là một ví dụ rất hay để học tư duy firmware, vì nó gần với những gì bạn đang học ở STM32: đọc cảm biến → quyết định trạng thái → điều khiển phần công suất → giám sát lỗi → chuyển trạng thái.
Một nồi cơm hiện đại không đơn giản là:
“Bấm Cook → bật nhiệt → đủ nhiệt → tắt.”
Nó thường được thiết kế như một máy trạng thái (State Machine) kết hợp điều khiển nhiệt độ, thời gian và bảo vệ.
1. Nhìn tổng thể phần mềm của một nồi cơm
Có thể hình dung kiến trúc như sau:
┌──────────────────────┐
│ NGƯỜI DÙNG │
│ Phím / Touch / Menu │
└──────────┬───────────┘
│
▼
┌──────────────────────┐
│ USER INTERFACE │
│ Đọc phím / hiển thị │
└──────────┬───────────┘
│
▼
┌───────────────┐ ┌──────────────────────┐ ┌────────────────┐
│ Cảm biến nhiệt│──►│ CONTROL ALGORITHM │──►│ Công suất │
│ Thermistor │ │ │ │ Heater / IGBT │
└───────────────┘ │ State Machine │ └────────────────┘
│ Temperature Control │
┌───────────────┐ │ Timer │
│ Cảm biến nắp │──►│ Safety │
│ / áp suất │ │ Error Management │
└───────────────┘ └──────────┬───────────┘
│
▼
┌───────────────┐
│ LCD / Buzzer │
│ LED / Display │
└───────────────┘Về bản chất:
Sensor → MCU → thuật toán → công suất → nhiệt → Sensor → MCU…
Đó chính là một vòng điều khiển kín (closed-loop control).
2. Nồi cơm thường có những phần cứng nào?
Ví dụ một nồi cơm điện tử:
MCU
│
┌───────────┼───────────┐
│ │ │
▼ ▼ ▼
Thermistor Keypad Display
│
▼
ADC của MCU
│
▼
Thuật toán
│
▼
Relay / Triac
│
▼
HeaterNồi cao tần (IH) phức tạp hơn:
AC 220V
│
▼
Rectifier
│
▼
DC Bus
│
▼
IGBT / Power MOSFET
│
▼
Cuộn dây IH
│
▼
Nồi / lòng nồi
│
▼
CơmMCU sẽ điều khiển IGBT bằng PWM hoặc các phương pháp điều chế phù hợp.
Vì vậy, nồi cao tần có phần công suất và thuật toán điều khiển phức tạp hơn nồi điện tử thông thường rất nhiều.
3. Điều quan trọng nhất: State Machine
Đây là phần tôi nghĩ bạn sẽ rất thích vì nó liên quan trực tiếp đến những gì chúng ta đã nói về firmware.
Một chương trình nồi cơm có thể có các trạng thái:
┌──────────────┐
│ POWER ON │
└──────┬───────┘
▼
┌──────────────┐
│ IDLE │
└──────┬───────┘
│
USER PRESS COOK
│
▼
┌──────────────┐
│ COOKING │
└──────┬───────┘
│
đủ điều kiện
│
▼
┌──────────────┐
│ ABSORBING │
└──────┬───────┘
│
▼
┌──────────────┐
│ STEAMING │
└──────┬───────┘
│
▼
┌──────────────┐
│ KEEP WARM │
└──────┬───────┘
│
USER CANCEL
│
▼
IDLEĐây chính là kiểu tư duy:
switch(state)
{
case IDLE:
...
break;
case COOKING:
...
break;
case STEAMING:
...
break;
case KEEP_WARM:
...
break;
case ERROR:
...
break;
}4. Nhưng nồi không chỉ có một State Machine
Đây mới là điểm thú vị.
Một firmware thực tế thường có nhiều nhiệm vụ chạy song song về mặt logic.
Ví dụ:
MAIN CONTROL
│
┌──────────────┼───────────────┐
▼ ▼ ▼
Temperature User Input Safety
Control Processing Monitor
│ │ │
▼ ▼ ▼
Heater Buttons Errors
Control Display ProtectionMCU có thể chạy các task kiểu:
Task 1: đọc nhiệt độ
Task 2: xử lý phím
Task 3: điều khiển heater
Task 4: cập nhật LCD
Task 5: buzzer
Task 6: timer
Task 7: kiểm tra lỗiKhông nhất thiết phải có RTOS. Một MCU nhỏ hoàn toàn có thể làm bằng super-loop + timer interrupt.
5. Ví dụ thuật toán khi người dùng bấm COOK
Giả sử nồi đang:
IDLENgười dùng bấm:
COOKFirmware có thể thực hiện:
Đọc phím
↓
Xác nhận phím hợp lệ
↓
Xác định chế độ nấu
↓
Đọc cảm biến nhiệt
↓
Kiểm tra lỗi
↓
Khởi động quá trình nấu
↓
Điều khiển công suấtSau đó vòng lặp liên tục:
READ TEMPERATURE
↓
CHECK ERROR
↓
CALCULATE POWER
↓
CONTROL HEATER
↓
UPDATE DISPLAY
↓
CHECK TIME
↓
REPEAT6. Cảm biến nhiệt là cực kỳ quan trọng
Thông thường có thể dùng thermistor NTC.
Ví dụ:
VCC
│
R
│
├──────── ADC
│
NTC
│
GNDMCU đọc ADC:
ADC = 2350Sau đó firmware chuyển:
ADC
↓
Voltage
↓
Resistance
↓
TemperatureVí dụ:
ADC = 2350
↓
NTC = 12.4 kΩ
↓
Temperature = 82°CTất nhiên bảng/ phương trình thực tế phụ thuộc NTC được sử dụng.
7. Sau đó thuật toán quyết định công suất
Ví dụ rất đơn giản:
Temperature < 70°C
↓
HEATER ON
70–90°C
↓
giảm công suất
90–100°C
↓
tiếp tục kiểm soát
> giới hạn
↓
HEATER OFFĐây là kiểu bang-bang control / hysteresis.
Ví dụ:
if temperature < 95°C
heater = ON;
if temperature > 100°C
heater = OFF;Nhưng nồi cao cấp có thể phức tạp hơn nhiều.
8. Có thể dùng PID không?
Có thể.
Nhưng không nên mặc định rằng mọi nồi cơm đều dùng PID.
Tùy thiết kế, nhà sản xuất có thể dùng:
- On/Off control
- hysteresis
- time-proportional control
- phase control
- PWM
- các thuật toán điều khiển công suất riêng
- PID hoặc biến thể PID
- lookup table
- điều khiển theo profile nhiệt độ
Ví dụ profile:
Temperature
│
100│ ─────────────
│ /
80│ /
│ /
60│ /
│ /
40│____/
│
└────────────────────────────── Time
↑ ↑ ↑
Heat Absorb SteamĐiều này rất quan trọng.
Nồi không chỉ quan tâm “nhiệt độ hiện tại bao nhiêu”, mà còn quan tâm nhiệt độ đang tăng nhanh hay chậm và đã trải qua bao lâu.
9. Đây chính là điểm làm firmware nồi cơm trở nên thông minh
Ví dụ:
T = 75°CHai trường hợp hoàn toàn khác nhau:
Trường hợp A
60 → 65 → 70 → 75Nhiệt đang tăng.
Trường hợp B
90 → 85 → 80 → 75Nhiệt đang giảm.
Cùng:
T = 75°Cnhưng trạng thái hệ thống khác nhau.
Vì vậy firmware có thể phải biết:
Temperature
Temperature history
Temperature slope
Elapsed time
Current cooking state10. Một thuật toán rất thú vị: phát hiện nước đã cạn
Đây là một ví dụ cực hay.
Khi có nước:
nước + gạo
↓
nhiệt độ bị giới hạn bởi quá trình bay hơi
↓
nhiệt độ đáy tăng tương đối chậmKhi nước gần cạn:
nước giảm
↓
bay hơi giảm
↓
nhiệt độ đáy tăng nhanhFirmware có thể quan sát:
T(t)và:
dT/dtNếu phát hiện:
dT/dt tăng bất thườngthì có thể chuyển:
COOKING
↓
WATER ABSORBED
↓
STEAMINGĐây là lý do cùng một cảm biến nhiệt nhưng firmware có thể suy luận được trạng thái bên trong nồi.
11. Nồi cao tần còn phức tạp hơn
Với IH:
AC
↓
Rectifier
↓
DC
↓
IGBT
↓
Coil
↓
Magnetic field
↓
Lòng nồi
↓
NhiệtMCU phải điều khiển:
IGBT switchingđồng thời giám sát:
Current
Voltage
Temperature
Frequency
Power
Pan detection
IGBT temperature
Coil temperatureMột thuật toán tổng quát:
START
│
▼
Check hardware
│
├── ERROR → ERROR
│
▼
Detect pot
│
├── NO POT → WAIT
│
▼
Select power
│
▼
Generate drive
│
▼
Measure current
│
▼
Measure temperature
│
▼
Calculate power
│
▼
Adjust IGBT drive
│
└───────────────┐
│
▼
REPEAT12. Và luôn có một “Safety State”
Đây là phần cực kỳ quan trọng trong firmware thiết bị gia dụng.
Ví dụ:
NORMAL
│
├── Sensor abnormal
│
├── Over temperature
│
├── Over current
│
├── Over voltage
│
├── IGBT over temperature
│
├── Communication error
│
└── Memory error
│
▼
ERRORVí dụ NTC bị đứt:
ADC ≈ VCCFirmware nhận thấy:
Temperature = impossible→ không được tiếp tục gia nhiệt.
Nó có thể:
HEATER OFF
IGBT OFF
BUZZER
DISPLAY ERROR CODE13. Watchdog cũng thường rất quan trọng
Ví dụ firmware bị treo:
main()
↓
...
↓
software bug
↓
CPU stuckWatchdog:
┌───────────────┐
│ WATCHDOG │
└───────┬───────┘
│
timeout?
│
YES
↓
RESET MCUVới thiết bị gia nhiệt, đây là lớp bảo vệ rất quan trọng.
14. Một firmware nồi cơm hoàn chỉnh có thể hình dung như thế này
POWER ON
│
▼
Hardware Init
│
▼
Self Diagnosis
│
┌────────────┴────────────┐
│ │
ERROR OK
│ │
▼ ▼
ERROR MODE IDLE
│
User selects mode
│
▼
COOKING INIT
│
▼
┌─────────────────┐
│ Read Sensors │
│ │
│ Temperature │
│ Current │
│ Voltage │
│ Lid │
└────────┬────────┘
│
▼
Safety Check
│
┌──────┴──────┐
│ │
ERROR OK
│ │
▼ ▼
SHUTDOWN Control Power
│
▼
Update Timer
│
▼
Update Display
│
▼
Check Condition
│
┌───────────────┼──────────────┐
│ │ │
Continue Finish Error
│ │ │
└───────┐ ▼ ▼
│ KEEP WARM ERROR
│
└───► LOOP15. Nếu viết thành firmware STM32 thì tư duy sẽ rất giống dự án của bạn
Ví dụ kiến trúc:
int main(void)
{
HAL_Init();
SystemClock_Config();
MX_GPIO_Init();
MX_ADC_Init();
MX_TIM_Init();
MX_UART_Init();
Cooker_Init();
while (1)
{
Key_Process();
Temperature_Process();
Cooking_Control();
Safety_Process();
Display_Process();
Buzzer_Process();
HAL_Delay(10);
}
}Nhưng các hàm thực tế có thể được kích hoạt theo timer:
1 ms → timer/system tick
10 ms → key scan
100 ms → temperature control
500 ms → display update
1 s → cooking timerVí dụ:
TIMER
│
┌───────┼────────┐
▼ ▼ ▼
1 ms 10 ms 1 sec
│ │ │
▼ ▼ ▼
system keypad timer
tick scan countĐây chính là tư duy firmware embedded thực tế.
16. Một điều rất đáng chú ý
Nếu bạn đang học firmware, tôi khuyên bạn đừng bắt đầu bằng việc nghĩ “nồi cơm cần bao nhiêu dòng code?”
Hãy nghĩ theo 5 tầng:
TẦNG 1
HARDWARE
↓
MCU / ADC / Timer / GPIO / PWM
TẦNG 2
SENSOR
↓
Temperature / Current / Voltage
TẦNG 3
STATE MACHINE
↓
IDLE / COOK / STEAM / WARM / ERROR
TẦNG 4
CONTROL ALGORITHM
↓
Temperature → Power
TẦNG 5
SAFETY
↓
Abnormal → ShutdownĐây chính là cách một kỹ sư firmware thường tư duy về một sản phẩm.
Và nó rất gần với những gì bạn đang làm với STM32 + TIM2 + ADC + UART + IR: IR của bạn hiện tại chỉ là một “nguồn sự kiện đầu vào”; còn với nồi cơm thì nguồn đầu vào có thể là nhiệt độ, phím, dòng điện, điện áp, cảm biến nắp…
Nếu bạn muốn, tôi có thể đi tiếp một bước rất thực tế: thiết kế cho bạn toàn bộ “firmware nồi cơm điện tử” giả lập trên STM32F103, từ sơ đồ phần cứng → ADC đọc NTC → State Machine → thuật toán nấu cơm → PWM/relay điều khiển heater → lỗi E1/E2 → watchdog → lưu đồ → code C, giống như một dự án firmware sản phẩm thực tế.
