Verilog $display: การใช้งาน พื้นฐาน เทคนิค และตัวอย่างจริง

By 佐川 直弘 | Naohiro Sagawa (運営者)

※記事内に広告を含みます。Amazonアソシエイトとして適格販売により収入を得ています。

1. บทนำ: ความสำคัญและวัตถุประสงค์ของ “display” ใน Verilog

“display” ใน Verilog คืออะไร?

$display ใน Verilog เป็นหนึ่งใน system task ที่ใช้สำหรับ “แสดงผล” สถานะภายในของโปรแกรมระหว่างการจำลอง คล้ายกับ printf ของภาษา C โดยสามารถแสดงค่าของสัญญาณ ตัวแปร หรือสตริงไปยังเทอร์มินัลหรือคอนโซลได้ ถือเป็นฟังก์ชันที่มีประโยชน์อย่างยิ่งในการดีบักและตรวจสอบการทำงาน

ทำไม $display จึงจำเป็นในงานพัฒนา Verilog

• เพิ่มประสิทธิภาพการดีบัก: ในวงจรที่ซับซ้อน การมองเห็นสัญญาณภายในเป็นสิ่งสำคัญ $display ช่วยให้สามารถตรวจสอบค่าได้ทันทีระหว่างการจำลอง
• ทำให้การจำลองเข้าใจง่ายขึ้น: การดูเฉพาะ waveform อาจไม่เพียงพอ การบันทึก log ด้วยข้อความช่วยให้เข้าใจการเปลี่ยนค่าได้ชัดเจนขึ้น
• มีประโยชน์ต่อการเขียนเอกสาร: สามารถใส่คำอธิบายหรือ hint ลงใน log เพื่อช่วยให้ผู้อื่นเข้าใจโค้ดได้ง่ายขึ้น

วัตถุประสงค์และโครงสร้างของบทความ

บทความนี้จะอธิบายตามลำดับดังนี้:

1. รูปแบบและวิธีใช้พื้นฐาน: อธิบาย syntax และวิธีใช้ $display
2. เปรียบเทียบกับ system task อื่น ๆ: เช่น $write, $strobe, $monitor
3. ฟอร์แมตสเปคิไฟเออร์และเทคนิค: เช่น %d, %b, %h, %s
4. ตัวอย่างการใช้งานจริง: พร้อมโค้ดใน testbench
5. การประยุกต์ใช้ในการควบคุม display: เช่น LCD หรือ monitor

ด้วยโครงสร้างนี้ ผู้อ่านตั้งแต่ระดับเริ่มต้นถึงระดับกลางจะสามารถเข้าใจและใช้ $display ใน Verilog ได้อย่างถูกต้องและนำไปใช้งานจริง

2. พื้นฐานของ $display: วิธีเขียน การใช้งาน และข้อควรระวัง

โครงสร้างพื้นฐานของ $display

โครงสร้างพื้นฐานของการใช้ $display ใน Verilog มีดังนี้:

$display("สตริงหรือฟอร์แมตสเปคิไฟเออร์", สัญญาณ1, สัญญาณ2, ...);

• ส่วนของสตริง: ใส่ข้อความหรือฟอร์แมตสเปคิไฟเออร์ (เช่น %d, %b, %h)
• อาร์กิวเมนต์: ใส่ชื่อสัญญาณหรือตัวแปรที่จะถูกแสดงผลตามรูปแบบ

ตัวอย่าง: แสดงค่า clock counter และสัญญาณ

$display("Time=%0t : clk=%b, reset=%b", $time, clk, reset);

ผลลัพธ์: เวลาในการจำลองพร้อมค่าของสัญญาณ clock และ reset จะถูกแสดง

การใช้งานของ $display

1. ติดตามความคืบหน้าของการจำลอง
   ใส่ $display ในตำแหน่งเฉพาะเพื่อดูว่าโค้ดทำงานถึงจุดใดแล้ว
2. ตรวจสอบค่าของสัญญาณ
   ช่วยให้เข้าใจเงื่อนไขหรือการเปลี่ยนสถานะได้ง่ายขึ้นเมื่อแสดงผลเป็นข้อความ
