Đồng hồ đếm thời gian
vì sao đồng hồ tự làm luôn chạy sai, và sai bao nhiêu

Bốn bài trước, sản phẩm chạy đúng là xong. Bài này khác: chương trình sẽ chạy gần đúng, và phần thú vị nằm ở chữ "gần". Học sinh sẽ đo được sai lệch, chỉ ra nguyên nhân, ước lượng độ lớn của nó, rồi sửa. Đó là toàn bộ chu trình làm việc của một người đo đạc.

Sau bài này học sinh làm được

• Làm được một đồng hồ đếm giây và đặt lại về 0 bằng nút nhấn.
• Đo được sai lệch tích luỹ so với đồng hồ chuẩn.
• Giải thích vì sao đồng hồ đếm bằng sleep luôn chạy chậm.
• Ước lượng thời gian các lệnh khác chiếm trong mỗi vòng lặp.
• Dùng ticks_ms() để làm đồng hồ không tích luỹ sai lệch.

Cách nghĩ đầu tiên ai cũng nghĩ ra

Chờ một giây rồi cộng một, lặp lại. Hợp lí, và đó là chương trình ở Bước 0. Chỗ ít ai nghĩ tới: ngoài lệnh chờ, mỗi vòng còn phải chạy những lệnh khác — cộng biến, gọi print, đọc nút, nháy đèn. Mỗi việc tốn một chút thời gian.

Sai lệch tích luỹ

Gọi thời gian các lệnh khác là t. Mỗi vòng thực tế dài 1000 + t ms. Sau n vòng, đồng hồ chỉ n giây trong khi thời gian thật đã trôi n × (1000 + t) ms.

Đáng sợ ở chỗ nó cộng dồn: t chỉ 3 ms thì sau 1000 giây đồng hồ đã chậm 3 giây, sau một giờ chậm ~11 giây.

ticks_ms và ticks_diff

time.ticks_ms() trả về số ms kể từ lúc bo khởi động. Con số này chạy đến một mức rồi quay vòng về 0, nên phải lấy hiệu bằng time.ticks_diff(sau, truoc) chứ không trừ trực tiếp — ticks_diff xử lí đúng cả trường hợp quay vòng.

▶ Mở sơ đồ này trên Wokwi Mô phỏng ngay trên trình duyệt, chưa cần bo mạch — hợp cho lúc chuẩn bị bài hoặc khi lớp thiếu thiết bị. ↗

Không có gì mới

Mạch của bài này giống hệt Bài 4. Nếu lớp vừa học Bài 4 xong thì không phải rút một sợi dây nào — chỉ đổi chương trình.

1. Nút nhấn: một chân → GPIO4, chân chéo góc → GND.
2. LED: GPIO23 → điện trở 220 Ω → chân dài, chân ngắn → GND.

Toàn bộ mã trong bài chạy trên MicroPython 1.28 cho ESP32. Chép vào bo rồi đổi tên thành main.py là chạy mỗi lần cấp nguồn.

Bước 0 — đồng hồ ngây thơ, cố tình để nó lệch

# ------------------------------------------------------------
#  Bai 5 - Buoc 0: dong ho dem bang cach cho. Co tinh de no LECH.
# ------------------------------------------------------------
import time

so_giay = 0

while True:
    time.sleep_ms(1000)
    so_giay = so_giay + 1
    print("So giay:", so_giay)

Bốn dòng, không dùng linh kiện nào. Cho chạy song song với đồng hồ bấm giờ và để yên đó suốt cả tiết học. Đến cuối tiết, hai con số sẽ lệch nhau rõ rệt — và cả lớp sẽ có một câu hỏi thật sự để trả lời.

Chương trình chính — thêm nút đặt lại và đèn nháy

# ------------------------------------------------------------
#  Bai 5 - Dong ho dem thoi gian
#  Phan cung: GPIO4 -> nut nhan -> GND
#             GPIO23 -> dien tro 220 ohm -> LED -> GND
# ------------------------------------------------------------
from machine import Pin
import time

# ===== CẤU HÌNH =====
CHAN_NUT = 4
CHAN_LED = 23
NHIP = 1000               # ms - bao lau thi cong them mot giay
CHONG_DOI = 200           # ms
# ====================

nut = Pin(CHAN_NUT, Pin.IN, Pin.PULL_UP)
led = Pin(CHAN_LED, Pin.OUT)

so_giay = 0
truoc_do = False

