企业官网建设流程全解析

先说结论：这个项目我前后折腾了两个周末才跑顺，踩了不少坑，但做完之后对FPGA的状态机设计、时序约束和数据通路理解直接上了一个台阶。如果你正在学Verilog，又不想只点个流水灯，用FPGA驱动WS2812B点阵做动态文字显示是一个非常合适的练手项目——它把协议解析、状态机控制、缓冲区管理和显示刷新这些真实工程里天天要碰的东西全串起来了。

这次我实现的是一个8行32列的全彩点阵，用FPGA直接输出时序驱动WS2812B灯珠，动态滚动显示“FPGA OK”等字符。整篇文章不整虚的，直接把硬件方案、协议分析、核心算法、完整Verilog代码和调试踩坑记录全部摊开。代码基于50MHz系统时钟，模块化设计，可以直接拿去改参数复用。

1. 项目到底在做什么：整体方案与硬件选型

1.1 系统组成与显示效果

整个系统的核心链路是：FPGA内部维护一个“虚拟屏幕”缓冲区，这个缓冲区里存的是8行32列的像素数据，每个像素对应一颗WS2812B灯珠的颜色。系统通过一个滚屏引擎把字符点阵数据不断左移更新缓冲区，然后把缓冲区内容按WS2812B协议串行发送到灯珠上，形成肉眼看到的滚动字幕。

我这里用的点阵规模是8x32，总共256颗灯珠。为什么选这个尺寸？因为它刚好能完整显示4个8x8字符，用来做滚动字幕非常直观。如果你手里是16x16或者32x8的灯板，只需要改参数和映射关系，核心代码不用动。

显示效果就是典型的LED滚动屏：字符从右往左逐列移动，到最左边之后消失，新的字符从右边进来。滚动速度可以通过一个定时器参数调节，10ms到50ms移一列都可以。

1.2 为什么选FPGA而不是单片机

很多人会问：WS2812B用STM32或者ESP32不是也能驱动吗？确实能，而且网上例程一堆。但FPGA做这个事有几个独到的地方。

首先是时序精度。WS2812B对0码和1码的高电平时间要求很严，虽然有容差范围，但单片机在中断嵌套或者系统调用多的时候，时序抖动会让灯珠出现偶发花屏。FPGA用纯硬件状态机驱动，时钟一拍一拍走，时序是确定性的，不受软件执行流影响。

其次是多路扩展潜力。用单片机驱动一路灯带很简单，但如果你想在同一个屏上同时驱动4路、8路WS2812B，单片机就会很吃力。FPGA的IO可以多个并行输出逻辑，扩展性完全不同。

最后是学习价值。这个项目写下来，你对Verilog的时序逻辑、状态机、模块划分、数据缓存和握手信号会有非常具体的体感，比单纯看教程强太多。

1.3 硬件连接与电平适配

硬件连接其实很简单。FPGA只需要一根数据线接到点阵的DIN端，点阵的VCC和GND接5V电源。

有一个容易忽略的点：WS2812B的输入高电平阈值，数据手册上通常写0.7倍VDD，也就是3.5V左右。不少FPGA开发板的IO是3.3V电平，严格来说是不达标的。实际测试中，很多WS2812B在3.3V下也能正常工作，但如果你发现第一颗灯珠偶尔异常、后面的灯全灭或者整条链路不稳定，优先怀疑电平问题。

最稳妥的方案是用一颗74AHCT1G125或者类似的单路电平转换芯片，把FPGA的3.3V信号抬到5V。如果手头没有专用芯片，用两个三极管搭个简易电平转换也能用。我是直接买的转换小板，几块钱解决问题。

供电也要单独说。256颗灯珠全亮白光的理论电流接近15A，但实际滚动显示时，点亮的灯珠通常不到一半，而且我建议显示颜色别用满亮度，比如绿色给个0x00FF00，电流能控制到2A以内。即便如此也建议用5V/5A以上的电源，不要依赖开发板的USB口供电。电线上并联一颗470uF电解电容和一颗0.1uF陶瓷电容，靠近点阵的电源端放置，能有效防止首灯附近的电压跌落。