3. แสดงข้อความตามเงื่อนไข
   สามารถใช้ร่วมกับ if เช่น if (reset) $display("Reset asserted at %0t", $time);

ความแตกต่างระหว่าง $display และ $write

$display จะเพิ่มการขึ้นบรรทัดใหม่อัตโนมัติ แต่ $write จะไม่ขึ้นบรรทัดใหม่

ตัวอย่าง:

$display("Hello");
$display("World");

ผลลัพธ์:

Hello
World

$write("Hello");
$write("World");

ผลลัพธ์:

HelloWorld

ดังนั้น หากต้องการ log ที่อ่านง่ายให้ใช้ $display แต่หากต้องการต่อข้อความในบรรทัดเดียวใช้ $write

ข้อควรระวัง

1. หลีกเลี่ยงการแสดงผลมากเกินไป
   การใช้ $display ทุก clock จะทำให้ log มีขนาดใหญ่และอ่านยาก
   → ควรใช้เงื่อนไข
2. ใช้การแสดงเวลา
   สามารถใช้ $time หรือ $realtime เพื่อดูเวลาได้อย่างแม่นยำ
3. เป็น task สำหรับการจำลองเท่านั้น
   $display ใช้ไม่ได้ในการสังเคราะห์ (FPGA/ASIC) ต้องเข้าใจว่าเป็นเครื่องมือสำหรับ debug เท่านั้น

3. การเปรียบเทียบ System Task สำหรับการแสดงผล: $display · $write · $strobe · $monitor

นอกจาก $display แล้ว Verilog ยังมี system task อื่น ๆ ที่ใช้ในการแสดงผล ความแตกต่างอยู่ที่วัตถุประสงค์และเวลาที่ข้อมูลถูกแสดง การเข้าใจและเลือกใช้ให้ถูกต้องช่วยให้การดีบักมีประสิทธิภาพมากขึ้น

$display: การแสดงผลมาตรฐาน

• คุณสมบัติ
  เพิ่มการขึ้นบรรทัดใหม่อัตโนมัติ ทำให้ log ถูกจัดเรียงอ่านง่าย
• การใช้งาน
  ใช้บ่อยที่สุดสำหรับการ debug เพื่อแสดงผลตามเวลาที่กำหนด

$write: การแสดงผลโดยไม่ขึ้นบรรทัดใหม่

• คุณสมบัติ
  ไม่เพิ่มการขึ้นบรรทัดใหม่ ข้อความจะต่อเนื่องกัน
• การใช้งาน
  เหมาะสำหรับแสดงผลหลายค่าต่อเนื่องในบรรทัดเดียว
• ตัวอย่าง $write("A=%d, ", a); $write("B=%dn", b); → ผลลัพธ์ A=5, B=10 แสดงในบรรทัดเดียว

$strobe: แสดงค่าหลังจากสิ้นสุดรอบการจำลอง

• คุณสมบัติ
  จะแสดงค่าหลังจากที่สัญญาณทั้งหมดถูกประเมินเสร็จแล้วในรอบปัจจุบัน
• การใช้งาน
  ช่วยหลีกเลี่ยง race condition เมื่อหลายสัญญาณเปลี่ยนพร้อมกัน
• ตัวอย่าง $strobe("Time=%0t, signal=%b", $time, sig); → แสดงค่าที่เสถียรแล้ว

$monitor: การติดตามค่าอัตโนมัติ

• คุณสมบัติ
  จะแสดงผลทุกครั้งที่สัญญาณที่กำหนดมีการเปลี่ยนแปลง
• การใช้งาน
  เหมาะสำหรับติดตามสัญญาณตลอดเวลา
• ตัวอย่าง $monitor("At %0t: a=%b, b=%b", $time, a, b); → ทุกครั้งที่ a หรือ b เปลี่ยน จะมี log แสดงผล

ตารางเปรียบเทียบ

เคล็ดลับการเลือกใช้

• ใช้ $display เป็นหลัก: อ่านง่าย เหมาะสำหรับผู้เริ่มต้น
• ใช้ $write เมื่ออยากรวมข้อมูลหลายค่าในบรรทัดเดียว
• ใช้ $strobe เมื่ออยากได้ค่าที่เสถียรหลังจากการประเมินทั้งหมด
• ใช้ $monitor สำหรับติดตามสัญญาณแบบเรียลไทม์