while True:
    time.sleep_ms(NHIP)

    so_giay = so_giay + 1
    print("So giay:", so_giay)

    # nhay den mot cai moi giay cho de theo doi
    led.on()
    time.sleep_ms(30)
    led.off()

    # nhan nut thi dat lai ve 0
    dang_nhan = nut.value() == 0
    if dang_nhan and not truoc_do:
        so_giay = 0
        print("Da dat lai ve 0")
        time.sleep_ms(CHONG_DOI)
    truoc_do = dang_nhan

Phần phát hiện sườn nhấn ở cuối là bản sao nguyên xi từ Bài 4. Đây là lần đầu học sinh dùng lại một kĩ thuật đã học ở bài trước, trong một hoàn cảnh hoàn toàn khác. Hãy chỉ rõ điều đó.

Chú ý bản này lệch nhiều hơn Bước 0, vì có thêm lệnh nháy đèn và lệnh đọc nút trong mỗi vòng. Đó không phải bước lùi — đó là số liệu cho mục Hiệu chuẩn.

Biến thể — đồng hồ dựa mốc, không tích luỹ sai lệch

# Bien the: dong ho KHONG lech, dua vao dong ho noi cua chip
import time

# ticks_ms() dem so mili giay tu luc bo khoi dong
moc = time.ticks_ms()
da_bao = 0

while True:
    troi_qua = time.ticks_diff(time.ticks_ms(), moc)
    giay = troi_qua // 1000

    if giay > da_bao:
        da_bao = giay
        print("So giay:", giay)

    time.sleep_ms(10)

Bản này không cộng dồn gì cả. Mỗi vòng nó hỏi lại "từ mốc gốc tới giờ trôi bao lâu rồi" và chia cho 1000. Dù các lệnh khác có tốn bao nhiêu thời gian, số giây in ra vẫn bám đúng đồng hồ thật.

Thử thay đổi bài này với AI

Em mô tả bằng tiếng Việt, hệ thống dựng thuật toán và chương trình, rồi nạp thẳng xuống ESP32 qua Wi-Fi.

Phép đo chính của bài

1. Nạp chương trình chính, bấm đồng hồ điện thoại cùng lúc bo khởi động.
2. Để chạy đúng 5 phút theo đồng hồ điện thoại.
3. Đọc số giây chương trình in ra ngay khoảnh khắc đó.
4. Sai lệch = 300 − số máy đếm được.

Từ sai lệch suy ngược ra thời gian mỗi vòng

Nếu sau 300 giây thật mà máy chỉ đếm được 299, nghĩa là 299 vòng đã chiếm hết 300 giây. Mỗi vòng dài 300 000 / 299 ≈ 1003,3 ms, tức các lệnh khác chiếm khoảng 3,3 ms. Đây là một phép đo gián tiếp rất đẹp: học sinh đo được thời gian chạy của vài câu lệnh mà không cần dụng cụ nào ngoài đồng hồ bấm giờ.

Danh sách kiểm trước khi coi là xong

• Đồng hồ đếm đều, đèn nháy đúng mỗi giây một cái.
• Nhấn nút thì số về 0 và đếm lại từ đầu.
• Bảng ba dòng ở trên đã điền đủ số liệu đo thật.
• Bản dựa mốc sai lệch nhỏ hơn hẳn hai bản kia.
• Học sinh tính được thời gian một vòng lặp từ sai lệch đo được.

Toán — sai số tuyệt đối và sai số tương đối có số liệu thật

Bảng ba dòng ở mục Hiệu chuẩn là một bộ số liệu thật do chính học sinh đo được. Từ đó tính sai số tuyệt đối (mấy giây) và sai số tương đối (bao nhiêu phần trăm), rồi ngoại suy: sau một ngày thì lệch bao nhiêu? Sau một tháng?

Vật lí — mọi dụng cụ đo đều có sai số

Đây là bài dạy khái niệm sai số dụng cụ mà không cần giảng lí thuyết. Học sinh vừa làm ra một dụng cụ đo, vừa phát hiện nó sai, vừa định lượng được cái sai đó. Đồng hồ điện thoại đóng vai chuẩn — và cũng nên hỏi: cái chuẩn ấy lấy độ chính xác từ đâu?

Tin học — câu lệnh cũng tốn thời gian

Học sinh thường nghĩ máy chạy tức thì. Bài này cho thấy mỗi câu lệnh đều có giá của nó, và một câu print tưởng vô hại lại là thứ tốn nhất trong vòng lặp. Đó là bước đầu của tư duy về hiệu năng chương trình.