2. WS2812B的协议与时序设计

2.1 单线归零码的关键参数

WS2812B用的是一种单线归零码，一根线上既传数据又传时钟。每颗灯珠接收24bit数据，数据格式是绿色G(7:0)、红色R(7:0)、蓝色B(7:0)，注意不是常见的RGB顺序，这个顺序搞反了颜色就会完全不对。

每个bit的传输周期是1.25us左右。0码和1码的区别在于高电平持续时间：

数据是先发高位，每颗灯珠的数据按GRB顺序发完24bit后，后续的灯珠数据继续级联传输，一整帧发完256颗灯的数据后，需要拉低至少50us，让所有灯珠锁存当前数据并显示。这个复位时间非常关键，如果小于规格，灯珠会把新旧数据混在一起。

2.2 用50MHz时钟生成精确时序

我的开发板系统时钟是50MHz，一个时钟周期正好20ns。用这个时钟去分频WS2812B的时序非常方便。

因为一个bit周期是1.25us，换算成50MHz时钟就是62.5拍，四舍五入用63拍。0码高电平取18拍，也就是360ns；低电平45拍，900ns。1码高电平取35拍，700ns；低电平28拍，560ns。这样0码和1码的总周期都是63拍，非常整齐：

这个参数在规格范围内，而且两个码型的周期保持一致，时序设计简单很多。如果你的系统时钟是100MHz，只需要把这些拍数翻倍即可，换算思路完全一样。

2.3 级联与数据链路分析

WS2812B的级联机制比较特殊：每颗灯珠内部有一个24bit移位寄存器。数据从DIN进来，灯珠先把前24bit锁存给自己，后续的数据继续从DOUT输出给下一颗灯珠。所以整个链路就是一个超长的移位寄存器，你必须在每一帧里把256颗灯的数据全部发完，顺序不能错。

这意味着，无论显示内容是否变化，每一帧都要完整发送全部256x24=6144个bit，不能像传统扫描点阵那样只更新变化的行。这是WS2812B点阵和普通共阴共阳点阵在架构上最大的区别，很多第一次做的人会在这个地方卡住。

3. 点阵布局与坐标映射

3.1 8x32点阵的走线与串联顺序

点阵的灯珠排列和灯带内部的串联顺序是两回事。排列是物理位置，串联顺序是数据流方向。如果你买的是一块成品8x32点阵屏，走线可能有两种：一种是蛇形走线，第一列从上到下，第二列从下到上，循环往复；另一种是逐行走线，第一行从左到右，第二行从左到右，逐行往下。

这个顺序必须在代码里体现，否则你往缓冲区里写一个“0”形，屏幕上可能是乱码。我在项目里用的是最常见的蛇形走线方案：数据从左上角进入，第一列从第0行到第7行，第二列从第7行到第0行，以此类推。

3.2 链式地址与行列坐标的换算

有了蛇形走线约定，就需要一个映射函数，把逻辑坐标(row, col)换算成链式索引n。假设链式索引从0开始，col从0到31，row从0到7：

• 先求当前列：col = n / 8
• 再求列内序号：idx = n % 8
• 判断这一列是正向还是反向：如果col是偶数，row = idx；如果col是奇数，row = 7 - idx

也就是说，只要拿到链式索引n，就能反推出它在屏幕上的逻辑位置。这个映射关系同时还用在显示引擎向缓冲区写入数据的那一步，代码里必须保持同一个映射逻辑，否则写入和发送会错位。

如果屏幕是逐行走线，则应该用n = row * 32 + col的映射。做之前一定先确认你的灯板是什么走线。

3.3 刷新率与帧时间估算

WS2812B没有PWM扫描的“亮度保持”机制，它靠重复发送数据来维持显示。所以每帧都要发送完整数据，帧率由数据量和bit周期决定。

