串口发送+RAM+VGA传图

已于 2023-09-04 18:01:44 修改
阅读量843 收藏 13
点赞数 3
分类专栏： FPGA代码分享 文章标签： fpga开发 vscode 嵌入式硬件
于 2022-12-21 18:30:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wd12306/article/details/128399680
版权

串口-RAM-VGA系列知识分享：
（0）串口通信实现-串口接收
（1）VGA成像原理与简单实现
（2）VGA显示板级验证
（3）VGA显示-多分辨率输入
（4）串口发送+RAM+VGA传图

串口发送+RAM+VGA传图

前言

本文使用串口发送模块发送数据存储到RAM中，通过RAM读取数据传输图片给TFT显示屏。

提示：以下是本篇文章正文内容，下面案例可供参考

一、结构总体设计

1.UART_RAM_TFT总体设计草图
总体设计草图
2.img_rx_wr（RAM写入逻辑）设计草图
img_rx_wr草图

二、顶层模块

代码如下：

`timescale 1ns / 1ps

module UART_RAM_TFT(
    Clk,
    Reset_n,
    uart_rx,
    VGA_RGB,//TFT数据输出
    VGA_HS, //TFT行同步信号
    VGA_VS, //TFT场同步信号
    VGA_BLK,        //VGA 场消隐信号
    VGA_CLK,
    TFT_BL  //背光
);


    input Clk;
    input Reset_n;
    input uart_rx;
    output [15:0]VGA_RGB;
    output VGA_HS;
    output VGA_VS;
    output VGA_BLK;     //VGA 场消隐信号
    output VGA_CLK; 
    output TFT_BL;

    wire [7:0]rx_data;
    wire rx_done;
    
    wire ram_wren;
    wire [15:0]ram_wraddr;
    wire [15:0]ram_wrdata;
    reg [15:0]ram_rdaddr;
    wire Clk_TFT;
    wire [15:0]ram_rddata;
    
    assign VGA_CLK = Clk_TFT;
    assign TFT_BL = 1;
    
    MMCM MMCM(
        .clk_out1(Clk_TFT),
        .clk_in1(Clk)
    );
    
    uart_byte_rx uart_byte_rx(
        .Clk(Clk),
        .Reset_n(Reset_n),
        .Baud_Set(4),
        .uart_rx(uart_rx),
        .Data(rx_data),
        .Rx_Done(rx_done)  
    ); 
    
    img_rx_wr img_rx_wr(
        .Clk(Clk),
        .Reset_n(Reset_n),
        .rx_data(rx_data),
        .rx_done(rx_done),
        .ram_wren(ram_wren),
        .ram_wraddr(ram_wraddr),
        .ram_wrdata(ram_wrdata)
    );
    
    RAM RAM (
      .clka(Clk),    // input wire clka
      .ena(1),      // input wire ena
      .wea(ram_wren),      // input wire [0 : 0] wea
      .addra(ram_wraddr),  // input wire [15 : 0] addra
      .dina(ram_wrdata),    // input wire [15 : 0] dina
      .clkb(Clk_TFT),    // input wire clkb
      .enb(1),      // input wire enb
      .addrb(ram_rdaddr),  // input wire [15 : 0] addrb
      .doutb(ram_rddata)  // output wire [15 : 0] doutb
    );

    wire Data_Req;
    wire [11:0]hcount,vcount;
    
    wire [15:0]disp_data;
    VGA_CTRL VGA_CTRL(
        .Clk(Clk_TFT),    //系统输入时钟33MHZ
        .Reset_n(Reset_n),
        .Data(disp_data),    //待显示数据
		.Data_Req(Data_Req),
        .hcount(hcount),        //VGA行扫描计数器
        .vcount(vcount),        //VGA场扫描计数器
        .VGA_RGB(VGA_RGB),  //VGA数据输出
        .VGA_HS(VGA_HS),        //VGA行同步信号
        .VGA_VS(VGA_VS),        //VGA场同步信号
        .VGA_BLK(VGA_BLK)      //VGA 场消隐信号
    );
    
    //RAM中存储的图像是256*256的像素矩阵
     wire ram_data_en;
    assign ram_data_en = Data_Req && (hcount <= 255) && (vcount <= 255);
    
    always@(posedge Clk_TFT or negedge Reset_n)
    if(!Reset_n)
        ram_rdaddr <= 0;
    else if(ram_data_en)
        ram_rdaddr <= ram_rdaddr + 1'd1;
    
    wire data_en;
    wire [7:0]R ,G ,B;
    assign R = 8'hFF,G = 8'h00,B = 8'h00;
    wire [15:0]RED; 
    assign RED = {R[7:3],G[7:2],B[7:3]};
    assign data_en = Data_Req && (hcount <= 257) && (vcount <= 255);
    assign disp_data = data_en? ram_rddata:RED;//将多余图像显示红色
    //assign disp_data = ram_data_en? ram_rddata:0;    //将多余数据归0显示黑色
    
endmodule

三、img_rx_wr模块

module img_rx_wr(
    Clk,
    Reset_n,
    rx_data,
    rx_done,
    ram_wren,
    ram_wraddr,
    ram_wrdata
);
    input Clk;
    input Reset_n;
    input [7:0]rx_data;    //串口数据
    input rx_done;         //串口发送停止信号
    output reg ram_wren;   //开始写入信号
    output reg[15:0]ram_wraddr;   //RAM核写入地址
    output [15:0]ram_wrdata;      //写入数据
    
    reg [15:0]rx_data_tmp;
    
    reg [16:0]data_cnt; //统计串口接收的数据个数计数器
    always@(posedge Clk or negedge Reset_n)
    if(!Reset_n) 
        data_cnt <= 0;
    else if(rx_done)
        data_cnt <= data_cnt + 1'd1;
 
    always@(posedge Clk or negedge Reset_n)
    if(!Reset_n) 
        rx_data_tmp <= 0;
    else if(rx_done)     //串口一次发一个字节，RGB565一次需要2个字节
        rx_data_tmp <= {rx_data_tmp[7:0], rx_data};
 
 
 
//---------------------------------------------------------------
  //17'h0      ...0000
  //17'h1      ...0001
  //17'h2      ...0010
  //根据规律奇数末位为1
//---------------------------------------------------------------       
    always@(posedge Clk or negedge Reset_n)
    if(!Reset_n) 
        ram_wren <= 0;
    else if(rx_done && data_cnt[0])    //每两个字节进行一次写入
        ram_wren <= 1'd1;
    else
        ram_wren <= 0;
 
 
        
    always@(posedge Clk or negedge Reset_n)
    if(!Reset_n) 
        ram_wraddr <= 0;
    else if(rx_done && data_cnt[0]) 
        ram_wraddr <= data_cnt[16:1];  //data_cnt/2    
        
    assign ram_wrdata = rx_data_tmp;
    
endmodule

四、UART_rx模块

`timescale 1ns/1ns

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]sync_uart_rx;
   
   always@(posedge Clk)begin
       sync_uart_rx[0] <= #1 uart_rx;
       sync_uart_rx[1] <= #1 sync_uart_rx[0] ;
   end
   
   reg [1:0]uart_rx_r;
   always@(posedge Clk)begin
        uart_rx_r[0] <= #1 sync_uart_rx[1];
        uart_rx_r[1] <= #1 uart_rx_r[0] ;
   end

    wire pedge_uart_rx;
