Count on the LEDs, and watch it wrap用 LED 數數，並看著它繞回 0LED でカウントし、ラップするのを見るMencacah di LED, dan mengamati saat ia berputar kembali

• Verilog
• Counter
• Clock enable
• Pin constraints

“use the led on dev. board to show the output of counter and wrap” ↳ added as the warm-up

The first thing that has to work: a bitstream on the board, pins assigned correctly, and something moving. Run a free counter, put it on the LEDs, and make the wrap from 255 back to 0 visible as its own event rather than something you infer. 第一件必須成功的事：bitstream 燒進板子、腳位指定正確、而且看得到東西在動。跑一個自由計數器，把它接到 LED 上，並讓 255 繞回 0 這件事本身變成看得見的事件，而不是用推的。最初に動かなければならないもの：ボードに書き込まれたビットストリーム、正しく割り当てられたピン、そして何かが動いていること。フリーランのカウンタを走らせて LED に出し、255 から 0 へのラップを推測ではなく目に見えるイベントにする。Hal pertama yang harus jalan: bitstream di papan, pin yang ditetapkan dengan benar, dan sesuatu yang bergerak. Jalankan pencacah bebas, tampilkan di LED, dan buat perputaran dari 255 kembali ke 0 terlihat sebagai kejadian tersendiri, bukan sesuatu yang hanya kamu simpulkan.

50 MHz is far too fast to watch, so the counter does not run on every clock — it runs on a tick. One clock, one enable: that habit is the reason this task comes before everything else. 50 MHz 快到根本看不見，所以計數器不是每個時脈都走——它是靠 tick 走。單一時脈、單一 enable：這個習慣就是這題排在最前面的理由。50 MHz は速すぎて見えないので、カウンタは毎クロックではなく tick で進む。クロックは一つ、イネーブルは一つ——この習慣こそ、この課題が最初に来る理由だ。50 MHz jauh terlalu cepat untuk diamati, jadi pencacahnya tidak berjalan pada setiap clock — ia berjalan pada sebuah tick. Satu clock, satu enable: kebiasaan itulah alasan tugas ini datang sebelum yang lain.

// one clock, one enable — never a counter bit as a clock
wire tick = (pre == DIV-1);   // 0.5 Hz
if (tick) cnt <= cnt + 1'b1;  // 8-bit, wraps by itself

Target numbers目標數字目標値Angka target

Tick ratetick 頻率tick レートLaju tick

0.5 Hz → 1 count / 2 s

Prescale divisor前置除數プリスケール分周値Pembagi prescale

50e6 / 0.5 = 100,000,000

Prescaler width前置計數器位寬プリスケーラ幅Lebar prescaler

27 bits (2^27 > 1e8)

Counter

8 bits → 256 states

Wrap period繞回週期ラップ周期Periode perputaran

512 s = 8 min 32 s

Wrap flash繞回閃燈ラップ点灯Kedip saat berputar

1 tick = 2 s

Traps陷阱落とし穴Jebakan

• Never write always @(posedge cnt[24]). A counter bit used as a clock is a ripple clock: it works on the bench, and it makes every timing report after it meaningless. Use a clock enable.絕對不要寫 always @(posedge cnt[24])。把計數器的某個位元拿來當時脈就是 ripple clock：在桌上會動，但之後每一份 timing report 都失去意義。請改用 clock enable。always @(posedge cnt[24]) と書いてはいけない。カウンタのビットをクロックに使うのはリップルクロックで、机の上では動くがそれ以降のタイミングレポートをすべて無意味にする。クロックイネーブルを使うこと。Jangan pernah menulis always @(posedge cnt[24]). Bit pencacah yang dipakai sebagai clock adalah ripple clock: ia jalan di meja praktik, dan membuat setiap laporan timing setelahnya tidak bermakna. Pakai clock enable.
• Most boards wire LEDs active low. All eight stuck on usually means a missing ~, not a dead board.多數板子的 LED 是低電位點亮。八顆全亮通常是少了一個 ~，不是板子壞了。多くのボードで LED はアクティブロー配線。8 個とも点きっぱなしなら、たいていはボードの故障ではなく ~ の書き忘れ。Kebanyakan papan memasang LED secara active low. Kedelapan LED yang menyala terus biasanya berarti ada ~ yang hilang, bukan papan yang mati.
• The carry-out is one clock wide — 20 ns. Stretch it to a full tick or you will never see the wrap.進位輸出只有一個時脈寬——20 ns。把它拉長成一整個 tick，否則你永遠看不到繞回。キャリーアウトは 1 クロック幅、つまり 20 ns。1 tick 分に伸ばさなければラップは絶対に見えない。Carry-out hanya selebar satu clock — 20 ns. Regangkan menjadi satu tick penuh atau kamu tidak akan pernah melihat perputarannya.
• No pin assignment, no light. Quartus wants a .qsf location and I/O standard per pin; Vivado wants the same pair in an .xdc.沒有指定腳位就沒有燈。Quartus 需要在 .qsf 裡給每支腳位置與 I/O standard；Vivado 則是在 .xdc 裡寫同樣兩項。ピン割り当てが無ければ光らない。Quartus は .qsf にピンごとの位置と I/O 規格を要求し、Vivado は同じ二つを .xdc に要求する。Tanpa penetapan pin, tidak ada cahaya. Quartus meminta lokasi .qsf dan standar I/O per pin; Vivado meminta pasangan yang sama di dalam .xdc.
• Give it a reset and use it. An uninitialised counter starts wherever the fabric powers up, which makes "it starts at a weird number" your first wasted afternoon.給它一個 reset，而且真的要用。沒初始化的計數器會從上電當下的任意值開始，「怎麼從奇怪的數字開始」會是你第一個浪費掉的下午。リセットを用意し、実際に使うこと。初期化されていないカウンタは電源投入時の値から始まり、「変な数字から始まる」で最初の午後を丸ごと潰すことになる。Beri ia reset dan gunakan. Pencacah yang tidak diinisialisasi mulai dari nilai apa pun yang muncul saat fabric menyala, dan itulah yang membuat "kok mulainya dari angka aneh" menjadi sore pertama yang kamu buang percuma.

Done when完成條件完了条件Selesai bila

• Eight LEDs count up in binary at 0.5 Hz — one count every two seconds — and the value is readable.八顆 LED 以 0.5 Hz 用二進位往上數——每兩秒加一——而且讀得出數值。8 個の LED が 0.5 Hz で二進カウントし——2 秒に 1 カウント——値が読み取れる。Delapan LED mencacah naik dalam biner pada 0.5 Hz — satu hitungan tiap dua detik — dan nilainya terbaca.
• A ninth LED lights for one whole tick each time the count rolls 255 → 0, once every 512 s.每當計數從 255 繞回 0，第九顆 LED 就亮滿一個 tick，每 512 秒一次。カウントが 255 → 0 とラップするたび、9 個目の LED が 1 tick 分点灯する（512 秒に 1 回）。LED kesembilan menyala selama satu tick penuh setiap kali hitungan berputar 255 → 0, sekali tiap 512 s.
• Reset returns the display to zero while the board is running.板子執行中按 reset，顯示會回到零。ボード動作中にリセットすると表示がゼロに戻る。Reset mengembalikan tampilan ke nol selagi papan tetap berjalan.
• The project contains exactly one clock — grep it and confirm no counter bit is used as one.整個專案只有一個時脈——用 grep 檢查，確認沒有任何計數器位元被當成時脈。プロジェクト内のクロックはちょうど一つ——grep して、カウンタのビットがクロックに使われていないことを確認する。Proyek berisi tepat satu clock — grep isinya dan pastikan tidak ada bit pencacah yang dipakai sebagai clock.
• Handed in: a testbench waveform showing the 255 → 0 wrap, and a YouTube clip of the board counting (raise the tick for the clip rather than filming eight minutes).已交件：testbench 波形顯示 255 → 0 的繞回，以及板子計數的 YouTube 影片（拍片時把 tick 調快，不要真的錄八分鐘）。提出済み：255 → 0 のラップを示す testbench 波形と、ボードがカウントしている YouTube 動画（8 分撮る代わりに tick を速くすること）。Dikumpulkan: bentuk gelombang testbench yang menunjukkan perputaran 255 → 0, dan klip YouTube papan yang sedang mencacah (naikkan laju tick untuk klipnya daripada merekam delapan menit).

Reference answer — not released yet參考解答 —— 尚未開放参考解答 — まだ公開されていませんJawaban acuan — belum dirilis

