基于FPGA的VGA协议实现显示 条纹-文字-图片

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

文章目录

一、简单认识VGA和HDMI

HDMI 是新一代的多媒体接口标准，英文全称是 High-Definition Multimedia Interface，即高清多媒体接口。
它能够同时传输视频和音频，简化了设备的接口和连线；同时提供了更高的数据传输带宽，可以传输无压缩的数字音频及高分辨率视频信号。HDMI 1.0 版本于 2002 年发布，最高数据传输速度为 5Gbps；而2017 年发布的 HDMI 2.1 标准的理论带宽可达 48Gbps。
在 HDMI 接口出现之前，被广泛应用的是 VGA 接口。VGA 的全称是 Video Graphics Array，即视频图形阵列，是一个使用模拟信号进行视频传输的标准。VGA 接口采用 15 针插针式结构，里面传输模拟信号颜色分量、同步等信号，是很多老显卡、笔记本和投影仪所使用的接口。由于 VGA 接口传输的是模拟信号，其信号容易受到干扰，因此 VGA 在高分辨率下字体容易虚，信号线长的话，图像有拖尾现象。VGA接口由下图所示：

在这里插入图片描述

二、VGA协议原理简述

协议包含的信号：HS行同步信号，VS场同步信号，RGB三种颜色信号一共5种信号。

RGB分为RGB888，RGB565和RGB332三种不同长度的颜色信号，RGB888表示红绿蓝三个信号各占8个比特，RGB565则红绿蓝分别占5，6，5个比特。
在这里插入图片描述
在这里插入图片描述
这里以 RGB888 格式为例，介绍不同的颜色分量。在图 23.1.3 中，一个像素点占用 3 个字节，其中bit23~bit16 是 RED 通道，bit15~bit8 是 GREEN 通道，bit7~bit0 是 BLUE 通道。所以红色对应的值就是24’hFF0000，
蓝色对应的值就是 24’h0000FF，
绿色对应的值为 24’h00FF00。
通过调节 R、G、B 的比例可以产生其它的颜色，比如 24’hFFFF00 就是黄色，24’h000000 就是黑色，24’hFFFFFF 就是白色。大家可以打开电脑的“画图”工具，在里面使用调色板即可获取到想要的颜色对应的数值，如图 所示：
在这里插入图片描述

VGA协议扫描屏幕的顺序是从左到右，从上到下，从左上到右下。
在这里插入图片描述
根据VGA协议的定义，VGA的行同步信号HSYNC，在每一行开始时产生一个高电平脉冲，场同步信号在每一帧开始时产生一个高电平脉冲。

行同步（横轴），场同步（纵轴），以及它们会产生的脉冲信号：
在这里插入图片描述
VGA协议各种信号的参数来源，根据数据手册（640x480，60HZ和75HZ）：
在这里插入图片描述

三、程序实现

1、相关代码

data_drive.v

module data_drive (input			wire						vga_clk,
                input			wire						rst_n,
                input			wire		[ 11:0 ]		addr_h,
                input			wire		[ 11:0 ]		addr_v,
                input			wire		[ 2:0 ]		 key,
                output			reg		[ 23:0 ]				rgb_data);
    
   

    localparam orange = 24'd16750899;   // 11111100_11111111_00001000
    localparam yellow = 24'd16776960;   // 11111111_11111111_10000000
    localparam green  = 24'd65280;      // 00111111_11111111_00000000
    localparam blue   = 24'd255;        // 00000001_11111111_00000000
    localparam indigo = 24'd10027161;    // 01111100_10000000_00000000
    localparam purple = 24'd16738047;      // 00001111_11111111_00000000
    localparam white  = 24'd16777215;   // 11111111_11111111_11111111
    localparam black  = 24'd0;          // 00000000_00000000_00000000
    localparam red    = 24'd16711936;   // 11111111_11111111_11110000


    // 分辨率为 640*480 时行时序各个参数定义
    parameter       C_H_SYNC_PULSE      =   96  , 
                    C_H_BACK_PORCH      =   48  ,
                    C_H_ACTIVE_TIME     =   640 ,
                    C_H_FRONT_PORCH     =   16  ,
                    C_H_LINE_PERIOD     =   800 ;

    // 分辨率为 640*480 时场时序各个参数定义
    parameter       C_V_SYNC_PULSE      =   2   , 
                    C_V_BACK_PORCH      =   33  ,
                    C_V_ACTIVE_TIME     =   480 ,
                    C_V_FRONT_PORCH     =   10  ,
                    C_V_FRAME_PERIOD    =   525 ;