256颗灯，每颗24bit，总共6144bit，每bit约1.26us，加上80us复位时间，总耗时约7.8ms，帧率在128Hz左右。这个刷新率远高于人眼能感知的闪烁频率，显示效果非常稳定。需要注意的是，帧率不受显示内容影响，就算所有灯都不亮，每一帧的数据也照样要发完。

如果你要扩展到64x64也就是4096颗灯，单链256灯的计算就不适用了，帧率会掉到8Hz左右，必须用多路并行发送或者重新设计驱动架构。这一点放到最后扩展部分再说。

4. 动态滚动显示的核心算法

4.1 字模数据的组织方式

8x8点阵字符是滚动系统的基础。常见的方式是用取模软件生成字模，每个字符8个字节，每个字节是一行的像素。

但这里有一个容易搞错的地方：WS2812B点阵的屏幕缓冲区是按“列”组织的，而传统取模软件给的是按“行”组织的数据，两者需要转置。我代码里的做法是直接在查表函数里写好纵向取模的数据，也就是每一列对应一个字节，lambda位从上到下排列。

例如字符“F”的纵向列数据，代码里写的就是：

1: case (col) 0: char_rom_lookup = 8'h7E; 1: char_rom_lookup = 8'h40; 2: char_rom_lookup = 8'h40; 3: char_rom_lookup = 8'h78; 4: char_rom_lookup = 8'h40; 5: char_rom_lookup = 8'h40; 6: char_rom_lookup = 8'h40; 7: char_rom_lookup = 8'h00; endcase

这里每一列数据对应屏幕一列从上到下的8个灯珠。如果你用取模软件，记得选择“纵向取模”模式，然后按列顺序填进查表函数。

4.2 列缓冲与左移滚动的思路

滚动显示最核心的数据结构是屏幕上的一列像素，我用了一个宽度32的寄存器数组来保存整屏内容：

reg [7:0] scr[0:31];

每次滚动时，把所有列左移一格，scr[0]会被丢弃，scr[31]填入新的一列数据。这个新数据来自当前正在显示字符的字模列。由于每个字符占8列，所以维护一个字符指针char_ptr和一个列指针char_col_idx，每填8列后字符指针加一，进入下一个字符。

这个方案的好处是直观，且不依赖复杂的地址计算。代价是占用了一小块寄存器资源，但8x32的规模完全无所谓。

4.3 滚动速度的控制

滚动速度不能直接放在WS2812B的数据发送循环里，因为那个循环是以bit为单位高频运转的。正确的做法是单独做一个分频计数器，每隔固定时间产生一个tick脉冲，tick到来时滚动一列。

我在代码里用了一个20bit计数器，50MHz时钟下计数到500000，也就是10ms产生一个tick。这样每10ms移动一列，每个字符大约80ms移完，显示节奏比较舒服。嫌快就把这个值调大，嫌慢就调小，非常灵活。

4.4 驱动与显示引擎的握手

显示引擎和WS2812B驱动模块之间需要一个握手机制，否则会出现读写冲突。我的做法是：WS2812B驱动每发完一帧数据，输出一个单周期frame_done脉冲；显示引擎收到这个脉冲后，进入一个短暂的数据写入状态，把当前屏幕缓冲区的内容映射成256颗灯珠的GRB颜色序列，逐个写入到驱动模块的led_buffer中。

因为写入256个数据只需要256个时钟周期，也就是5us左右，而下一帧开始前WS2812B驱动还要先经历80us复位，所以写入完全来得及，不会干扰下一帧的发送。

5. Verilog代码分模块拆解

5.1 顶层模块top_ws2812b_banner.v

顶层模块负责例化驱动和滚动引擎，并把它们连接起来。代码里有一个debug_led可以用来观察状态机是否正常，方便调试。