4. ฟอร์แมตสเปคิไฟเออร์และเทคนิคการแสดงผลพิเศษ

ในการใช้ $display หรือ $write เราสามารถใส่ “ฟอร์แมตสเปคิไฟเออร์” ลงในสตริงเพื่อควบคุมวิธีแสดงผลของสัญญาณหรือตัวแปร คล้ายกับการใช้ printf ของภาษา C การเลือกใช้สเปคิไฟเออร์ที่เหมาะสมช่วยเพิ่มประสิทธิภาพการดีบักได้มาก

ฟอร์แมตสเปคิไฟเออร์พื้นฐาน

ตัวอย่างการใช้งานจริง

1. แสดงสัญญาณในหลายรูปแบบ
   reg [7:0] data = 8'b10101010; $display("data = %b (bin), %d (dec), %h (hex)", data, data, data);
   → ผลลัพธ์: data = 10101010 (bin), 170 (dec), AA (hex)
2. ตรวจสอบโมดูลในลำดับชั้น
   $display("โมดูลปัจจุบันคือ %m");
   → ผลลัพธ์: โมดูลปัจจุบันคือ top.u1.counter
3. แสดงเวลาจำลอง
   $display("Time=%0t: clk=%b", $time, clk);
   → ผลลัพธ์: Time=100: clk=1

เทคนิคการแสดงผลพิเศษ

• การเติมศูนย์และกำหนดหลัก
  ใช้ %0d เช่น $display("Count=%04d", count);
  → ผลลัพธ์: Count=0012
• ระบุค่า signed/unsigned
  %d คือ signed ส่วน %u คือ unsigned หากค่าติดลบแสดงไม่ถูกต้องให้เปลี่ยนสเปคิไฟเออร์
• การแสดงผลหลายบรรทัด
  ใช้ \n เพื่อขึ้นบรรทัดใหม่ เช่น
  $display("Start of test\nSignal A=%b\nSignal B=%b", A, B);

ข้อควรระวัง

• ระวังเรื่องความกว้างบิต: หากใช้ %d กับสัญญาณที่มีบิตกว้าง อาจเกิดการตัดบิตหรือ sign extension
• ค่าที่ไม่กำหนด (X, Z): เมื่อมีบิต X หรือ Z ค่าเหล่านี้จะแสดงตรง ๆ ใน %b

5. ตัวอย่างการใช้งานจริง: การใช้ $display ใน Testbench และภายในโมดูล

ในส่วนนี้ เราจะนำเสนอวิธีการใช้ $display ผ่านตัวอย่างโค้ดจริงใน Verilog ตั้งแต่ testbench พื้นฐานไปจนถึงการดีบักตามเงื่อนไข

ตัวอย่างพื้นฐาน: การแสดงผลใน Testbench

การใส่ $display ใน testbench ช่วยให้ตรวจสอบการทำงานของวงจรระหว่างการจำลองได้ง่ายขึ้น

module tb_counter;
  reg clk;
  reg reset;
  wire [3:0] count;

  // DUT (Device Under Test)
  counter uut (
    .clk(clk),
    .reset(reset),
    .count(count)
  );

  // สร้างสัญญาณ clock
  initial begin
    clk = 0;
    forever #5 clk = ~clk;  // สลับทุก 5 หน่วยเวลา
  end

  // สถานการณ์ทดสอบ
  initial begin
    reset = 1;
    #10 reset = 0;

    #50 $finish;
  end

  // แสดงสถานะ
  always @(posedge clk) begin
    $display("Time=%0t | reset=%b | count=%d", $time, reset, count);
  end
endmodule

ในตัวอย่างนี้ ทุกครั้งที่ขอบ rising edge ของ clock มาถึง ค่า reset และ count จะถูกพิมพ์ออกมา ทำให้ตรวจสอบการทำงานได้ทั้งจาก waveform และข้อความ log

ตัวอย่างการแสดงผลตามเงื่อนไข

