第十一章 UART 实验

串口实验，异步串行通信，异步串行是指UART（Universal Asynchronous Receiver/Transmitter），通用异步接收/发送。
使用PL每秒钟向外部发送数据，同时将收到的数据也发送出去即回环。

实验原理

异步串口通信协议
消息帧从一个低位起始位开始，后面是7 个或8 个数据位，一个可用的奇偶位和一个或几个高位停止位。接收器发现开始位时它就知道数据准备发送，并尝试与发送器时钟频率同步。
奇偶校验用于检验传输是否出差。
时序图如下，注意该图只常用的设计时序，实际还可能相反，比如（高电平为0，低电平为1，默认为低电平，RS232）。
一个消息帧只传输8个字节以下的数据，在起始位进行时钟同步，根据波特率进行数据采样。

根据传输协议，需要根据起始位进行数据的传输。

实验步骤

这里尝试使用软件工程的思想去进行描述，学习下软件工程。

需求分析

为了加深用户对verilog语言和串口知识的掌握，需要使用开发板实现一个“伪”回环的串口，实现功能如下：

1. 串口数据为8位，停止位为1位。
2. 每秒向外发送“HELLO ALINX”字符串。
3. 串口将收到的数据发送回去，实现回环的功能。

概要设计

模块设计

开发板对外的接口是一个micro-usb的接口，可简单理解为一个两条线（发送tx，接收rx）的串口，时钟是一个200MHz的差分时钟，一个复位按钮，电平默认为高，按下为低。
一共划分为3个模块，数据接收模块，数据发送模块，数据处理模块。
数据接收模块实现对硬件接收管脚的采样，完成对串口数据的接收。
数据发送模块实现将数据按串口协议通过发送管脚发送出去的功能。
数据处理模块负责每秒钟向外发送字符串，将接收数据发送出去的功能。
其中，数据处理模块调用数据接收模块和数据发送模块，数据接收模块和数据发送模块相互独立。
各个模块的接口设计其实也比较简单。在verilog中，时钟是驱动模块的灵魂，复位是保证模块正常工作的基础，因此在设计中这两个是不可或缺的。还有硬件的物理管脚也需要加上去。除了这些不可以改变的，剩下的主要是一些控制信号，由开发者自行设计。
数据接收模块设计接口如下，clk、rst_n为时钟和复位信号，rx_pin为硬件接收接口，rx_data存放接收到的数据，rx_data_valid用来表示接收数据是否有效，rx_data_ready表示后端是否已将数据接收，如果接收了才可正常进行下一个数据的采样。参数CLK_FRE、BAUD_RATE用来表示输入时钟频率和需要的波特率，增加模块的可移植性。

module uart_rx
#(
	parameter CLK_FRE = 50,      //clock frequency(Mhz)
	parameter BAUD_RATE = 115200 //serial baud rate
)
(
	input                        clk,              //clock input
	input                        rst_n,            //asynchronous reset input, low active 
	output reg[7:0]              rx_data,          //received serial data
	output reg                   rx_data_valid,    //received serial data is valid
	input                        rx_data_ready,    //data receiver module ready
	input                        rx_pin            //serial data input
);

数据发送模块的设计接口如下，clk为输入时钟，rst_n为输入复位信号，tx_data为输入发送数据寄存器，tx_data_valid为输入发送有效信号，tx_data_ready为输出发送准备信号（为高时表示可以进行数据的发送），tx_pin为输出发送管脚。

module uart_tx
#(
	parameter CLK_FRE = 50,      //clock frequency(Mhz)
	parameter BAUD_RATE = 115200 //serial baud rate
)
(
	input                        clk,              //clock input
	input                        rst_n,            //asynchronous reset input, low active 
	input[7:0]                   tx_data,          //data to send
	input                        tx_data_valid,    //data to be sent is valid
	output reg                   tx_data_ready,    //send ready
	output                       tx_pin            //serial data output
);

数据处理模块的设计接口如下，sys_clk_p、sys_clk_n为输入差分时钟，rst_n为输入复位信号，uart_rx为输入接收管脚，uart_tx为输出发送管脚。

module uart_test(
    input      					 sys_clk_p,            //system clock 200Mhz postive pin
	input      					 sys_clk_n,            //system clock 200Mhz negetive pin 
    input                        rst_n,        //reset ,low active
	input                        uart_rx,
	output                       uart_tx
);

详细设计

详细设计前面概要设计中的各个模块。

数据接收模块