module top_ws2812b_banner( input wire clk_50m, input wire rst_n, output wire ws2812b_dout, output wire [3:0] debug_led ); wire [7:0] led_waddr; wire [23:0] led_wdata; wire led_wen; wire frame_done; assign debug_led = 4'b0001; ws2812b_driver #( .NUM_LEDS(256) ) u_driver ( .clk (clk_50m), .rst_n (rst_n), .wr_addr (led_waddr), .wr_data (led_wdata), .wr_en (led_wen), .dout (ws2812b_dout), .frame_done (frame_done) ); banner_engine #( .COLS (32), .TOTAL_CHARS (8) ) u_engine ( .clk (clk_50m), .rst_n (rst_n), .frame_done (frame_done), .led_addr (led_waddr), .led_rgb (led_wdata), .led_wr_en (led_wen) ); endmodule

5.2 WS2812B协议驱动模块

这个模块是整个项目里最核心的模块，负责生成精确的WS2812B时序。我把状态机设计成三个状态：复位、发送高电平、发送低电平。由于一帧发完后不需要等待外部命令，直接重新进入复位状态开始下一帧，所以这个状态机是一个循环结构。

module ws2812b_driver #( parameter NUM_LEDS = 256 )( input wire clk, input wire rst_n, input wire [7:0] wr_addr, input wire [23:0] wr_data, input wire wr_en, output reg dout, output reg frame_done ); // 50MHz时钟下的时序参数 localparam T0H = 18; // 360ns localparam T0L = 45; // 900ns localparam T1H = 35; // 700ns localparam T1L = 28; // 560ns localparam RESET_CYCLES = 4000; // 80us localparam STATE_RESET = 2'd0; localparam STATE_TX_HIGH = 2'd1; localparam STATE_TX_LOW = 2'd2; reg [23:0] led_buffer [0:NUM_LEDS-1]; reg [1:0] state; reg [11:0] reset_cnt; reg [7:0] led_idx; reg [4:0] bit_idx; reg [5:0] clk_cnt; reg [23:0] current_rgb; integer i; // 写端口 always @(posedge clk) begin if (wr_en) led_buffer[wr_addr] <= wr_data; end // 复位清零 always @(posedge clk or negedge rst_n) begin if (!rst_n) begin state <= STATE_RESET; reset_cnt <= 0; led_idx <= 0; bit_idx <= 23; clk_cnt <= 0; current_rgb <= 24'h000000; dout <= 1'b0; frame_done <= 1'b0; for (i = 0; i < NUM_LEDS; i = i + 1) led_buffer[i] <= 24'h000000; end else begin case (state) STATE_RESET: begin dout <= 1'b0; frame_done <= 1'b0; if (reset_cnt == RESET_CYCLES - 1) begin reset_cnt <= 0; led_idx <= 0; bit_idx <= 23; current_rgb <= led_buffer[0]; state <= STATE_TX_HIGH; clk_cnt <= 0; end else begin reset_cnt <= reset_cnt + 1; end end STATE_TX_HIGH: begin dout <= 1'b1; if (clk_cnt == (current_rgb[23] ? T1H : T0H) - 1) begin clk_cnt <= 0; dout <= 1'b0; state <= STATE_TX_LOW; end else begin clk_cnt <= clk_cnt + 1; end end STATE_TX_LOW: begin dout <= 1'b0; if (clk_cnt == (current_rgb[23] ? T1L : T0L) - 1) begin clk_cnt <= 0; if (bit_idx == 0) begin if (led_idx == NUM_LEDS - 1) begin led_idx <= 0; bit_idx <= 23; state <= STATE_RESET; frame_done <= 1'b1; end else begin led_idx <= led_idx + 1; current_rgb <= led_buffer[led_idx + 1]; bit_idx <= 23; end end else begin bit_idx <= bit_idx - 1; current_rgb <= {current_rgb[22:0], 1'b0}; end end else begin clk_cnt <= clk_cnt + 1; end end endcase end end endmodule

有几个细节需要说明。第一，current_rgb在复位状态结束时从led_buffer[0]加载，这样进入TX_HIGH时，current_rgb[23]就是第一颗灯的最高位。第二，在TX_LOW结束时，如果当前bit是0，说明整颗灯的数据发完了，切换下一颗灯；否则把current_rgb左移一位，让下一位成为最高位。第三，frame_done在最后一颗灯最后一位发送完毕后拉高一个周期，显示引擎会在这个信号触发下更新led_buffer。