สามารถใช้ if เพื่อตรวจสอบและพิมพ์ log เฉพาะเมื่อเงื่อนไขเป็นจริง

always @(posedge clk) begin
  if (count == 4'd10) begin
    $display("นับถึง 10 แล้ว (Time=%0t)", $time);
  end
end

→ ช่วยลดปริมาณ log โดยแสดงเฉพาะเหตุการณ์สำคัญ

ข้อความสำหรับการดีบัก

ในการตรวจสอบข้อผิดพลาด เราอาจพิมพ์ข้อความเตือนเมื่อค่าไม่เป็นไปตามที่คาดหวัง

always @(posedge clk) begin
  if (count > 4'd12) begin
    $display("WARNING: ตรวจพบการล้นของ count! Time=%0t, value=%d", $time, count);
  end
end

→ ทำให้สามารถตรวจพบ bug หรือพฤติกรรมที่ไม่คาดคิดได้เร็วขึ้น

การแสดงผลหลายสัญญาณพร้อมกัน

เมื่อมีหลายสัญญาณ ควรรวมไว้ในบรรทัดเดียวเพื่อให้ log อ่านง่าย

$display("Time=%0t | clk=%b | reset=%b | A=%h | B=%h | SUM=%h",
         $time, clk, reset, A, B, SUM);

สรุปจุดสำคัญในการใช้งานจริง

• ใช้ใน testbench เพื่อดูความคืบหน้า
• กรอง log ด้วยเงื่อนไขเพื่อหลีกเลี่ยงข้อมูลเกินจำเป็น
• ใส่ข้อความเตือนเมื่อพบเหตุการณ์ผิดปกติ
• รวมหลายสัญญาณให้อยู่ในบรรทัดเดียวเพื่อความชัดเจน

6. การประยุกต์ใช้การควบคุม Display (การแสดงผลพิกเซล / ข้อความ / ภาพ)

ที่ผ่านมาฟังก์ชัน $display ถูกใช้สำหรับการแสดงข้อความ log และการดีบักระหว่างการจำลอง
อย่างไรก็ตาม Verilog ยังถูกนำมาใช้กับการควบคุมจอแสดงผลจริง เช่น LCD, VGA หรือ HDMI อีกด้วย ในส่วนนี้จะอธิบายแนวคิดการแสดงผลบนฮาร์ดแวร์

แนวคิดพื้นฐานของการควบคุม Display

การแสดงข้อความหรือภาพบนจอ ไม่สามารถใช้ $display ได้โดยตรง แต่ต้อง สร้างสัญญาณวิดีโอ ขึ้นมา ตัวอย่างสัญญาณที่ใช้ ได้แก่:

• HSYNC (Horizontal Sync): สัญญาณบอกการสิ้นสุดหนึ่งบรรทัด
• VSYNC (Vertical Sync): สัญญาณบอกการสิ้นสุดหนึ่งเฟรม
• RGB Data: ข้อมูลสีของพิกเซล (เช่น 24-bit color: 8-bit × 3)

ใน Verilog จะใช้ counter และ state machine เพื่อสร้างสัญญาณเหล่านี้ และส่งออกตามเวลาที่เหมาะสมเพื่อให้เกิดภาพบนจอ

ตัวอย่างที่ 1: การแสดงแถบสี (Color Bar)

ตัวอย่างพื้นฐานที่สุดคือการแสดงแถบสีบนจอ

always @(posedge clk) begin
  if (h_counter < 100)       rgb <= 24'hFF0000; // แดง
  else if (h_counter < 200)  rgb <= 24'h00FF00; // เขียว
  else if (h_counter < 300)  rgb <= 24'h0000FF; // น้ำเงิน
  else                       rgb <= 24'h000000; // ดำ
end

→ ผลลัพธ์คือจะแสดงแถบสีแดง เขียว น้ำเงิน เรียงกันในแนวนอน

ตัวอย่างที่ 2: การแสดงข้อความ

สำหรับข้อความ ต้องใช้ Font ROM ซึ่งเก็บลวดลาย dot ของตัวอักษร จากนั้นนำมาแปลงเป็นพิกเซล

// แสดงตัวอักษร 'A' โดยอ้างอิงจาก Font ROM
if (font_rom[char_code][y][x] == 1'b1)
    rgb <= 24'hFFFFFF;  // สีขาว
else
    rgb <= 24'h000000;  // พื้นหลังสีดำ

→ ทำให้ตัวอักษร “A” ถูกวาดลงบนหน้าจอ

ตัวอย่างที่ 3: การแสดงภาพ

การแสดงภาพทำโดยโหลดข้อมูลบิตแมป (bitmap) จาก ROM หรือหน่วยความจำภายนอก แล้วนำไปแสดงผลเป็นพิกเซล

rgb <= image_rom[addr];  // อ่านค่าสีจาก ROM

ในระบบ embedded ที่ใช้ FPGA วิธีนี้สามารถนำมาใช้สำหรับไอคอนหรือโลโก้ขนาดเล็กได้

ความแตกต่างกับการใช้ $display สำหรับ debug

• $display = การแสดงข้อความ (ใช้เฉพาะการจำลอง)
• การควบคุมจอจริง = การสร้างสัญญาณวิดีโอ (สามารถสังเคราะห์ได้)

ทั้งสองมีวัตถุประสงค์ต่างกัน แต่ผู้เรียน Verilog มักสับสนได้ง่าย:

• “อยากดูค่าระหว่างการจำลอง” → ใช้ $display
• “อยากแสดงผลจริงบนจอ” → ต้องเขียนวงจรควบคุมสัญญาณวิดีโอ

การประยุกต์เพิ่มเติม

• บอร์ด FPGA สำหรับการศึกษา มักใช้ 7-segment LED หรือ LCD ขนาดเล็ก สำหรับแสดงผล
• หากพัฒนาเพิ่มเติม อาจทำ VGA/HDMI output สำหรับเกมหรือ GUI ได้
• เมื่อรวมความรู้การใช้ $display (สำหรับจำลอง) กับความรู้การสร้างสัญญาณวิดีโอ (สำหรับฮาร์ดแวร์) จะทำให้ควบคุมการแสดงผลได้ทั้งสองโลก

7. การเลือกใช้และเคล็ดลับตามสถานการณ์

ใน Verilog คำว่า “การแสดงผล” มี 2 ความหมายหลัก ได้แก่ การใช้ task ตระกูล $display สำหรับการจำลอง และ การควบคุมจอแสดงผลจริงในฮาร์ดแวร์ การเข้าใจความแตกต่างและเลือกใช้อย่างเหมาะสมจะช่วยเพิ่มประสิทธิภาพในการพัฒนาและดีบัก

การใช้งานระหว่างการจำลอง (Simulation)

1. การใช้ $display เป็น debug log
   • แสดงค่าของตัวแปรหรือสัญญาณที่สำคัญเพื่อยืนยันการทำงานถูกต้อง
   • เหมาะสำหรับตรวจสอบค่าตามเงื่อนไข เช่น counter หรือ flag
2. หลีกเลี่ยงการแสดงผลมากเกินไป
   • หากแสดงผลทุก clock จะทำให้ log มีขนาดใหญ่เกินไป
   • ควรกรองเฉพาะเหตุการณ์ที่สำคัญ เช่น if (state == ERROR) $display("เกิด ERROR ที่ %0t", $time);
3. การเลือกใช้ task อื่น ๆ ร่วมกัน
   • $monitor → ใช้สำหรับติดตามสัญญาณที่ต้องการดูตลอดเวลา
   • $strobe → ใช้เมื่ออยากได้ค่าที่เสถียรหลังจบรอบการประเมิน
   • $write → ใช้สำหรับการจัดรูปแบบ log แบบหลายค่าในบรรทัดเดียว

การใช้งานกับฮาร์ดแวร์จริง (Display Control)

1. การแสดงผลด้วย 7-segment
   • เป็นตัวอย่างพื้นฐานที่นิยมใช้สำหรับผู้เริ่มต้น FPGA
   • สามารถใช้ควบคู่กับ $display ใน simulation เพื่อยืนยันผลลัพธ์
2. การควบคุม LCD/VGA
   • ใช้ font ROM หรือ image ROM เพื่อสร้างข้อความและภาพบนจอ
   • สามารถตรวจสอบการทำงานโดยใช้ $display ระหว่าง simulation เพื่อดูว่าค่าสัญญาณถูกสร้างถูกต้อง
3. Overlay สำหรับการดีบัก
   • สามารถซ้อนข้อมูล debug เช่น ค่า counter หรือพิกัดลงบนภาพจริง
   • วิธีนี้ช่วยให้ “หน้าจอ” กลายเป็นเครื่องมือ debug ได้โดยตรง

เคล็ดลับในการใช้งานจริง

• ทำงานเป็นขั้นตอน: จาก Simulation → ไปยัง Hardware
  ตรวจสอบการทำงานด้วย $display ก่อน แล้วจึงเขียนวงจรควบคุมจอจริง
• ใช้ทั้ง Log และ Waveform ร่วมกัน
  ข้อความจาก $display ช่วยดูเวลาและเหตุการณ์ ขณะที่ waveform แสดงรายละเอียดการเปลี่ยนแปลง → เมื่อใช้ร่วมกันจะช่วยดีบักได้แม่นยำขึ้น
• สร้างมาตรฐาน Log สำหรับทีม
  หากทำงานเป็นทีม ควรกำหนดรูปแบบข้อความ $display ให้เหมือนกัน (เช่น มี prefix หรือแสดงเวลาเสมอ) เพื่อให้อ่าน log ได้ง่าย

สรุป

• $display และ task ที่เกี่ยวข้อง = เครื่องมือสำหรับการจำลอง
• การควบคุมจอ = การสร้างสัญญาณวิดีโอในฮาร์ดแวร์จริง
• เมื่อเลือกใช้อย่างถูกต้อง และผสมผสานทั้งสอง จะช่วยให้การพัฒนาและดีบักมีประสิทธิภาพสูงสุด

8. FAQ (คำถามที่พบบ่อยและคำตอบ)

Q1. ความแตกต่างระหว่าง $display และ $monitor คืออะไร?

A. $display จะพิมพ์ผล เพียงครั้งเดียวเมื่อถูกเรียก ขณะที่ $monitor จะพิมพ์ผล ทุกครั้งที่สัญญาณที่กำหนดมีการเปลี่ยนแปลง

• ใช้สำหรับ debug แบบครั้งเดียว → $display
• ใช้สำหรับติดตามต่อเนื่อง → $monitor

Q2. มีสถานการณ์ใดบ้างที่ควรใช้ $strobe?

A. $strobe จะพิมพ์ค่าหลังจากสิ้นสุดรอบการจำลอง ทำให้ได้ค่าที่เสถียร
เช่น เมื่อสัญญาณหลายตัวเปลี่ยนพร้อมกัน $display อาจแสดงค่าชั่วคราว แต่ $strobe จะแสดงค่าที่ถูกประเมินเสร็จแล้ว

Q3. ฟอร์แมตสเปคิไฟเออร์ %m ใช้ทำอะไร?

A. %m ใช้เพื่อแสดง ชื่อโมดูลตามลำดับชั้น เหมาะสำหรับการออกแบบขนาดใหญ่ เพราะช่วยระบุว่า log มาจากโมดูลใด

$display("โมดูลปัจจุบัน: %m");

ผลลัพธ์:

โมดูลปัจจุบัน: top.u1.counter

Q4. ถ้าใช้ $display จำนวนมาก log จะมีขนาดใหญ่มาก ควรทำอย่างไร?

A. มีวิธีแก้ดังนี้:

• ใช้ if เพื่อกรองเฉพาะเงื่อนไขที่ต้องการ
• พิมพ์เฉพาะเหตุการณ์สำคัญหรือ error
• ใช้ $monitor เพื่อติดตามสัญญาณสำคัญเท่านั้น
• ส่งออกไปยังไฟล์ log แล้วใช้เครื่องมือภายนอกกรองข้อมูล

Q5. สามารถใช้ $display ในการสังเคราะห์ (FPGA/ASIC) ได้หรือไม่?

A. ไม่ได้ $display เป็น task สำหรับการจำลองเท่านั้น และจะถูกละเว้นในขั้นตอนการสังเคราะห์ หากต้องการแสดงผลจริง ต้องใช้วงจรเช่น 7-segment LED, LCD หรือ VGA controller

Q6. ถ้าอยากแสดงข้อความหรือภาพบนฮาร์ดแวร์จริงควรทำอย่างไร?

A. ต้องสร้างสัญญาณวิดีโอ ไม่สามารถใช้ $display ได้

• 7-segment → แสดงตัวเลขอย่างง่าย
• VGA/LCD → สร้างสัญญาณ HSYNC, VSYNC, RGB
• ข้อความ → ใช้ font ROM สำหรับตัวอักษร
• ภาพ → โหลด bitmap จาก ROM หรือหน่วยความจำ

9. สรุปและก้าวต่อไป

สรุปเนื้อหาบทความ

บทความนี้ได้อธิบายเกี่ยวกับ “display” ใน Verilog ตั้งแต่พื้นฐานไปจนถึงการประยุกต์ใช้งาน โดยสรุปประเด็นสำคัญได้ดังนี้:

1. $display พื้นฐาน
   • ใช้แสดงค่าของสัญญาณหรือตัวแปรระหว่างการจำลอง คล้ายกับ printf ในภาษา C
2. ความแตกต่างกับ task อื่น ๆ
   • $write → แสดงผลโดยไม่ขึ้นบรรทัดใหม่
   • $strobe → แสดงค่าที่เสถียรหลังสิ้นสุดรอบการจำลอง
   • $monitor → แสดงผลอัตโนมัติเมื่อสัญญาณเปลี่ยน
3. การใช้ฟอร์แมตสเปคิไฟเออร์
   • เช่น %b, %d, %h, %m, %t เพื่อทำให้ log อ่านง่ายและมีประโยชน์มากขึ้น
4. ตัวอย่างการใช้งานจริง
   • แทรก $display ใน testbench เพื่อติดตามความคืบหน้า
   • ใช้เงื่อนไขเพื่อแสดง log เฉพาะเมื่อจำเป็น ทำให้ debug มีประสิทธิภาพ
5. การประยุกต์ใช้ในการควบคุมจอ
   • $display ใช้สำหรับการจำลองเท่านั้น
   • หากต้องการแสดงผลจริงบน FPGA ต้องสร้างสัญญาณ HSYNC, VSYNC, RGB
   • เริ่มตั้งแต่ 7-segment ไปจนถึง VGA/HDMI ได้

ก้าวต่อไป

• ศึกษาต่อยอดไปที่ SystemVerilog
  → ภาคต่อของ Verilog ที่มีฟีเจอร์ debug ขั้นสูง เช่น assertion และ $display ที่ถูกปรับปรุง
• ใช้ร่วมกับ waveform viewer
  → ผสาน log จาก $display เข้ากับ waveform เพื่อดูทั้งค่าเชิงตัวเลขและการเปลี่ยนแปลงของสัญญาณ
• เรียนรู้การแสดงผลบนฮาร์ดแวร์จริง
  → ทดลองโครงการเล็ก ๆ เช่น 7-segment หรือ LCD เพื่อเข้าใจความแตกต่างระหว่าง simulation และ hardware
• การทำงานเป็นทีม
  → ควรกำหนดมาตรฐานรูปแบบข้อความ $display ให้เหมือนกัน เพื่อให้ทีมอ่าน log ได้ง่าย

บทส่งท้าย

$display ไม่ได้เป็นเพียงแค่ “การพิมพ์ข้อความ” เท่านั้น แต่เป็น เครื่องมือสำคัญสำหรับการดีบักในการจำลอง และเมื่อก้าวเข้าสู่โลกของ “การควบคุมจอ” ด้วย FPGA ก็จะได้สัมผัสความสนุกในการสร้างกราฟิกจริงบนฮาร์ดแวร์

หวังว่าบทความนี้จะช่วยให้ผู้อ่านเข้าใจทั้ง การดีบักใน simulation และ การแสดงผลในฮาร์ดแวร์จริง เพื่อสามารถนำไปใช้งานได้อย่างมั่นใจ