//


    reg [11:0]  x;
    reg [11:0]  y;

    reg turn_flag_x;
    reg turn_flag_y;

    
    //方块的长和宽
    parameter LENGTH1 = 200;
    parameter WIDTH1  = 200;
    
    reg frame_flag;             		//帧结束标志


    //帧结束标志
    always @(posedge vga_clk or negedge rst_n) begin
        if (!rst_n) begin
            frame_flag <= 1'b0;
        end
        else if ((addr_h == 23) && (addr_v == 23)) begin
            frame_flag <= 1'b1;
        end
        else begin
            frame_flag <= 1'b0;
        end
    end
    
    //变量y
    always @(posedge vga_clk or negedge rst_n) begin
        if (!rst_n) begin
            y <= 'd0;
        end
        else if ((turn_flag_y == 1'b0 && frame_flag == 1'b1 && (y == 480 - WIDTH1 - 1)) || (turn_flag_y == 1'b1 && frame_flag == 1'b1 && (y == 'd0)))begin
            y <= y;
        end
        else if (turn_flag_y == 1'b0 && frame_flag == 1'b1) begin
            y <= y + 1'b1;
        end
        else if (turn_flag_y == 1'b1 && frame_flag == 1'b1) begin
            y <= y - 1'b1;
        end
    end

    //位置变量y翻转标志
    always @(posedge vga_clk or negedge rst_n) begin
        if (!rst_n) begin
            turn_flag_y <= 1'b0;
        end
        else if ((y == 480 - WIDTH1 - 1) && frame_flag == 1'b1 && turn_flag_y == 1'b0) begin
            turn_flag_y <= 1'b1;
        end
        else if (y == 'd0 && frame_flag == 1'b1 && turn_flag_y == 1'b1) begin
            turn_flag_y <= 1'b0;
        end
    end

    //变量x
    always @(posedge vga_clk or negedge rst_n) begin
        if (!rst_n) begin
            x <= 'd0;
        end
        else if((turn_flag_x == 1'b0 && frame_flag == 1'b1 && x == (640 - LENGTH1 - 1'b1)) || (turn_flag_x == 1'b1 && frame_flag == 1'b1 && x == 'd0)) begin
            x <= x;
        end
        else if (turn_flag_x == 1'b0 && frame_flag == 1'b1) begin
            x <= x + 1'b1;
        end
        else if (turn_flag_x == 1'b1 && frame_flag == 1'b1) begin
            x <= x - 1'b1;
        end
    end

    //位置变量x翻转标志
    always @(posedge vga_clk or negedge rst_n) begin
        if (!rst_n) begin
            turn_flag_x <= 1'b0;
        end
        else if (turn_flag_x == 1'b0 && frame_flag == 1'b1 && x == 640 - LENGTH1 - 1'b1) begin
            turn_flag_x <= 1'b1;
        end
        else if (turn_flag_x == 1'b1 && frame_flag == 1'b1 && x == 'd0) begin
            turn_flag_x <= 1'b0;
        end
    end
//



    reg [ 447:0 ] char_line[ 64:0 ];
    localparam	states_1 = 1; // 彩条
    localparam	states_2 = 2; // 字符
    localparam	states_3 = 3; // 图片
    parameter	height = 52; // 图片高度
    parameter	width  = 52; // 图片宽度
    reg			[ 1:0 ]			states_current			; // 当前状态
    reg			[ 1:0 ]			states_next			    ; // 下个状态
    reg			[ 17:0 ]		rom_address				; // ROM地址
    wire			[ 23:0 ]		rom_data				; // 图片数据
    wire							flag_enable_out1			; // 文字有效区域
    wire							flag_enable_out2			; // 图片有效区域
    wire							flag_clear_rom_address		; // 地址清零
    wire							flag_begin_h			    ; // 图片显示行
    wire							flag_begin_v			    ; // 图片显示列
    //状态转移
    always @( posedge vga_clk or negedge rst_n ) begin
        if ( !rst_n ) begin
            states_current <= states_1;
        end
        else begin
            states_current <= states_next;
        end
    end
    //状态判断
    always @( posedge vga_clk or negedge rst_n ) begin
        if ( !rst_n ) begin
            states_next <= states_1;
        end
        else if ( key[ 0 ] ) begin
            states_next <= states_1;
        end
            else if ( key[ 1 ] ) begin
            states_next <= states_2;
            end
            else if ( key[ 2 ] ) begin
            states_next <= states_3;
            end
        else begin
            states_next <= states_next;
        end
    end
    //状态输出
    always @( * ) begin
        case ( states_current )
            states_1 : begin
                if ( addr_h == 0 ) begin
                    rgb_data = black;
                end
                else if(addr_h >= C_H_SYNC_PULSE + C_H_BACK_PORCH + x && addr_h < C_H_SYNC_PULSE + C_H_BACK_PORCH + x + LENGTH1 && addr_v >= C_V_SYNC_PULSE + C_V_BACK_PORCH + y && addr_v < C_V_SYNC_PULSE + C_V_BACK_PORCH + y + WIDTH1)
                        rgb_data = white;
                else if ( addr_h >0 && addr_h <81 ) begin
                    rgb_data = red;
                end
                else if ( addr_h >80 && addr_h <161 ) begin
                    rgb_data = orange;
                end
                else if ( addr_h >160 && addr_h <241 ) begin
                    rgb_data = yellow;
                end
                else if ( addr_h >240 && addr_h <321 ) begin
                    rgb_data = green;
                end
                else if ( addr_h >320 && addr_h <401 ) begin
                    rgb_data = blue;
                end
                else if ( addr_h >400 && addr_h <481 ) begin
                    rgb_data = indigo;
                end
                else if ( addr_h >480 && addr_h <561 ) begin
                    rgb_data = purple;
                end
                else if ( addr_h >560 && addr_h <641 ) begin
                    rgb_data = white;
                end
                else begin
                    rgb_data = black;
                end
                
            end
            states_2 : begin
                if ( flag_enable_out1 ) begin
                    rgb_data = char_line[ addr_v-208 ][ 532 - addr_h ]? white:black;
                end
                else begin
                    rgb_data = black;
                end
            end
            states_3 : begin
                if ( flag_enable_out2 ) begin
                    rgb_data = rom_data;
                end
                else begin
                    rgb_data = black;
                end
                
            end
            default: begin
                case ( addr_h )
                    0 : rgb_data      = black;
                    1 : rgb_data      = red;
                    81 : rgb_data     = orange;
                    161: rgb_data     = yellow;
                    241: rgb_data     = green;
                    321: rgb_data     = blue;
                    401: rgb_data     = indigo;
                    481: rgb_data     = purple;
                    561: rgb_data     = white;
                    default: rgb_data = rgb_data;
                endcase
            end
        endcase
    end
    assign flag_enable_out1 = states_current == states_2 && addr_h > 80 && addr_h < 80+448+1 && addr_v > 208  && addr_v < 273 ;
    assign flag_begin_h     = addr_h > ( ( 640 - width ) / 2 ) && addr_h < ( ( 640 - width ) / 2 ) + width + 1;
    assign flag_begin_v     = addr_v > ( ( 480 - height )/2 ) && addr_v <( ( 480 - height )/2 ) + height + 1;
    assign flag_enable_out2 = states_current == states_3 && flag_begin_h && flag_begin_v;
    //ROM地址计数器
    always @( posedge vga_clk or negedge rst_n ) begin
        if ( !rst_n ) begin
            rom_address <= 0;
        end
        else if ( flag_clear_rom_address  ||  key[ 2 ] ) begin //计数满清零
            rom_address <= 0;
        end
            else if ( flag_enable_out2 ) begin  //在有效区域内+1
            rom_address <= rom_address + 1;
            end
        else begin  //无效区域保持
            rom_address <= rom_address;
        end
    end
    assign flag_clear_rom_address = rom_address == height * width - 1;
    //初始化显示文字
    always@( posedge vga_clk or negedge rst_n ) begin
        if ( !rst_n ) begin
           
    char_line[0]=240'h00000000000000000000000000000000;
    char_line[1]=240'h00000000000000000000000000000000;
    char_line[2]=240'h00000000000000000000000001C00000;
    char_line[3]=240'h000000000000000000000FFF81FC0000;
    char_line[4]=240'h38F9F1C79FDE1C7871F1C0FBBFFE0000;
    char_line[5]=240'h31DBB3CEC1BB18ECF3B3C2FB1FFE0000;
    char_line[6]=240'h709B37CCC3B338CDF137C7DF1FF80000;
    char_line[7]=240'h7C3871CCE333BECE7071C3DF0FFC0000;
    char_line[8]=240'hEE7861CCE733F7CE70F1C1DB0FFC0000;
    char_line[9]=240'hCE18E1CCE633E7CE7031C1DBBFFE0000;
    char_line[10]=240'hCF99C1CEC63B67EC7331C3FB9FFE0000;
    char_line[11]=240'hEFFBF1CFCE3F77FC73F1C77F0FF80000;
    char_line[12]=240'h7CF3F1C78E1E3E7871E1CE180FF80000;
    char_line[13]=240'h0000000000000000000000180FF80000;
    char_line[14]=240'h00000000000000000000001804100000;
    char_line[15]=240'h00000000000000000000000000000000;
        end
    end
    
    //实例化ROM
    ROM1	ROM1_inst (
    .address ( rom_address ),
    .clock ( vga_clk ),
    .q ( rom_data )
    );
endmodule // data_drive

key_debounce.v

module key_debounce(
    input 	wire	clk,
    input 	wire 	rst_n,
    input 	wire 	key,
    
    output 	reg 	flag,// 0抖动, 1抖动结束
    output 	reg	key_value//key抖动结束后的值
);
    
    parameter MAX_NUM = 20'd1_000_000;
    
    reg [19:0] delay_cnt;//1_000_000
    
    reg key_reg;//key上一次的值
    
    always @(posedge clk or negedge rst_n) begin
        if(!rst_n) begin
            key_reg <= 1;
            delay_cnt <= 0;
        end
        
        else begin
            key_reg <= key;
            //当key为1 key 为0 表示按下抖动,开始计时
            if(key_reg  != key  ) begin 
            delay_cnt <= MAX_NUM ;
            end
            else begin
                if(delay_cnt > 0)
                    delay_cnt <= delay_cnt -1;
                else
                    delay_cnt <= 0;
            end
        end
    end
    
    
    //当计时完成,获取key的值
    always @(posedge clk or negedge rst_n) begin
        if(!rst_n) begin
            flag <= 0;
            key_value <= 1;
        end
    
        else begin
            
            // 计时完成 处于稳定状态,进行赋值
            if(delay_cnt == 1) begin
                flag <= 1;
                key_value <= key;
            end
            else begin
                flag <= 0;
                key_value <= key_value;
            end
        end
    end
    
endmodule

top.v

module top(
                input			wire						clk,
                input			wire						rst_n,
                input			wire		[ 2:0 ]		    key,
                output			wire						vga_clk,
                output			wire						h_sync,
                output			wire						v_sync,
                output			wire		[ 7:0 ]			rgb_r,
                output			wire		[ 7:0 ]			rgb_g,
                output			wire		[ 7:0 ]			rgb_b,
                output			reg		    [ 3:0 ]			led);

    reg			[ 27:0 ]			cnt			        ;
    wire		[ 11:0 ]		    addr_h              ;
    wire		[ 11:0 ]		    addr_v              ;
    wire		[ 23:0 ]			rgb_data			;
    wire		[ 2:0 ]			    key_flag			;
    wire		[ 2:0 ]			    key_value			;

    //vga模块
    vga_dirve u_vga_dirve(
        
    .clk      ( clk ),
    .rst_n    ( rst_n ),
    .rgb_data ( rgb_data ),
    .vga_clk  ( vga_clk ),
    .h_sync   ( h_sync ),
    .v_sync   ( v_sync ),
    .rgb_r    ( rgb_r ),
    .rgb_g    ( rgb_g ),
    .rgb_b    ( rgb_b ),
    .addr_h   ( addr_h ),
    .addr_v   ( addr_v )
    );

    //数据模块
    data_drive u_data_drive(
    .vga_clk ( vga_clk ),
    .rst_n   ( rst_n ),
    .addr_h  ( addr_h ),
    .addr_v  ( addr_v ),
    .key     ( {key_value[ 2 ] && key_flag[ 2 ], key_value[ 1 ] && key_flag[ 1 ], key_value[ 0 ] && key_flag[ 0 ] } ),
    .rgb_data  ( rgb_data )
    );


    //按键消抖
    key_debounce u_key_debounce0(
    .clk   ( vga_clk ),
    .rst_n ( rst_n ),
    .key   ( key[ 0 ] ),
    .flag  ( key_flag[ 0 ] ),
    .key_value  ( key_value[ 0 ] )
    );

    key_debounce u_key_debounce1(
    .clk   ( vga_clk ),
    .rst_n ( rst_n ),
    .key   ( key[ 1 ] ),
    .flag  ( key_flag[ 1 ] ),
    .key_value  ( key_value[ 1 ] )
    );

    key_debounce u_key_debounce2(
    .clk   ( vga_clk ),
    .rst_n ( rst_n ),
    .key   ( key[ 2 ] ),
    .flag  ( key_flag[ 2 ] ),
    .key_value  ( key_value[ 2 ] )
    );

    // led
    always @( posedge clk or negedge rst_n ) begin
        if ( !rst_n ) begin
            cnt <= 0;
        end
        else if ( cnt == 50_000_000 - 1 ) begin
            cnt <= 0;
        end
        else begin
            cnt <= cnt + 1;
        end
    end
    always @( posedge clk or negedge rst_n ) begin
        if ( !rst_n ) begin
            led <= 4'b0000;
        end
        else if ( cnt == 50_000_000 -1 )begin
            led <= ~led;
        end
        else begin
            led <= led;
        end
    end
endmodule // vga_top

vga_dirve.v

module vga_dirve (input			wire						clk,            //系统时钟
                input			wire						rst_n,          //复位
                input			wire		[ 23:0 ]		rgb_data,       //16位RGB对应值
                output			wire							vga_clk,    //vga时钟 25M
                output			reg							h_sync,     //行同步信号
                output			reg							v_sync,     //场同步信号
                output			reg		[ 11:0 ]				addr_h, //行地址
                output			reg		[ 11:0 ]				addr_v,  //列地址
                output			wire		[ 7:0 ]				rgb_r,  //红基色
                output			wire		[ 7:0 ]				rgb_g,  //绿基色
                output			wire		[ 7:0 ]				rgb_b  //蓝基色
);
    
    // 640 * 480 60HZ
    localparam	 H_FRONT = 16; // 行同步前沿信号周期长
    localparam	 H_SYNC  = 96; // 行同步信号周期长
    localparam	 H_BLACK = 48; // 行同步后沿信号周期长
    localparam	 H_ACT   = 640; // 行显示周期长
    localparam	 V_FRONT = 11; // 场同步前沿信号周期长
    localparam	 V_SYNC  = 2; // 场同步信号周期长
    localparam	 V_BLACK = 31; // 场同步后沿信号周期长
    localparam	 V_ACT   = 480; // 场显示周期长
    
    // 800 * 600 72HZ
    // localparam	 H_FRONT = 40; // 行同步前沿信号周期长
    // localparam	 H_SYNC  = 120; // 行同步信号周期长
    // localparam	 H_BLACK = 88; // 行同步后沿信号周期长
    // localparam	 H_ACT   = 800; // 行显示周期长
    // localparam	 V_FRONT = 37; // 场同步前沿信号周期长
    // localparam	 V_SYNC  = 6; // 场同步信号周期长
    // localparam	 V_BLACK = 23; // 场同步后沿信号周期长
    // localparam	 V_ACT   = 600; // 场显示周期长
    
    
    localparam	H_TOTAL = H_FRONT + H_SYNC + H_BLACK + H_ACT; // 行周期
    localparam	V_TOTAL = V_FRONT + V_SYNC + V_BLACK + V_ACT; // 列周期
    
    reg			[ 11:0 ]			cnt_h			; // 行计数器
    reg			[ 11:0 ]			cnt_v			; // 场计数器
    reg			[ 23:0 ]			rgb			; // 对应显示颜色值
    
    // 对应计数器开始、结束、计数信号
    wire							flag_enable_cnt_h			;
    wire							flag_clear_cnt_h			;
    wire							flag_enable_cnt_v			;
    wire							flag_clear_cnt_v			;
    wire							flag_add_cnt_v  			;
    wire							valid_area      			;
    
    
    // 25M时钟 行周期*场周期*刷新率 = 800 * 525* 60
    wire							clk_25			;
    // 50M时钟 1040 * 666 * 72
    wire							clk_50			;
    //
    pll	pll_inst (
        .areset ( ~rst_n ),
        .inclk0 ( clk ),
        .c0 ( clk_50 ), //50M
        .c1 ( clk_25 ), //25M
        );
    //根据不同分配率选择不同频率时钟
    assign vga_clk = clk_25;
    
    
    // 行计数
    always @( posedge vga_clk or negedge rst_n ) begin
        if ( !rst_n ) begin
            cnt_h <= 0;
        end
        else if ( flag_enable_cnt_h ) begin
            if ( flag_clear_cnt_h ) begin
                cnt_h <= 0;
            end
            else begin
                cnt_h <= cnt_h + 1;
            end
        end
        else begin
            cnt_h <= 0;
        end
    end
    assign flag_enable_cnt_h = 1;
    assign flag_clear_cnt_h  = cnt_h == H_TOTAL - 1;
    
    // 行同步信号
    always @( posedge vga_clk or negedge rst_n ) begin
        if ( !rst_n ) begin
            h_sync <= 0;
        end
        else if ( cnt_h == H_SYNC - 1 ) begin // 同步周期时为1
            h_sync <= 1;
        end
            else if ( flag_clear_cnt_h ) begin // 其余为0
            h_sync <= 0;
            end
        else begin
            h_sync <= h_sync;
        end
    end
    
    // 场计数
    always @( posedge vga_clk or negedge rst_n ) begin
        if ( !rst_n ) begin
            cnt_v <= 0;
        end
        else if ( flag_enable_cnt_v ) begin
            if ( flag_clear_cnt_v ) begin
                cnt_v <= 0;
            end
            else if ( flag_add_cnt_v ) begin
                cnt_v <= cnt_v + 1;
            end
            else begin
                cnt_v <= cnt_v;
            end
        end
        else begin
            cnt_v <= 0;
        end
    end
    assign flag_enable_cnt_v = flag_enable_cnt_h;
    assign flag_clear_cnt_v  = cnt_v == V_TOTAL - 1;
    assign flag_add_cnt_v    = flag_clear_cnt_h;
    
    // 场同步信号
    always @( posedge vga_clk or negedge rst_n ) begin
        if ( !rst_n ) begin
            v_sync <= 0;
        end
        else if ( cnt_v == V_SYNC - 1 ) begin
            v_sync <= 1;
        end
            else if ( flag_clear_cnt_v ) begin
            v_sync <= 0;
            end
        else begin
            v_sync <= v_sync;
        end
    end
    
    // 对应有效区域行地址 1-640
    always @( posedge vga_clk or negedge rst_n ) begin
        if ( !rst_n ) begin
            addr_h <= 0;
        end
        else if ( valid_area ) begin
            addr_h <= cnt_h - H_SYNC - H_BLACK + 1;
        end
        else begin
            addr_h <= 0;
        end
    end
    // 对应有效区域列地址 1-480
    always @( posedge vga_clk or negedge rst_n ) begin
        if ( !rst_n ) begin
            addr_v <= 0;
        end
        else if ( valid_area ) begin
            addr_v <= cnt_v -V_SYNC - V_BLACK + 1;
        end
        else begin
            addr_v <= 0;
        end
    end
    // 有效显示区域
    assign valid_area = cnt_h >= H_SYNC + H_BLACK && cnt_h <= H_SYNC + H_BLACK + H_ACT && cnt_v >= V_SYNC + V_BLACK && cnt_v <= V_SYNC + V_BLACK + V_ACT;


    // 显示颜色
    always @( posedge vga_clk or negedge rst_n ) begin
        if ( !rst_n ) begin
            rgb <= 24'h0;
        end
        else if ( valid_area ) begin
            rgb <= rgb_data;
        end
        else begin
            rgb <= 24'b0;
        end
    end
    assign rgb_r = rgb[ 23:16 ];
    assign rgb_g = rgb[ 15:8 ];
    assign rgb_b = rgb[ 7:0 ];

endmodule // vga_dirve

2、添加IP核

Tools -> IP Catalog
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
点击next
在这里插入图片描述
一直next到这里
在这里插入图片描述
在这里插入图片描述
然后点finish就可以了
在这里插入图片描述
还要添加一个ROM核用于展示大一点的图片的内容
在这里插入图片描述
用电脑自带的画图软件可以点击“重新调整大小”修改图片的大小，还可以保存为24位位图格式
在这里插入图片描述

用这个软件可以把位图输出成mif格式或者hex格式，下载链接在下面，网上也可以搜到下载链接
在这里插入图片描述
链接：https://pan.baidu.com/s/1E3v6Au58HmBqQC0xouC2cQ?pwd=1234
提取码：1234
在这里插入图片描述
我这个图片的大小是52*52，选择比图片大的大小，所以选的24 4096 如图所示
在这里插入图片描述
在这里插入图片描述
选择生成的.hex文件
在这里插入图片描述
在这里插入图片描述
勾选好点finish就可以了

四、运行结果

在这里插入图片描述

qwert_qqq
关注
  • 26
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
VGA系列之一：VGA显示网络图片
善良の一休君的博客
06-17 1万+
VGA系列之一：VGA显示网络图片VGA系列之一VGA显示网络图片 1 如何用FPGA实现VGA显示 2 网络图片和VGA显示有何区别 3VGA如何显示图片
基于FPGA的VGA协议实现----条纹-文字-图片
LX567567的博客
05-20 997
深入了解VGA协议理解不同显示模式下的VGA控制时序参数完成在VGA上显示对应的条纹-文字-图片为了适应匹配不同厂家的 VGA 显示器， VGA 视频传输接口有自己的一套 VGA 时序标准，只有遵循 VGA 的时序标准，才能正确的进行图像信息的显示。在这里我们以 VESA VGA 时序标准为例，为大家讲解一下 VGA 时序标准，具体见图 2。图 2 VESA VGA时序标准图。
实验二-基于FPGA的VGA协议实现
whynotsolve的博客
05-24 269
OSC_50, //原CLK2_50时钟信号VGA_CLK, //VGA自时钟VGA_HS, //行同步信号VGA_VS, //场同步信号VGA_BLANK, //复合空白信号控制信号 当BLANK为低电平时模拟视频输出消隐电平，此时从R9~R0,G9~G0,B9~B0输入的所有数据被忽略VGA_SYNC, //符合同步控制信号 行时序和场时序都要产生同步脉冲VGA_R, //VGA绿色VGA_B, //VGA蓝色VGA_G);//VGA绿色//外部时钟信号CLK2_50。
基于FPGA的VGA协议实现
qq_33700652的博客
06-07 390
vga显示
FPGA——VGA协议实现特定文字与图像显示
羚漆的博客
06-13 333
FPGA入门——VGA显示
基于fpga的VGA协议实现
m0_65936231的博客
05-24 758
VGA（Video Graphics Array）是一种显示协议，用于控制计算机屏幕的显示。下面是一些常见的VGA控制时序参数及其计算方式。①行频率（Horizontal Refresh Rate）：指每秒钟显示器上水平扫描线的数目。计算方式为行频率 = 垂直频率 × 垂直分辨率。②场频率（Vertical Refresh Rate）：指每秒钟显示器刷新整个屏幕的次数。计算方式为场频率 = 水平频率 ÷ 屏幕上的行数。
御神楽的学习记录之基于FPGA的VGA协议实现
御神楽的博客
06-13 212
VGA(Video Graphics Array) 是IBM在1987年随PS/2机⼀起推出的⼀种视频，具有分辨率⾼ 、显⽰速率快、颜⾊丰富等优点，在彩⾊显⽰器领域得到了⼴泛的应⽤。不⽀持热插拔，不⽀持⾳频传输。对于⼀些嵌⼊式VGA显⽰系统，可以在不使⽤VGA显⽰卡和计算机的情况下，实现VGA图像的显⽰和控制。VGA显⽰器具有成本低、结构简单、应⽤灵活的优点。对于⼀名FPGA⼯程师，尤其是视频图像的⽅向的学习者，VGA协议是必须要掌握的。VGA显⽰器扫描⽅式分为逐⾏扫描和隔⾏扫描：逐⾏扫描是扫描从屏幕左上⾓
EDA/PLD中的基于FPGA的VGA时序彩条信号设计实现
11-10
在这里尝试用FPGA实现 VGA图像显示控制器，这一过程通过编程实现，之后通过软件的测试和仿真，当软件验证无误后完成硬件的下载验证，最终在CRT显示器上实现输出，基本原理就是利用FPGA的可编程原理和VGA的时序控制...
基于FPGA的VGA时序彩条信号设计实现
07-30
"抛弃"VGA的显示专用芯片,采用现场可编程门阵列(FPGA)产生VGA时序信号和彩条图像信号,并在Altera公司的QuartusⅡ软件环境下完成VGA时序彩条信号模块的仿真,最后下载到FPGA开发板中进行硬件验证,并在CRT显示器上得到...
FPGA-VGA-interface.rar_FPGA vga显示_FPGA vga_fpga vga显示_vga_vga v
07-15
基于FPGA的VGA接口显示程序，可显示三种彩色条纹
基于FPGA的VGA图形控制器设计
08-31
利用FPGA设计并实现了一种VGA图形控制器。根据VGA显示原理，利用VHDL作为逻辑描述语言，在Xilinx的开发板Nexys2上完成了设计的功能。通过按动开发板上的按键可切换显示屏显示的图形，可实现横条纹、竖条纹、方格棋盘...
基于FPGA的VGA控制器实现
10-23
摘要：依据标准的VGA显示接口的显示原理，介绍了一种利用可编程逻辑器件FPGA，并以VerilogHDL语言为逻辑描述工具来完成VGA接口的控制，从而实现简单的彩色条纹显示的具体方法。关键宇：VGA；FPGA；VerilogHDL；彩色
System Verilog实现流水灯
wakeup_high的博客
06-09 1061
SystemVerilog既是硬件描述语言（rtl（Register Transfer Level）级），也是硬件验证语言用于为ASIC和FPGA/SoC算法和系统建模、设计、仿真、验证、测试和实现。SystemVerilog基于Verilog语言并进行了大量扩张，并在2009年与Verilog一样称为了同一IEEE标准的一部分。支持有约束随机验证、断言和功能覆盖率，并且支持面向对象的编程。//使用//错误使用light1 = 0;//将reg[7:0] 定义为opreg_t//使用。
第18篇 Intel FPGA Monitor Program的使用＜一＞
weixin_47841246的博客
06-11 272
Intel FPGA Monitor Program开发工具支持Terasic的FPGA开发板使用
RGMII接口---＞(013)FPGA实现RGMII接口(十三)
2401_84405631的博客
06-09 145
（a）FPGA（Field Programmable Gate Array）是在PAL （可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）FPGA工程师就业应用于通信、航空航天、汽车电子，还是人工智能、物联网等新兴领域。
RAM IP核配置
最新发布
hhh123987_的博客
06-12 974
RAM IP核创建与测试
18.双线性插值缩放算法的matlab与FPGA实现（二）
q1594的博客
06-09 592
在图像算法中，可以知道算法本身不算复杂，但是在FPGA中，视频主要用视频流的方式在FPGA中，基本不可能对图像进行任意位置的索引。因此，如何根据视频流来进行插值最难的点在于如何寻找到缩放后的点对应的四个点坐标。根据视频流的特点，可以知道视频流的索引式按照左上到右下进行依次索引的。根据这个特点，可以实现只缓存几行数据即可实现图像的索引。这里缩放算法对视频流有两种，一种是主动式(act)，另一种是被动式（inact），主动式是指算法的视频流输入不受缩放模块控制，视频信息通常以视频流的方式直接进入模块。
AXI Quad SPI IP核中的STARTUPEn原语参数
u011565038的博客
06-09 679
启动STARTUPEn Primitive（原语）参数在 FPGA的主 SPI模式下非常有用。当你启用这个参数时，对于 7 系列设备，STARTUPE2原语会被包含在设计中；而对于 UltraScale™ 设备，则是STARTUPE3原语。这些原语在 FPGA 配置后成为IP核的一部分。
基于FPGA的VGA彩条显示
09-14
对于基于FPGA的VGA彩条显示，你可以按照以下步骤进行设计和实现： 1. 首先，你需要熟悉VGA接口协议和彩色图像的表示方式。VGA接口通常有红（R）、绿（G）、蓝（B）三个颜色通道和水平（Hsync）和垂直（Vsync）同步...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值