5.3 文字滚屏引擎模块

滚屏引擎负责维护屏幕缓冲区和滚动逻辑，并在frame_done后把屏幕数据转换为灯珠的GRB值写入驱动模块。我额外设计了一个初始化状态，在复位后先把屏幕矩形填充为预设字符串的前4个字符，避免出现开机空白。

module banner_engine #( parameter COLS = 32, parameter TOTAL_CHARS = 8 )( input wire clk, input wire rst_n, input wire frame_done, output reg [7:0] led_addr, output reg [23:0] led_rgb, output reg led_wr_en ); // 屏幕缓冲，scr[c]表示第c列的8bit像素，bit7对应第0行，bit0对应第7行 reg [7:0] scr[0:31]; localparam NUM_LEDS = COLS * 8; localparam ENG_INIT = 2'd0; localparam ENG_RUN = 2'd1; localparam ENG_WRITE = 2'd2; reg [1:0] eng_state; reg [5:0] init_cnt; reg [7:0] wr_cnt; reg [3:0] char_ptr; reg [2:0] char_col_idx; // 滚动tick：10ms reg [19:0] tick_cnt; localparam TICK_MAX = 500000; wire tick_pulse = (tick_cnt == TICK_MAX - 1); always @(posedge clk or negedge rst_n) begin if (!rst_n) tick_cnt <= 0; else if (tick_pulse) tick_cnt <= 0; else tick_cnt <= tick_cnt + 1; end always @(posedge clk or negedge rst_n) begin if (!rst_n) begin eng_state <= ENG_INIT; init_cnt <= 0; wr_cnt <= 0; char_ptr <= 0; char_col_idx <= 0; end else begin case (eng_state) ENG_INIT: begin if (init_cnt < COLS) begin scr[init_cnt] <= char_rom_lookup(init_cnt[5:3], init_cnt[2:0]); init_cnt <= init_cnt + 1; end else begin eng_state <= ENG_RUN; end end ENG_RUN: begin if (tick_pulse) begin scr[0] <= scr[1]; scr[1] <= scr[2]; scr[2] <= scr[3]; scr[3] <= scr[4]; scr[4] <= scr[5]; scr[5] <= scr[6]; scr[6] <= scr[7]; scr[7] <= scr[8]; scr[8] <= scr[9]; scr[9] <= scr[10]; scr[10] <= scr[11]; scr[11] <= scr[12]; scr[12] <= scr[13]; scr[13] <= scr[14]; scr[14] <= scr[15]; scr[15] <= scr[16]; scr[16] <= scr[17]; scr[17] <= scr[18]; scr[18] <= scr[19]; scr[19] <= scr[20]; scr[20] <= scr[21]; scr[21] <= scr[22]; scr[22] <= scr[23]; scr[23] <= scr[24]; scr[24] <= scr[25]; scr[25] <= scr[26]; scr[26] <= scr[27]; scr[27] <= scr[28]; scr[28] <= scr[29]; scr[29] <= scr[30]; scr[30] <= scr[31]; scr[31] <= char_rom_lookup(char_ptr, char_col_idx); if (char_col_idx == 3'd7) begin char_col_idx <= 0; if (char_ptr == TOTAL_CHARS - 1) char_ptr <= 0; else char_ptr <= char_ptr + 1; end else begin char_col_idx <= char_col_idx + 1; end end if (frame_done) begin eng_state <= ENG_WRITE; wr_cnt <= 0; end end ENG_WRITE: begin if (wr_cnt < NUM_LEDS) begin wr_cnt <= wr_cnt + 1; end else begin led_wr_en <= 0; eng_state <= ENG_RUN; end end endcase end end // 组合逻辑：把链式地址换算成屏幕坐标，再取出对应像素的显示颜色 reg [23:0] next_rgb; reg next_wr_en; always @(*) begin if (eng_state == ENG_WRITE && wr_cnt < NUM_LEDS) begin next_wr_en = 1'b1; next_rgb = 24'h000000; // 蛇形走线映射：col = n/8, row_index = n%8 // 偶数列正序，奇数列反序 case (wr_cnt[2:0]) 3'd0: begin if (wr_cnt[5:3][0] == 0) next_rgb = scr[wr_cnt[7:3]][7] ? 24'h18FF00 : 24'h000000; else next_rgb = scr[wr_cnt[7:3]][0] ? 24'h18FF00 : 24'h000000; end 3'd1: begin if (wr_cnt[5:3][0] == 0) next_rgb = scr[wr_cnt[7:3]][6] ? 24'h18FF00 : 24'h000000; else next_rgb = scr[wr_cnt[7:3]][1] ? 24'h18FF00 : 24'h000000; end 3'd2: begin if (wr_cnt[5:3][0] == 0) next_rgb = scr[wr_cnt[7:3]][5] ? 24'h18FF00 : 24'h000000; else next_rgb = scr[wr_cnt[7:3]][2] ? 24'h18FF00 : 24'h000000; end 3'd3: begin if (wr_cnt[5:3][0] == 0) next_rgb = scr[wr_cnt[7:3]][4] ? 24'h18FF00 : 24'h000000; else next_rgb = scr[wr_cnt[7:3]][3] ? 24'h18FF00 : 24'h000000; end 3'd4: begin if (wr_cnt[5:3][0] == 0) next_rgb = scr[wr_cnt[7:3]][3] ? 24'h18FF00 : 24'h000000; else next_rgb = scr[wr_cnt[7:3]][4] ? 24'h18FF00 : 24'h000000; end 3'd5: begin if (wr_cnt[5:3][0] == 0) next_rgb = scr[wr_cnt[7:3]][2] ? 24'h18FF00 : 24'h000000; else next_rgb = scr[wr_cnt[7:3]][5] ? 24'h18FF00 : 24'h000000; end 3'd6: begin if (wr_cnt[5:3][0] == 0) next_rgb = scr[wr_cnt[7:3]][1] ? 24'h18FF00 : 24'h000000; else next_rgb = scr[wr_cnt[7:3]][6] ? 24'h18FF00 : 24'h000000; end 3'd7: begin if (wr_cnt[5:3][0] == 0) next_rgb = scr[wr_cnt[7:3]][0] ? 24'h18FF00 : 24'h000000; else next_rgb = scr[wr_cnt[7:3]][7] ? 24'h18FF00 : 24'h000000; end endcase end else begin next_wr_en = 0; next_rgb = 24'h000000; end end always @(posedge clk) begin led_wr_en <= next_wr_en; led_rgb <= next_rgb; if (eng_state == ENG_WRITE && wr_cnt < NUM_LEDS) led_addr <= wr_cnt; end // 字模ROM查询函数，返回一列的8bit数据，bit7为最上行 function [7:0] char_rom_lookup; input [3:0] char_index; input [2:0] col; begin case (char_index) 0: case (col) // F 0: char_rom_lookup = 8'h7E; 1: char_rom_lookup = 8'h40; 2: char_rom_lookup = 8'h40; 3: char_rom_lookup = 8'h78; 4: char_rom_lookup = 8'h40; 5: char_rom_lookup = 8'h40; 6: char_rom_lookup = 8'h40; 7: char_rom_lookup = 8'h00; endcase 1: case (col) // P 0: char_rom_lookup = 8'h7C; 1: char_rom_lookup = 8'h42; 2: char_rom_lookup = 8'h42; 3: char_rom_lookup = 8'h7C; 4: char_rom_lookup = 8'h40; 5: char_rom_lookup = 8'h40; 6: char_rom_lookup = 8'h40; 7: char_rom_lookup = 8'h00; endcase 2: case (col) // G 0: char_rom_lookup = 8'h3C; 1: char_rom_lookup = 8'h42; 2: char_rom_lookup = 8'h40; 3: char_rom_lookup = 8'h40; 4: char_rom_lookup = 8'h4E; 5: char_rom_lookup = 8'h42; 6: char_rom_lookup = 8'h3C; 7: char_rom_lookup = 8'h00; endcase 3: case (col) // A 0: char_rom_lookup = 8'h00; 1: char_rom_lookup = 8'h3E; 2: char_rom_lookup = 8'h50; 3: char_rom_lookup = 8'h90; 4: char_rom_lookup = 8'h90; 5: char_rom_lookup = 8'h50; 6: char_rom_lookup = 8'h3E; 7: char_rom_lookup = 8'h00; endcase 4: case (col) // 空格 0: char_rom_lookup = 8'h00; 1: char_rom_lookup = 8'h00; 2: char_rom_lookup = 8'h00; 3: char_rom_lookup = 8'h00; 4: char_rom_lookup = 8'h00; 5: char_rom_lookup = 8'h00; 6: char_rom_lookup = 8'h00; 7: char_rom_lookup = 8'h00; endcase 5: case (col) // O 0: char_rom_lookup = 8'h3C; 1: char_rom_lookup = 8'h42; 2: char_rom_lookup = 8'h42; 3: char_rom_lookup = 8'h42; 4: char_rom_lookup = 8'h42; 5: char_rom_lookup = 8'h42; 6: char_rom_lookup = 8'h3C; 7: char_rom_lookup = 8'h00; endcase 6: case (col) // K 0: char_rom_lookup = 8'h42; 1: char_rom_lookup = 8'h44; 2: char_rom_lookup = 8'h48; 3: char_rom_lookup = 8'h70; 4: char_rom_lookup = 8'h48; 5: char_rom_lookup = 8'h44; 6: char_rom_lookup = 8'h42; 7: char_rom_lookup = 8'h00; endcase 7: case (col) // 空格 0: char_rom_lookup = 8'h00; 1: char_rom_lookup = 8'h00; 2: char_rom_lookup = 8'h00; 3: char_rom_lookup = 8'h00; 4: char_rom_lookup = 8'h00; 5: char_rom_lookup = 8'h00; 6: char_rom_lookup = 8'h00; 7: char_rom_lookup = 8'h00; endcase endcase end endfunction endmodule

