基于FPGA的VGA协议实现

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

目录

一、 内容概要

  1. 深入了解VGA协议，理解不同显示模式下的VGA控制时序参数（行频、场频、水平/垂直同步时钟周期、显示后沿/前沿等概念和计算方式）

  2. 通过Verilog编程，在至少2种显示模式下（640480@60Hz,1024768@75Hz）分别实现以下VGA显示，并对照VGA协议信号做时序分析：1）屏幕上显示彩色条纹；2）显示自定义的汉字字符（姓名-学号）；3）（FPGA方向同学做）输出一幅彩色图像。

二、 了解VGA

2.1 概念

VGA（Video Graphics Array）视频图形阵列是IBM于1987年提出的一个使用模拟信号的电脑显示标准。VGA接口即电脑采用VGA标准输出数据的专用接口。VGA接口共有15针，分成3排，每排5个孔，显卡上应用最为广泛的接口类型，绝大多数显卡都带有此种接口。它传输红、绿、蓝模拟信号以及同步信号(水平和垂直信号)。

VGA接口是一种D型接口，上面共有15针孔，分成三排，每排五个。 其中，除了2根NC（Not Connect)信号、3根显示数据总线和5个GND信号，比较重要的是3根RGB彩色分量信号和2根扫描同步信号HSYNC和VSYNC针。VGA接口中彩色分量采用RS343电平标准。RS343电平标准的峰值电压为1V。VGA接口是显卡上应用最为广泛的接口类型，多数的显卡都带有此种接口。有些不带VGA接口而带有DVI(Digital Visual Interface数字视频接口）接口的显卡，也可以通过一个简单的转接头将DVI接口转成VGA接口，通常没有VGA接口的显卡会附赠这样的转接头。

外观：

在这里插入图片描述
管脚图：
在这里插入图片描述
通信协议：
VGA接口的通信协议主要基于模拟信号传输，具体包括：

  1. 视频信号：通过VGA接口传输的信号包括RGB（红绿蓝）颜色分量和同步信号。
  2. 同步信号：包括水平同步（HSync）和垂直同步（VSync）信号，用于同步显示器的刷新率。
  3. 控制信号：如DDC（Display Data Channel），用于传输显示器的配置信息。
    通信方式：
  4. 模拟传输：VGA接口通过模拟信号传输视频数据，这意味着信号在传输过程中可能会受到干扰，导致画质下降。
  5. 信号类型：VGA接口传输的信号包括RGB颜色分量信号和同步信号。
  6. 信号传输：信号通过VGA电缆中的导线传输，通常需要屏蔽以减少电磁干扰。
    特点：
  7. 易用性：VGA接口易于使用，且在很多设备上都能找到。
  8. 普及性：由于其历史悠久，VGA接口在很多老旧设备上仍然得到支持。
  9. 局限性：由于是模拟信号，VGA在长距离传输或高分辨率显示时可能会遇到信号衰减和画质下降的问题。

三、 VGA基础显示

VGA管脚说明:
在这里插入图片描述

3.1 条纹显示

直接编译烧录此代码就行

module VGA_colorbar_test(
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绿色
 input OSC_50;     //外部时钟信号CLK2_50
 output VGA_CLK,VGA_HS,VGA_VS,VGA_BLANK,VGA_SYNC;
 output [7:0] VGA_R,VGA_B,VGA_G;
 parameter H_FRONT = 16;     //行同步前沿信号周期长
 parameter H_SYNC = 96;      //行同步信号周期长
 parameter H_BACK = 48;      //行同步后沿信号周期长
 parameter H_ACT = 640;      //行显示周期长
 parameter H_BLANK = H_FRONT+H_SYNC+H_BACK;        //行空白信号总周期长
 parameter H_TOTAL = H_FRONT+H_SYNC+H_BACK+H_ACT;  //行总周期长耗时
 parameter V_FRONT = 11;     //场同步前沿信号周期长
 parameter V_SYNC = 2;       //场同步信号周期长
 parameter V_BACK = 31;      //场同步后沿信号周期长
 parameter V_ACT = 480;      //场显示周期长
 parameter V_BLANK = V_FRONT+V_SYNC+V_BACK;        //场空白信号总周期长
 parameter V_TOTAL = V_FRONT+V_SYNC+V_BACK+V_ACT;  //场总周期长耗时
 reg [10:0] H_Cont;        //行周期计数器
 reg [10:0] V_Cont;        //场周期计数器
 wire [7:0] VGA_R;         //VGA红色控制线
 wire [7:0] VGA_G;         //VGA绿色控制线
 wire [7:0] VGA_B;         //VGA蓝色控制线
 reg VGA_HS;
 reg VGA_VS;
 reg [10:0] X;             //当前行第几个像素点
 reg [10:0] Y;             //当前场第几行
 reg CLK_25;
 always@(posedge OSC_50)begin 
      CLK_25=~CLK_25;         //时钟
 end 

 assign VGA_SYNC = 1'b0;   //同步信号低电平
 assign VGA_BLANK = ~((H_Cont<H_BLANK)||(V_Cont<V_BLANK));  //当行计数器小于行空白总长或场计数器小于场空白总长时，空白信号低电平
 assign VGA_CLK = ~CLK_to_DAC;  //VGA时钟等于CLK_25取反
 assign CLK_to_DAC = CLK_25;

 always@(posedge CLK_to_DAC)begin
        if(H_Cont<H_TOTAL)           //如果行计数器小于行总时长
            H_Cont<=H_Cont+1'b1;      //行计数器+1
        else H_Cont<=0;              //否则行计数器清零
        if(H_Cont==H_FRONT-1)        //如果行计数器等于行前沿空白时间-1
            VGA_HS<=1'b0;             //行同步信号置0
        if(H_Cont==H_FRONT+H_SYNC-1) //如果行计数器等于行前沿+行同步-1
            VGA_HS<=1'b1;             //行同步信号置1
        if(H_Cont>=H_BLANK)          //如果行计数器大于等于行空白总时长
            X<=H_Cont-H_BLANK;        //X等于行计数器-行空白总时长   （X为当前行第几个像素点）
        else X<=0;                   //否则X为0
end

 always@(posedge VGA_HS)begin
        if(V_Cont<V_TOTAL)           //如果场计数器小于行总时长
            V_Cont<=V_Cont+1'b1;      //场计数器+1
        else V_Cont<=0;              //否则场计数器清零
        if(V_Cont==V_FRONT-1)       //如果场计数器等于场前沿空白时间-1
            VGA_VS<=1'b0;             //场同步信号置0
        if(V_Cont==V_FRONT+V_SYNC-1) //如果场计数器等于行前沿+场同步-1
            VGA_VS<=1'b1;             //场同步信号置1
        if(V_Cont>=V_BLANK)          //如果场计数器大于等于场空白总时长
            Y<=V_Cont-V_BLANK;        //Y等于场计数器-场空白总时长    （Y为当前场第几行）  
        else Y<=0;                   //否则Y为0
end

 reg valid_yr;

 always@(posedge CLK_to_DAC)begin
    if(V_Cont == 10'd32)         //场计数器=32时
        valid_yr<=1'b1;           //行输入激活
    else if(V_Cont==10'd512)     //场计数器=512时
        valid_yr<=1'b0;           //行输入冻结
 end

 wire valid_y=valid_yr;       //连线   
 reg valid_r;     

 always@(posedge CLK_to_DAC)begin
    if((H_Cont == 10'd32)&&valid_y)     //行计数器=32时
        valid_r<=1'b1;                   //像素输入激活
    else if((H_Cont==10'd512)&&valid_y) //行计数器=512时 
        valid_r<=1'b0;                   //像素输入冻结
 end

 wire valid = valid_r;               //连线
 assign x_dis=X;       //连线X
 assign y_dis=Y;       //连线Y
 // reg[7:0] char_bit;
 // always@(posedge CLK_to_DAC)
 //     if(X==10'd144)char_bit<=9'd240;   //当显示到144像素时准备开始输出图像数据
 //     else if(X>10'd144&&X<10'd384)     //左边距屏幕144像素到416像素时    416=144+272（图像宽度）
 //         char_bit<=char_bit-1'b1;       //倒着输出图像信息
         
 reg[29:0] vga_rgb;                //定义颜色缓存
 always@(posedge CLK_to_DAC) begin
     if(X>=0&&X<200)begin    //X控制图像的横向显示边界：左边距屏幕左边144像素  右边界距屏幕左边界416像素
         vga_rgb<=30'hffffffffff;   //白色
     end
     else if(X>=200&&X<400)begin
         vga_rgb<=30'hf00ff65f1f;   
     end
     else if(X>=400&&X<600)begin
         vga_rgb<=30'h9563486251; 
     end
     else begin
         vga_rgb<=30'h5864928654; 
     end
 end
 assign VGA_R=vga_rgb[23:16];
 assign VGA_G=vga_rgb[15:8];
 assign VGA_B=vga_rgb[7:0];
endmodule

结果:
在这里插入图片描述
此640*480@60hz，修改模式照着上面参数表修改参数即可
在这里插入图片描述
可以参考表：
在这里插入图片描述
也可以直接问AI：
在这里插入图片描述

3.2 显示字符

3.2.1 准备工作

  1. 汉字点阵提取软件

链接：https://pan.baidu.com/s/1EInMlOq8J4y0kcXMPFYUGQ
提取码：1234

  1. 转换程序（自己写的，将提取的字模转换为verilog变量）
//CharacterData.java
import java.util.List;

public class CharacterData {
    private List<String> charData;
    private String charaName;

    public CharacterData(List<String> charData, String charaName) {
        this.charData = charData;
        this.charaName = charaName;
    }

    // Getters and Setters
    public List<String> getCharData() {
        return charData;
    }

    public void setCharData(List<String> charData) {
        this.charData = charData;
    }

    public String getCharaName() {
        return charaName;
    }

    public void setCharaName(String charaName) {
        this.charaName = charaName;
    }
}

//CharDataParser.java
import java.io.*;
import java.util.ArrayList;
import java.util.List;

public class CharDataParser {

    public static List<CharacterData> parseCharDataFromFile(String filePath) {
        List<CharacterData> charDataList = new ArrayList<>();
        List<String> currentData = new ArrayList<>();
        String currentName = null;

        try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
            String line;
            while ((line = reader.readLine()) != null) {
                line = line.trim(); // 去除行首行尾的空白字符
                String[] items = line.split(",");
                // 查找 "//" 并检查其后是否有非空白字符
                int commentIndex = line.indexOf("//");
                if (commentIndex != -1) {
                    // 截取 "//" 后面的字符名称
                    currentName = line.substring(commentIndex + 2).trim();
                    // 截取 "//" 之前的数据作为字模数据
                    items = line.substring(0, commentIndex).trim().split(",");
                    for (int i =0; i < items.length; i++) {
                        currentData.add(items[i]);
                    }
                    // 如果当前已经有字符名称，保存当前数据
                    if (currentName != null && !currentData.isEmpty()) {
                        charDataList.add(new CharacterData(currentData, currentName));
                        currentData = new ArrayList<>(); // 重置当前数据列表
                        currentName = null; // 重置字符名称
                    }
                } else if (!line.isEmpty()) {
                    for (int i =0; i < items.length; i++) {
                        currentData.add(items[i]);
                    }
                }
            }
            // 检查文件末尾是否有未保存的数据
            if (currentName != null && !currentData.isEmpty()) {
                charDataList.add(new CharacterData(currentData, currentName));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        return charDataList;
    }
    public static List<String> parseToVGA(List<CharacterData> charDataList) {
        List<String> charData = new ArrayList<>();

        for (int i = 0 ;i<16;i++){
            String data="";
            for (int j = 0; j<charDataList.size();j++) {
                data+=charDataList.get(j).getCharData().get(i*2);
                data+=charDataList.get(j).getCharData().get(i*2+1);
            }
            charData.add(data);
        }
        return charData;
    }
    public static void writeToFile(List<String> charDataList, String filePath) {
        int dataSize = 16; // 每行数据的大小
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(filePath))) {

            // 写入文件
            for (int i = 0; i < charDataList.size(); i++) {
                String lineName = "char_line" + String.format("%02x", i) + "=240'h";
                writer.write(lineName);
                writer.write(charDataList.get(i));
                if(i==charDataList.size()-1){
                    writer.write(";");
                }else {
                    writer.write(",");
                }
                writer.newLine(); // 添加换行符以便分隔每行数据
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        // 假设你的文件路径是 "path/to/your/notepad.txt"
        List<CharacterData> charDataList = parseCharDataFromFile("E:/file.txt");
        // 打印结果，以验证解析是否正确
        for (CharacterData data : charDataList) {
            System.out.println("Character Name: " + data.getCharaName());
            for (String line : data.getCharData()) {
                System.out.println(line);
            }
        }
        List<String> charDataList2 = parseToVGA(charDataList);
        for (String line : charDataList2) {
            System.out.println(line);
        }
        writeToFile(charDataList2, "E:/file_out.txt");
    }
}

3.2.2 提取文字

打开取字模软件

点击设置进行参数调整
在这里插入图片描述

输入文字点击生成字模
在这里插入图片描述

这个时候可以手动将字模数据转换成verilog变量，格式是：
VGA是一行一行刷新数据的，共16行，所以需要提取出字模的每一行（每四位为一行）每个字四位四位提取拼接为一行
如“你好”：

10010800
1001083F
10010820
887F0810
88403F08
4C202404
2C042404
0A04A47F
89142404
88241204
48241404
48440804
28441404
08042204
08052105
08020002

接下来使用下我提供的一键转换代码

首先打开idea新建项目，创建两个文件到main里
在这里插入图片描述
修改参数：
在这里插入图片描述
建议不要用提供的路径，把相对路径修改为绝对路径，如D:/file.txt
打开输入文件，将字模文件生成的数据复制粘贴到里面
在这里插入图片描述
点击运行
在这里插入图片描述
然后找到输出文件:
在这里插入图片描述
直接复制到代码里面就行

3.2.3 编写代码

vga打印字符代码：

module vga(
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绿色
 input OSC_50;     //外部时钟信号CLK2_50
 output VGA_CLK,VGA_HS,VGA_VS,VGA_BLANK,VGA_SYNC;
 output [7:0] VGA_R,VGA_B,VGA_G;
 parameter H_FRONT = 16;     //行同步前沿信号周期长
 parameter H_SYNC = 96;      //行同步信号周期长
 parameter H_BACK = 48;      //行同步后沿信号周期长
 parameter H_ACT = 640;      //行显示周期长
 parameter H_BLANK = H_FRONT+H_SYNC+H_BACK;        //行空白信号总周期长
 parameter H_TOTAL = H_FRONT+H_SYNC+H_BACK+H_ACT;  //行总周期长耗时
 parameter V_FRONT = 11;     //场同步前沿信号周期长
 parameter V_SYNC = 2;       //场同步信号周期长
 parameter V_BACK = 31;      //场同步后沿信号周期长
 parameter V_ACT = 480;      //场显示周期长
 parameter V_BLANK = V_FRONT+V_SYNC+V_BACK;        //场空白信号总周期长
 parameter V_TOTAL = V_FRONT+V_SYNC+V_BACK+V_ACT;  //场总周期长耗时
 reg [10:0] H_Cont;        //行周期计数器
 reg [10:0] V_Cont;        //场周期计数器
 wire [7:0] VGA_R;         //VGA红色控制线
 wire [7:0] VGA_G;         //VGA绿色控制线
 wire [7:0] VGA_B;         //VGA蓝色控制线
 reg VGA_HS;
 reg VGA_VS;
 reg [10:0] X;             //当前行第几个像素点
 reg [10:0] Y;             //当前场第几行
 reg CLK_25;
 always@(posedge OSC_50)
    begin 
      CLK_25=~CLK_25;         //时钟
    end 
    assign VGA_SYNC = 1'b0;   //同步信号低电平
    assign VGA_BLANK = ~((H_Cont<H_BLANK)||(V_Cont<V_BLANK));  //当行计数器小于行空白总长或场计数器小于场空白总长时，空白信号低电平
    assign VGA_CLK = ~CLK_to_DAC;  //VGA时钟等于CLK_25取反
    assign CLK_to_DAC = CLK_25;
 always@(posedge CLK_to_DAC)
    begin
        if(H_Cont<H_TOTAL)           //如果行计数器小于行总时长
            H_Cont<=H_Cont+1'b1;      //行计数器+1
        else H_Cont<=0;              //否则行计数器清零
        if(H_Cont==H_FRONT-1)        //如果行计数器等于行前沿空白时间-1
            VGA_HS<=1'b0;             //行同步信号置0
        if(H_Cont==H_FRONT+H_SYNC-1) //如果行计数器等于行前沿+行同步-1
            VGA_HS<=1'b1;             //行同步信号置1
        if(H_Cont>=H_BLANK)          //如果行计数器大于等于行空白总时长
            X<=H_Cont-H_BLANK;        //X等于行计数器-行空白总时长   （X为当前行第几个像素点）
        else X<=0;                   //否则X为0
    end
 always@(posedge VGA_HS)
    begin
        if(V_Cont<V_TOTAL)           //如果场计数器小于行总时长
            V_Cont<=V_Cont+1'b1;      //场计数器+1
        else V_Cont<=0;              //否则场计数器清零
        if(V_Cont==V_FRONT-1)       //如果场计数器等于场前沿空白时间-1
            VGA_VS<=1'b0;             //场同步信号置0
        if(V_Cont==V_FRONT+V_SYNC-1) //如果场计数器等于行前沿+场同步-1
            VGA_VS<=1'b1;             //场同步信号置1
        if(V_Cont>=V_BLANK)          //如果场计数器大于等于场空白总时长
            Y<=V_Cont-V_BLANK;        //Y等于场计数器-场空白总时长    （Y为当前场第几行）  
        else Y<=0;                   //否则Y为0
    end
    reg valid_yr;
 always@(posedge CLK_to_DAC)
    if(V_Cont == 10'd32)         //场计数器=32时
        valid_yr<=1'b1;           //行输入激活
    else if(V_Cont==10'd512)     //场计数器=512时
        valid_yr<=1'b0;           //行输入冻结
    wire valid_y=valid_yr;       //连线   
    reg valid_r;            
 always@(posedge CLK_to_DAC)   
    if((H_Cont == 10'd32)&&valid_y)     //行计数器=32时
        valid_r<=1'b1;                   //像素输入激活
    else if((H_Cont==10'd512)&&valid_y) //行计数器=512时 
        valid_r<=1'b0;                   //像素输入冻结
    wire valid = valid_r;               //连线
    wire[10:0] x_dis;     //像素显示控制信号
    wire[10:0] y_dis;     //行显示控制信号
    assign x_dis=X;       //连线X
    assign y_dis=Y;       //连线Y
        parameter

        char_line00=256'h0000210400200000000000000000000000000000000000000000000000000000,
        char_line01=256'h1FF0108402220000000000000000000000000000000000000000000000000000,
        char_line02=256'h10101088FA220000000000000000000000000000000000000000000000000000,
        char_line03=256'h1010F8002222000007F00FE00FF0008007E01FFC07E007F007E00FE00FF00FE0,
        char_line04=256'h10100BFE23FE0000081830183018078018183008181808181818301830183018,
        char_line05=256'h101010202000000010003818380C0180381C2010381C1000381C3818380C3818,
        char_line06=256'h1FF0102027FE00003000001810180180300C0020300C3000300C001810180018,
        char_line07=256'h000039FCF820000037F0006000180180300C0040300C37F0300C006000180060,
        char_line08=256'h0000542020400000380C01F000600180300C0080300C380C300C01F0006001F0,
        char_line09=256'h3FF8902023FE0000300C001801800180300C0180300C300C300C001801800018,
        char_line0a=256'h200813FE22520000300C000C06000180300C0300300C300C300C000C0600000C,
        char_line0b=256'h200810203A520000300C380C08040180381803003818300C3818380C0804380C,
        char_line0c=256'h20081020E252000018183018300C01801C1003801C1018181C103018300C3018,
        char_line0d=256'h200810204252000007E00FE03FF80FF807E0030007E007E007E00FE03FF80FE0,
        char_line0e=256'h3FF8102002520000000000000000000000000000000000000000000000000000,
        char_line0f=256'h2008102002060000000000000000000000000000000000000000000000000000;

    reg[7:0] char_bit;
    always@(posedge CLK_to_DAC)
        if(X==10'd164)char_bit<=9'd256;   //当显示到164像素时准备开始输出图像数据
        else if(X>10'd164&&X<10'd420)     //左边距屏幕164像素到420像素时    420=164+256（图像宽度）
            char_bit<=char_bit-1'b1;       //倒着输出图像信息
            
    reg[29:0] vga_rgb;                //定义颜色缓存
    always@(posedge CLK_to_DAC) 
        if(X>10'd164&&X<10'd420)    //X控制图像的横向显示边界：左边距屏幕左边164像素  右边界距屏幕左边界420像素
            begin case(Y)            //Y控制图像的纵向显示边界：从距离屏幕顶部160像素开始显示第一行数据
                10'd200:
                if(char_line00[char_bit])vga_rgb<=30'b1111111111_0000000000_0000000000;  //如果该行有数据 则颜色为红色
                else vga_rgb<=30'b0000000000_0000000000_0000000000;                      //否则为黑色
                10'd201:
                if(char_line01[char_bit])vga_rgb<=30'b1111111111_0000000000_0000000000;
                else vga_rgb<=30'b0000000000_0000000000_0000000000;
                10'd202:
                if(char_line02[char_bit])vga_rgb<=30'b1111111111_0000000000_0000000000;
                else vga_rgb<=30'b0000000000_0000000000_0000000000;
                10'd203:
                if(char_line03[char_bit])vga_rgb<=30'b1111111111_0000000000_0000000000;
                else vga_rgb<=30'b0000000000_0000000000_0000000000;
                10'd204:
                if(char_line04[char_bit])vga_rgb<=30'b1111111111_0000000000_0000000000;
                else vga_rgb<=30'b0000000000_0000000000_0000000000; 
                10'd205:
                if(char_line05[char_bit])vga_rgb<=30'b1111111111_0000000000_0000000000;
                else vga_rgb<=30'b0000000000_0000000000_0000000000;
                10'd206:
                if(char_line06[char_bit])vga_rgb<=30'b1111111111_0000000000_0000000000;
                else vga_rgb<=30'b0000000000_0000000000_0000000000; 
                10'd207:
                if(char_line07[char_bit])vga_rgb<=30'b1111111111_0000000000_0000000000;
                else vga_rgb<=30'b0000000000_0000000000_0000000000;
                10'd208:
                if(char_line08[char_bit])vga_rgb<=30'b1111111111_0000000000_0000000000;
                else vga_rgb<=30'b0000000000_0000000000_0000000000; 
                10'd209:
                if(char_line09[char_bit])vga_rgb<=30'b1111111111_0000000000_0000000000;
                else vga_rgb<=30'b0000000000_0000000000_0000000000;
                10'd210:
                if(char_line0a[char_bit])vga_rgb<=30'b1111111111_0000000000_0000000000;
                else vga_rgb<=30'b0000000000_0000000000_0000000000;
                10'd211:
                if(char_line0b[char_bit])vga_rgb<=30'b1111111111_0000000000_0000000000;
                else vga_rgb<=30'b0000000000_0000000000_0000000000;
                10'd212:
                if(char_line0c[char_bit])vga_rgb<=30'b1111111111_0000000000_0000000000;
                else vga_rgb<=30'b0000000000_0000000000_0000000000;
                10'd213:
                if(char_line0d[char_bit])vga_rgb<=30'b1111111111_0000000000_0000000000;
                else vga_rgb<=30'b0000000000_0000000000_0000000000;
                10'd214:
                if(char_line0e[char_bit])vga_rgb<=30'b1111111111_0000000000_0000000000;
                else vga_rgb<=30'b0000000000_0000000000_0000000000;
                10'd215:
                if(char_line0f[char_bit])vga_rgb<=30'b1111111111_0000000000_0000000000;
                else vga_rgb<=30'b0000000000_0000000000_0000000000;
                default:vga_rgb<=30'h0000000000;   //默认颜色黑色
            endcase 
        end
    else vga_rgb<=30'h000000000;             //否则黑色
    assign VGA_R=vga_rgb[23:16];
    assign VGA_G=vga_rgb[15:8];
    assign VGA_B=vga_rgb[7:0];
endmodule

注意:
代码中这几个部分是控制显示长度的，根据实际情况调整,256是代表宽度，420是代表逆向打印的起始位置，164是起始位置减去长度(420-256)，一个汉字16位，可以根据实际情况计算宽度
在这里插入图片描述

3.2.4 编译烧录

新建Quartus项目编译烧录
在这里插入图片描述
结果:
在这里插入图片描述

3.3 显示图像

3.3.1 准备工作

  1. 首先下载位图转换软件
    BMP2MIf
  2. 找到一张图片，转化为位图，可以去在线转换
  3. 把bmp图片转化为mif在这里插入图片描述

3.3.2 实现例程

引入IP核，在右侧找到ip catalog，如果没有则可以从顶部view里面找到打开
搜索找到ROM:1-PORT双击
在这里插入图片描述
设置：
words大小取决于图片大小，大于图片大小就行,
24是图片位数，根据实际情况修改
在这里插入图片描述
next
取消勾选
在这里插入图片描述
next
选择生成的mif文件(24位位图是mif，若是16位应该使用HEX）
勾选然后finish
在这里插入图片描述

编写代码：

//vga_para.v
`define 	vga_640_480

`ifdef	vga_640_480
	`define	H_Right_Border 8
	`define	H_Front_Porch  8
	`define	H_Sync_Time    96
	`define	H_Back_Porch	40
	`define	H_Left_Border	8
	`define	H_Data_Time		640
	`define	H_Total_Time	800
	`define	V_Bottom_Border	8
	`define	V_Front_Porch	2
	`define	V_Sync_Time		2
	`define	V_Back_Porch	25
	`define	V_Top_Border	8
	`define	V_Data_Time		480
	`define	V_Total_Time	525

`elsif	vga_1920_1080
	`define	H_Right_Border 0
	`define	H_Front_Porch  88
	`define	H_Sync_Time    44
	`define	H_Back_Porch	148
	`define	H_Left_Border	0
	`define	H_Data_Time		1920
	`define	H_Total_Time	2200
	`define	V_Bottom_Borde	0
	`define	V_Front_Porch	4
	`define	V_Sync_Time		5
	`define	V_Back_Porch	36
	`define	v_Top_Border	2
	`define	v_Data_Time		1080
	`define	v_Total_Time	1125

	
`endif


//vga_drive.v
//`define 	vga_1920_1080L
`include "vga_para.v"

module vga_drive(

	input						clk			, //640*480--25.2M
	input						rst_n			,
	input	 		[15:0]	data_display,
	
	output reg	[11:0] 	h_addr		,//数据有效显示区域行地址
	output reg	[11:0]	v_addr		,//数据有效显示区域场地址
	
	output reg				vsync			,
	output reg				hsync			,
	output reg 	[4:0]		vga_r			,
	output reg 	[5:0]		vga_g			,
	output reg 	[4:0]		vga_b			,
	output reg				vga_blk		,//消隐信号
	output					vga_clk		,
	output 					sync			
	
);

wire				clk_25M;	
wire				locked;

pll25	pll_inst (
	.areset 		( ~rst_n ),
	.inclk0     ( clk ),
	.c0 		   ( clk_25M ),
	);
	


assign	vga_clk = clk_25M;

assign	sync = hsync && vsync;

parameter	H_SYNC_STA = 1;
parameter   H_SYNC_STO = `H_Sync_Time;
parameter   H_Data_STA = `H_Right_Border + `H_Front_Porch + `H_Sync_Time;
parameter   H_Data_STO = `H_Right_Border + `H_Front_Porch + `H_Sync_Time + `H_Data_Time;

parameter   V_SYNC_STA = 1;
parameter   V_SYNC_STO = `V_Sync_Time;
parameter   V_Data_STA = `V_Bottom_Border + `V_Front_Porch + `V_Sync_Time;
parameter   V_Data_STO = `V_Bottom_Border + `V_Front_Porch + `V_Sync_Time + `V_Data_Time;


wire				add_h_addr		;
wire				end_h_addr		;


reg	[11:0]	cnt_v_addr;//行地址寄存器
wire				add_cnt_v_addr	;
wire				end_cnt_v_addr	;

reg	[11:0]	cnt_h_addr		;//场地址寄存器
wire				add_cnt_h_addr ;
wire				end_cnt_h_addr ;

always@(posedge	vga_clk or negedge	rst_n)begin
	if(!rst_n)begin
		cnt_h_addr <= 12'd0;
	end
	else if(add_cnt_h_addr)begin
		if(end_cnt_h_addr)
			cnt_h_addr <= 12'd0;
		else
			cnt_h_addr <= cnt_h_addr + 12'd1;
	end
	else begin
		cnt_h_addr <= 12'd0;
	end
		
	
end
assign	add_cnt_h_addr = 1'b1;
assign	end_cnt_h_addr = add_cnt_h_addr && cnt_h_addr >= `H_Total_Time - 1;
 

always@(posedge	vga_clk or negedge	rst_n)begin
	if(!rst_n)begin
		cnt_v_addr <= 12'd0;
	end
	else if(add_cnt_v_addr)begin
		if(end_cnt_v_addr)
			cnt_v_addr <= 12'd0;
		else
			cnt_v_addr <= cnt_v_addr + 12'd1;
	end
	else begin
		cnt_v_addr <= cnt_v_addr;
	end
		
	
end
assign	add_cnt_v_addr = end_cnt_h_addr;
assign	end_cnt_v_addr = add_cnt_v_addr && cnt_v_addr >= `V_Total_Time - 1; 


//行场同步信号
always@(posedge	vga_clk or negedge	rst_n)begin
	if(!rst_n)
		hsync <= 1'b1;
	else if(cnt_h_addr == H_SYNC_STA -1)
		hsync <= 1'b0;
	else if(cnt_h_addr == H_SYNC_STO-1)
		hsync <= 1'b1;
	else
		hsync <= hsync;
end

always@(posedge	vga_clk or negedge	rst_n)begin
	if(!rst_n)
		vsync <= 1'b1;
	else if(cnt_v_addr == V_SYNC_STA -1)
		vsync <= 1'b0;
	else if(cnt_v_addr == V_SYNC_STO-1)
		vsync <= 1'b1;
	else
		vsync <= vsync;
end



//有效显示区域
always@(posedge vga_clk or negedge rst_n)begin
	if(!rst_n)
		h_addr <= 12'b0;
	else	if(cnt_h_addr >= H_Data_STA && cnt_h_addr <= H_Data_STO)begin
		h_addr <= cnt_h_addr - H_Data_STA ;
		vga_blk <= 1'b1;
	end
   else begin
		h_addr <= 12'b0;
		vga_blk <= 1'b0;
	end
	
end
always@(posedge vga_clk or negedge rst_n)begin
	if(!rst_n)
		v_addr <= 12'b0;
	else	if(cnt_v_addr >= V_Data_STA  && cnt_v_addr <= V_Data_STO)begin
		v_addr <= cnt_v_addr - V_Data_STA;
	end
   else begin
		v_addr <= 12'b0;
	end
	
end


//数据显示
always@(posedge vga_clk or negedge rst_n)begin
	if(!rst_n)begin
		vga_r <= 5'h0;
		vga_g <= 6'h0;
		vga_b <= 5'h0;
	end
	else	if(cnt_h_addr >= H_Data_STA - 1 && cnt_h_addr <= H_Data_STO - 1 && 
					cnt_v_addr >= V_Data_STA - 1 && cnt_v_addr <= V_Data_STO - 1)begin
		vga_r <= data_display[15:11];	//data_display[23-:8]
		vga_g <= data_display[10:5];	//data_display[15-:8]
		vga_b <= data_display[4:0];	//data_display[7-:8]
	end
	else begin
		vga_r <= 5'h0;
		vga_g <= 6'h0;
		vga_b <= 5'h0;
	end
		
end








endmodule



//top.v
module	top(
input						clk,
input						rst_n,
	
 output	 				vsync,	
 output 					hsync,		
 output  	[4:0]		vga_r,		
 output  	[5:0]		vga_g,		
 output  	[4:0]		vga_b,		
 output					vga_clk,
 output					vga_blk,
 output					sync
);





wire	[11:0]   h_addr;
wire	[11:0]   v_addr;
wire	[15:0]	data_display;



vga_drive  inst_vga_drive(
.clk				(clk), //640*480--25.2M
.rst_n			(rst_n),
.data_display	(data_display),

.h_addr			(h_addr),//数据有效显示区域行地址
.v_addr			(v_addr),//数据有效显示区域场地址

.vsync			(vsync),
.hsync			(hsync),
.vga_r			(vga_r),
.vga_g			(vga_g),
.vga_b			(vga_b),
.vga_blk			(vga_blk),
.vga_clk     	(vga_clk),
.sync				(sync)
	
);

data_gen		inst_data_gen(	
.clk				(vga_clk), //640*480--25.2M
.rst_n			(rst_n),
.h_addr			(h_addr),//数据有效显示区域行地址
.v_addr			(v_addr),//数据有效显示区域场地output	

.data_disp	(data_display)
);





endmodule



//data_gen.v
module data_gen (
    input   wire              clk         , //vga clk 640*480 25.2MHz
    input   wire              rst_n       , //复位信号

    input   wire   [10:0]     h_addr      , //数据有效显示区域行地址
    input   wire   [10:0]     v_addr      , //数据有效显示区域场地址

    output  reg    [23:0]     data_disp     //

);

    
    reg			[ 13:0 ]		rom_address				; // ROM地址
    wire		[ 23:0 ]		rom_data				; // 图片数据

    wire						flag_enable_out2			; // 图片有效区域
    wire						flag_clear_rom_address		; // 地址清零
    wire						flag_begin_h			    ; // 图片显示行
    wire						flag_begin_v			    ; // 图片显示列
    
    parameter	height = 24; // 图片高度
    parameter	width  = 24; // 图片宽度

    reg [ 223:0 ] char_line[ 15:0 ];//16*14个字符=224,224*16的字符存储区
//参数定义
    parameter
        BLACK   = 24'h000000,
        RED     = 24'hFF0000,
        GREEN   = 24'h00FF00,
        BLUE    = 24'h0000FF,
        YELLOW  = 24'hFFFF00,
        SKY_BULE= 24'h00FFFF,
        PURPLE  = 24'hFF00FF,
        GRAY    = 24'hC0C0C0,
        WHITE   = 24'hFFFFFF; 

    always @( posedge clk or negedge rst_n) begin
    if(!rst_n)begin
        data_disp = BLACK;
    end
    else if ( flag_enable_out2 ) begin
        data_disp = rom_data;
    end
    else begin
        data_disp = BLACK;
    end
    end

    //ROM地址计数器
    always @( posedge clk or negedge rst_n ) begin
        if ( !rst_n ) begin
            rom_address <= 0;
        end
        else if ( flag_clear_rom_address ) 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;
    assign flag_begin_h     = h_addr > ( ( 640 - width ) / 2 ) && h_addr < ( ( 640 - width ) / 2 ) + width + 1;
    assign flag_begin_v     = v_addr > ( ( 480 - height )/2 ) && v_addr <( ( 480 - height )/2 ) + height + 1;
    assign flag_enable_out2 = flag_begin_h && flag_begin_v;

    //实例化ROM
    pic_rom	rom_inst (
    .address    ( rom_address   ),
    .clock      ( clk           ),
    .q          ( rom_data      )
    );
endmodule

3.3.3 编译烧录

结果：
在这里插入图片描述

四、参考链接

1.https://blog.csdn.net/qq_45659777/article/details/124834294

AspyRain
关注
  • 25
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于fpga的VGA协议实现
m0_65936231的博客
05-24 767
VGA（Video Graphics Array）是一种显示协议，用于控制计算机屏幕的显示。下面是一些常见的VGA控制时序参数及其计算方式。①行频率（Horizontal Refresh Rate）：指每秒钟显示器上水平扫描线的数目。计算方式为行频率 = 垂直频率 × 垂直分辨率。②场频率（Vertical Refresh Rate）：指每秒钟显示器刷新整个屏幕的次数。计算方式为场频率 = 水平频率 ÷ 屏幕上的行数。
实验二-基于FPGA的VGA协议实现
whynotsolve的博客
05-24 273
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显示赛车游戏
05-15
基于FPAG的小游戏开发，内含自编了VGA协议
基于FPGA的ov7670摄像头显示
10-22
FPGA中主要模块包含：时钟模块、OV7670初始化模块、DVP协议数据流模块、写FIFO模块、写FIFO控制模块、SDRAM控制模块、读FIFO模块、读FIFO控制模块、VGA控制模块。 其中OV7670初始化模块、DVP协议数据流模块和VGA...
FPGA驱动VGA接口的VHDL语言实现
03-22
FPGA驱动VGA接口的VHDL语言实现 FPGA驱动VGA接口的VHDL语言实现是指使用Very High-Speed Integrated Circuit Hardware Description Language（VHDL）语言在Field-Programmable Gate Array（FPGA）芯片上实现VGA接口...
eetop.cn_基于FPGA之低速协议设计实验手稿及源码.rar
02-25
基于FPGA之低速协议设计实验手稿及源码,包含原理及代码 IIC , ps2 , SPI , uart , VGA
基于FPGA的sobel边沿检测
05-14
成功调试成功的VGA显示边沿检测算法，实时的显示CMOS摄像头采集的数据，涉及到了I2C总线协议的编写、异步FIFO的编写
第19篇 Intel FPGA Monitor Program的使用＜二＞
weixin_47841246的博客
06-12 393
DE2-115_Computer System系统架构简介
AXI 1G/2.5G Ethernet Subsystem IP核使用过程中参数配置全解
u011565038的博客
06-11 1393
AXI 1G/2.5G Ethernet Subsystem 是一个为FPGA设计的以太网子系统，它支持1Gbps和2.5Gbps的数据传输速率，使得FPGA能够直接进行高速以太网通信。这个子系统通常包含以太网MAC控制器、GMII（千兆媒体独立接口）或RGMII（简化GMII）接口、以及可选的PHY（物理层）接口支持。
AXI Quad SPI IP核配置详解
u011565038的博客
06-11 1131
AXI Quad SPI IP核（Quad Serial Peripheral Interface）是一个提供串行接口连接SPI从设备的解决方案，它支持Standard（单线）、Dual（双线）、Quad（四线）模式，其中线数越多，传输速度越快。
【Quartus 13.0】EP1C3144I7 部署4*6矩阵键盘
SHNIXU的博客
06-12 341
按键的值先打一拍(key_reg
常用原语介绍
Pual_Georg的博客
06-17 67
在Xilinx的example（wavegen example）中看到他们的顶层模块的输入输出管脚都手动例化原语IBUF以及OBUF——工具也会自动给我们加上不必要自己加。
(27)ADC接口---＞(002)FPGA实现AD7606接口
2401_84405631的博客
06-11 100
（a）FPGA（Field Programmable Gate Array）是在PAL （可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）FPGA工程师就业应用于通信、航空航天、汽车电子，还是人工智能、物联网等新兴领域。
基于Verilog表达的FSM状态机
li_kin的博客
06-13 988
基于Verilog的三段式状态机表达
野火FPGA跟练（四）——串口RS232、亚稳态
weixin_45926435的博客
06-09 974
介绍FPGA-RS232中完整的原理和实现内容，包括RS232简介、接口、亚稳态的定义、RS232发送模块和接收模块的框图、功能描述、时序波形图、波形图分析、RTL代码、TESTBENCH代码
华为FPGA工程师面试题
道亦无名
06-04 1074
FPGA工程师面试会涉及多个方面，包括基础知识、项目经验、编程能力、硬件调试和分析等。
FPGA - 滤波器 - IIR滤波器设计
最新发布
博客
06-17 710
在FPGA - 滤波器 - FIR滤波器设计中可知，数字滤波器是一个时域离散系统。任何一个时域离散系统都可以用一个N阶差分方程来表示，即： 式中，x(n)和y(n)分别是系统的输入序列和输出序列；aj和bi均为常数；y(n-j)和x(n-i)项只有一次幂，没有相互交叉相乘项，故称为线性常系数差分方程。差分方程的阶数是由方程y(n-j)项中j的最大值与 最小值之差确定的。式中，y(n-j)项j的最大值取N，最小值取 0，因此称为N阶差分方程。 当aj=0且j>0时，N阶差分方程表示的系统为FIR
基于fpga的贪吃蛇游戏vga模块实现
11-02
基于FPGA的贪吃蛇游戏VGA模块实现是将贪吃蛇游戏的逻辑和显示功能集成到FPGA芯片中，并通过VGA接口将游戏画面显示在显示器上。 实现该模块的主要步骤如下： 1. 首先，需要使用Verilog等硬件描述语言编写贪吃蛇游戏的逻辑代码。该代码包括控制贪吃蛇移动、吃食物、死亡等功能的逻辑。 2. 在代码中，需要使用FPGA提供的IO口与外部设备进行通信。例如，利用FPGA的GPIO口读取玩家输入的控制信号，来控制贪吃蛇的方向。 3. 为了在显示器上显示游戏画面，需要编写VGA显示模块的代码。该代码通过FPGA的VGA接口将图像信号输出至显示器，实现游戏画面的实时显示。 4. 在VGA显示模块中，需要实现一些基本功能，如帧缓冲区（Frame Buffer）来存储游戏画面，以及水平和垂直同步信号的生成。 5. 通过将贪吃蛇游戏逻辑和VGA显示模块进行连接，可以实现在显示器上实时显示贪吃蛇的移动、食物的生成和吃食物等游戏功能。 通过将贪吃蛇游戏逻辑和VGA显示模块结合在一起，可以在FPGA上实现一个具有实时图像显示的贪吃蛇游戏。这种设计方式利用了FPGA的并行计算和显示处理能力，提供了更好的游戏体验和更高的性能。同时，该方案也可以通过修改代码来实现其他类型的游戏，为用户提供更多选择和乐趣。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值