#mermaid-svg-7FEQ0SqAnPSZ7F1F {font-family:“trebuchet ms”,verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .error-icon{fill:#552222;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .edge-thickness-normal{stroke-width:2px;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .marker{fill:#333333;stroke:#333333;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .marker.cross{stroke:#333333;}#mermaid-svg-7FEQ0SqAnPSZ7F1F svg{font-family:“trebuchet ms”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-7FEQ0SqAnPSZ7F1F defs #statediagram-barbEnd{fill:#333333;stroke:#333333;}#mermaid-svg-7FEQ0SqAnPSZ7F1F g.stateGroup text{fill:#9370DB;stroke:none;font-size:10px;}#mermaid-svg-7FEQ0SqAnPSZ7F1F g.stateGroup text{fill:#333;stroke:none;font-size:10px;}#mermaid-svg-7FEQ0SqAnPSZ7F1F g.stateGroup .state-title{font-weight:bolder;fill:#131300;}#mermaid-svg-7FEQ0SqAnPSZ7F1F g.stateGroup rect{fill:#ECECFF;stroke:#9370DB;}#mermaid-svg-7FEQ0SqAnPSZ7F1F g.stateGroup line{stroke:#333333;stroke-width:1;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .transition{stroke:#333333;stroke-width:1;fill:none;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .stateGroup .composit{fill:white;border-bottom:1px;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .stateGroup .alt-composit{fill:#e0e0e0;border-bottom:1px;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .state-note{stroke:#aaaa33;fill:#fff5ad;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .state-note text{fill:black;stroke:none;font-size:10px;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .stateLabel .box{stroke:none;stroke-width:0;fill:#ECECFF;opacity:0.5;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .edgeLabel .label rect{fill:#ECECFF;opacity:0.5;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .edgeLabel .label text{fill:#333;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .label div .edgeLabel{color:#333;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .stateLabel text{fill:#131300;font-size:10px;font-weight:bold;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .node circle.state-start{fill:#333333;stroke:#333333;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .node .fork-join{fill:#333333;stroke:#333333;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .node circle.state-end{fill:#9370DB;stroke:white;stroke-width:1.5;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .end-state-inner{fill:white;stroke-width:1.5;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .node rect{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .node polygon{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-7FEQ0SqAnPSZ7F1F #statediagram-barbEnd{fill:#333333;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .statediagram-cluster rect{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .cluster-label,#mermaid-svg-7FEQ0SqAnPSZ7F1F .nodeLabel{color:#131300;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .statediagram-cluster rect.outer{rx:5px;ry:5px;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .statediagram-state .divider{stroke:#9370DB;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .statediagram-state .title-state{rx:5px;ry:5px;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .statediagram-cluster.statediagram-cluster .inner{fill:white;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .statediagram-cluster.statediagram-cluster-alt .inner{fill:#f0f0f0;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .statediagram-cluster .inner{rx:0;ry:0;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .statediagram-state rect.basic{rx:5px;ry:5px;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .statediagram-state rect.divider{stroke-dasharray:10,10;fill:#f0f0f0;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .note-edge{stroke-dasharray:5;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .statediagram-note rect{fill:#fff5ad;stroke:#aaaa33;stroke-width:1px;rx:0;ry:0;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .statediagram-note rect{fill:#fff5ad;stroke:#aaaa33;stroke-width:1px;rx:0;ry:0;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .statediagram-note text{fill:black;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .statediagram-note .nodeLabel{color:black;}#mermaid-svg-7FEQ0SqAnPSZ7F1F .statediagram .edgeLabel{color:red;}#mermaid-svg-7FEQ0SqAnPSZ7F1F #dependencyStart,#mermaid-svg-7FEQ0SqAnPSZ7F1F #dependencyEnd{fill:#333333;stroke:#333333;stroke-width:1;}#mermaid-svg-7FEQ0SqAnPSZ7F1F :root{–mermaid-font-family:“trebuchet ms”,verdana,arial,sans-serif;}

下降沿

等待1bit

接收8bit数据

停止位，等待0.5bit

S_IDLE

S_START

S_REC_BYTE

S_STOP

S_DATA

上电进入S_IDLE空闲状态，下降沿到来到S_START起始位状态，等待1bit的停止位，开始接收数据S_REV_BYTE，接收（采样）8个数据位进入停止位S_STOP，等待0.5bit后发送数据到其他模块S_DATA，后端接收数据后再次进入空闲状态。这里主要的难点是各个状态之间的转移关系。

起始位检测设计

这里串口的起始位为下降沿，主要是边沿判断，这一需要记录电平的两个状态，当前一个状态为1，后一个状态为0时，则表示下降沿到来。这是要注意在时间上前一个状态为旧的，后一个状态为新的。可以使用两个rx_d0、rx_d1寄存器来实现，rx_d0记录输入管脚最新的电平，rx_d1用来保存rx_d0上次的电平，只要rx_d1&&~rx_d0为真时，表明下降沿到来。