5.4 字模ROM的设计与扩展

代码里的char_rom_lookup是核心的字模数据表。这里演示了F、P、G、A、空格、O、K这几个字符。实际项目中，你需要用取模软件生成完整的字库，然后把这些数据填进case语句。

我用的取模方式是纵向取模，也就是每个字节对应字符的一列。生成的时候，软件设置要选“纵向取模、字节倒序、非反码”，这样生成出来的数据可以直接填进这个函数。如果你不熟悉取模软件，也可以自己用文本画一个8x8的点阵，然后按列提取bit，人工整理成8个字节。虽然慢一点，但对理解字模原理非常有帮助。

要扩展字符串内容，你只需要增加TOTAL_CHARS参数，并在case语句里增加新的字符索引和对应的列数据。滚动引擎会自动按顺序循环播放这些字符。

6. 常见问题与调试避坑实录

6.1 时序参数为什么不能照抄

网上很多WS2812B驱动代码的时序参数是“能用就行”，比如0码高电平给300ns，1码高电平给800ns，这些参数不一定能在不同批次灯珠上稳定工作。我建议你计算一下自己的时钟周期，核对芯片手册的容差范围，而不是直接复制参数。

我给的50MHz参数是360ns和700ns，在规格范围内。但如果你换了12MHz、100MHz或者其他晶振频率，必须重新换算。比如用100MHz时钟，一个周期10ns，0码高电平就是36拍，1码高电平就是70拍。公式很简单，但要养成自己算的习惯。

