FPGA串口通信----uart（一）

最新推荐文章于 2024-08-09 22:00:08 发布
最新推荐文章于 2024-08-09 22:00:08 发布
阅读量315 收藏 10
点赞数 5
文章标签： fpga开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mvpkuku/article/details/137742055
版权

 一、Fpga--PLL锁相环的使用

通过PLL锁相环IP的使用，可以输入时钟进行分频，倍频，也可以产生多路时钟输出信号。

外部提供晶振的原因:①Fpga电路大多数需要时序分析

                                 ②晶振在Fpga内部占空间大，所以放置于外部PCB板上

Uart异步传输速率不能很快的原因：考虑到工程实际问题，假如时钟周期大（传输速率慢的话），采取到数据电平变化的边沿时刻的概率会小很多，这样数据也很准确，通常uart适用于2M.

二、Uart 发送

2.1 uart_byte_tx（字节发送）

2.1.1模块设计框图 

2.1.2 Verilog设计及仿真 

`timescale 1ns / 1ps
//
// Description:  UART 字节发送 
//
module uart_tx_byte(
    Clk			,
	Rst_n		,
  
	data_byte	,
	send_en		,   
	Baud_Set	,  
	
	uart_tx		,  
	Tx_Done		,   
	uart_state 
);

	input 		Clk 		;    //模块全局时钟输入，50M
	input 		Rst_n		;    //复位信号输入，低有效
	input [7:0]	data_byte	;    //待传输8bit数据
	input 		send_en		;    //发送使能
	input [2:0]	Baud_Set	;    //波特率设置
	
	output reg 	uart_tx		;  //串口输出信号
	output reg 	Tx_Done		;  //1byte数据发送完成标志
	output reg 	uart_state	;  //发送数据状态

	localparam START_BIT = 1'b0;
	localparam STOP_BIT  = 1'b1; 
	
	reg 		bps_clk		 ; //波特率时钟	
	reg [15:0]	div_cnt		 ; //分频计数器	
	reg [15:0]	bps_DR		 ; //分频计数最大值	
	reg [3:0]	bps_cnt		 ; //波特率时钟计数器	
	reg [7:0]	data_byte_reg; //data_byte寄存后数据

//******************** UART发送状态标志 ****************** \\
	always@(posedge Clk or negedge Rst_n)begin
		if(!Rst_n)
			uart_state <= 1'b0;
		else if(send_en)
			uart_state <= 1'b1;
		else if(bps_cnt >= 4'd11)
			uart_state <= 1'b0;
		else
			uart_state <= uart_state;
	end
//******************** 输入数据锁存 ****************** \\
	always@(posedge Clk or negedge Rst_n)begin
		if(!Rst_n)
			data_byte_reg <= 8'd0;
		else if(send_en)
			data_byte_reg <= data_byte;
		else
			data_byte_reg <= data_byte_reg;
	end

//******************** 波特率时钟的生成模块 ****************** \\
	always@(posedge Clk or negedge Rst_n)begin
		if(!Rst_n)
			bps_DR <= 16'd5207;
		else begin
			case(Baud_Set)
				0:bps_DR <= 16'd5207;  //波特率为9600      1_000_000_000/9600/20
				1:bps_DR <= 16'd2603;  //波特率为19200		
				2:bps_DR <= 16'd1301;  //波特率为38400
				3:bps_DR <= 16'd867;   //波特率为57600
				4:bps_DR <= 16'd433;   //波特率为115200
				default:bps_DR <= 16'd5207;			
			endcase
		end	
	end
	//counter
	always@(posedge Clk or negedge Rst_n)begin
		if(!Rst_n)
			div_cnt <= 16'd0;
		else if(uart_state)begin
			if(div_cnt >= bps_DR)
				div_cnt <= 16'd0;
			else
				div_cnt <= div_cnt + 1'b1;
		end
		else
			div_cnt <= 16'd0;
	end
	// bps_clk gen
	always@(posedge Clk or negedge Rst_n)begin
		if(!Rst_n)
			bps_clk <= 1'b0;
		else if(div_cnt == 16'd1)     //由于UART发送是从bps_cnt =1 发起始位，而不是从0，因此为了尽快进入发送模块，我们计数器不计满+1，等于一时+1
			bps_clk <= 1'b1;
		else
			bps_clk <= 1'b0;
	end
//******************** Uart的数据发送模块 ****************** \\
	//bps counter
	always@(posedge Clk or negedge Rst_n)begin
		if(!Rst_n)	
			bps_cnt <= 4'd0;
		else if(bps_cnt >= 4'd11)
			bps_cnt <= 4'd0;
		else if(bps_clk)
			bps_cnt <= bps_cnt + 1'b1;
		else
			bps_cnt <= bps_cnt;
	end	
	//数据发送
	always@(posedge Clk or negedge Rst_n)begin
		if(!Rst_n)
			uart_tx <= 1'b1;
		else begin
			case(bps_cnt)
				0:uart_tx <= 1'b1;
				1:uart_tx <= START_BIT;        // 从1开始，避免了起始位0与空闲态1冲突
				2:uart_tx <= data_byte_reg[0];
				3:uart_tx <= data_byte_reg[1];
				4:uart_tx <= data_byte_reg[2];
				5:uart_tx <= data_byte_reg[3];
				6:uart_tx <= data_byte_reg[4];
				7:uart_tx <= data_byte_reg[5];
				8:uart_tx <= data_byte_reg[6];
				9:uart_tx <= data_byte_reg[7];
				10:uart_tx <= STOP_BIT;
				default:uart_tx <= 1'b1;
			endcase
		end
	end	
	//数据发送完成标志 
	always@(posedge Clk or negedge Rst_n)begin
		if(!Rst_n)
			Tx_Done <= 1'b0;
		else if(bps_cnt >= 4'd11)
			Tx_Done <= 1'b1;
		else
			Tx_Done <= 1'b0;
	end	
endmodule

 由上图可知，uart发送先发低位再发高位（aa 10101010）

三、Uart接收 

3.1 uart_byte_rx （字节接收）

 3.1.1模块设计框图 

3.1.2 Verilog设计及仿真  

我们接收数据（1起始位+8数据位+1停止位）总共接受10个数据，为避免电磁等干扰，对每一个数据进行16等分，对数据中间进行采样7次，然后比较得出真值，因此总共需160个小数据段，因此bps_clk需要161个这样才能进行保证数据的完整性。 

verilog 文件
`timescale 1ns / 1ps
//
// Dependencies: UART字节接收
//
module uart_byte_rx(
    Clk     ,
    Reset_n ,
    Baud_Set,
    uart_rx ,
    Data    ,
    Rx_Done
);
   input            Clk     ;
   input            Reset_n ;
   input     [2:0]  Baud_Set;
   input            uart_rx ;
   output reg[7:0]  Data    ; 
   output reg       Rx_Done ;

	reg [1:0]   uart_rx_r   ;
    reg         RX_EN       ;
    reg [8:0]   Bps_DR      ; 
	reg [8:0]   div_cnt     ;
    reg         bps_clk_16x ; 
    reg [7:0]   bps_cnt     ;