reg                              rx_d0;            //delay 1 clock for rx_pin
reg                              rx_d1;            //delay 1 clock for rx_d0
assign rx_negedge = rx_d1 && ~rx_d0;
always@(posedge clk or negedge rst_n)
begin
	if(rst_n == 1'b0)
	begin
		rx_d0 <= 1'b0;
		rx_d1 <= 1'b0;	
	end
	else
	begin
		rx_d0 <= rx_pin;
		rx_d1 <= rx_d0;
	end
end

时钟周期计数设计

模块中需要等待固定的时间，比如1个bit、0.5个bit，这里计数一个bit位需要的时钟周期数（从这个方面来看的话，串口是不是用频率高的时钟实现一个频率低的数据，接收数据就是用频率高的时钟去采样、还原数据的过程）。
使用一个16位的寄存器cycle_cnt来进行计数，计数周期根据输入时钟CLK_FRE和波特率BAUD_RATE进行计算即一个bit占用的时钟周期数为CYCLE = CLK_FRE * 1000000 / BAUD_RATE。
复位有效时，寄存器清零。
当状态发生变化时，也进行清零操作。接收数据时需要接收8位，因此在周期到头时也进行清零。
其余时间进行递增即可。

localparam                       CYCLE = CLK_FRE * 1000000 / BAUD_RATE;
reg[15:0]                        cycle_cnt;        //baud counter
always@(posedge clk or negedge rst_n)
begin
	if(rst_n == 1'b0)
		cycle_cnt <= 16'd0;
	else if((state == S_REC_BYTE && cycle_cnt == CYCLE - 1) || next_state != state)
		cycle_cnt <= 16'd0;
	else
		cycle_cnt <= cycle_cnt + 16'd1;	
end

接收位计数设计

接收数据时需要接收特定bit位时才可结束，同时保存数据时也需要知道当前的处理的位数。
由于只有8位，使用一个3位的寄存器进行计数。在接收数据状态时进行计数，当时钟周期数到最大时寄存器递增1，否则保持即可。其余状态为0。

reg[2:0]                         bit_cnt;          //bit counter
always@(posedge clk or negedge rst_n)
begin
	if(rst_n == 1'b0)
		begin
			bit_cnt <= 3'd0;
		end
	else if(state == S_REC_BYTE)
		if(cycle_cnt == CYCLE - 1)
			bit_cnt <= bit_cnt + 3'd1;
		else
			bit_cnt <= bit_cnt;
	else
		bit_cnt <= 3'd0;
end

数据采样设计

在数据接收状态进行工作，使用一个8bit的寄存器rx_bits来保存采样数据，同时在时钟周期计数的中点进行采样以避免出错。

reg[7:0]                         rx_bits;          //temporary storage of received data
//receive serial data bit data
always@(posedge clk or negedge rst_n)
begin
	if(rst_n == 1'b0)
		rx_bits <= 8'd0;
	else if(state == S_REC_BYTE && cycle_cnt == CYCLE/2 - 1)
		rx_bits[bit_cnt] <= rx_pin;
	else
		rx_bits <= rx_bits; 
end

数据输出设计

将采样的数据进行输出，在即将从停止状态转为数据状态时，将数据输出到tx_data寄存器，同时将接收数据有效信号rx_data_valid置为高，告诉后端模块已经有数据。后端读取数据之后要将rx_data_ready拉高一下，使状态机从数据状态退出。

always@(posedge clk or negedge rst_n)
begin
	if(rst_n == 1'b0)
		rx_data_valid <= 1'b0;
	else if(state == S_STOP && next_state != state)
		rx_data_valid <= 1'b1;
	else if(state == S_DATA && rx_data_ready)
		rx_data_valid <= 1'b0;
end

always@(posedge clk or negedge rst_n)
begin
	if(rst_n == 1'b0)
		rx_data <= 8'd0;
	else if(state == S_STOP && next_state != state)
		rx_data <= rx_bits;//latch received data
end

状态机设计

算上前面的，应该是三段式的写法。第一段现态，第二段次态，第三段输出。

always@(posedge clk or negedge rst_n)
begin
	if(rst_n == 1'b0)
		state <= S_IDLE;
	else
		state <= next_state;
end

always@(*)
begin
	case(state)
		S_IDLE:
			if(rx_negedge)
				next_state <= S_START;
			else
				next_state <= S_IDLE;
		S_START:
			if(cycle_cnt == CYCLE - 1)//one data cycle 
				next_state <= S_REC_BYTE;
			else
				next_state <= S_START;
		S_REC_BYTE:
			if(cycle_cnt == CYCLE - 1  && bit_cnt == 3'd7)  //receive 8bit data
				next_state <= S_STOP;
			else
				next_state <= S_REC_BYTE;
		S_STOP:
			if(cycle_cnt == CYCLE/2 - 1)//half bit cycle,to avoid missing the next byte receiver
				next_state <= S_DATA;
			else
				next_state <= S_STOP;
		S_DATA:
			if(rx_data_ready)    //data receive complete
				next_state <= S_IDLE;
			else
				next_state <= S_DATA;
		default:
			next_state <= S_IDLE;
	endcase
end

数据发送模块

#mermaid-svg-CE1XBPwXOUuIPjPU {font-family:“trebuchet ms”,verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-CE1XBPwXOUuIPjPU .error-icon{fill:#552222;}#mermaid-svg-CE1XBPwXOUuIPjPU .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-CE1XBPwXOUuIPjPU .edge-thickness-normal{stroke-width:2px;}#mermaid-svg-CE1XBPwXOUuIPjPU .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-CE1XBPwXOUuIPjPU .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-CE1XBPwXOUuIPjPU .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-CE1XBPwXOUuIPjPU .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-CE1XBPwXOUuIPjPU .marker{fill:#333333;stroke:#333333;}#mermaid-svg-CE1XBPwXOUuIPjPU .marker.cross{stroke:#333333;}#mermaid-svg-CE1XBPwXOUuIPjPU svg{font-family:“trebuchet ms”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-CE1XBPwXOUuIPjPU defs #statediagram-barbEnd{fill:#333333;stroke:#333333;}#mermaid-svg-CE1XBPwXOUuIPjPU g.stateGroup text{fill:#9370DB;stroke:none;font-size:10px;}#mermaid-svg-CE1XBPwXOUuIPjPU g.stateGroup text{fill:#333;stroke:none;font-size:10px;}#mermaid-svg-CE1XBPwXOUuIPjPU g.stateGroup .state-title{font-weight:bolder;fill:#131300;}#mermaid-svg-CE1XBPwXOUuIPjPU g.stateGroup rect{fill:#ECECFF;stroke:#9370DB;}#mermaid-svg-CE1XBPwXOUuIPjPU g.stateGroup line{stroke:#333333;stroke-width:1;}#mermaid-svg-CE1XBPwXOUuIPjPU .transition{stroke:#333333;stroke-width:1;fill:none;}#mermaid-svg-CE1XBPwXOUuIPjPU .stateGroup .composit{fill:white;border-bottom:1px;}#mermaid-svg-CE1XBPwXOUuIPjPU .stateGroup .alt-composit{fill:#e0e0e0;border-bottom:1px;}#mermaid-svg-CE1XBPwXOUuIPjPU .state-note{stroke:#aaaa33;fill:#fff5ad;}#mermaid-svg-CE1XBPwXOUuIPjPU .state-note text{fill:black;stroke:none;font-size:10px;}#mermaid-svg-CE1XBPwXOUuIPjPU .stateLabel .box{stroke:none;stroke-width:0;fill:#ECECFF;opacity:0.5;}#mermaid-svg-CE1XBPwXOUuIPjPU .edgeLabel .label rect{fill:#ECECFF;opacity:0.5;}#mermaid-svg-CE1XBPwXOUuIPjPU .edgeLabel .label text{fill:#333;}#mermaid-svg-CE1XBPwXOUuIPjPU .label div .edgeLabel{color:#333;}#mermaid-svg-CE1XBPwXOUuIPjPU .stateLabel text{fill:#131300;font-size:10px;font-weight:bold;}#mermaid-svg-CE1XBPwXOUuIPjPU .node circle.state-start{fill:#333333;stroke:#333333;}#mermaid-svg-CE1XBPwXOUuIPjPU .node .fork-join{fill:#333333;stroke:#333333;}#mermaid-svg-CE1XBPwXOUuIPjPU .node circle.state-end{fill:#9370DB;stroke:white;stroke-width:1.5;}#mermaid-svg-CE1XBPwXOUuIPjPU .end-state-inner{fill:white;stroke-width:1.5;}#mermaid-svg-CE1XBPwXOUuIPjPU .node rect{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-CE1XBPwXOUuIPjPU .node polygon{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-CE1XBPwXOUuIPjPU #statediagram-barbEnd{fill:#333333;}#mermaid-svg-CE1XBPwXOUuIPjPU .statediagram-cluster rect{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-CE1XBPwXOUuIPjPU .cluster-label,#mermaid-svg-CE1XBPwXOUuIPjPU .nodeLabel{color:#131300;}#mermaid-svg-CE1XBPwXOUuIPjPU .statediagram-cluster rect.outer{rx:5px;ry:5px;}#mermaid-svg-CE1XBPwXOUuIPjPU .statediagram-state .divider{stroke:#9370DB;}#mermaid-svg-CE1XBPwXOUuIPjPU .statediagram-state .title-state{rx:5px;ry:5px;}#mermaid-svg-CE1XBPwXOUuIPjPU .statediagram-cluster.statediagram-cluster .inner{fill:white;}#mermaid-svg-CE1XBPwXOUuIPjPU .statediagram-cluster.statediagram-cluster-alt .inner{fill:#f0f0f0;}#mermaid-svg-CE1XBPwXOUuIPjPU .statediagram-cluster .inner{rx:0;ry:0;}#mermaid-svg-CE1XBPwXOUuIPjPU .statediagram-state rect.basic{rx:5px;ry:5px;}#mermaid-svg-CE1XBPwXOUuIPjPU .statediagram-state rect.divider{stroke-dasharray:10,10;fill:#f0f0f0;}#mermaid-svg-CE1XBPwXOUuIPjPU .note-edge{stroke-dasharray:5;}#mermaid-svg-CE1XBPwXOUuIPjPU .statediagram-note rect{fill:#fff5ad;stroke:#aaaa33;stroke-width:1px;rx:0;ry:0;}#mermaid-svg-CE1XBPwXOUuIPjPU .statediagram-note rect{fill:#fff5ad;stroke:#aaaa33;stroke-width:1px;rx:0;ry:0;}#mermaid-svg-CE1XBPwXOUuIPjPU .statediagram-note text{fill:black;}#mermaid-svg-CE1XBPwXOUuIPjPU .statediagram-note .nodeLabel{color:black;}#mermaid-svg-CE1XBPwXOUuIPjPU .statediagram .edgeLabel{color:red;}#mermaid-svg-CE1XBPwXOUuIPjPU #dependencyStart,#mermaid-svg-CE1XBPwXOUuIPjPU #dependencyEnd{fill:#333333;stroke:#333333;stroke-width:1;}#mermaid-svg-CE1XBPwXOUuIPjPU :root{–mermaid-font-family:“trebuchet ms”,verdana,arial,sans-serif;}

S_IDLE

S_START

S_SEND_BYTE

S_STOP

上电为空闲状态，有数据发送请求进入起始位，起始位结束后进行数据位发送，数据位完毕后发送停止位，停止位发送完毕后进入空闲状态。

时钟周期计数设计

和数据接收一样，数据发送每位的时间也需要精确计数。

数据发送设计

数据只能在空闲状态，或者停止位状态进行发送，是否可以发送数据由信号tx_data_ready决定。该信号表示当前模块是否空闲，是否可以进行数据的发送，在空闲状态且发送数据tx_data_valid无效时为1，或者数据发送停止位后为1。

always@(posedge clk or  negedge rst_n)
begin
	if(rst_n == 1'b0)
		begin
			tx_data_ready <= 1'b0;
		end
	else if(state == S_IDLE)
		if(tx_data_valid == 1'b1)
			tx_data_ready <= 1'b0;
		else
			tx_data_read <= 1'b1;
	else if(state == S_STOP && cycle_cnt == CYCLE-1
		tx_data_ready <= 1'b1;
end

数据锁存模块

在复位时候清零。
在空闲状态且发送数据tx_data_valid 有效的时候，将发送数据锁存到内部寄存器tx_data_latch 。（为什么要在内部使用一个寄存器，是可以提前准备发送的数据吗，流水线？）

reg[7:0]                         tx_data_latch; //latch data to send
always@(posedge clk or negedge rst_n)
begin
	if(rst_n == 1'b0)
		begin
			tx_data_latch <= 8'd0;
		end
	else if(state == S_IDLE && tx_data_valid == 1'b1)
			tx_data_latch <= tx_data;
		
end

时钟周期计数设计

和前面接收一样，计数一个波特的时间。在发送状态变化或者需要多次计数的时候进行清零，这里只有发送的时候需要多次计数，其余状态一个bit就够了。

always@(posedge clk or negedge rst_n)
begin
	if(rst_n == 1'b0)
		cycle_cnt <= 16'd0;
	else if((state == S_SEND_BYTE && cycle_cnt == CYCLE - 1) || next_state != state)
		cycle_cnt <= 16'd0;
	else
		cycle_cnt <= cycle_cnt + 16'd1;	
end

接收位计数设计

计数bit位数，便于发送。

always@(posedge clk or negedge rst_n)
begin
	if(rst_n == 1'b0)
		begin
			bit_cnt <= 3'd0;
		end
	else if(state == S_SEND_BYTE)
		if(cycle_cnt == CYCLE - 1)
			bit_cnt <= bit_cnt + 3'd1;
		else
			bit_cnt <= bit_cnt;
	else
		bit_cnt <= 3'd0;
end

数据发送设计

根据状态机的状态输出即可，空闲态或者停止位态输出高，起始位输出低，发送状态根据发送数据进行管脚的状态控制即可，注意这里是从最低位开始的（协议要求），默认状态也为高。

always@(posedge clk or negedge rst_n)
begin
	if(rst_n == 1'b0)
		tx_reg <= 1'b1;
	else
		case(state)
			S_IDLE,S_STOP:
				tx_reg <= 1'b1; 
			S_START:
				tx_reg <= 1'b0; 
			S_SEND_BYTE:
				tx_reg <= tx_data_latch[bit_cnt];
			default:
				tx_reg <= 1'b1; 
		endcase
end

状态机设计

和接收差不多，比较简单。

always@(posedge clk or negedge rst_n)
begin
	if(rst_n == 1'b0)
		state <= S_IDLE;
	else
		state <= next_state;
end

always@(*)
begin
	case(state)
		S_IDLE:
			if(tx_data_valid == 1'b1)
				next_state <= S_START;
			else
				next_state <= S_IDLE;
		S_START:
			if(cycle_cnt == CYCLE - 1)
				next_state <= S_SEND_BYTE;
			else
				next_state <= S_START;
		S_SEND_BYTE:
			if(cycle_cnt == CYCLE - 1  && bit_cnt == 3'd7)
				next_state <= S_STOP;
			else
				next_state <= S_SEND_BYTE;
		S_STOP:
			if(cycle_cnt == CYCLE - 1)
				next_state <= S_IDLE;
			else
				next_state <= S_STOP;
		default:
			next_state <= S_IDLE;
	endcase
end

数据处理模块

数据处理模块也使用了状态机。
空闲状态比较简单。
发送状态，这里发送的数据是指定数据，并不是串口数据的发送。主要是串口发送模块tx_data_valid和tx_data_ready 信号的处理。在指定的数据发送完之前tx_data_valid一直有效，当tx_data_ready有效的时候，表示可以开始下一个数据的发送，计数加1，等待数据发送完毕后进入等待状态。
等待状态，等待1s，如果有接收数据就把数据在被状态发送回去，1s后转回发送状态。rx_data_valid有效表示接收到一个数据，读取数据到tx_data，设置发送数据信号tx_data_valid有效，当tx_data_valid和tx_data_ready都有效的时候，表示该字节已经发送出去，设置发送数据信号tx_data_valid无效。

always@(posedge sys_clk or negedge rst_n)
begin
	if(rst_n == 1'b0)
	begin
		wait_cnt <= 32'd0;
		tx_data <= 8'd0;
		state <= IDLE;
		tx_cnt <= 8'd0;
		tx_data_valid <= 1'b0;
	end
	else
	case(state)
		IDLE:
			state <= SEND;
		SEND:
		begin
			wait_cnt <= 32'd0;
			tx_data <= tx_str;

			if(tx_data_valid == 1'b1 && tx_data_ready == 1'b1 && tx_cnt < 8'd12)//Send 12 bytes data
			begin
				tx_cnt <= tx_cnt + 8'd1; //Send data counter
			end
			else if(tx_data_valid && tx_data_ready)//last byte sent is complete
			begin
				tx_cnt <= 8'd0;
				tx_data_valid <= 1'b0;
				state <= WAIT;
			end
			else if(~tx_data_valid)
			begin
				tx_data_valid <= 1'b1;
			end
		end
		WAIT:
		begin
			wait_cnt <= wait_cnt + 32'd1;

			if(rx_data_valid == 1'b1)
			begin
				tx_data_valid <= 1'b1;
				tx_data <= rx_data;   // send uart received data
			end
			else if(tx_data_valid && tx_data_ready)
			begin
				tx_data_valid <= 1'b0;
			end
			else if(wait_cnt >= CLK_FRE * 1000000) // wait for 1 second
				state <= SEND;
		end
		default:
			state <= IDLE;
	endcase
end

实验记录

创建工程，按照前面的详细设计进行编码，生成bit，不再复述。

在线仿真

这里的仿真主要需要模拟一个数据的接收，时钟和数据的延时都由我们控制。

`timescale 1ns / 1ps
module vtf_uart_test;
	// Inputs
	reg sys_clk_p;
	wire sys_clk_n;
	reg rst_n;
	reg uart_rx;
	// Outputs
    wire uart_tx;
	// Instantiate the Unit Under Test (UUT)
    uart_test uut (
        .sys_clk_p					(sys_clk_p), 		
		.sys_clk_n					(sys_clk_n), 	
        .rst_n                      (rst_n              ),
        .uart_rx                    (uart_rx            ),
        .uart_tx                    (uart_tx            )

    );
	initial begin
		// Initialize Inputs
		sys_clk_p = 0;
		rst_n = 0;
		// Wait 1000 ns for global reset to finish
		#100;
          rst_n = 1;        
		// Add stimulus here
		#20000;
      //  $stop;
	 end
 
    always #2.5 sys_clk_p = ~ sys_clk_p;   //5ns一个周期，产生200MHz时钟源
	assign sys_clk_n = ~ sys_clk_p;
    parameter                        BPS_115200 = 8680;//每个比特的时间
    parameter                        SEND_DATA = 8'b1010_0011;//要发送的数据     
    
    integer i = 0;
      initial begin
        uart_rx = 1'b1;    //bus idle
        #1000 uart_rx = 1'b0;     //transmit start bit
        for (i=0;i<8;i=i+1)
        #BPS_115200 uart_rx = SEND_DATA[i];     //transmit data bit
        #BPS_115200 uart_rx = 1'b0;     //transmit stop bit
        #BPS_115200 uart_rx = 1'b1;     //bus idle
       end   
endmodule

不生成bit的时候也可以进行仿真，点击Run Simulation，也可以右键进行一些设置。



数据发送，发送计数可以看作下一个需要数据，在当前数据进入到串口发送模块就不管了，实际发送了13个。

数据接收，接收数据有效的时候表示有一个数据，但是这里是在数据发送状态，没去处理数据，相当于忽略了。而且这里的接收数据一直是0xa3，应该是因为数据接收模块会锁存一个接收的数据，rx_data是wire型的。

把接收的数据延时一些，与发送状态错过，再次仿真，可以看到数据被发送回去。

上板验证

在线加载，烧写到板子里面。使用串口调试助手可以进行收发数据的测试，这里用putty连接串口看打印信息。串口每秒打印指定的字符串，输入的数据会被接收到。

实验总结

本次实验使用fpga实现串口数据的解析和发送，掌握串口发送的时序。实现的本质是使用高频率的时钟进行采样。
简单使用了软件工程的一些思想，先进行功能的概要和详细设计，根据设计进行编码即可。不过在这里完全是对着源代码去写的，详细设计使用的也是源码，属实是先开枪后画靶。

问题记录

暂无。

TODO

能力暂时不够，后续有时间的话进行解决。

1. 三段式状态机怎么写，这里面的时钟是否有差1的问题？
2. 串口的发送和接收的控制信号是怎么控制的，连续发送或者接收的数据控制会不会有问题，特别是数据处理模块那里？
3. 现在发送和接收都需要前面模块的控制，能不能加上bram，后面直接从bram里面进行读取？
4. 添加ILA，在线加载的时候进行抓信号，确认下是否和仿真一致。
5. 查找一些关于信号采样与恢复的资料。

这两年，IT行业面临经济周期波动与AI产业结构调整的双重压力，确实有很多运维与网络工程师因企业缩编或技术迭代而暂时失业。

很多人都在提运维网工失业后就只能去跑滴滴送外卖了，但我想分享的是，对于运维人员来说，即便失业以后仍然有很多副业可以尝试。

运维网工测试副业方向

运维，千万不要再错过这些副业机会！

第一个是知识付费类副业：输出经验打造个人IP

在线教育平台讲师

操作路径：在慕课网、极客时间等平台开设《CCNA实战》《Linux运维从入门到精通》等课程，或与培训机构合作录制专题课。
收益模式：课程销售分成、企业内训。

技术博客与公众号运营

操作路径：撰写网络协议解析、故障排查案例、设备评测等深度文章，通过公众号广告、付费专栏及企业合作变现。
收益关键：每周更新2-3篇原创，结合SEO优化与社群运营。

第二个是技术类副业：深耕专业领域变现

企业网络设备配置与优化服务

操作路径：为中小型企业提供路由器、交换机、防火墙等设备的配置调试、性能优化及故障排查服务。可通过本地IT服务公司合作或自建线上接单平台获客。
收益模式：按项目收费或签订年度维护合同。

远程IT基础设施代维

操作路径：通过承接服务器监控、日志分析、备份恢复等远程代维任务。适合熟悉Zabbix、ELK等技术栈的工程师。
收益模式：按工时计费或包月服务。

网络安全顾问与渗透测试

操作路径：利用OWASP Top 10漏洞分析、Nmap/BurpSuite等工具，为企业提供漏洞扫描、渗透测试及安全加固方案。需考取CISP等认证提升资质。
收益模式：单次渗透测试报告收费；长期安全顾问年费。

比如不久前跟我一起聊天的一个粉丝，他自己之前是大四实习的时候做的运维，发现运维7*24小时待命受不了，就准备转网安，学了差不多2个月，然后开始挖漏洞，光是补天的漏洞奖励也有个四五千，他说自己每个月的房租和饭钱就够了。

为什么我会推荐你网安是运维人员的绝佳副业&转型方向?

1.你的经验是巨大优势: 你比任何人都懂系统、网络和架构。漏洞挖掘、内网渗透、应急响应，这些核心安全能力本质上是“攻击视角下的运维”。你的运维背景不是从零开始，而是降维打击。

2.越老越吃香，规避年龄危机: 安全行业极度依赖经验。你的排查思路、风险意识和对复杂系统的理解能力，会随着项目积累而愈发珍贵，真正做到“姜还是老的辣”。

3.职业选择极其灵活: 你可以加入企业成为安全专家，可以兼职“挖洞“获取丰厚奖金，甚至可以成为自由顾问。这种多样性为你提供了前所未有的抗风险能力。

4.市场需求爆发，前景广阔: 在国家级政策的推动下，从一线城市到二三线地区，安全人才缺口正在急剧扩大。现在布局，正是抢占未来先机的黄金时刻。

运维网工测试转行学习路线

（一）第一阶段：网络安全筑基

1. 阶段目标

你已经有运维经验了，所以操作系统、网络协议这些你不是零基础。但要学安全，得重新过一遍——只不过这次我们是带着“安全视角”去学。

2. 学习内容

**操作系统强化：**你需要重点学习 Windows、Linux 操作系统安全配置，对比运维工作中常规配置与安全配置的差异，深化系统安全认知（比如说日志审计配置，为应急响应日志分析打基础）。

**网络协议深化：**结合过往网络协议应用经验，聚焦 TCP/IP 协议簇中的安全漏洞及防护机制，如 ARP 欺骗、TCP 三次握手漏洞等（为 SRC 漏扫中协议层漏洞识别铺垫）。

**Web 与数据库基础：**补充 Web 架构、HTTP 协议及 MySQL、SQL Server 等数据库安全相关知识，了解 Web 应用与数据库在网安中的作用。

**编程语言入门：**学习 Python 基础语法，掌握简单脚本编写，为后续 SRC 漏扫自动化脚本开发及应急响应工具使用打基础。

**工具实战：**集中训练抓包工具（Wireshark）、渗透测试工具（Nmap）、漏洞扫描工具（Nessus 基础版）的使用，结合模拟场景练习工具应用（掌握基础扫描逻辑，为 SRC 漏扫工具进阶做准备）。

（二）第二阶段：漏洞挖掘与 SRC 漏扫实战

1. 阶段目标

这阶段是真正开始“动手”了。信息收集、漏洞分析、工具联动，一样不能少。

熟练运用漏洞挖掘及 SRC 漏扫工具，具备独立挖掘常见漏洞及 SRC 平台漏扫实战能力，尝试通过 SRC 挖洞搞钱，不管是低危漏洞还是高危漏洞，先挖到一个。

2. 学习内容

信息收集实战：结合运维中对网络拓扑、设备信息的了解，强化基本信息收集、网络空间搜索引擎（Shodan、ZoomEye）、域名及端口信息收集技巧，针对企业级网络场景开展信息收集练习（为 SRC 漏扫目标筛选提供支撑）。

漏洞原理与分析：深入学习 SQL 注入、CSRF、文件上传等常见漏洞的原理、危害及利用方法，结合运维工作中遇到的类似问题进行关联分析（明确 SRC 漏扫重点漏洞类型）。

工具进阶与 SRC 漏扫应用：

• 系统学习 SQLMap、BurpSuite、AWVS 等工具的高级功能，开展工具联用实战训练；

• 专项学习 SRC 漏扫流程：包括 SRC 平台规则解读（如漏洞提交规范、奖励机制）、漏扫目标范围界定、漏扫策略制定（全量扫描 vs 定向扫描）、漏扫结果验证与复现；

• 实战训练：使用 AWVS+BurpSuite 组合开展 SRC 平台目标漏扫，练习 “扫描 - 验证 - 漏洞报告撰写 - 平台提交” 全流程。
  SRC 实战演练：选择合适的 SRC 平台（如补天、CNVD）进行漏洞挖掘与漏扫实战，积累实战经验，尝试获取挖洞收益。

恭喜你，如果学到这里，你基本可以下班搞搞副业创收了，并且具备渗透测试工程师必备的「渗透技巧」、「溯源能力」，让你在黑客盛行的年代别背锅，工作实现升职加薪的同时也能开创副业创收！

如果你想要入坑黑客&网络安全，笔者给大家准备了一份：全网最全的网络安全资料包需要保存下方图片，微信扫码即可前往获取!

因篇幅有限，仅展示部分资料，需要点击下方链接即可前往获取

CSDN大礼包：《黑客&网络安全入门&进阶学习资源包》免费分享

（三）第三阶段：渗透测试技能学习

1. 阶段目标

全面掌握渗透测试理论与实战技能，能够独立完成渗透测试项目，编写规范的渗透测试报告，具备渗透测试工程师岗位能力，为护网红蓝对抗及应急响应提供技术支撑。

2. 学习内容

渗透测试核心理论：系统学习渗透测试流程、方法论及法律法规知识，明确渗透测试边界与规范（与红蓝对抗攻击边界要求一致）。

实战技能训练：开展漏洞扫描、漏洞利用、电商系统渗透测试、内网渗透、权限提升（Windows、Linux）、代码审计等实战训练，结合运维中熟悉的系统环境设计测试场景（强化红蓝对抗攻击端技术能力）。

工具开发实践：基于 Python 编程基础，学习渗透测试工具开发技巧，开发简单的自动化测试脚本（可拓展用于 SRC 漏扫自动化及应急响应辅助工具）。

报告编写指导：学习渗透测试报告的结构与编写规范，完成多个不同场景的渗透测试报告撰写练习（与 SRC 漏洞报告、应急响应报告撰写逻辑互通）。

（四）第四阶段：企业级安全攻防（含红蓝对抗）、应急响应

1. 阶段目标

掌握企业级安全攻防、护网红蓝对抗及应急响应核心技能，考取网安行业相关证书。

2. 学习内容

护网红蓝对抗专项：

• 红蓝对抗基础：学习护网行动背景、红蓝对抗规则（攻击范围、禁止行为）、红蓝双方角色职责（红队：模拟攻击；蓝队：防御检测与应急处置）；

• 红队实战技能：强化内网渗透、横向移动、权限维持、免杀攻击等高级技巧，模拟护网中常见攻击场景；

• 蓝队实战技能：学习安全设备（防火墙、IDS/IPS、WAF）联动防御配置、安全监控平台（SOC）使用、攻击行为研判与溯源方法；

• 模拟护网演练：参与团队式红蓝对抗演练，完整体验 “攻击 - 检测 - 防御 - 处置” 全流程。
  应急响应专项：

• 应急响应流程：学习应急响应 6 步流程（准备 - 检测 - 遏制 - 根除 - 恢复 - 总结），掌握各环节核心任务；

• 实战技能：开展操作系统入侵响应（如病毒木马清除、异常进程终止）、数据泄露应急处置、漏洞应急修补等实战训练；

• 工具应用：学习应急响应工具（如 Autoruns、Process Monitor、病毒分析工具）的使用，提升处置效率；

• 案例复盘：分析真实网络安全事件应急响应案例（如勒索病毒事件），总结处置经验。
  其他企业级攻防技能：学习社工与钓鱼、CTF 夺旗赛解析等内容，结合运维中企业安全防护需求深化理解。

证书备考：针对网安行业相关证书考试内容（含红蓝对抗、应急响应考点）进行专项复习，参加模拟考试，查漏补缺。

运维网工测试转行网络攻防知识库分享

网络安全这行，不是会几个工具就能搞定的。你得有体系，懂原理，能实战。尤其是从运维转过来的，别浪费你原来的经验——你比纯新人强多了。

但也要沉得住气，别学了两天Web安全就觉得自己是黑客了。内网、域渗透、代码审计、应急响应，要学的还多着呢。

如果你真的想转，按这个路子一步步走，没问题。如果你只是好奇，我劝你再想想——这行要持续学习，挺累的，但也是真有意思。

关于如何学习网络安全，笔者也给大家整理好了全套网络安全知识库，需要的可以扫码获取！

因篇幅有限，仅展示部分资料，需要点击下方链接即可前往获取

CSDN大礼包：《黑客&网络安全入门&进阶学习资源包》免费分享

1、网络安全意识

2、Linux操作系统

3、WEB架构基础与HTTP协议

4、Web渗透测试

5、渗透测试案例分享

6、渗透测试实战技巧

7、攻防对战实战

8、CTF之MISC实战讲解

关于如何学习网络安全，笔者也给大家整理好了全套网络安全知识库，需要的可以扫码获取！

因篇幅有限，仅展示部分资料，需要点击下方链接即可前往获取

CSDN大礼包：《黑客&网络安全入门&进阶学习资源包》免费分享