6.2 电源是很多问题的根源

我第一次上电测试的时候，整块屏花得没法看。一开始以为是时序问题，后来发现是电源压降导致灯珠工作不稳定。USB供电线太细，点亮的灯一多，远端灯珠的供电电压掉到4.2V以下，信号逻辑全部乱套。

排查方法是：接上足够粗的5V电源线，在点阵的电源输入端并联470uF电容，然后观察是否复现。如果问题消失，基本就是供电不足。还有一种情况是首灯附近电压正常，但后面的灯亮度明显变暗，这种也是压降问题，需要在灯带的中间和末端多接几根电源线。

6.3 映射错误导致显示错乱

如果滚动方向错乱、字符左右镜像、上下颠倒，基本都是坐标映射的问题。我遇到过最典型的情况是：字模看起来是反的，检查了半天发现取模软件生成的bit序和我的屏列序不一致。

解决办法是写一个简单的测试模式：让屏幕按顺序从左上角向右下角点亮，观察点亮的顺序。再用一个8x8的小块验证几个坐标点，就能快速定位是正向还是反向，是行优先还是列优先。

6.4 综合仿真与上板验证注意点

这个项目用Vivado和Quartus都能直接综合。我建议先跑行为仿真，重点观察WS2812B驱动模块的状态切换和dout波形，确认0码和1码的时间符合预期。仿真通过后再上板，不要直接盲调信号。