module led_counter #(parameter DIV = 100_000_000)  // 0.5 Hz at 50 MHz
  (input clk, input rst_n, output [7:0] led, output wrap_led);

  reg [26:0] pre;
  reg [7:0]  cnt;
  reg        wrap_q;

  wire tick = (pre == DIV-1);

  always @(posedge clk or negedge rst_n)
    if (!rst_n) begin
      pre <= 27'd0; cnt <= 8'd0; wrap_q <= 1'b0;
    end else begin
      pre <= tick ? 27'd0 : pre + 1'b1;
      if (tick) begin
        cnt    <= cnt + 1'b1;          // 255 + 1 wraps to 0
        wrap_q <= (cnt == 8'hFF);      // hold the carry for one whole tick
      end
    end

  assign led      = ~cnt;              // active-low board LEDs
  assign wrap_led = ~wrap_q;
endmodule

# Quartus, in the .qsf
set_location_assignment PIN_A8 -to led[0]
set_instance_assignment -name IO_STANDARD "3.3-V LVTTL" -to led[0]

# Vivado, in the .xdc
set_property -dict {PACKAGE_PIN U16 IOSTANDARD LVCMOS33} [get_ports {led[0]}]

Two FSMs, one clock, no stalls兩個 FSM、同一時脈、不停頓二つの FSM、一つのクロック、停滞なしDua FSM, satu clock, tanpa macet

• Verilog
• FSM
• Handshake
• Testbench

“multi-fsm running at same time (e.g. uart serialize & uart buffer allocater)”

Write the transmitter as two independent state machines that run every clock edge and talk only through a handshake — never through a shared variable. The serializer owns the bit timing; the allocator owns which byte comes next. Both live in their own always block; neither one waits for the other to finish a whole byte. 把發送端寫成兩個各自獨立、每個時脈邊緣都在跑的狀態機，彼此只透過 handshake 溝通——絕不共用變數。serializer 負責位元時序，allocator 負責決定下一個 byte。兩者各自待在自己的 always 區塊裡；誰都不必等對方把一整個 byte 做完。送信側は二つの独立したステートマシンとして書く。どちらも毎クロックエッジで動き、やり取りはハンドシェイクのみ——共有変数は使わない。シリアライザはビットタイミングを、アロケータは次のバイトを担当する。それぞれ自分の always ブロックに置き、相手が 1 バイトを終えるのを待たない。Tulis pemancarnya sebagai dua mesin keadaan mandiri yang berjalan pada setiap tepi clock dan hanya berbicara lewat handshake — jangan pernah lewat variabel bersama. Serializer memegang pewaktuan bit; alokator memegang byte mana yang menyusul. Keduanya hidup di blok always masing-masing; tidak satu pun menunggu yang lain menyelesaikan satu byte penuh.

// allocator → serializer, one byte per handshake
tx_valid  // allocator: this byte is real
tx_ready  // serializer: I latched it, give me the next
tx_data[7:0]
// transfer happens on the edge where both are high

Target numbers目標數字目標値Angka target

Baud divisorbaud 除數baud 分周値Pembagi baud

50e6 / 115200 = 434

Serializer statesserializer 狀態シリアライザの状態Keadaan serializer

IDLE·START·DATA·STOP

Bits per frame每個 frame 的位元數1 フレームのビット数Bit per frame

10 (1+8+1)

Ring buffer環形緩衝區リングバッファRing buffer

16 B, wrapping wr/rd ptr

Traps陷阱落とし穴Jebakan

• One always @(posedge clk) block per FSM. Two blocks driving the same reg is a compile error waiting for you.每個 FSM 一個 always @(posedge clk) 區塊。兩個區塊去驅動同一個 reg，等著吃編譯錯誤。FSM ごとに always @(posedge clk) ブロックを一つ。二つのブロックで同じ reg を駆動すればコンパイルエラーが待っている。Satu blok always @(posedge clk) untuk tiap FSM. Dua blok yang menggerakkan reg yang sama adalah galat kompilasi yang sedang menunggumu.
• The allocator must handle full and empty as distinct states — an equal read and write pointer means both unless you keep a count.allocator 必須把滿和空當成兩種不同狀態——讀寫指標相等時兩者都成立，除非你另外記一個計數。アロケータはフルとエンプティを別の状態として扱う必要がある——読み書きポインタが等しいだけでは両方を意味するので、カウントを別に持つこと。Alokator harus memperlakukan penuh dan kosong sebagai keadaan yang berbeda — pointer baca dan tulis yang sama nilainya berarti keduanya, kecuali kamu menyimpan pencacah.
• Register the outputs. Combinational tx straight off the state decoder will glitch.輸出要打一級暫存器。直接從狀態解碼拉出來的組合邏輯 tx 會有毛刺。出力はレジスタで受けること。ステートデコーダから直接出した組み合わせ論理の tx はグリッチする。Registerkan keluarannya. tx kombinasional langsung dari dekoder keadaan akan menghasilkan glitch.

Done when完成條件完了条件Selesai bila

• Testbench pushes 4 bytes back-to-back and all 4 come out, in order, with correct stop bits.testbench 連續塞入 4 個 byte，四個都照順序送出，stop bit 正確。testbench が 4 バイトを連続で投入し、4 バイトとも順序どおり、正しいストップビット付きで出てくる。Testbench mendorong 4 byte berturut-turut dan semua 4 byte itu keluar, berurutan, dengan stop bit yang benar.
• The allocator accepts a new byte while the serializer is still shifting the previous one.serializer 還在移位前一個 byte 時，allocator 就能接受新的 byte。シリアライザが前のバイトをシフト中でも、アロケータは新しいバイトを受け付ける。Alokator menerima byte baru selagi serializer masih menggeser byte sebelumnya.
• Overflow is refused (valid held off), never silently dropped.溢位時是拒收（valid 不拉起來），絕不默默丟掉。オーバーフローは受け付けを拒否し（valid を上げない）、黙って捨てない。Kelebihan data ditolak (valid ditahan), tidak pernah dibuang diam-diam.
• Handed in: a testbench waveform of both FSMs advancing on the same edge, and a YouTube clip of the bytes going out.已交件：兩個 FSM 在同一個邊緣一起前進的 testbench 波形，以及 byte 送出的 YouTube 影片。提出済み：二つの FSM が同じエッジで進む testbench 波形と、バイトが送出される YouTube 動画。Dikumpulkan: bentuk gelombang testbench yang menunjukkan kedua FSM maju pada tepi yang sama, dan klip YouTube byte-byte yang keluar.

Reference answer — not released yet參考解答 —— 尚未開放参考解答 — まだ公開されていませんJawaban acuan — belum dirilis

localparam DIV = 434;
reg [9:0] sh; reg [8:0] baud; reg [3:0] bit_i; reg st;

always @(posedge clk or negedge rst_n)
  if (!rst_n) begin st <= 0; tx <= 1'b1; end
  else if (!st) begin
    if (tx_valid) begin
      sh    <= {1'b1, tx_data, 1'b0};   // stop | data | start
      bit_i <= 0; baud <= 0; st <= 1;
    end
  end else begin
    tx <= sh[0];                        // drive the current bit
    if (baud == DIV-1) begin
      baud  <= 0;
      sh    <= {1'b1, sh[9:1]};         // shift in idle-high
      bit_i <= bit_i + 1'b1;
      if (bit_i == 4'd9) st <= 0;       // 10th bit sent
    end else baud <= baud + 1'b1;
  end

assign tx_ready = ~st;

reg [7:0] mem [0:15];
reg [4:0] wr, rd;                        // 5 bits for 16 slots

wire full  = (wr[3:0] == rd[3:0]) && (wr[4] != rd[4]);
wire empty = (wr == rd);

always @(posedge clk) begin
  if (push && !full)          begin mem[wr[3:0]] <= din; wr <= wr + 1'b1; end
  if (tx_valid && tx_ready)   rd <= rd + 1'b1;
end

assign tx_valid = ~empty;
assign tx_data  = mem[rd[3:0]];
assign can_push = ~full;                 // refuse, never drop

LabVIEW writes, the FPGA echoes it backLabVIEW 送出，FPGA 原封回傳LabVIEW が送り、FPGA がそのまま返すLabVIEW menulis, FPGA menggemakannya kembali

• UART RX
• Synchronizer
• VISA

“Use labview to send data to rx of uart on FPGA and FPGA echo the data back to labview”

Now build the receiver and wire it straight into the transmitter from task 2. The whole design is a wire with a clock in the middle: whatever the host writes, it should read back byte-identical. This is the test rig you will reuse for everything after it. 現在做接收端，並直接接到第 2 題的發送端。整個設計就是一條中間夾了時脈的線：主機寫什麼，就該原樣讀回什麼。這是你後面每一題都會重複用到的測試平台。次に受信側を作り、課題 2 の送信側へ直結する。設計全体は真ん中にクロックが入った一本の線で、ホストが書いた内容がそのまま読み戻せるはず。これ以降ずっと使い回すテスト治具になる。Sekarang bangun penerimanya dan sambungkan langsung ke pemancar dari tugas 2. Seluruh rancangannya adalah sehelai kabel dengan clock di tengahnya: apa pun yang ditulis host, harus terbaca kembali identik byte demi byte. Inilah perangkat uji yang akan kamu pakai lagi untuk semua yang berikutnya.

On the LabVIEW side: VISA Configure Serial Port → VISA Write → VISA Read → VISA Close, with the read byte count wired from Bytes at Port rather than a guess. LabVIEW 這邊：VISA Configure Serial Port → VISA Write → VISA Read → VISA Close，讀取的 byte 數要從 Bytes at Port 接過來，不要用猜的。LabVIEW 側は VISA Configure Serial Port → VISA Write → VISA Read → VISA Close。読み取りバイト数は当て推量ではなく Bytes at Port から配線する。Di sisi LabVIEW: VISA Configure Serial Port → VISA Write → VISA Read → VISA Close, dengan jumlah byte yang dibaca disambungkan dari Bytes at Port, bukan dari tebakan.

Target numbers目標數字目標値Angka target

Oversampling過取樣オーバーサンプリングOversampling

16× per bit

Tick divisortick 除數tick 分周値Pembagi tick

50e6/(115200·16) ≈ 27

Sample point取樣點サンプリング点Titik pencuplikan

tick 8 of 16 (mid-bit)

Input sync輸入同步入力同期Sinkronisasi masukan

2 flip-flops on rx

Soak test長時間測試ソークテストUji rendam

1000 random bytes, 0 mismatches

Traps陷阱落とし穴Jebakan

• The rx pin is asynchronous. Two flip-flops before it touches any FSM, or you will chase a bug that only appears once an hour.rx 腳是非同步訊號。在它碰到任何 FSM 之前先過兩級正反器，否則你會去追一個一小時才出現一次的 bug。rx ピンは非同期。FSM に触れる前にフリップフロップ 2 段を通すこと。さもないと 1 時間に 1 度しか出ないバグを追うことになる。Pin rx bersifat asinkron. Dua flip-flop sebelum ia menyentuh FSM mana pun, atau kamu akan mengejar bug yang hanya muncul sekali sejam.
• Re-check the start bit at mid-bit and abort if it went high — that is your noise rejection.在位元中央再確認一次 start bit，如果變成高電位就中止——這就是你的雜訊排除。ビット中央でスタートビットを再確認し、ハイになっていれば中止する——これがノイズ除去になる。Periksa ulang start bit di tengah bit dan batalkan kalau ternyata sudah naik — itulah penolakan derau milikmu.
• Flow control off, and confirm both ends agree on 8N1. Half the "corrupted echo" reports are a parity mismatch.關掉流量控制，並確認兩端都設 8N1。所謂「回傳資料壞掉」有一半是 parity 設定不一致。フロー制御はオフ、両端が 8N1 で一致していることを確認する。「エコーが壊れる」という報告の半分はパリティの不一致。Flow control mati, dan pastikan kedua ujung sepakat pada 8N1. Separuh laporan "gema rusak" sebenarnya adalah ketidakcocokan paritas.
• Echoing at the same baud you receive means zero headroom. Keep the FIFO from task 2 in the path.用跟接收相同的 baud 回傳等於毫無餘裕。把第 2 題的 FIFO 留在路徑上。受信と同じ baud で返すと余裕がゼロになる。課題 2 の FIFO を経路に残しておくこと。Menggemakan pada baud yang sama dengan yang kamu terima berarti nol ruang lega. Pertahankan FIFO dari tugas 2 tetap di jalurnya.

Done when完成條件完了条件Selesai bila

• Typing in a terminal at 115200 8N1 echoes each character exactly once.在終端機以 115200 8N1 打字，每個字元剛好回顯一次。ターミナルで 115200 8N1 で入力すると、各文字がちょうど一度だけエコーされる。Mengetik di terminal pada 115200 8N1 menggemakan tiap karakter tepat satu kali.
• A host loop of 1000 random bytes returns with zero mismatches.主機端跑 1000 個隨機 byte 的迴圈，零筆不一致。ホスト側で 1000 個のランダムバイトを往復させ、不一致ゼロ。Loop di host berisi 1000 byte acak kembali tanpa satu pun ketidakcocokan.
• Sending a 64-byte burst faster than the echo drains loses nothing.以快過回傳消化速度的方式送出 64 byte 突發，一個都沒掉。エコーの掃け具合より速く 64 バイトのバーストを送っても、1 バイトも失われない。Mengirim burst 64 byte lebih cepat daripada gema mengalir keluar tidak menghilangkan apa pun.
• Handed in: a testbench waveform of one frame sampled mid-bit, and a YouTube clip of the round trip.已交件：一個 frame 在位元中央取樣的 testbench 波形，以及來回傳輸的 YouTube 影片。提出済み：1 フレームをビット中央でサンプリングしている testbench 波形と、往復動作の YouTube 動画。Dikumpulkan: bentuk gelombang testbench satu frame yang dicuplik di tengah bit, dan klip YouTube perjalanan bolak-baliknya.

Reference answer — not released yet參考解答 —— 尚未開放参考解答 — まだ公開されていませんJawaban acuan — belum dirilis

reg [1:0] sync;
always @(posedge clk) sync <= {sync[0], rx_pin};   // 2-FF synchronizer
wire rx_s = sync[1];

localparam OS = 27;                      // 50e6 / (115200*16)
reg [4:0] os; reg [3:0] tick, bit_i; reg [7:0] sh; reg busy;

always @(posedge clk) begin
  rx_valid <= 1'b0;                      // one-cycle strobe
  if (!busy) begin
    if (!rx_s) begin busy <= 1'b1; os <= 0; tick <= 0; bit_i <= 0; end
  end else if (os == OS-1) begin
    os   <= 0;
    tick <= tick + 1'b1;
    if (tick == 4'd7) begin              // mid-bit
      if (bit_i == 4'd0)      begin if (rx_s) busy <= 1'b0; end  // false start
      else if (bit_i <= 4'd8) sh <= {rx_s, sh[7:1]};             // LSB first
      else begin rx_data <= sh; rx_valid <= 1'b1; busy <= 1'b0; end
    end
    if (tick == 4'd15) bit_i <= bit_i + 1'b1;
  end else os <= os + 1'b1;
end

assign push = rx_valid;
assign din  = rx_data;

A single-pole low-pass filter in Q format用 Q format 做單極點低通濾波器Q フォーマットによる 1 次ローパスフィルタTapis lolos-rendah kutub tunggal dalam format Q

• IIR
• Q format
• Saturation
• Host主機端ホスト側Sisi host

“fast low pass filter (for fixed point operation practice) with labview”

Integers only — no float, no double, anywhere in the loop. Every value is a Q-format number: a plain integer whose binary point you track in your head, not in the machine. The point is not the filter, it is knowing where that point sits after every multiply and what happens at the edges of the word. 整數，只有整數——迴圈裡不准有 float、不准有 double。每個值都是 Q format 數字：本質上就是整數，小數點位置由你自己記在腦子裡，而不是交給機器。重點不是濾波器，而是每次乘法之後那個小數點跑到哪裡，以及字組邊界會發生什麼事。整数のみ——ループ内に float も double も置かない。すべての値は Q フォーマットの数、つまり小数点の位置を機械ではなく自分の頭で管理する普通の整数だ。要点はフィルタではなく、掛け算のたびに小数点がどこへ動くか、そしてワードの端で何が起きるかを知ることにある。Bilangan bulat saja — tanpa float, tanpa double, di mana pun dalam loop. Setiap nilai adalah bilangan format Q: bilangan bulat biasa yang titik binernya kamu lacak di kepalamu, bukan di mesin. Intinya bukan tapisnya, melainkan mengetahui di mana titik itu berada setelah setiap perkalian dan apa yang terjadi di tepi word.

// y[n] = y[n-1] + a·(x[n] - y[n-1]),  15 fraction bits
err  = x - y            // I16, may overflow → saturate
acc  = a * err          // I32, 30 fraction bits
y    = y + (acc >> 15)  // shift back to 15

The coefficient is picked once, away from the bench, and enters the code as the integer 3869 — that is a 20 Hz corner at 1 kHz, scaled by 2¹⁵. Nothing in the running loop ever sees a fraction. 係數只在離開實驗桌時算一次，進到程式裡就是整數 3869——那是 1 kHz 取樣下 20 Hz 轉角頻率乘以 2¹⁵ 的結果。執行中的迴圈從頭到尾看不到任何分數。係数は机の外で一度だけ決め、コードには整数 3869 として入る——1 kHz サンプリングでの 20 Hz カットオフを 2¹⁵ 倍した値だ。実行中のループが小数を見ることは一度もない。Koefisiennya dipilih sekali, jauh dari meja praktik, dan masuk ke kode sebagai bilangan bulat 3869 — itu adalah sudut 20 Hz pada 1 kHz, diskalakan dengan 2¹⁵. Tidak ada satu pun bagian loop berjalan yang pernah melihat pecahan.

Target numbers目標數字目標値Angka target

Sample rate取樣率サンプリングレートLaju cuplik

1 kHz

Cutoff截止頻率カットオフFrekuensi potong

20 Hz

Format格式フォーマットFormat

16-bit Q, 15 frac bits

α as an integerα 的整數值整数としての αα sebagai bilangan bulat

3869 / 2^15 (0x0F1D)

Word字組ワードWord

I16 state, I32 accumulator

Settling (step, 95%)步階響應建立時間（95%）整定時間（ステップ、95%）Waktu tunak (step, 95%)

≈ 24 samples

Traps陷阱落とし穴Jebakan

• >> 15 on a negative number truncates toward −∞. Add the rounding term (1<<14) before shifting, or your output drifts down.對負數做 >> 15 會往 −∞ truncate。移位前先加上四捨五入項 (1<<14)，否則輸出會一路往下漂。負数に対する >> 15 は −∞ 方向に切り捨てられる。シフト前に丸め項 (1<<14) を足さないと出力が下へドリフトする。>> 15 pada bilangan negatif memotong ke arah −∞. Tambahkan suku pembulatan (1<<14) sebelum menggeser, atau keluaranmu akan melorot turun.
• Saturate x − y; do not let it wrap. A wrap turns a smooth step into a spike.把 x − y 做飽和處理，不要讓它 wrap。一旦 wrap，平滑的步階就會變成尖刺。x − y は飽和させ、ラップさせないこと。ラップすると滑らかなステップがスパイクに化ける。Jenuhkan x − y; jangan biarkan ia berputar. Perputaran mengubah step yang mulus menjadi lonjakan.
• With a small α the increment can round to zero — the output parks a few LSB short of the input and stays there. That limit cycle is expected; measure it, do not patch it away with a float.α 很小時，增量會被四捨五入成零——輸出會停在離輸入差幾個 LSB 的地方不動。這個極限環是預期中的現象；把它量出來，不要用浮點數把它蓋掉。α が小さいと増分がゼロに丸められ、出力は入力より数 LSB 手前で止まったままになる。このリミットサイクルは想定内であり、測定すべきもので、float で誤魔化すものではない。Dengan α yang kecil, penambahnya bisa membulat menjadi nol — keluarannya berhenti beberapa LSB di bawah masukan dan diam di situ. Siklus batas itu memang diharapkan; ukurlah, jangan ditambal dengan float.
• Force the wire/array types (I16, I32) explicitly. Leave it to coercion and you get doubles without noticing.明確指定接線／陣列型別（I16、I32）。放著讓它自動轉型，你會在不知不覺中拿到 double。配線や配列の型（I16、I32）は明示的に指定する。暗黙変換に任せると、気づかないうちに double になる。Paksakan tipe wire/array (I16, I32) secara eksplisit. Serahkan pada koersi dan kamu akan mendapat double tanpa menyadarinya.

Done when完成條件完了条件Selesai bila

• A +16384 step produces exactly 1935, 3641, 5146 — the integer sequence, checked by hand, not against a float model.+16384 的步階輸入正好產生 1935、3641、5146——用手算出來的整數序列，不是拿浮點模型來對。+16384 のステップ入力がちょうど 1935、3641、5146 を出す——float モデルとの比較ではなく、手計算した整数列で確認する。Step +16384 menghasilkan tepat 1935, 3641, 5146 — barisan bilangan bulatnya, diperiksa dengan tangan, bukan terhadap model float.
• A swept sine shows roughly −3 dB at 20 Hz and −20 dB/decade above it.掃頻正弦在 20 Hz 約 −3 dB，之上為每十倍頻 −20 dB。スイープ正弦波で 20 Hz が約 −3 dB、それより上は −20 dB/decade。Sinus tersapu menunjukkan kira-kira −3 dB pada 20 Hz dan −20 dB/dekade di atasnya.
• Full-scale ±32767 input never wraps to the opposite sign.滿刻度 ±32767 輸入不會 wrap 成相反符號。フルスケール ±32767 の入力が反対符号にラップしない。Masukan skala penuh ±32767 tidak pernah berputar ke tanda yang berlawanan.
• Filtered samples arrive over the task-3 UART link instead of a simulated array.濾波後的取樣是透過第 3 題的 UART 連線送來的，而不是模擬出來的陣列。フィルタ後のサンプルが、シミュレーションの配列ではなく課題 3 の UART 経由で届く。Cuplikan hasil tapis tiba lewat sambungan UART tugas 3, bukan lewat larik simulasi.
• Handed in: a testbench or script printing 1935, 3641, 5146, and a YouTube clip of the filtered trace.已交件：印出 1935、3641、5146 的 testbench 或程式，以及濾波後波形的 YouTube 影片。提出済み：1935、3641、5146 を出力する testbench またはスクリプトと、フィルタ後の波形の YouTube 動画。Dikumpulkan: testbench atau skrip yang mencetak 1935, 3641, 5146, dan klip YouTube jejak hasil tapisnya.

Reference answer — not released yet參考解答 —— 尚未開放参考解答 — まだ公開されていませんJawaban acuan — belum dirilis

A = 3869                          # alpha, 15 fraction bits

def sat16(v):
    return -32768 if v < -32768 else (32767 if v > 32767 else v)

def step(x, y):                   # one sample, both Q-format counts
    err = sat16(x - y)            # never let this wrap
    return sat16(y + ((A * err + (1 << 14)) >> 15))

PWM a positional servo to a commanded angle用 PWM 把位置型伺服機轉到指定角度PWM で位置制御サーボを指定角度へ回すMem-PWM servo posisional ke sudut yang diperintahkan

• PWM
• Pulse width
• Angle mapping
• Closed loop
• Bench supply

“pwm control the easy servo motor” ↳ positional, angle-commanded

A servo's PWM is not a throttle. The 50 Hz frame you send carries exactly one number — the width of the high pulse — and that width is an angle setpoint: 1.0 ms is one end of the travel, 2.0 ms the other, 1.5 ms the middle. Nothing in that signal tells the motor how fast to turn. Inside the case a potentiometer reads the actual shaft angle, a PI controller works on the error between it and your setpoint, and that loop decides the motor's speed and direction through the servo's own H-bridge. You command where; the servo decides how fast. Your job is the counter and the compare that turn an angle into that pulse width, with the angle read straight off the FPGA's GPIO pins.伺服機的 PWM 不是油門。你送出去的 50 Hz 框架只帶一個數字——高電位脈波的寬度——而那個寬度是角度設定值：1.0 ms 是行程的一端，2.0 ms 是另一端，1.5 ms 是中間。這個訊號裡沒有任何一處在告訴馬達要轉多快。殼子裡面有一顆電位器在讀實際的軸角度，一個 PI 控制器處理它與你的設定值之間的誤差，而決定馬達轉速與方向的是那個迴路，透過伺服機自己的 H 橋去驅動。你命令的是「到哪裡」，「轉多快」由伺服機自己決定。你要做的是把角度換成那個脈波寬度的計數器與比較器，而角度直接從 FPGA 的 GPIO 腳位讀進來。サーボの PWM はスロットルではない。送り出す 50 Hz のフレームが運ぶ数値はただ一つ——ハイパルスの幅——で、その幅は角度の設定値だ：1.0 ms が可動範囲の一端、2.0 ms がもう一端、1.5 ms が中央。この信号のどこにも、モータをどれだけ速く回すかという情報はない。ケースの中ではポテンショメータが実際の軸角度を読み、PI 制御器が設定値との誤差を処理し、モータの速度と方向を決めるのはそのループで、サーボ自身の H ブリッジを通して駆動する。指令するのは「どこへ」であり、「どれだけ速く」はサーボが決める。あなたの仕事は、角度をそのパルス幅に変換するカウンタと比較器で、角度は FPGA の GPIO ピンから直接読む。PWM sebuah servo bukanlah pengatur tenaga. Frame 50 Hz yang kamu kirim membawa tepat satu angka — lebar pulsa tingginya — dan lebar itu adalah setpoint sudut: 1.0 ms adalah salah satu ujung lintasan, 2.0 ms ujung yang lain, 1.5 ms bagian tengahnya. Tidak ada apa pun dalam sinyal itu yang memberi tahu motor seberapa cepat harus berputar. Di dalam casing-nya, sebuah potensiometer membaca sudut poros yang sebenarnya, sebuah kendali PI bekerja atas selisih antara nilai itu dan setpoint-mu, dan loop itulah yang menentukan kecepatan serta arah motor melalui H-bridge milik servo sendiri. Kamu memerintahkan ke mana; servo yang memutuskan secepat apa. Tugasmu adalah pencacah dan pembanding yang mengubah sudut menjadi lebar pulsa itu, dengan sudutnya dibaca langsung dari pin GPIO FPGA.

Those GPIO pins are asynchronous to your clock, so double-flop them before use and latch the whole word at the frame edge — sampling a multi-bit angle mid-transition hands you a value that was never on the pins at all, and the servo will faithfully drive to it.那些 GPIO 腳位跟你的時鐘不同步，所以要先過兩級正反器同步，再在框架邊界上把整個字一次鎖住——在多位元角度值跳變的中途取樣，拿到的會是一個從來沒出現在腳位上的值，而伺服機會忠實地轉到那個角度去。その GPIO ピンはクロックに非同期なので、使う前に二段フリップフロップで同期し、ワード全体をフレームのエッジでラッチすること——多ビットの角度値を遷移の途中でサンプルすると、ピン上に一度も存在しなかった値を拾い、サーボは忠実にその角度へ動いてしまう。Pin GPIO itu asinkron terhadap clock-mu, jadi lewatkan lebih dulu melalui dua flip-flop dan kunci seluruh word pada tepi frame — mencuplik sudut multi-bit di tengah transisi memberimu nilai yang sebenarnya tidak pernah ada di pin, dan servo akan dengan patuh bergerak ke sana.

This task needs no driver stage at all. The servo's signal wire is a logic input on its internal control board — a few hundred microamps, happy with 3.3 V — so it goes straight to an FPGA pin with nothing in between. No MOSFET, no H-bridge, no flyback diode: the bridge is already in there, one centimetre from the PI loop driving it, and a bridge of your own in front of a logic input would only destroy the signal. What the servo does need is power it can actually draw: its own 4.8–6 V rail, never the board's 5 V pin, with the two grounds tied at a single point so your pulse has a reference.這題完全不需要任何驅動級。伺服機的訊號線是它內部控制板上的一個邏輯輸入——幾百微安培，3.3 V 就吃得下——所以直接接到 FPGA 腳位，中間什麼都不用加。不用 MOSFET、不用 H 橋、不用續流二極體：橋本來就在裡面，離驅動它的 PI 迴路一公分遠，你自己在邏輯輸入前面再加一座橋，只會把訊號毀掉。伺服機真正需要的是它拉得動的電源：自己一條 4.8–6 V 的電源軌，絕對不要用板子的 5 V 腳，並且兩邊的地要在單一點接在一起，你的脈波才有參考點。この課題にドライバ段は一切不要だ。サーボの信号線は内部制御基板のロジック入力——数百マイクロアンペアで、3.3 V でも問題ない——なので、間に何も挟まず FPGA のピンへ直結する。MOSFET も H ブリッジもフライバックダイオードも要らない：ブリッジはすでに中にあり、それを駆動する PI ループから 1 cm の距離にある。ロジック入力の手前に自前のブリッジを置いても信号を壊すだけだ。サーボが本当に必要とするのは実際に引ける電力だ：専用の 4.8–6 V レールを用意し、ボードの 5 V ピンは使わない。そして両方の GND を一点で接続し、パルスに基準を与えること。Tugas ini sama sekali tidak memerlukan tingkat penggerak. Kabel sinyal servo adalah masukan logika pada papan kendali internalnya — beberapa ratus mikroampere, senang dengan 3.3 V — jadi ia langsung ke pin FPGA tanpa apa pun di antaranya. Tanpa MOSFET, tanpa H-bridge, tanpa dioda flyback: jembatannya sudah ada di dalam sana, satu sentimeter dari loop PI yang menggerakkannya, dan jembatan buatanmu sendiri di depan masukan logika hanya akan merusak sinyalnya. Yang justru dibutuhkan servo adalah daya yang benar-benar bisa ia tarik: rel 4.8–6 V miliknya sendiri, jangan pernah pin 5 V papan, dengan kedua ground disatukan di satu titik agar pulsamu punya acuan.

// 50 Hz servo frame from a 50 MHz clock
scnt  <= (scnt == 999999) ? 0 : scnt + 1;
servo <= (scnt < pulse);  // pulse 50000..100000 = 1.0..2.0 ms = 0..180°

Target numbers目標數字目標値Angka target

Frame框架週期フレーム周期Frame

50 Hz → 20 ms

Period counts週期計數值周期カウント数Hitungan periode

50e6 / 50 = 1,000,000

0° (one end)0°（一端）0°（一端）0° (satu ujung)

1.0 ms → 50,000

90° (centre)90°（中位）90°（中央）90° (tengah)

1.5 ms → 75,000

180° (other end)180°（另一端）180°（もう一端）180° (ujung lainnya)

2.0 ms → 100,000

Counts per degree每度計數值1 度あたりのカウントHitungan per derajat

≈ 278

Angle command角度命令角度指令Perintah sudut

GPIO, latched at frame edge

Driver驅動器ドライバPenggerak

none — the servo has its own

Supply供電電源Catu daya

4.8–6 V, own rail

Slew limit迴轉率限制スルーレート制限Batas laju

0 → 180° over ≥ 500 ms

Where to get one去哪裡買入手先Di mana membelinya

Read what that package actually is before wiring it: an MG90S is a brushed motor, a gearbox, a feedback potentiometer and the PI loop with its own H-bridge, all sealed in one case. That is why three wires are enough — power, ground, and one signal line carrying nothing but your angle.接線之前先搞清楚那顆東西是什麼：MG90S 是有刷馬達、齒輪箱、回饋電位器，加上那個帶自己 H 橋的 PI 迴路，全部封在同一個殼裡。這就是為什麼三條線就夠了——電源、地，以及一條只送角度的訊號線。配線する前にそれが何なのかを把握すること：MG90S はブラシモータ、ギアボックス、フィードバック用ポテンショメータ、そして自前の H ブリッジを備えた PI ループが、すべて一つのケースに封じられている。だから線は三本で足りる——電源、GND、そして角度だけを運ぶ信号線 1 本だ。Pahami dulu apa isi paket itu sebelum menyambungnya: sebuah MG90S adalah motor brushed, gearbox, potensiometer umpan balik dan loop PI dengan H-bridge-nya sendiri, semuanya tersegel dalam satu casing. Itulah sebabnya tiga kabel sudah cukup — daya, ground, dan satu jalur sinyal yang tidak membawa apa pun selain sudutmu.

Buy the 180° version. That is the positional servo this task is about: pulse width commands an angle and the internal loop holds it there against a load. The 360° version looks identical and is a different device — its potentiometer is decoupled from the output shaft, so there is no angle to hold, and the same pulse width becomes a speed and direction command with 1.5 ms meaning stop. With that part the angle checkpoints below are not reachable; it is an open-loop motor with a driver attached.請買 180° 的版本。那顆才是這題要的位置型伺服：脈波寬度命令角度，內部迴路會頂著負載把它維持在那裡。360° 那顆外觀一樣，但是另一種裝置——它的電位器已經和輸出軸脫開，所以沒有角度可以維持，同一個脈波寬度變成命令速度與方向，1.5 ms 代表停止。用那顆的話，下面的角度檢查點做不到；它只是一顆接了驅動器的開迴路馬達。180° 版を買うこと。それがこの課題で使う位置制御サーボだ：パルス幅が角度を指令し、内部ループが負荷に抗してそこを保持する。360° 版は見た目が同じでも別の装置で——ポテンショメータが出力軸から切り離されているため保持すべき角度が存在せず、同じパルス幅が速度と方向の指令になり、1.5 ms が停止を意味する。その部品では下の角度チェックポイントに到達できない。ドライバの付いた開ループのモータにすぎない。Belilah versi 180°. Itulah servo posisional yang menjadi pokok tugas ini: lebar pulsa memerintahkan sudut dan loop internal menahannya di sana melawan beban. Versi 360° terlihat identik tetapi merupakan perangkat yang berbeda — potensiometernya dilepas dari poros keluaran, sehingga tidak ada sudut untuk ditahan, dan lebar pulsa yang sama berubah menjadi perintah kecepatan dan arah dengan 1.5 ms berarti berhenti. Dengan komponen itu, checkpoint sudut di bawah tidak bisa dicapai; ia adalah motor loop-terbuka dengan penggerak yang menempel.

Do not write a new angle to the compare register the instant the GPIO pins change. A servo commanded from 0° to 180° in a single frame goes there as fast as its internal loop can manage — full current, full torque, and a supply sag that resets the FPGA if the two share a rail. Move the setpoint one degree per frame instead: full travel then takes 180 × 20 ms = 3.6 s, comfortably outside the 500 ms floor, and the mechanism never sees a step. This is the same ramp the brushed-motor extension needs, applied to a position instead of a duty.不要在 GPIO 腳位一變就把新角度寫進比較暫存器。一個在單一框架內從 0° 被命令到 180° 的伺服機，會用它內部迴路能給的最快速度衝過去——滿電流、滿扭矩，如果它和 FPGA 共用一條電源軌，電壓會塌到讓 FPGA 重置。改成每個框架只移動一度：跑完全行程要 180 × 20 ms = 3.6 s，穩穩地落在 500 ms 的下限之外，而機構永遠不會看到階躍。這和有刷馬達那一節需要的斜升是同一件事，只是作用在位置而不是 duty 上。GPIO ピンが変わった瞬間に新しい角度を比較レジスタへ書いてはいけない。1 フレームで 0° から 180° へ指令されたサーボは、内部ループが出せる限りの速さでそこへ飛ぶ——全電流、全トルク、そして FPGA と電源レールを共有していれば電圧が落ちて FPGA がリセットする。代わりに設定値をフレームごとに 1 度ずつ動かすこと：全行程は 180 × 20 ms = 3.6 s となり、500 ms の下限には余裕で収まり、機構がステップを見ることはない。これはブラシモータの発展課題で必要になるランプと同じ話を、デューティではなく位置に適用したものだ。Jangan menulis sudut baru ke register pembanding begitu pin GPIO berubah. Servo yang diperintahkan dari 0° ke 180° dalam satu frame akan ke sana secepat yang bisa dilakukan loop internalnya — arus penuh, torsi penuh, dan tegangan yang anjlok sehingga FPGA ter-reset kalau keduanya berbagi rel. Geser setpoint-nya satu derajat per frame saja: lintasan penuh lalu memakan 180 × 20 ms = 3.6 s, jauh di atas batas bawah 500 ms, dan mekanismenya tidak pernah menerima step. Ini adalah ramp yang sama dengan yang dibutuhkan perluasan motor brushed, hanya diterapkan pada posisi alih-alih duty.

Reference designs參考設計参考設計Rancangan acuan

• Wikipedia · Servo controlen.wikipedia.org ↗What the pulse width actually means to a servo, and why the frame rate carries none of the information.脈波寬度對伺服機到底代表什麼，以及為什麼框架頻率本身不帶任何資訊。パルス幅がサーボにとって何を意味するのか、そしてフレーム周波数自体は情報を持たない理由。Apa arti sebenarnya lebar pulsa bagi sebuah servo, dan mengapa laju frame tidak membawa informasi apa pun.
• SparkFun · Hobby servo tutoriallearn.sparkfun.com ↗A hobby servo opened up — potentiometer, gearbox, control board — with the 1–2 ms pulse mapped onto the angle. Start here.把玩具伺服機拆開來看——電位器、齒輪箱、控制板——並把 1–2 ms 的脈波對應到角度。從這裡開始。ホビーサーボを分解して見せている——ポテンショメータ、ギアボックス、制御基板——そして 1–2 ms のパルスを角度に対応づけている。まずはここから。Sebuah servo hobi yang dibuka — potensiometer, gearbox, papan kendali — dengan pulsa 1–2 ms dipetakan ke sudut. Mulailah dari sini.
• SparkFun · Transistorslearn.sparkfun.com ↗The transistor used as a switch, with base-resistor sizing worked through. Start here if you take the single-transistor route.把電晶體當開關用，並實際帶你算基極電阻。走單顆電晶體這條路就從這裡開始。トランジスタをスイッチとして使う方法と、ベース抵抗の求め方。トランジスタ 1 個で行くならここから。Transistor yang dipakai sebagai sakelar, lengkap dengan perhitungan resistor basis. Mulailah dari sini kalau kamu memilih jalur transistor tunggal.
• Wikipedia · Flyback diodeen.wikipedia.org ↗Why an inductive load develops a large reverse voltage when you switch it off, and why the diode is not optional.為什麼電感性負載被切斷時會產生很高的反向電壓，以及為什麼那顆二極體不是可有可無的。誘導性負荷を遮断したときに大きな逆電圧が生じる理由と、ダイオードが省略できない理由。Mengapa beban induktif menimbulkan tegangan balik yang besar ketika kamu memutusnya, dan mengapa diodanya bukan pilihan tambahan.
• Wikipedia · Opto-isolatoren.wikipedia.org ↗What a photocoupler is, what current transfer ratio means, and how much switching speed the cheap parts cost you.光耦合器是什麼、電流傳輸比（CTR）代表什麼，以及選便宜的那顆要付出多少切換速度。フォトカプラとは何か、電流伝達率（CTR）が何を意味するか、そして安価な品種で失うスイッチング速度はどれほどか。Apa itu photocoupler, apa arti current transfer ratio, dan berapa banyak kecepatan pensaklaran yang harus kamu bayar dengan komponen murah.
• Toshiba · How to use a photocoupler: input currenttoshiba.semicon-storage.com ↗The manufacturer's own worked example for the LED series resistor — R = (Vcc − VF) / IF, with real numbers substituted.原廠自己示範 LED 串聯電阻怎麼算——R = (Vcc − VF) / IF，數字都代進去了。LED の直列抵抗の計算をメーカー自身が example で示している——R = (Vcc − VF) / IF に実数を代入。Contoh perhitungan resistor seri LED dari pabrikannya sendiri — R = (Vcc − VF) / IF, dengan angka nyata yang sudah disubstitusikan.
• Digilent · Pmod HB3 reference manualdigilent.com ↗A complete 2 A H-bridge schematic drawn for a Digilent board — two FETs, 12 V motor rail. Its manual also states the rule this task makes you implement: never change Direction while Enable is high.一張為 Digilent 板子畫的完整 2 A H 橋電路圖——兩顆 FET、馬達電壓上限 12 V。它的手冊也寫著這題要你實作的規則：Enable 還在高電位時，絕不改變 Direction。Digilent ボード向けに描かれた 2 A H ブリッジの完全な回路図——FET 2 個、モータ電圧は最大 12 V。マニュアルにはこの課題で実装させる規則も書かれている：Enable がハイの間に Direction を変えないこと。Skematik H-bridge 2 A yang lengkap, digambar untuk papan Digilent — dua FET, rel motor 12 V. Manualnya juga menyatakan aturan yang harus kamu terapkan pada tugas ini: jangan pernah mengubah Direction selagi Enable masih tinggi.
• TI · DRV8871 brushed-DC driverti.com ↗A 3.6 A peak bridge in one package. Read the datasheet's typical application circuit and its layout section — where the bulk capacitor sits is not decoration.把 3.6 A 峰值的橋整合成一顆 IC。看它 datasheet 的典型應用電路和佈線章節——大電容擺哪裡不是裝飾用的。ピーク 3.6 A のブリッジを 1 パッケージに収めた IC。データシートの標準応用回路とレイアウトの章を読むこと——バルクコンデンサの位置は飾りではない。Jembatan dengan puncak 3.6 A dalam satu kemasan. Baca rangkaian aplikasi tipikal pada datasheet-nya beserta bagian tata letaknya — di mana kapasitor bulk diletakkan bukanlah hiasan.
• SparkFun · TB6612FNG hookup guidelearn.sparkfun.com ↗A dual driver wired up end to end with every logic pin explained — the closest thing to a breadboard reference you can copy.一顆雙通道驅動 IC 從頭接到尾，每一支邏輯腳都有解釋——最接近可以照抄的麵包板參考。デュアルドライバを最初から最後まで配線し、ロジックピンをすべて説明している——そのまま真似できるブレッドボードの参考例に最も近い。Penggerak ganda yang dirangkai dari ujung ke ujung dengan setiap pin logika dijelaskan — paling mendekati acuan breadboard yang bisa kamu tiru.

Extension — a bare brushed motor延伸：換成裸的有刷馬達発展——剥き出しのブラシモータPerluasan — motor brushed telanjang

Everything above stops at the servo's signal pin, because the loop that turns your angle into motor current is already inside the case. Build that inner half yourself — a bare brushed motor, no feedback — and this is what you have to add: a carrier fast enough to be inaudible, a compare value that now means speed, a bridge if you want reversal, and a buffer stage between the FPGA pin and the winding. Note that only reversal needs a bridge; one low-side transistor is enough for one direction.上面所有東西都停在伺服機的訊號腳，因為把你的角度變成馬達電流的那個迴路，已經在殼子裡了。自己把裡面那一半做出來——一顆裸的有刷馬達，沒有回饋——要加的就是這些：一個快到聽不見的載波、一個現在代表轉速的比較值、想換向的話再加一座橋，以及 FPGA 腳位與線圈之間的緩衝級。注意只有換向才需要橋；單一方向用一顆低邊電晶體就夠了。ここまでの内容はサーボの信号ピンで終わる。角度をモータ電流に変えるループは、すでにケースの中にあるからだ。その内側の半分を自分で作るなら——剥き出しのブラシモータ、フィードバックなし——追加が必要なのは次のものだ：可聴域を超えたキャリア、いまや速度を意味する比較値、反転させたいならブリッジ、そして FPGA のピンと巻線の間のバッファ段。ブリッジが必要なのは反転のときだけで、片方向なら低電位側のトランジスタ 1 個で足りる。Semua di atas berhenti pada pin sinyal servo, karena loop yang mengubah sudutmu menjadi arus motor sudah ada di dalam casing. Bangun sendiri separuh bagian dalam itu — motor brushed telanjang, tanpa umpan balik — dan inilah yang harus kamu tambahkan: pembawa yang cukup cepat sehingga tak terdengar, nilai pembanding yang sekarang berarti kecepatan, sebuah jembatan kalau kamu ingin pembalikan arah, dan tingkat penyangga antara pin FPGA dan lilitannya. Perhatikan bahwa hanya pembalikan arah yang butuh jembatan; satu transistor sisi-bawah sudah cukup untuk satu arah.

The FPGA pin is a control signal, not a power source. An I/O pin drives a few milliamps — 24 mA at the very most, and only if the bank is configured for it — while a small brushed motor pulls several hundred milliamps running and close to an amp stalled. Between the PWM output and the motor you have to design a buffer stage of your own. Wiring a motor straight to an I/O pin kills the pin, and often takes the whole bank with it.FPGA 的腳位是控制訊號，不是電源。一支 I/O 腳只能推幾毫安培——最多 24 mA，而且還要 bank 有這樣設定——但一顆小型有刷馬達運轉時要幾百毫安培，堵轉時接近一安培。PWM 輸出和馬達之間，你必須自己設計一級緩衝電路。把馬達直接接到 I/O 腳，那支腳會死，而且常常整個 bank 一起陪葬。FPGA のピンは制御信号であって電源ではない。I/O ピンが流せるのは数ミリアンペア——バンクの設定次第で最大 24 mA——に対し、小型のブラシモータは回転中で数百ミリアンペア、ストール時には 1 A 近くを引く。PWM 出力とモータの間には、自分で設計したバッファ段が必要だ。モータを I/O ピンに直結すればそのピンは壊れ、多くの場合バンクごと道連れになる。Pin FPGA adalah sinyal kendali, bukan sumber daya. Sebuah pin I/O menggerakkan beberapa miliampere — paling banter 24 mA, dan hanya kalau bank-nya dikonfigurasi untuk itu — sementara motor brushed kecil menarik beberapa ratus miliampere saat berjalan dan mendekati satu ampere saat macet. Di antara keluaran PWM dan motor, kamu harus merancang sendiri tingkat penyangga. Menyambungkan motor langsung ke pin I/O akan membunuh pin itu, dan sering kali membawa serta seluruh bank-nya.

That buffer can be a single transistor. One logic-level N-MOSFET as a low-side switch — source to ground, drain to the motor's negative terminal, motor positive to its own supply — gives you full PWM speed control in one direction, and an NPN BJT with a base resistor does the same job at lower current. Three details decide whether it works: the MOSFET must be logic-level, because a plain IRF540 never fully turns on at 3.3 V; a flyback diode across the motor catches the inductive kick; and a 10 kΩ pull-down on the gate keeps the motor still while the FPGA is still configuring and the pin is high-Z. For a BJT, size the base resistor from the current you need — at β ≈ 100 and 500 mA that is 5 mA of base current, so (3.3 − 0.7) / 5 mA ≈ 470 Ω. Only the reversal checkpoint needs more than one transistor; that is what the H-bridge is for.這個緩衝電路可以只有一顆電晶體。一顆邏輯準位 N-MOSFET 當低邊開關——source 接地、drain 接馬達負端、馬達正端接它自己的電源——就能在單一方向上做完整的 PWM 調速；電流不大時，一顆 NPN BJT 加上基極電阻也能做同樣的事。成敗取決於三個細節：MOSFET 必須是邏輯準位的，因為一般的 IRF540 在 3.3 V 下根本不會完全導通；馬達要並一顆續流二極體吸收電感回衝；閘極要接一顆 10 kΩ 下拉電阻，讓 FPGA 還在組態、腳位還是高阻抗時馬達不會亂動。用 BJT 的話，基極電阻要照需要的電流算——β ≈ 100、負載 500 mA 時基極要 5 mA，所以 (3.3 − 0.7) / 5 mA ≈ 470 Ω。只有「換向」那個檢查點需要一顆以上的電晶體，那正是 H 橋存在的理由。このバッファはトランジスタ 1 個でも構わない。ロジックレベルの N-MOSFET をローサイドスイッチとして使えば——ソースを GND、ドレインをモータのマイナス端子、モータのプラス端子は専用電源へ——片方向で完全な PWM 速度制御ができる。電流が小さければ、ベース抵抗付きの NPN BJT でも同じ役目を果たす。成否を決めるのは三点：MOSFET はロジックレベル品であること（普通の IRF540 は 3.3 V では完全にオンしない）、モータと並列のフライバックダイオードで誘導性のキックを逃がすこと、そしてゲートの 10 kΩ プルダウンで、FPGA がまだコンフィグ中でピンがハイインピーダンスの間にモータが動かないようにすること。BJT ならベース抵抗は必要な電流から決める——β ≈ 100 で 500 mA ならベース電流 5 mA、つまり (3.3 − 0.7) / 5 mA ≈ 470 Ω。トランジスタが 1 個で足りないのは反転のチェックポイントだけで、そのために H ブリッジがある。Penyangga itu bisa berupa satu transistor. Satu N-MOSFET logic-level sebagai sakelar sisi-bawah — source ke ground, drain ke terminal negatif motor, positif motor ke catu dayanya sendiri — sudah memberimu kendali kecepatan PWM penuh dalam satu arah, dan BJT NPN dengan resistor basis melakukan pekerjaan yang sama pada arus yang lebih rendah. Tiga hal menentukan apakah ini berhasil: MOSFET-nya harus logic-level, karena IRF540 biasa tidak pernah benar-benar menyala penuh pada 3.3 V; dioda flyback melintang pada motor menangkap tendangan induktifnya; dan pull-down 10 kΩ pada gate menjaga motor tetap diam selagi FPGA masih dikonfigurasi dan pin-nya masih high-Z. Untuk BJT, hitung resistor basis dari arus yang kamu butuhkan — pada β ≈ 100 dan 500 mA itu berarti arus basis 5 mA, jadi (3.3 − 0.7) / 5 mA ≈ 470 Ω. Hanya checkpoint pembalikan arah yang butuh lebih dari satu transistor; untuk itulah H-bridge ada.

If you want the motor's noise to stay out of the FPGA altogether, put a photocoupler between the two: the PWM pin drives the coupler's LED through a series resistor, the phototransistor on the far side drives the gate, and the only thing crossing between the two grounds is light. Watch the speed — a common PC817 takes a few microseconds to switch, which is a visible slice of a 50 µs PWM period and distorts the duty; at 20 kHz reach for a fast logic coupler (6N137) or a gate-driver coupler (TLP250) instead. Size the LED resistor from the coupler's forward voltage — (3.3 − 1.2) / 5 mA ≈ 470 Ω — and remember the transistor side needs its own supply and pull-up, or the isolation buys you nothing.如果你希望馬達的雜訊完全進不了 FPGA，就在兩者之間放一顆光耦合器：PWM 腳透過一顆串聯電阻去推光耦裡的 LED，另一端的光電晶體再去驅動閘極，兩邊的地之間就只剩下光在傳遞。要注意速度——常見的 PC817 切換要好幾微秒，在 50 µs 的 PWM 週期裡是看得出來的一塊，會讓 duty 失真；20 kHz 請改用高速邏輯型光耦（6N137）或閘極驅動型光耦（TLP250）。LED 的限流電阻依它的順向電壓計算——(3.3 − 1.2) / 5 mA ≈ 470 Ω——另外別忘了電晶體那一側要有自己的電源與上拉電阻，否則這層隔離等於白做。モータのノイズを FPGA に一切入れたくないなら、両者の間にフォトカプラを置く：PWM ピンが直列抵抗を介してカプラの LED を駆動し、反対側のフォトトランジスタがゲートを駆動する。二つのグラウンドの間を渡るのは光だけになる。速度には注意——よくある PC817 はスイッチングに数マイクロ秒かかり、50 µs の PWM 周期では無視できない割合を占めてデューティを歪ませる。20 kHz なら高速ロジック用（6N137）かゲートドライバ用（TLP250）のフォトカプラを使うこと。LED の抵抗は順方向電圧から決める——(3.3 − 1.2) / 5 mA ≈ 470 Ω——そしてトランジスタ側には独自の電源とプルアップが要る。でなければ絶縁した意味がない。Kalau kamu ingin derau motor sama sekali tidak masuk ke FPGA, pasang photocoupler di antara keduanya: pin PWM menggerakkan LED coupler lewat resistor seri, fototransistor di seberangnya menggerakkan gate, dan satu-satunya yang menyeberang di antara kedua ground adalah cahaya. Perhatikan kecepatannya — PC817 yang umum butuh beberapa mikrodetik untuk beralih, dan itu potongan yang kelihatan dari periode PWM 50 µs sehingga merusak duty-nya; pada 20 kHz, pilihlah coupler logika cepat (6N137) atau coupler gate-driver (TLP250). Hitung resistor LED dari tegangan maju coupler-nya — (3.3 − 1.2) / 5 mA ≈ 470 Ω — dan ingat sisi transistornya butuh catu daya dan pull-up sendiri, kalau tidak isolasinya tidak memberimu apa-apa.

// 20 kHz carrier from a 50 MHz clock
cnt <= (cnt == 2499) ? 0 : cnt + 1;
pwm <= (cnt < duty);   // duty 0..2500 = 0..100%

Carrier載波キャリアPembawa

20 kHz (above audible)

Period counts週期計數值周期カウント数Hitungan periode

50e6 / 20e3 = 2500

Duty resolutionduty 解析度デューティ分解能Resolusi duty

≈ 11.3 bits

Driver驅動器ドライバPenggerak

H-bridge, not a bare FET

Dead time死區時間デッドタイムDead time

≥ 1 µs between high/low side

Ramp斜升ランプRamp

0 → 100% over ≥ 200 ms

Traps陷阱落とし穴Jebakan

• Putting a MOSFET or an H-bridge in front of the servo's signal wire. It is a logic input, not a winding — drive it directly.在伺服機訊號線前面加 MOSFET 或 H 橋。那是邏輯輸入，不是線圈——直接推它就好。サーボの信号線の手前に MOSFET や H ブリッジを置くこと。あれは巻線ではなくロジック入力だ——直結して駆動する。Memasang MOSFET atau H-bridge di depan kabel sinyal servo. Itu masukan logika, bukan lilitan — gerakkan langsung.
• A frame that is only approximately 20 ms, or a pulse that jitters by a microsecond, makes the horn buzz and hunt — that is your counter, not the servo.框架只是「大約」20 ms，或脈波抖動個一微秒，舵臂就會嗡嗡叫並來回找位——那是你的計數器的問題，不是伺服機的。フレームが「およそ」20 ms しかない、あるいはパルスが 1 マイクロ秒ジッタするだけで、ホーンは唸って位置を探し続ける——それはサーボではなく自分のカウンタの問題だ。Frame yang hanya kira-kira 20 ms, atau pulsa yang bergetar sebesar satu mikrodetik, membuat horn berdengung dan mencari-cari — itu pencacahmu, bukan servonya.
• Commanding past the mechanical end stop. Below 1.0 ms or above 2.0 ms the loop keeps pushing against the stop, draws stall current and cooks the gearbox — clamp the angle in hardware, not in the host that feeds the pins.命令超過機械極限。低於 1.0 ms 或高於 2.0 ms 時，迴路會一直頂著限位推，吃堵轉電流並把齒輪箱燒掉——角度要在硬體裡夾住，不要靠餵腳位的那一端自律。機械的なエンドストップを越えて指令すること。1.0 ms 未満または 2.0 ms 超では、ループはストッパを押し続けてストール電流を引き、ギアボックスを焼く——角度はハードウェアでクランプする。ピンに値を送る側の良心に任せてはいけない。Memerintahkan melewati batas mekanis. Di bawah 1.0 ms atau di atas 2.0 ms, loop-nya terus mendorong melawan batas itu, menarik arus macet dan memanggang gearbox — kunci sudutnya di perangkat keras, bukan di host yang memberi umpan ke pin.
• An MG90S takes 3.3 V logic on the signal pin happily, but never power it from the board's 5 V pin — a stalled servo pulls close to an amp and the FPGA resets with it.MG90S 的訊號腳吃 3.3 V 邏輯沒問題，但絕對不要用板子的 5 V 腳供電——伺服機堵轉時電流接近一安培，FPGA 會跟著重置。MG90S の信号ピンは 3.3 V ロジックで問題なく動くが、ボードの 5 V ピンから電源を取ってはいけない——ストール時に 1 A 近く流れ、FPGA も一緒にリセットする。MG90S menerima logika 3.3 V pada pin sinyal dengan senang hati, tetapi jangan pernah memberinya daya dari pin 5 V papan — servo yang macet menarik mendekati satu ampere dan FPGA ikut ter-reset.
• Separate motor supply, grounds tied at one point. Powering the motor off the board rail browns out the FPGA the moment it stalls.馬達要獨立供電，接地只在一點共接。用板子的電源軌去推馬達，堵轉那一瞬間 FPGA 就會掉電。モータ電源は別系統にし、グラウンドは一点で接続する。ボードの電源レールからモータを回すと、ストールした瞬間に FPGA が電圧降下で落ちる。Catu daya motor terpisah, ground disatukan di satu titik. Memberi daya motor dari rel papan akan membuat FPGA brownout begitu motornya macet.
• Step the duty from 0 to full and the inrush trips the supply. Ramp the compare register.把 duty 從 0 一步跳到滿，突入電流會讓電源跳掉。比較暫存器要用斜升的。デューティを 0 から一気に全開にすると突入電流で電源が落ちる。比較レジスタはランプさせること。Naikkan duty dari 0 ke penuh sekaligus dan arus inrush-nya akan menjatuhkan catu daya. Ramp-kan register pembandingnya.
• Never drive both sides of a bridge leg on at once. Insert the dead time in the FSM, not in your head.絕不要讓橋臂的上下兩側同時導通。死區時間要寫進 FSM 裡，不是放在你腦子裡。ブリッジの上下アームを同時にオンにしてはいけない。デッドタイムは頭の中ではなく FSM に入れること。Jangan pernah menyalakan kedua sisi satu kaki jembatan sekaligus. Sisipkan dead time-nya di dalam FSM, bukan di kepalamu.
• Below a few percent duty the motor buzzes and does not turn — that is the deadband, not a bug.duty 低於百分之幾時馬達只會嗡嗡叫而不轉——那是死區，不是 bug。デューティが数パーセントを下回るとモータは唸るだけで回らない——それはデッドバンドであってバグではない。Di bawah beberapa persen duty, motor berdengung dan tidak berputar — itu deadband, bukan bug.

Done when完成條件完了条件Selesai bila

• Scope shows a 20 ms frame whose high time is 1.50 ms ± 10 µs with the angle commanded to centre.示波器上是 20 ms 的框架，角度命令在中位時高電位時間為 1.50 ms ± 10 µs。オシロで 20 ms のフレームが見え、角度指令が中央のときハイ時間が 1.50 ms ± 10 µs。Osiloskop menunjukkan frame 20 ms yang waktu tingginya 1.50 ms ± 10 µs ketika sudut diperintahkan ke tengah.
• An angle set on the GPIO input pins is the angle the horn actually reaches, checked against a protractor at 0°, 90° and 180°.在 GPIO 輸入腳位上設定的角度，就是舵臂實際到達的角度；用量角器在 0°、90°、180° 三點對過。GPIO 入力ピンで設定した角度が、ホーンが実際に到達する角度である。0°、90°、180° の三点で分度器と照合する。Sudut yang diset pada pin masukan GPIO adalah sudut yang benar-benar dicapai horn, diperiksa dengan busur derajat pada 0°, 90° dan 180°.
• The horn holds its commanded angle when you push against it by hand, and returns to it when you let go — that is the internal PI loop, and your pulse never changed.用手去推舵臂時它仍守住被命令的角度，放手後回到原位——那是內部的 PI 迴路在動作，而你的脈波從頭到尾沒有變。ホーンを手で押しても指令された角度を保持し、離すと戻る——動いているのは内部の PI ループで、こちらのパルスは一度も変わっていない。Horn menahan sudut yang diperintahkan ketika kamu mendorongnya dengan tangan, dan kembali ke sana ketika kamu lepaskan — itulah loop PI internalnya, dan pulsamu tidak pernah berubah.
• A full-travel command sweeps rather than snaps, and stalling the horn at an end stop does not reset the FPGA.全行程的命令是掃過去而不是彈過去，而且把舵臂堵在極限位置時不會讓 FPGA 重置。全行程の指令がスナップせずスイープし、ホーンをエンドストップで拘束しても FPGA がリセットしない。Perintah lintasan penuh menyapu alih-alih menyentak, dan memacetkan horn pada batas ujung tidak me-reset FPGA.
• An out-of-range value on the pins is clamped to 1.0/2.0 ms instead of being passed through.腳位上超出範圍的值會被夾到 1.0/2.0 ms，而不是照原樣送出去。ピン上の範囲外の値がそのまま通されず、1.0/2.0 ms にクランプされる。Nilai di luar jangkauan pada pin dikunci ke 1.0/2.0 ms alih-alih diteruskan begitu saja.
• Handed in: a testbench waveform of one frame at three commanded angles, and a YouTube clip of the horn stepping through them.已交件：三個命令角度下各一個框架的 testbench 波形，以及舵臂依序走過這三個角度的 YouTube 影片。提出済み：三つの指令角度における 1 フレームずつの testbench 波形と、ホーンがその三点を順に進む YouTube 動画。Dikumpulkan: bentuk gelombang testbench satu frame pada tiga sudut yang diperintahkan, dan klip YouTube horn yang melangkah melewatinya.
• Extension — on a bare brushed motor: a clean 20 kHz carrier, duty from the GPIO pins changing the speed within one period, and direction reversing without a shoot-through spike.延伸——在裸的有刷馬達上：乾淨的 20 kHz 載波、從 GPIO 腳位來的 duty 在一個週期內改變轉速，以及換向時沒有貫穿導通尖峰。発展——剥き出しのブラシモータで：きれいな 20 kHz キャリア、GPIO ピンからのデューティが 1 周期以内に速度を変えること、そして反転時に貫通電流のスパイクが出ないこと。Perluasan — pada motor brushed telanjang: pembawa 20 kHz yang bersih, duty dari pin GPIO yang mengubah kecepatan dalam satu periode, dan arah yang berbalik tanpa lonjakan shoot-through.

Reference answer — not released yet參考解答 —— 尚未開放参考解答 — まだ公開されていませんJawaban acuan — belum dirilis

localparam SPER = 1000000;               // 20 ms at 50 MHz
reg [19:0] scnt;                         // 2^20 > 1e6

always @(posedge clk)
  scnt <= (scnt == SPER-1) ? 20'd0 : scnt + 1'b1;

assign servo = (scnt < pulse);           // 50000..100000 = 1.0..2.0 ms

localparam MIN = 50000;                // 1.0 ms, angle 0
wire [16:0] pulse = MIN + ((ang_q * 71111) >> 8);
                                       // ang_q 180 -> 99999

reg [7:0] g1, g2, ang_q;
wire [7:0] tgt = (g2 > 180) ? 8'd180 : g2;   // clamp once, here

always @(posedge clk) begin
  g1 <= gpio_angle; g2 <= g1;            // two flops, async in
  if (scnt == SPER-1)                        // once per 20 ms frame
    if      (ang_q < tgt) ang_q <= ang_q + 1'b1;
    else if (ang_q > tgt) ang_q <= ang_q - 1'b1;
end

localparam PER = 2500;
reg [11:0] cnt, duty;

always @(posedge clk) begin
  cnt <= (cnt == PER-1) ? 12'd0 : cnt + 1'b1;
  if (cnt == PER-1) duty <= duty_next;   // atomic update
end

assign pwm = (cnt < duty);

localparam DEAD = 50;                    // 1 us at 50 MHz
reg [5:0] dead; reg dir_q;

always @(posedge clk) begin
  if (dir != dir_q) begin dead <= DEAD; dir_q <= dir; end
  else if (|dead)   dead <= dead - 1'b1;
end

wire coast = |dead;
assign in_a = coast ? 1'b0 : ( dir & pwm);
assign in_b = coast ? 1'b0 : (~dir & pwm);

Retire LabVIEW: the same panel in Python讓 LabVIEW 退休：用 Python 做同一個控制面板LabVIEW を引退させる：同じパネルを Python でPensiunkan LabVIEW: panel yang sama dalam Python

• pyserial
• Tkinter
• Threads
• Python 3

“better use python to code gui program to replace labview” ↳ added after the notebook page

Rebuild tasks 3–5 as one Python window: a port selector, an echo self-test, a live plot of the filtered stream, and a duty slider. Same FPGA bitstream, same 115200 8N1 link — only the desk side changes. pyserial plus stdlib tkinter is the whole dependency list, which is the argument for doing it this way. 把第 3 到第 5 題重做成一個 Python 視窗：串列埠選單、回傳自我測試、濾波資料的即時繪圖，以及一根 duty 滑桿。FPGA 的 bitstream 一樣、115200 8N1 的連線一樣——只有桌上這端換掉。相依套件就只有 pyserial 加上標準函式庫的 tkinter，這就是這樣做的理由。課題 3〜5 を一つの Python ウィンドウとして作り直す：ポート選択、エコーの自己テスト、フィルタ済みデータのライブプロット、そしてデューティのスライダ。FPGA のビットストリームも 115200 8N1 のリンクも同じで、変わるのは机の上だけだ。依存は pyserial と標準ライブラリの tkinter だけ——それがこのやり方を選ぶ理由になる。Bangun ulang tugas 3–5 sebagai satu jendela Python: pemilih port, uji-mandiri gema, plot langsung aliran hasil tapis, dan penggeser duty. Bitstream FPGA yang sama, sambungan 115200 8N1 yang sama — hanya sisi mejanya yang berubah. pyserial ditambah tkinter dari stdlib adalah seluruh daftar dependensinya, dan itulah alasan melakukannya dengan cara ini.

One byte stream now carries three different things, so give it a frame: A5 | cmd | len | payload… | xor. Sync on A5, drop the frame if the checksum disagrees, and never assume one read() returns one frame. 同一條位元組串流現在要載三種東西，所以給它一個框架：A5 | cmd | len | payload… | xor。用 A5 同步，checksum 不合就丟掉整個 frame，而且永遠不要假設一次 read() 剛好回來一個 frame。一本のバイトストリームが三種類のものを運ぶことになるので、フレームを与える：A5 | cmd | len | payload… | xor。A5 で同期し、チェックサムが合わなければそのフレームを捨てる。1 回の read() が 1 フレームを返すとは決して仮定しないこと。Satu aliran byte sekarang membawa tiga hal berbeda, jadi berilah ia frame: A5 | cmd | len | payload… | xor. Sinkronkan pada A5, buang frame-nya kalau checksum tidak cocok, dan jangan pernah mengandaikan satu read() mengembalikan satu frame.

Target numbers目標數字目標値Angka target

Port串列埠ポートPort

serial.Serial(port, 115200)

Defaults預設值デフォルトNilai bawaan

8N1, no flow control

Reader讀取執行緒リーダPembaca

1 daemon thread → queue

UI drainUI 取用UI の取り出しPengurasan UI

root.after(30 ms)

Frame框架フレームFrame

A5 · cmd · len · data · xor

Windows port ≥ 10Windows 埠號 ≥ 10Windows のポート番号 ≥ 10Port Windows ≥ 10

\\.\COM10

Traps陷阱落とし穴Jebakan

• Never touch a Tk widget from the reader thread. Push bytes into a queue.Queue and drain it from after() on the main thread — this is the single most common way these panels hang.絕對不要從讀取執行緒去碰 Tk 元件。把位元組丟進 queue.Queue，再由主執行緒的 after() 取出——這類面板當掉，最常見的原因就是這個。リーダスレッドから Tk のウィジェットに触れてはいけない。バイト列は queue.Queue に入れ、メインスレッドの after() で取り出す——この種のパネルがフリーズする原因の第一位がこれだ。Jangan pernah menyentuh widget Tk dari thread pembaca. Dorong byte-nya ke dalam queue.Queue dan kuras dari after() di thread utama — inilah cara paling umum panel semacam ini menggantung.
• ser.read(n) returns up to n bytes when the timeout expires. Accumulate into a buffer and parse frames out of it; do not treat one read as one message.ser.read(n) 在逾時的時候回傳的是最多 n 個位元組。請累積到緩衝區裡再從中解析 frame；不要把一次讀取當成一則訊息。ser.read(n) はタイムアウト時に最大 n バイトを返す。バッファに貯めてからフレームを切り出すこと。1 回の read を 1 メッセージとして扱ってはいけない。ser.read(n) mengembalikan paling banyak n byte ketika timeout-nya habis. Kumpulkan ke dalam buffer dan parse frame-nya dari sana; jangan perlakukan satu read sebagai satu pesan.
• A Tk Scale fires its callback on every pixel of drag. Throttle it, or send only on release, or you queue hundreds of duty writes into a 115200 pipe.Tk 的 Scale 每拖動一個像素就觸發一次回呼。要節流，或只在放開時送出，否則你會把幾百筆 duty 寫入塞進 115200 的管線裡。Tk の Scale はドラッグ 1 ピクセルごとにコールバックを呼ぶ。スロットリングするか、離した時だけ送ること。さもないと 115200 の細い管に数百回の書き込みを詰め込むことになる。Scale pada Tk memicu callback-nya pada setiap piksel gerakan. Batasi lajunya, atau kirim hanya saat dilepas, kalau tidak kamu menumpuk ratusan penulisan duty ke dalam pipa 115200.
• Close the port on WM_DELETE_WINDOW. On Windows the handle stays locked and the next run fails with "Access is denied" until you replug.在 WM_DELETE_WINDOW 時關閉串列埠。在 Windows 上那個 handle 會一直被鎖住，下次執行會出現「Access is denied」，直到你把線拔掉重插。WM_DELETE_WINDOW でポートを閉じること。Windows ではハンドルがロックされたままになり、挿し直すまで次回の実行が「Access is denied」で失敗する。Tutup port-nya pada WM_DELETE_WINDOW. Di Windows, handle-nya tetap terkunci dan jalan berikutnya gagal dengan "Access is denied" sampai kamu mencabut dan memasangnya lagi.
• Plot decimated data. Redrawing 1000 points at 1 kHz starves the event loop; keep a ring of the last ~500 samples and redraw at 30 Hz.繪圖前先抽取。以 1 kHz 重畫 1000 個點會把事件迴圈餓死；保留最近約 500 筆的環形緩衝，用 30 Hz 重畫就好。プロットは間引くこと。1 kHz で 1000 点を再描画するとイベントループが飽和する。直近 500 サンプル程度のリングを持ち、30 Hz で描き直す。Plot data yang sudah didesimasi. Menggambar ulang 1000 titik pada 1 kHz membuat event loop kelaparan; simpan ring berisi ~500 cuplikan terakhir dan gambar ulang pada 30 Hz.

Done when完成條件完了条件Selesai bila

• The panel opens the port, runs the 1000-byte echo test from task 3, and reports the mismatch count.面板能開啟串列埠、跑第 3 題那個 1000 byte 的回傳測試，並回報不一致的筆數。パネルがポートを開き、課題 3 の 1000 バイトのエコーテストを実行し、不一致件数を報告する。Panelnya membuka port, menjalankan uji gema 1000 byte dari tugas 3, dan melaporkan jumlah ketidakcocokannya.
• The filtered stream plots live without the window going unresponsive.濾波後的資料能即時繪圖，而視窗不會沒有反應。フィルタ済みのデータがリアルタイムに描画され、ウィンドウが無応答にならない。Aliran hasil tapis terplot secara langsung tanpa jendelanya menjadi tidak responsif.
• The duty slider spins the motor, and unplugging the cable shows an error instead of a traceback.duty 滑桿能讓馬達轉動；把線拔掉時顯示的是錯誤訊息，而不是一整串 traceback。デューティのスライダでモータが回り、ケーブルを抜くとトレースバックではなくエラーメッセージが出る。Penggeser duty memutar motornya, dan mencabut kabelnya memunculkan pesan galat alih-alih traceback.
• Closing the window releases the COM port — reopening works with no replug.關掉視窗會釋放 COM 埠——不用重插線就能再開一次。ウィンドウを閉じると COM ポートが解放され、挿し直さずに再度開ける。Menutup jendela membebaskan port COM — membukanya kembali berhasil tanpa perlu mencabut dan memasang lagi.
• Handed in: the self-test output with zero mismatches, and a YouTube screen recording of the panel driving the board.已交件：不一致為零的自我測試輸出，以及面板操控板子的 YouTube 螢幕錄影。提出済み：不一致ゼロの自己テスト出力と、パネルがボードを動かしている YouTube の画面録画。Dikumpulkan: keluaran uji-mandiri tanpa satu pun ketidakcocokan, dan rekaman layar YouTube panel yang menggerakkan papan.

Reference answer — not released yet參考解答 —— 尚未開放参考解答 — まだ公開されていませんJawaban acuan — belum dirilis

import queue, threading, tkinter as tk
import serial

ser = serial.Serial("COM7", 115200, timeout=0.05)   # 8N1 is default
rx  = queue.Queue()
alive = threading.Event(); alive.set()

def reader():                       # thread: bytes in, frames out
    buf = bytearray()
    while alive.is_set():
        try:
            buf += ser.read(256)
        except serial.SerialException as e:
            rx.put(("error", str(e))); break
        while len(buf) >= 3 and (n := buf[2]) + 4 <= len(buf):
            if buf[0] != 0xA5:
                del buf[0]; continue
            frame = bytes(buf[:n+4])
            del buf[:n+4]
            rx.put(("frame", frame))

threading.Thread(target=reader, daemon=True).start()

def drain():
    while not rx.empty():
        kind, payload = rx.get()
        if kind == "error": status.set(payload)
        else:               plot_push(payload)
    root.after(30, drain)

def on_close():
    alive.clear(); ser.close(); root.destroy()   # release the port

root.protocol("WM_DELETE_WINDOW", on_close)
root.after(30, drain)
root.mainloop()

pending = None
def on_duty(v):                      # Scale(from_=0, to=255, resolution=1)
    global pending
    pending = int(v)                 # slider counts ARE the duty byte

def flush_duty():                    # at most 20 writes/second
    global pending
    if pending is not None:
        ser.write(bytes([0xA5, 0x02, 1, pending, 0x02 ^ 1 ^ pending]))
        pending = None
    root.after(50, flush_duty)