//    assign pedge_uart_rx = ((uart_rx_r[1] == 0) && (uart_rx_r[0] == 1));
    assign pedge_uart_rx = (uart_rx_r == 2'b01);
    wire nedge_uart_rx;
//    assign nedge_uart_rx = ((uart_rx_r[1] == 1) && (uart_rx_r[0] == 0));  
    assign nedge_uart_rx = (uart_rx_r == 2'b10);  
 
    reg [8:0]  Bps_DR;
    always@(*)
        case(Baud_Set)
            0:Bps_DR = 1000000000/9600/16/20 - 2;
            1:Bps_DR = 1000000000/19200/16/20 -2;
            2:Bps_DR = 1000000000/38400/16/20 - 2;
            3:Bps_DR = 1000000000/57600/16/20 - 2;
            4:Bps_DR = 1000000000/115200/16/20 - 2;
            5:Bps_DR = 1000000000/1562500/16/20 - 2;
            default:Bps_DR = 1000000000/9600/16/20 - 1;
        endcase
        
    wire bps_clk_16x;
    assign bps_clk_16x = (div_cnt == Bps_DR / 2);

    reg RX_EN;
    always@(posedge Clk or negedge Reset_n)
    if(!Reset_n) 
        RX_EN <= #1 0;
    else if(nedge_uart_rx)
        RX_EN <= #1 1;
    else if(Rx_Done || (sta_bit >= 4))
        RX_EN <= #1 0;
        
    reg [8:0]div_cnt;
    always@(posedge Clk or negedge Reset_n)
    if(!Reset_n)    
        div_cnt <= #1 0;
    else if(RX_EN)begin
        if(div_cnt == Bps_DR)
            div_cnt <= #1 0;
        else
            div_cnt <= #1 div_cnt + 1'b1;
    end
    else
        div_cnt <= #1 0;

    reg [7:0]bps_cnt;
    always@(posedge Clk or negedge Reset_n)
    if(!Reset_n) 
        bps_cnt <= #1 0;
    else if(RX_EN)begin
        if(bps_clk_16x)begin
            if(bps_cnt == 160)
                bps_cnt <= #1 0;
            else
                bps_cnt <= #1 bps_cnt + 1'b1;
        end
        else
            bps_cnt <= #1 bps_cnt;
     end
     else
        bps_cnt <= #1 0;
       
    //reg width name number/depth
    reg[2:0]r_data[7:0];
    reg [2:0]sta_bit;
    reg [2:0]sto_bit;
    
    always@(posedge Clk or negedge Reset_n)
    if(!Reset_n) begin
        sta_bit <= #1 0;
        sto_bit <= #1 0;
        r_data[0] <= #1 0;
        r_data[1] <= #1 0;
        r_data[2] <= #1 0;
        r_data[3] <= #1 0;
        r_data[4] <= #1 0;
        r_data[5] <= #1 0;
        r_data[6] <= #1 0;
        r_data[7] <= #1 0;
    end
    else if(bps_clk_16x)begin
        case(bps_cnt)
            0:begin
                sta_bit <= #1 0;
                sto_bit <= #1 0;
                r_data[0] <= #1 0;
                r_data[1] <= #1 0;
                r_data[2] <= #1 0;
                r_data[3] <= #1 0;
                r_data[4] <= #1 0;
                r_data[5] <= #1 0;
                r_data[6] <= #1 0;
                r_data[7] <= #1 0;
            end
            5,6,7,8,9,10,11:sta_bit <= #1 sta_bit + sync_uart_rx[1];
            21,22,23,24,25,26,27: r_data[0] <= #1 r_data[0] + sync_uart_rx[1];
            37,38,39,40,41,42,43: r_data[1] <= #1 r_data[1] + sync_uart_rx[1];
            53,54,55,56,57,58,59: r_data[2] <= #1 r_data[2] + sync_uart_rx[1];
            69,70,71,72,73,74,75: r_data[3] <= #1 r_data[3] + sync_uart_rx[1];
            85,86,87,88,89,90,91: r_data[4] <= #1 r_data[4] + sync_uart_rx[1];
            101,102,103,104,105,106,107: r_data[5] <= #1 r_data[5] + sync_uart_rx[1];
            117,118,119,120,121,122,123: r_data[6] <= #1 r_data[6] + sync_uart_rx[1];
            133,134,135,136,137,138,139: r_data[7] <= #1 r_data[7] + sync_uart_rx[1];
            149,150,151,152,153,154,155: sto_bit <= #1 sto_bit + sync_uart_rx[1];
            default:;
        endcase
    end
        
    always@(posedge Clk or negedge Reset_n)
    if(!Reset_n) 
        Data <= #1 0;        
    else if(bps_clk_16x && (bps_cnt == 159))begin
        Data[0] <= #1 (r_data[0] >= 4)?1'b1:1'b0;
        Data[1] <= #1 (r_data[1] >= 4)?1'b1:1'b0;
        Data[2] <= #1 (r_data[2] >= 4)?1'b1:1'b0;
        Data[3] <= #1 (r_data[3] >= 4)?1'b1:1'b0;
        Data[4] <= #1 (r_data[4] >= 4)?1'b1:1'b0;
        Data[5] <= #1 (r_data[5] >= 4)?1'b1:1'b0;
        Data[6] <= #1 (r_data[6] >= 4)?1'b1:1'b0;
        Data[7] <= #1 (r_data[7] >= 4)?1'b1:1'b0;
    end 
    
//    always@(posedge Clk or negedge Reset_n)
//    if(!Reset_n) 
//        Data <= #1 0;        
//    else if(bps_clk_16x && (bps_cnt == 159))begin
//        Data[0] <= #1 r_data[0][2];
//        Data[1] <= #1 r_data[1][2];
//        Data[2] <= #1 r_data[2][2];
//        Data[3] <= #1 r_data[3][2];
//        Data[4] <= #1 r_data[4][2];
//        Data[5] <= #1 r_data[5][2];
//        Data[6] <= #1 r_data[6][2];
//        Data[7] <= #1 r_data[7][2];
//    end 

    always@(posedge Clk or negedge Reset_n)
    if(!Reset_n) 
        Rx_Done <= #1 0;
    else if((div_cnt == Bps_DR/2) && (bps_cnt == 160))
        Rx_Done <= #1 1;
    else
        Rx_Done <= #1 0; 
        
endmodule

五、VGA_CTRL模块

module VGA_CTRL(
    Clk,
    Reset_n,
    Data,
    Data_Req,
    hcount,
    vcount,
    VGA_HS,
    VGA_VS,
    VGA_BLK,
    VGA_RGB
);
    
    input Clk;
    input Reset_n;
    input [15:0]Data;
    output reg Data_Req;
    output reg [11:0]hcount; //当前扫描点的H坐标
    output reg [11:0]vcount; //当前扫描点的V坐标
    output VGA_HS;
    output VGA_VS; 
    output VGA_BLK;
    output reg [15:0]VGA_RGB;//{R[4:0]、G[5:0]、B[4:0]}
    
    `include "vga_parameter.v"
    localparam Hsync_End = `H_Total_Time;
    localparam HS_End = `H_Sync_Time;
    localparam Hdat_Begin = `H_Sync_Time + `H_Back_Porch + `H_Left_Border;
    localparam Hdat_End = `H_Sync_Time + `H_Left_Border + `H_Back_Porch + `H_Data_Time;
    localparam Vsync_End = `V_Total_Time;
    localparam VS_End = `V_Sync_Time;
    localparam Vdat_Begin =  `V_Sync_Time + `V_Back_Porch + `V_Top_Border;
    localparam Vdat_End = `V_Sync_Time + `V_Back_Porch + `V_Top_Border + `V_Data_Time;
    
    reg [11:0]hcnt;//行扫描计数器
    always@(posedge Clk or negedge Reset_n)
    if(!Reset_n)
        hcnt <= 0;
    else if(hcnt >= Hsync_End -1)
        hcnt <= 0;
    else
        hcnt <= hcnt + 1'b1;
    
    
    //RAM_IP核输出数据有三拍延迟此处为了对齐数据传输
    
    reg [3:0]VGA_HS_r;
        
    always@(posedge Clk)begin
        VGA_HS_r[0] <= (hcnt < HS_End)?0:1;
        VGA_HS_r[3:1] <= VGA_HS_r[2:0];        
    end
    
    assign VGA_HS = VGA_HS_r[2];

    reg [11:0]vcnt;//场扫描计数器
    always@(posedge Clk or negedge Reset_n)
    if(!Reset_n)
        vcnt <= 0;
    else if(hcnt == Hsync_End -1)begin
        if(vcnt >= Vsync_End -1)
            vcnt <= 0;
        else
            vcnt <= vcnt + 1'd1;
    end
    else
        vcnt <= vcnt;
    
    //RAM_IP核输出数据有三拍延迟此处为了对齐数据传输
    reg [3:0]VGA_VS_r;   
    always@(posedge Clk)begin
        VGA_VS_r[0]  <= (vcnt < VS_End)?0:1;
        VGA_VS_r[3:1] <= VGA_VS_r[2:0];
    end

    assign VGA_VS = VGA_VS_r[2];
            
    //BLK表示的就是输出输出的时间段
//    assign VGA_BLK = ((hcnt >= Hdat_Begin - 1) && (hcnt < Hdat_End - 1) && (vcnt >= Vdat_Begin - 1) && (vcnt < Vdat_End))?1:0;
//    always@(posedge Clk)
//         VGA_BLK <= ((hcnt >= Hdat_Begin - 1) && (hcnt < Hdat_End - 1) && (vcnt >= Vdat_Begin - 1) && (vcnt < Vdat_End))?1:0;   

    always@(posedge Clk)
       Data_Req <= ((hcnt >= Hdat_Begin - 1) && (hcnt < Hdat_End - 1) && (vcnt >= Vdat_Begin) && (vcnt < Vdat_End))?1:0;
    
    //RAM_IP核输出数据有三拍延迟此处为了对齐数据传输
    reg [3:0]VGA_BLK_r;
    always@(posedge Clk)begin
       VGA_BLK_r[0] <= Data_Req;
       VGA_BLK_r[3:1] <= VGA_BLK_r[2:0];
    end
        assign VGA_BLK = VGA_BLK_r[3];
            
//    assign VGA_RGB = VGA_BLK? Data:0;
    always@(posedge Clk)
        VGA_RGB <= Data_Req? Data:0;
        
    always@(posedge Clk)
       hcount <= Data_Req? hcnt - Hdat_Begin:0; 

    always@(posedge Clk)
       vcount <= Data_Req? (vcnt - Vdat_Begin):vcount;          
        
endmodule

六、parameter.v文件

//`define Resolution_480x272 1	//刷新率为60Hz时像素时钟为9MHz
//`define Resolution_640x480 1	//刷新率为60Hz时像素时钟为25.175MHz
`define Resolution_800x480 1	//刷新率为60Hz时像素时钟为33MHz
//`define Resolution_800x600 1	//刷新率为60Hz时像素时钟为40MHz
//`define Resolution_1024x768 1	//刷新率为60Hz时像素时钟为65MHz
//`define Resolution_1280x720 1	//刷新率为60Hz时像素时钟为74.25MHz
//`define Resolution_1920x1080 1	//刷新率为60Hz时像素时钟为148.5MHz

`ifdef Resolution_480x272    
    `define H_Right_Border 0
    `define H_Front_Porch 2
    `define H_Sync_Time 41
    `define H_Back_Porch 2
    `define H_Left_Border 0
    `define H_Data_Time 480
    `define H_Total_Time 525
    `define V_Bottom_Border 0
    `define V_Front_Porch 2
    `define V_Sync_Time 10
    `define V_Back_Porch 2
    `define V_Top_Border 0
    `define V_Data_Time 272
    `define V_Total_Time 286
    
`elsif Resolution_640x480
	`define H_Total_Time  12'd800
	`define H_Right_Border  12'd8
	`define H_Front_Porch  12'd8
	`define H_Sync_Time  12'd96
	`define H_Data_Time 12'd640
	`define H_Back_Porch  12'd40
	`define H_Left_Border  12'd8
	`define V_Total_Time  12'd525
	`define V_Bottom_Border  12'd8
	`define V_Front_Porch  12'd2
	`define V_Sync_Time  12'd2
	`define V_Data_Time 12'd480
	`define V_Back_Porch  12'd25
	`define V_Top_Border  12'd8
	
`elsif Resolution_800x480
	`define H_Total_Time 12'd1056
	`define H_Right_Border 12'd0
	`define H_Front_Porch 12'd40
	`define H_Sync_Time 12'd128
	`define H_Data_Time 12'd800
	`define H_Back_Porch 12'd88
	`define H_Left_Border 12'd0

	`define V_Total_Time 12'd525
	`define V_Bottom_Border 12'd8
	`define V_Front_Porch 12'd2
	`define V_Sync_Time 12'd2
	`define V_Data_Time 12'd480
	`define V_Back_Porch 12'd25
	`define V_Top_Border 12'd8

`elsif Resolution_800x600
	`define H_Total_Time 12'd1056
	`define H_Right_Border 12'd0
	`define H_Front_Porch 12'd40
	`define H_Sync_Time 12'd128
	`define H_Data_Time 12'd800
	`define H_Back_Porch 12'd88
	`define H_Left_Border 12'd0

	`define V_Total_Time 12'd628
	`define V_Bottom_Border 12'd0
	`define V_Front_Porch 12'd1
	`define V_Sync_Time 12'd4
	`define V_Data_Time 12'd600
	`define V_Back_Porch 12'd23
	`define V_Top_Border 12'd0

`elsif Resolution_1024x768
	`define H_Total_Time 12'd1344
	`define H_Right_Border 12'd0
	`define H_Front_Porch 12'd24
	`define H_Sync_Time 12'd136
	`define H_Data_Time 12'd1024
	`define H_Back_Porch 12'd160
	`define H_Left_Border 12'd0

	`define V_Total_Time 12'd806
	`define V_Bottom_Border 12'd0
	`define V_Front_Porch 12'd3
	`define V_Sync_Time 12'd6
	`define V_Data_Time 12'd768
	`define V_Back_Porch 12'd29
	`define V_Top_Border 12'd0

`elsif Resolution_1280x720
	`define H_Total_Time 12'd1650
	`define H_Right_Border 12'd0
	`define H_Front_Porch 12'd110
	`define H_Sync_Time 12'd40
	`define H_Data_Time 12'd1280
	`define H_Back_Porch 12'd220
	`define H_Left_Border 12'd0

	`define V_Total_Time 12'd750
	`define V_Bottom_Border 12'd0
	`define V_Front_Porch 12'd5
	`define V_Sync_Time 12'd5
	`define V_Data_Time 12'd720
	`define V_Back_Porch 12'd20
	`define V_Top_Border 12'd0
		
`elsif Resolution_1920x1080
	`define H_Total_Time 12'd2200
	`define H_Right_Border 12'd0
	`define H_Front_Porch 12'd88
	`define H_Sync_Time 12'd44
	`define H_Data_Time 12'd1920
	`define H_Back_Porch 12'd148
	`define H_Left_Border 12'd0

	`define V_Total_Time 12'd1125
	`define V_Bottom_Border 12'd0
	`define V_Front_Porch 12'd4
	`define V_Sync_Time 12'd5
	`define V_Data_Time 12'd1080
	`define V_Back_Porch 12'd36
	`define V_Top_Border 12'd0	
	
`endif

七、clk_IP和RAM_IP配置

具体IP配置根据所需选择，可参考我之前文章，自行根据所需配置。

八、仿真文件展示

`timescale 1ns / 1ps

module UART_RAM_TFT_tb(

    );
    
    reg Clk;
    reg Reset_n;
    reg uart_rx;
    wire [15:0]VGA_RGB;
    wire VGA_HS;
    wire VGA_VS;
    wire VGA_BLK;     //VGA 场消隐信号
    wire VGA_CLK; 
    wire TFT_BL;
        
    UART_RAM_TFT UART_RAM_TFT(
        Clk,
        Reset_n,
        uart_rx,
        VGA_RGB,//TFT数据输出
        VGA_HS, //TFT行同步信号
        VGA_VS, //TFT场同步信号
        VGA_BLK,        //VGA 场消隐信号
        VGA_CLK,
        TFT_BL  //背光
    );
    
    initial Clk = 1;
    always#10 Clk = ~Clk;
    
    initial begin
        Reset_n = 0;
        #201;
        Reset_n = 1;
        #2000;
        #2000000;
        $stop;
    end    
    
endmodule

九、上板演示

在这里插入图片描述
串口传图展示：

在这里插入图片描述
【附件：】链接：https://pan.baidu.com/s/1wWgnTeCfzlFzGWUCQe7ANg?pwd=mnz3
提取码：mnz3

C.V-Pupil
关注
  • 3
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
专栏目录
C#串口通信从入门到精通（6）——串口发送数据（字符串、16进制、图片等文件）
qq_34059233的博客
05-06 5987
本文详细介绍串口发送数据的三种方式：发送字符串、发送16进制、发送文件
串口传图显示
不想秃发的博客
03-07 3036
串口传图 使用串口通信协议传输一张图像到SDRAM存储后VGA协议显示到屏幕。 工程设计 图片生成 使用小梅哥资源中的Picture2Hex软件生成任意分辨率的图片（我这里选择640*480）。 matlab将得到合适分辨率的照片使用matlab软件分析为文本便于串口发送（图片中每一个像素点都有具体的数值）。这里有两种方法： 1 将图片转为RGB332 使用野火提供视频资源基于RS232的VGA显示中的matlab代码，一个像素点为8位数据使用串口发送。 clc;
串口 单片机 文件_串口通讯你真的会了吗？
weixin_40000131的博客
10-25 359
平时使用串口打印出现乱码的绝大部分原因是串口波特率没对。那么我们怎么测量实际的波特率呢？在这之前，顺便一起回顾一下波特率的概念。什么是波特率、比特率？比特率(Bitrate)表示每秒钟传输的二进制位数，单位为比特每秒(bit/s)。波特率(Baudrate)表示每秒钟传送的码元符号的个数，是衡量数据传送速率的指标。码元是通讯信号调制的概念，通讯中常用时间间隔相同的符号来表示一个二进制数字...
OpenMV 图像串口传输示例
最新发布
yandadzf的博客
05-08 854
这个例程主要实现了以下功能: 1. OpenMV 端采集图像:使用OpenMV开发板上的摄像头采集实时图像数据。 2. 通过串口传输图像数据:将采集到的图像数据打包成字节流,通过串口发送到连接的PC端。 3. PC端接收并保存图像:PC端接收来自OpenMV的图像数据,并使用OpenCV库将其解码保存为图片文件。 整个过程模拟了一个简单的图像采集-传输-保存的应用场景。OpenMV负责图像采集和数据发送,PC端负责接收和保存图像。
支持串口上传图片和数据到服务器的4G低功耗摄像头方案
mode0202的博客
08-14 1785
当今网络信息自动化的时代，通过网络进行远程监控和远程数据采集成为一种最经济最可靠的方式。但由于部分场景现场监控并不需要过多的检测，只需定时返回现场环境即可，4G串口摄像头极大的方便这方面的需求。不需过多的流量，及能反馈现场环境。 针对目前野外的环境，无电无网情况下，需要使用全网通的4G网络，低功耗也是4G模块的硬伤，寻觅了很久，朋友介绍过合方圆的4G低功耗模块G8100B,该模块的特点是功耗同比其它模块降低了%50的功耗，能很好地控制整个产品的功耗。 刚好合方圆原厂也提供有4G低功耗摄像头方案，在厂家的技
sobel.rar_FPGA 串口 图片_VGA 串口 图片_fpga 中值_verilog实现sobel_二值化verilog
07-14
工程使用到ram、fifo、pll三种ip核，design文件夹下包含ram、fifo、vga控制以及串口收发和sobel算法模块，sim和doc文件夹下分别包含modelsim的仿真模块和仿真结果；测试时将200*200分辨率的图片用matlab文件夹下的...
Basys3原理图+使用手册-电路方案
04-22
双用户接口开关、双板载输出数量、升级了外部端口（从 6 引脚、单排 Pmod 到 12 引脚、双排 Pmod）和 USB UART 桥接器。 现代编程的挑战: 由于从 Spartan 3E 系列到 Artix 7 类器件的迁移，Basys3 增加了大量硬件...
fpga_adc 经VGA显示，经uart同时传给pc
05-22
使用按键(key1)的下降沿来使能采样，所有点能显示到VGA上，同时经串口把此次采样的所有点(由ram的大小决定，目前为1024个点)传输到pc上。 ---------------------------------------------------
Edu_design.rar
05-25
FPGA实现串口下发图片数据到RAM里，通过VGA显示，整个串口的波特率为9600bps，而显示的图片分辨率为640*480.
基于FPGA的TV-VGA设计.pdf
07-13
"基于FPGA的TV-VGA设计.pdf" 本文主要介绍了一种基于FPGA的TV-VGA设计，旨在解决电视信号(TV)与计算机监视器的VGA信号之间的不兼容问题。设计的核心是基于Altera Cyclone IV E FPGA的TV-VGA转换控制器，该控制器...
串口传图，发送，接收
07-12
串口传图，发送，接收,串口 编程，Linux环境测试ok，代码上传。
FPGA学习项目——RAM读写与UART串口数据发送
qq_51535126的博客
11-27 2132
使用正点原子达芬奇A7板子，在学习8位以及多字节数据的UART串口的接受和发送，以及ROM，RAM存储器IP核的建立和使用等课程后，尝试完成了一道自命题项目：向RAM中循环写入2048个16位数据，通过UART串口将数据发送至上位机，且在发送数据的同时还在向RAM中继续存数据。1.数据是16位的，使用串口发送2个字节的数据到电脑上。2.写入的数据这里暂定与写地址相同，因为位宽不等（2048个数据地址是12位的，这里写入的数据是16位的，进行高位补零）。
中显串口屏 VGUS（Viewtech GraphicalUser Software）
soul_mate_zhao的博客
06-16 5057
5V的串口屏，5英寸以下的小尺寸串口屏才能用USB口供电，7英寸的功耗大，用USB供电可能会导致串口屏闪烁或反反复复复位现象
使用VGUS简单做一个串口屏
weixin_60874964的博客
07-29 2260
①在第二种方法完成的基础上，32位操作系统的到c\windows\system32文件夹下找到cmd.exe文件，右键--以管理员身份运行（关键）--输入regsvr32MSCOMM32.OCX，问题就解决了；关闭掉吧，还不知道这玩意儿怎么使（我好困，我想睡觉，我在沙发上都要瘫了，人太多不好意思睡，其实我还喝了半瓶瑞幸呢，我好想变成猫猫q_q）我发现了，有那么多好看的设计是自己先前底图做的，不是在vgus上面画的。第一和第二种方法部分系统下是可以成功的，第三种方法是所有系统下都可以成功的。...
UART串口传图LCD显示----图像处理
weixin_44939178的博客
03-08 5261
UART串口传图LCD显示----图像处理 设计介绍 首先需要准备一个txt文本，里面存储一个16进制200* 200的图片数据，通过串口调试助手使用串口传输一个200* 200图片，然后通过开发板上的480* 272LCD屏幕显示此图片（数据格式为RGB565）。本篇博客也是图像处理的基础篇，在此基础上可以做一些图像处理项目然后通过LCD屏幕观察实验效果。整体效果如下图所示，因为图片大小为200* 200而显示屏为480* 272，所以剩余部分填充为黑色。 设计思路 通过串口接收模块输出的po_flag
FPGA学习——串口通信与RAM读写
zsisinterested的博客
07-31 5765
串口通信及RAM读写一、工程简介二、功能介绍三、具体实现1.顶层模块三级目录 一、工程简介 （为了方便理解，已将设计中的各个变量名称或程序略作调整，可能在实际运行过程中会出现变量名称不匹配等错误，并不是逻辑错误； 完整程序设计地址如下： ） 串口通信简单来说就是一种以连续的串行数据流形式发送或接收数据的方式。也就是每次传输一个二进制位。 一般来说，一帧数据有八个二进制位。 本工程就是利用串口通信的方式将上位机发送过来的数据接收后写入到FPGA的RAM中，等待发送信号出发后，在将RAM中的信息读取出来发送到上
FPGA串口收发+按键+双口RAM组成的简易系统设计
qq_42761380的博客
04-21 322
FPGA串口收发+按键+双口RAM组成的简易系统设计
qt+串口通信+百度地图
05-14
Qt串口通信模块是Qt中的一个重要模块之一，它可以实现串口通信的各种操作，如数据发送、接收、设置串口参数等。而百度地图是百度公司提供的一款高精度、高实时的在线地图应用，它可以为用户提供周边信息、轨迹规划、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

C.V-Pupil

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值