上板时，记得给数据输出引脚做管脚约束和电平标准约束。如果FPGA的IO标准使用LVCMOS33，但WS2812B需要5V，板级转换电路一定要接好。另外在综合报告里留意一下资源占用，256颗灯的led_buffer如果用distributed RAM，资源占用影响不大，但如果灯珠数量上万，还是考虑用Block RAM承载缓冲区。

6.5 调试工具的选择

调试WS2812B协议，示波器是最好用的工具。没有示波器的话，逻辑分析仪也能凑合，但是要注意采样率必须足够高，至少要能分辨出360ns和700ns的高电平区别。

如果手头什么仪器都没有，可以写一个自检代码：先把所有灯设置为纯红色，再设置为纯绿色，最后设置为纯蓝色，每两秒切换一次。如果这三种纯色都正常，说明基本时序通路没问题；如果颜色混乱，大概率是GRB顺序写反了。

7. 项目扩展方向

这个项目做完之后，往下的扩展空间很大。最直接的改进是把颜色做成可配置的，比如用按键切换字符颜色，或者让不同的字符显示不同颜色。再往上一步，可以在滚动引擎里加一个显示模式切换状态机，支持静止显示、闪烁、逐字弹出、双色交替等效果。

性能方向也有文章可做。当前是单路输出256颗灯，帧率128Hz。如果你想要更大的屏，比如8x64或者16x32，单链帧率会下降。FPGA的优势这时候就体现出来了：你可以把灯带分成两路或者四路，用多个IO同时发送数据，每路分担一部分灯珠，帧率就能维持在60Hz以上。

再进一步，可以给系统加UART接口，用上位机实时修改要显示的字符串。这需要设计一个简单的命令帧格式，比如帧头加长度加数据，滚动引擎从FIFO里读字符。这就把通信协议和数据通路设计也串进来了，项目的综合度会更高。

还有一个方向是把字模换成汉字。8x8点阵太小，显示汉字至少需要16x16点阵。这样屏幕宽度要增加，行数也要加倍，缓冲区从8bit扩展成16bit。实现思路上完全兼容，只是数据宽度和映射逻辑需要调整。

我个人的体会是，这个项目最值得研究的不是WS2812B灯珠本身，而是“驱动慢速外设时如何处理数据生成和数据发送的速度差异”这个问题。滚动引擎是慢速侧，WS2812B发送是快速侧，二者通过led_buffer解耦，用frame_done握手。这个模式在以后的串口、以太网、视频输出项目里会反复出现。把这个结构想明白，比背一百个例程都管用。

最后再分享一个小技巧：写完代码先别急着上板，把所有状态机的状态编码、握手信号、tick周期都打印在仿真波形里，逐帧对齐看一遍。整个数据链路从滚动引擎到led_buffer再到dout波形串起来看，逻辑对错一清二楚。上板之后反而不好查，因为你不知道是在哪一级断掉的。仿真阶段多花半小时，上板调试能省半天。