//reg width name number/depth
    reg [2:0]   r_data[7:0];
    reg [2:0]   sta_bit;
    reg [2:0]   sto_bit;

    wire pedge_uart_rx;
//    assign pedge_uart_rx = ((uart_rx_r[1] == 0) && (uart_rx_r[0] == 1));
    wire nedge_uart_rx;
//    assign nedge_uart_rx = ((uart_rx_r[1] == 1) && (uart_rx_r[0] == 0)); 
//*******************  边沿检测(下降沿/上升沿)模块 ********************* \\
   always@(posedge Clk,negedge Reset_n)begin
        if(!Reset_n)
            uart_rx_r <= 'd0;
        else begin
            uart_rx_r[0] <= uart_rx;
            uart_rx_r[1] <= uart_rx_r[0] ;
        end
   end

    assign pedge_uart_rx = (uart_rx_r == 2'b01);
    assign nedge_uart_rx = (uart_rx_r == 2'b10);  
//*******************  Uart数据接收状态标志 ********************* \\    
    always@(posedge Clk or negedge Reset_n)begin
        if(!Reset_n) 
            RX_EN <= 0;
        else if(nedge_uart_rx)
            RX_EN <= 1;
        else if((bps_cnt == 'd160 && bps_clk_16x) || (sta_bit >= 4))// 起始位异常不产生RX_EN
            RX_EN <= 0;
        else
            RX_EN <= RX_EN;
    end   
//*******************  采样时钟(bps_clk_16x)产生模块 ********************* \\
    always@(posedge Clk or negedge Reset_n)begin
        if(!Reset_n)
            Bps_DR <= 16'd324;
        else begin
            case(Baud_Set)
                0:Bps_DR <= 16'd324; //波特率为9600      1_000_000_000/9600/20 /16
                1:Bps_DR <= 16'd162; //波特率为19200		
                2:Bps_DR <= 16'd80 ; //波特率为38400
                3:Bps_DR <= 16'd53 ; //波特率为57600
                4:Bps_DR <= 16'd26 ; //波特率为115200
                default:Bps_DR <= 16'd324; 
            endcase
        end
    end
    //counter
    always@(posedge Clk or negedge Reset_n)begin
        if(!Reset_n)    
            div_cnt <= 0;
        else if(RX_EN)begin
            if(div_cnt >= Bps_DR)
                div_cnt <= 0;
            else
                div_cnt <= div_cnt + 1'b1;
        end
        else
            div_cnt <= 0;
    end
    // bps_clk_16x gen
    always@(posedge Clk or negedge Reset_n)begin
        if(!Reset_n)
            bps_clk_16x <= 1'b0;
        else if(div_cnt == 16'd1)
            bps_clk_16x <= 1'b1;
        else
            bps_clk_16x <= 1'b0;
    end
//******************** Uart的数据接收模块 ****************** \\
    always@(posedge Clk or negedge Reset_n)begin
        if(!Reset_n) 
            bps_cnt <= 0;
        else if(RX_EN)begin
            if(bps_clk_16x)begin
                if(bps_cnt >= 160)
                    bps_cnt <= 0;
                else
                    bps_cnt <= bps_cnt + 1'b1;
            end
            else
                bps_cnt <= bps_cnt;
        end
        else
            bps_cnt <= 0;
    end
    //数据接收
    always@(posedge Clk or negedge Reset_n)begin
        if(!Reset_n) begin
            sta_bit <= 0;
            sto_bit <= 0;
            r_data[0] <= 0;
            r_data[1] <= 0;
            r_data[2] <= 0;
            r_data[3] <= 0;
            r_data[4] <= 0;
            r_data[5] <= 0;
            r_data[6] <= 0;
            r_data[7] <= 0;
        end
        else if(bps_clk_16x)begin
            case(bps_cnt)
                0:begin
                    sta_bit <= 0;
                    sto_bit <= 0;
                    r_data[0] <= 0;
                    r_data[1] <= 0;
                    r_data[2] <= 0;
                    r_data[3] <= 0;
                    r_data[4] <= 0;
                    r_data[5] <= 0;
                    r_data[6] <= 0;
                    r_data[7] <= 0;
                end
                5,6,7,8,9,10,11:sta_bit <= sta_bit + uart_rx;
                21,22,23,24,25,26,27: r_data[0] <= r_data[0] + uart_rx;
                37,38,39,40,41,42,43: r_data[1] <= r_data[1] + uart_rx;
                53,54,55,56,57,58,59: r_data[2] <= r_data[2] + uart_rx;
                69,70,71,72,73,74,75: r_data[3] <= r_data[3] + uart_rx;
                85,86,87,88,89,90,91: r_data[4] <= r_data[4] + uart_rx;
                101,102,103,104,105,106,107: r_data[5] <= r_data[5] + uart_rx;
                117,118,119,120,121,122,123: r_data[6] <= r_data[6] + uart_rx;
                133,134,135,136,137,138,139: r_data[7] <= r_data[7] + uart_rx;
                149,150,151,152,153,154,155: sto_bit <= sto_bit + uart_rx;
                default:;
            endcase
        end
    end
    //数据判断    
    always@(posedge Clk or negedge Reset_n)begin
        if(!Reset_n) 
            Data <= 0;        
        else if(bps_clk_16x && (bps_cnt == 160))begin
            Data[0] <= (r_data[0] >= 4)?1'b1:1'b0;
            Data[1] <= (r_data[1] >= 4)?1'b1:1'b0;
            Data[2] <= (r_data[2] >= 4)?1'b1:1'b0;
            Data[3] <= (r_data[3] >= 4)?1'b1:1'b0;
            Data[4] <= (r_data[4] >= 4)?1'b1:1'b0;
            Data[5] <= (r_data[5] >= 4)?1'b1:1'b0;
            Data[6] <= (r_data[6] >= 4)?1'b1:1'b0;
            Data[7] <= (r_data[7] >= 4)?1'b1:1'b0;
        end 
    end
    
//    always@(posedge Clk or negedge Reset_n)
//    if(!Reset_n) 
//        Data <= 0;        
//    else if(bps_clk_16x && (bps_cnt == 159))begin
//        Data[0] <= r_data[0][2];
//        Data[1] <= r_data[1][2];
//        Data[2] <= r_data[2][2];
//        Data[3] <= r_data[3][2];
//        Data[4] <= r_data[4][2];
//        Data[5] <= r_data[5][2];
//        Data[6] <= r_data[6][2];
//        Data[7] <= r_data[7][2];
//    end 
//******************** Uart接受完成标志 ****************** \\
    always@(posedge Clk or negedge Reset_n)begin
        if(!Reset_n) 
            Rx_Done <= 0;
        else if(bps_cnt == 'd160 && bps_clk_16x)
            Rx_Done <= 1;
        else
            Rx_Done <= 0; 
    end
endmodule

这边注意RX-done 以及RX_EN拉低的条件 。

TB文件
`timescale 1ns / 1ps
module uart_byte_rx_tb();

   reg           Clk     ;
   reg           Reset_n ;
   reg    [2:0]  Baud_Set;
   reg           uart_rx ;
   wire   [7:0]  Data    ; 
   wire          Rx_Done ;
uart_byte_rx uart_byte_rx_u0(
    .Clk        (Clk     ),
    .Reset_n    (Reset_n ),
    .Baud_Set   (  'd4   ),
    .uart_rx    (uart_rx ),
    .Data       (Data    ),
    .Rx_Done    (Rx_Done )
    );
initial  Clk = 0;
always #10 Clk = ~Clk;

initial begin
    Reset_n  = 0;
    #200;
    Reset_n = 1;
    #20;
    uart_tx_byte(8'haa);
    #90000//@(posedge Rx_Done);
    #5000;
    uart_tx_byte(8'h55);
    #90000;
    #5000;
    $stop;
end

task uart_tx_byte;
    input [7:0]tx_data;
    begin
        uart_rx = 1;
        #20;
        uart_rx = 0;
        #8680;
        uart_rx = tx_data[0];
        #8680;
        uart_rx = tx_data[1];
        #8680;
        uart_rx = tx_data[2];
        #8680;
        uart_rx = tx_data[3];
        #8680;
        uart_rx = tx_data[4];
        #8680;
        uart_rx = tx_data[5];
        #8680;
        uart_rx = tx_data[6];
        #8680;
        uart_rx = tx_data[7];
        #8680;
        uart_rx = 1;
        #8680;
    end
endtask
endmodule

 四、Uart串口控制LED灯闪烁

4.1 设计思路分析

4.2 verilog设计及仿真

4.2.1  .v文件

以下分别为cmd，LED以及top顶层代码：

`timescale 1ns / 1ps
//
// Description: 控制命令转换模块：将接受的8字节数据进行缓存，通过判断输出周期/控制的控制字给予LED模块
//
module uart_cmd(
    Clk     ,
    Reset_n ,
    rx_data ,
    rx_done ,
    ctrl    ,
    time_set,
);

input              Clk     ;
input              Reset_n ;
input      [7:0]   rx_data ;
input              rx_done ;
output reg [7:0]   ctrl    ;
output reg [31:0]  time_set;

reg [7:0] data_str [7:0];
reg       r_rx_done;
//***************** 字节缓存模块 *****************\\
always @(posedge Clk or negedge Reset_n) begin
    if(!Reset_n)begin
        data_str[7] <= 'd0;
        data_str[6] <= 'd0;
        data_str[5] <= 'd0;
        data_str[4] <= 'd0;
        data_str[3] <= 'd0;
        data_str[2] <= 'd0;
        data_str[1] <= 'd0;
        data_str[0] <= 'd0;
    end
    else if(rx_done) begin
        data_str[7] <= rx_data    ;
        data_str[6] <= data_str[7];
        data_str[5] <= data_str[6];
        data_str[4] <= data_str[5];
        data_str[3] <= data_str[4];
        data_str[2] <= data_str[3];
        data_str[1] <= data_str[2];
        data_str[0] <= data_str[1];
    end
    else begin
        data_str[7] <= data_str[7];
        data_str[6] <= data_str[6];
        data_str[5] <= data_str[5];
        data_str[4] <= data_str[4];
        data_str[3] <= data_str[3];
        data_str[2] <= data_str[2];
        data_str[1] <= data_str[1];
        data_str[0] <= data_str[0];
    end
end
//***************** 帧结构判断输出周期/控制 控制字 *****************\\
always @(posedge Clk or negedge Reset_n) begin
    if(!Reset_n)
       r_rx_done <= 'd0;
    else
       r_rx_done <= rx_done;
end

always @(posedge Clk or negedge Reset_n) begin
    if(!Reset_n)begin
        ctrl     <= 'd0;
        time_set <= 'd0;
    end
    else if(r_rx_done)begin
        if((data_str[0] == 8'h55)&&(data_str[1]==8'hA5)&&(data_str[7]==8'hF0))begin
             time_set[31:24] <= data_str[2];
             time_set[23:16] <= data_str[3];
             time_set[15: 8] <= data_str[4];
             time_set[ 7: 0] <= data_str[5]; 
             ctrl            <= data_str[6];     
        end
        else begin
            time_set <= time_set;
            ctrl     <= ctrl;
        end
    end
    else begin
        time_set <= time_set;
        ctrl     <= ctrl    ;
    end       
end
endmodule
`timescale 1ns / 1ps
//
// Description: led亮灭闪烁
//
module led_flash(
    Clk     ,
    Reset_n ,
    Time    ,
    ctrl    ,
    led     
);
input              Clk     ;
input              Reset_n ;
input      [7:0]   ctrl    ;
input      [31:0]  Time    ;
output reg         led     ;

reg[31:0]   time_cnt;
always @(posedge Clk or negedge Reset_n) begin
    if(!Reset_n)
        time_cnt <= 'd0;
    else if(time_cnt >= Time -1)
        time_cnt <= 'd0;
    else
        time_cnt <= time_cnt + 1;
end

reg[2:0]  led_cnt;
always @(posedge Clk or negedge Reset_n) begin
    if(!Reset_n)
        led_cnt <= 'd0;
    else if(time_cnt >= Time -1)begin
        if(led_cnt >= 7)
            led_cnt <= 'd0;
        else
            led_cnt <= led_cnt + 1;
    end
    else
        led_cnt <= led_cnt;
end

always @(posedge Clk or negedge Reset_n) begin
    if(!Reset_n)
        led <= 'd0;
    else begin
        case(led_cnt)
            0:led <= ctrl[0];
            1:led <= ctrl[1];
            2:led <= ctrl[2];
            3:led <= ctrl[3];
            4:led <= ctrl[4];
            5:led <= ctrl[5];
            6:led <= ctrl[6];
            7:led <= ctrl[7];
            default:led <= 'd0;
        endcase
    end
end
endmodule

`timescale 1ns / 1ps
module uart_led_top(
    Clk     ,
    Reset_n ,
    uart_rx ,
    led 
);
input        Clk     ;
input        Reset_n ;
input        uart_rx ;
output       led     ;

wire [7:0]   Data    ;
wire         Rx_Done ;
wire [7:0]   ctrl    ;
wire [31:0]  time_set;

uart_byte_rx uart_byte_rx_u0(
    .Clk      (Clk      ),
    .Reset_n  (Reset_n  ),
    .Baud_Set ('d4      ),
    .uart_rx  (uart_rx  ),
    .Data     (Data     ),
    .Rx_Done  (Rx_Done  )
);
uart_cmd uart_cmd_u0(
    .Clk      (Clk      ),
    .Reset_n  (Reset_n  ),
    .rx_data  (Data     ),
    .rx_done  (Rx_Done  ),
    .ctrl     (ctrl     ),
    .time_set (time_set )
);
led_flash led_flash_u0(
    .Clk      (Clk      ),
    .Reset_n  (Reset_n  ),
    .Time     (time_set ),
    .ctrl     (ctrl     ),
    .led      (led      )
);
endmodule

 

4.2.2 tb文件及仿真 

 

`timescale 1ns / 1ps
module uart_led_tb();
reg         Clk        ;
reg         Reset_n    ;
wire        Led        ;
reg         uart_rx    ;
wire [31:0] delay_time ;

uart_led_top uart_led_top_u0(
    .Clk      (Clk      ),
    .Reset_n  (Reset_n  ),
    .uart_rx  (uart_rx  ),
    .led      (Led      )
); 
parameter Baud_Set = 3'd4;
assign delay_time = (Baud_Set == 3'd0) ? 20'd104166:
                    (Baud_Set == 3'd1) ? 20'd52083:
                    (Baud_Set == 3'd2) ? 20'd26041:
                    (Baud_Set == 3'd3) ? 20'd17361:
                                         20'd8680;
initial Clk = 1;
always#10 Clk = ~Clk;

initial begin
    Reset_n = 0;
    uart_rx = 1;
    #201;
    Reset_n = 1;
    #200; 
    uart_tx_byte(8'h55);
    #(delay_time*10);
    uart_tx_byte(8'ha5);
    #(delay_time*10);
    uart_tx_byte(8'h55);
    #(delay_time*10);
    uart_tx_byte(8'ha5);
    #(delay_time*10);
    uart_tx_byte(8'h00);
    #(delay_time*10);
    uart_tx_byte(8'h00);
    #(delay_time*10);
    uart_tx_byte(8'hc3);
    #(delay_time*10);
    uart_tx_byte(8'h50);
    #(delay_time*10); 
    uart_tx_byte(8'hAA);
    #(delay_time*10); 
    uart_tx_byte(8'hf0);
    #(delay_time*10); 
    uart_tx_byte(8'h55);
    #(delay_time*10);
    uart_tx_byte(8'ha5);
    #(delay_time*10);
    uart_tx_byte(8'h9a);
    #(delay_time*10);
    uart_tx_byte(8'h78);
    #(delay_time*10);
    uart_tx_byte(8'h56);
    #(delay_time*10);
    uart_tx_byte(8'h34);
    #(delay_time*10); 
    uart_tx_byte(8'h12);
    #(delay_time*10); 
    uart_tx_byte(8'hf1);
    #(delay_time*10);
    #15000000; 
    $stop;
end

task uart_tx_byte;
    input [7:0]tx_data;
    begin
        uart_rx = 1;
        #20;
        uart_rx = 0;
        #delay_time;
        uart_rx = tx_data[0];
        #delay_time;
        uart_rx = tx_data[1];
        #delay_time;
        uart_rx = tx_data[2];
        #delay_time;
        uart_rx = tx_data[3];
        #delay_time;
        uart_rx = tx_data[4];
        #delay_time;
        uart_rx = tx_data[5];
        #delay_time;
        uart_rx = tx_data[6];
        #delay_time;
        uart_rx = tx_data[7];
        #delay_time;
        uart_rx = 1;
        #delay_time; 
    end
endtask

endmodule

 关于：rx_done

r_rx_done：这里由于最高位的缓存数据与输入数据间存在一个时钟周期的延迟，因此需要对
rx_done 信号打一拍后再作为条件去判断缓存中的数据。

 4.3 板级试验

 指令多发，有效指令为 55 A5 02 FA F0 80 F0 F0。因此 LED 按照亮亮亮亮灭灭灭(8’b11110000，0xF0)的规律，每 1s 变化一次，每 8 次变化为一组，不断循环变化。 与操作对应的板级现象吻合。亮四秒灭四秒，可以正确显示操作Led灯。

 

 

MVP-curry-萌神
关注
  • 5
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
FPGA实现串口（UART）
孤独的单刀
03-10 26万+
通过本文您会学到：1、什么是UART？2、如何用FPGA实现它？
FPGA-UART串口
博客
01-17 1869
UART:全称为Universal Asynchronous Receiver/Transmitter,通用异步收发器。是一种串行异步的通信协议,该协议规定了传输数据时数据的传输方式以及所使用的信号,在嵌入式领域中有着非常广泛的应用。通用异步收发传输器（Universal Asynchronous Receiver/Transmitter，UART）是一种异步 收发传输器，其在数据发送时将并行数据转换成串行数据来传输，在数据接收时将接收到的 串行数据转换成并行数据，可以实现全双工传输和接收。
FPGA——UART串口通信
zhu1289的博客
10-16 837
UART通信——FPGA
FPGA开发实验（8）- UART串口实验
a1329054153的博客
07-25 680
UART即通用异步收发器，串口是串行接口的简称，两者组合起来就是通用异步串行通信接口，它包括了 RS232、RS499、RS423、RS422 和 RS485等接口标准规范和总线标准规范，因此串口广泛应用于嵌入式、工业控制等领域。1)数据通信的概念通信方式在日常的应用中一般分为串行通信和并行通信。并行通信:并行通信是指多比特数据。
FPGA串口通信----uart（二）
mvpkuku的博客
08-08 143
一、多字节发送（Tx_bytes）在UART（一）中主要解决的是单字节的发送和接受但是单字节的应用场景相对较小。在大多数场景下，串口都是用于连续多字节的收发工作。因此，本篇文章将基于已有的单字节串口收发模块，结合上一章学习的状态机，完成多字节串口发送模块和多字节串口接收模块的设计，并通过仿真和板级测试对设计进行验证,完成多字节串口收发的验证。一、多字节发送（Tx_bytes）
FPGA-UART(串口通信)
j98022154的博客
07-22 464
FPGA-UART串口调试
FPGA-UART串口通信
qq_45268949的博客
05-10 1872
FPGA-UART串口通信
【FPGA】UART串口通信---基于FIFO
热门推荐
wanerXR的博客
06-04 1万+
我们在上一章完成了UART串口通信的收发模块，这一章我们将FIFO引入进来，使用FIFO进行缓存数据，来连接串口通信的收发模块同步FIFO 读和写应用同一个时钟。它的作用一般是做交互数据的一个缓冲，也就是说它的主要作用就是一个buffer1。异步FIFO 读写应用不同的时钟，它有两个主要的作用，一个是实现数据在不同时钟域进行传递，另一个作用就是实现不同数据宽度的数据接口。同步FIFO和异步FIFO略有不同，下面的参数适用于两者。，用参数FIFO_data_size表示，也就是FIFO存储的数据宽度； ，用参
FPGA-UART-全双工串行通信
qq_46303613的博客
03-24 2195
FPGA-停车场计数器 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录FPGA-停车场计数器前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文
fpga-uart.zip_FPGA串口通信
09-14
**FPGA串口通信详解** 在电子工程领域，FPGA（Field-Programmable Gate Array）因其可编程性被广泛应用于各种系统设计中，其中包括与外部设备进行数据交互的串行通信。本实验以"FPGA-UART.zip"为主题，旨在探讨如何...
基于FPGA的AXI-lite接口 UART设计
03-13
UART是一种常见的串行通信接口，广泛用于设备间的低速通信。它通过一对数据线（TX和RX）进行数据传输，通常用于调试、打印输出或者连接不同系统之间的简单通信。在FPGA设计中，UART模块可以实现与外部世界的串行通信...
FPGA基础入门－开发板USB-UART串口通信配置工程文件
08-19
与教程--FPGA基础入门【11】开发板USB-UART串口通信配置--相应的源代码。 根目录包含： 1. 相关文档，nexys4ddr_rm.pdf是开发板文档；DS_FT2232H.pdf是UART芯片FT2232HQ文档 2. src/包含所有源代码 3. sim/包含...
FPGA实现的串口通信-综合文档
05-22
串口通信是一种常见的数据传输方式，如UART（通用异步收发传输器）、SPI（串行外围接口）和I2C（集成电路间通信）等。在FPGA中实现串口通信，可以灵活地配置波特率、数据位、停止位和校验位，满足不同设备间的通信...
可编程逻辑设计原则
最新发布
m0_66619666的博客
08-09 891
面积指FPGA逻辑器件的逻辑资源。在逻辑器件资源有限，设计规模庞大的情况下，必须采用牺牲速度以减少资源消耗，节约面积。例如，减少实例化模块数量，分时复用模块。以上是用一个查找表ROM模块在7个周期内实现4组十六进制数转换为十进制数的程序，下面是在4个周期内实现4组十六进制数转换为十进制数的程序。
FPGA开发——IP核的FIFO调用
weixin_63553972的博客
08-09 1183
FIFO 的英文全称是 First In First Out，即先进先出。FPGA 使用的 FIFO 一般指的是对数据的存储具有先进先出特性的一个缓存器，常被用于数据的缓存或者高速异步数据的交互，也即所谓的跨时钟域信号传递。它与 FPGA 内部的 RAM 和 ROM 的区别是没有外部读写地址线，采取顺序写入数据，顺序读出数据的方式，使用起来简单方便，由此带来的缺点就是不能像 RAM 和 ROM 那样可以由地址线决定读取或写入某个指定的地址。
FPGA设计之跨时钟域（CDC）设计篇（5）----同步FIFO的两种设计方法（计数器法/高位扩展法 | 手撕代码）
孤独的单刀
08-05 1367
FPGA设计之跨时钟域（CDC）设计篇（5）----同步FIFO的两种设计方法（计数器法/高位扩展法 | 手撕代码）
FPGA常见型号
qq_53529450的博客
08-09 585
FPGA（现场可编程门阵列）开发板种类繁多，涵盖了从入门级教育用途到高性能工业应用的广泛领域。本文介绍一些常见的 FPGA 开发板型号及其特点。
Nexys 3 FPGA开发板：Spartan-6技术详解
5. **USB-UART端口**：方便地将FPGA与PC或其他设备通过USB进行串行通信，用于调试和数据传输。 6. **USB主机端口**：可以直接连接鼠标和键盘，增强了开发板作为嵌入式系统的实用性。 7. **高速扩展连接器**：这个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值