VERILOG的I2C代码块，注册接口变量

最新推荐文章于 2024-08-16 08:38:22 发布
最新推荐文章于 2024-08-16 08:38:22 发布
阅读量271 收藏 1
点赞数
分类专栏： FPGA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/USB_ABC/article/details/113694597
版权
这篇博客介绍了VERILOG中的I2CSlave核心模块的registerInterface子模块，该模块作为用户接口，定义了如何处理I2C的读写操作。当I2C总线上的地址匹配时，数据会被写入或读取到相应的寄存器，如vin_s_width、clipper_left等。此外，还包含了一个名为chip_state的芯片状态寄存器，用于读写。博客详细列出了每个地址对应的寄存器和数据映射。
摘要由CSDN通过智能技术生成

VERILOG的I2C代码块，注册接口变量，看一下注释就明白了。
//

registerInterface.v

This file is part of the i2cSlave opencores effort.
http://www.opencores.org/cores//

Module Description:
You will need to modify this file to implement your
interface.
Add your control and status bytes/bits to module inputs and outputs,
and also to the I2C read and write process blocks

To Do:


Author(s):
- Steve Fielding, sfielding@base2designs.com

//

Copyright © 2008 Steve Fielding and OPENCORES.ORG

This source file may be used and distributed without
restriction provided that this copyright statement is not
removed from the file and that any derivative work contains
the original copyright notice and the associated disclaimer.

This source file is free software; you can redistribute it
and/or modify it under the terms of the GNU Lesser General
Public License as published by the Free Software Foundation;
either version 2.1 of the License, or (at your option) any
later version.

This source is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied
warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the GNU Lesser General Public License for more
details.

You should have received a copy of the GNU Lesser General
Public License along with this source; if not, download it
from http://www.opencores.org/lgpl.shtml

//
//
`include “i2cSlave_define.v”

//
// 这要注册接口模块的作用：它实际上就是I2C的CORE模块向用户（使用I2C CORE的人）声明。READ或WRITE这个操作时，寄存器的地址和数据时，实际
// 要写入哪一个地址值。I2C MODULE是通用的，但使用I2C的人需要说明一下，读写哪一个寄存器实际代表什么意思
//

module registerInterface #
(
parameter VCH_NUM = 4
)(
input clk,
input [7:0] addr, // 寄存器地址
input [7:0] dataIn, // 写入到寄存器中的数据
input writeEn,
output reg[7:0] dataOut, // 从寄存器中读出的数据
output reg[16 * VCH_NUM - 1 :0] vin_s_width,
output reg[16 * VCH_NUM - 1 :0] vin_s_height,
output reg[16 * VCH_NUM - 1 :0] clipper_left,
output reg[16 * VCH_NUM - 1 :0] clipper_width,
output reg[16 * VCH_NUM - 1 :0] clipper_top,
output reg[16 * VCH_NUM - 1 :0] clipper_height,
output reg[16 * VCH_NUM - 1 :0] vout_t_width,
output reg[16 * VCH_NUM - 1 :0] vout_t_height,
output reg[8 * VCH_NUM - 1 :0] alpha,
output reg[16 * VCH_NUM - 1 :0] disp_top,
output reg[16 * VCH_NUM - 1 :0] disp_left,
output reg[ 8 * VCH_NUM - 1 :0] source,
output reg[16 * VCH_NUM - 1 :0] scaler_k_h,
output reg[16 * VCH_NUM - 1 :0] scaler_k_v
);

parameter DEV_TYPE = 8’hA5;
parameter VERSION = 8’h01;

// 这个REG表示芯片状态CHIP_STATE，由用户写进来，再由用户读出去。
reg[7:0] chip_state;
// — I2C Read
always @(posedge clk) begin
case (addr)
8’hff: dataOut <= chip_state; // 0XFF代表CHIP_STATE这个功能值，当I2C总线上寄存器的值为0XFF时， 就把chip_state给到dataOut
default: dataOut <= 8’h00;
endcase
end

// — I2C Write
always @(posedge clk) begin
if (writeEn == 1’b1) begin // 表示写数据，也就是I2C的地址值的B0位，也就是区分WRITE和READ,
case (addr)
8’h00: vin_s_width [16 * 1 - 9 : 16 * 1 - 16] <= dataIn;
8’h01: vin_s_width [16 * 1 - 1 : 16 * 1 - 8] <= dataIn;
8’h02: vin_s_height [16 * 1 - 9 : 16 * 1 - 16] <= dataIn;
8’h03: vin_s_height [16 * 1 - 1 : 16 * 1 - 8] <= dataIn;
8’h04: clipper_left [16 * 1 - 9 : 16 * 1 - 16] <= dataIn;
8’h05: clipper_left [16 * 1 - 1 : 16 * 1 - 8] <= dataIn;
8’h06: clipper_width [16 * 1 - 9 : 16 * 1 - 16] <= dataIn;
8’h07: clipper_width [16 * 1 - 1 : 16 * 1 - 8] <= dataIn;
8’h08: clipper_top [16 * 1 - 9 : 16 * 1 - 16] <= dataIn;
8’h09: clipper_top [16 * 1 - 1 : 16 * 1 - 8] <= dataIn;
8’h0a: clipper_height [16 * 1 - 9 : 16 * 1 - 16] <= dataIn;
8’h0b: clipper_height [16 * 1 - 1 : 16 * 1 - 8] <= dataIn;
8’h0c: vout_t_width [16 * 1 - 9 : 16 * 1 - 16] <= dataIn;
8’h0d: vout_t_width [16 * 1 - 1 : 16 * 1 - 8] <= dataIn;
8’h0e: vout_t_height [16 * 1 - 9 : 16 * 1 - 16] <= dataIn;
8’h0f: vout_t_height [16 * 1 - 1 : 16 * 1 - 8] <= dataIn;
8’h10: alpha [ 8 * 1 - 1 : 8 * 1 - 8] <= dataIn;
8’h11: disp_top [16 * 1 - 9 : 16 * 1 - 16] <= dataIn;
8’h12: disp_top [16 * 1 - 1 : 16 * 1 - 8] <= dataIn;
8’h13: disp_left [16 * 1 - 9 : 16 * 1 - 16] <= dataIn;
8’h14: disp_left [16 * 1 - 1 : 16 * 1 - 8] <= dataIn;
8’h15: source [ 8 * 1 - 1 : 8 * 1 - 8] <= dataIn;
8’h16: scaler_k_h [16 * 1 - 9 : 16 * 1 - 16] <= dataIn;
8’h17: scaler_k_h [16 * 1 - 1 : 16 * 1 - 8] <= dataIn;
8’h18: scaler_k_v [16 * 1 - 9 : 16 * 1 - 16] <= dataIn;
8’h19: scaler_k_v [16 * 1 - 1 : 16 * 1 - 8] <= dataIn;

			8'h20: vin_s_width          [16 * 2 - 9 : 16 * 2 - 16] <= dataIn;
			8'h21: vin_s_width          [16 * 2 - 1 : 16 * 2 -  8] <= dataIn;
			8'h22: vin_s_height         [16 * 2 - 9 : 16 * 2 - 16] <= dataIn;
			8'h23: vin_s_height         [16 * 2 - 1 : 16 * 2 -  8] <= dataIn;
			8'h24: clipper_left         [16 * 2 - 9 : 16 * 2 - 16] <= dataIn;
			8'h25: clipper_left         [16 * 2 - 1 : 16 * 2 -  8] <= dataIn;
			8'h26: clipper_width        [16 * 2 - 9 : 16 * 2 - 16] <= dataIn;
			8'h27: clipper_width        [16 * 2 - 1 : 16 * 2 -  8] <= dataIn;
			8'h28: clipper_top          [16 * 2 - 9 : 16 * 2 - 16] <= dataIn;
			8'h29: clipper_top          [16 * 2 - 1 : 16 * 2 -  8] <= dataIn;
			8'h2a: clipper_height       [16 * 2 - 9 : 16 * 2 - 16] <= dataIn;
			8'h2b: clipper_height       [16 * 2 - 1 : 16 * 2 -  8] <= dataIn;
			8'h2c: vout_t_width         [16 * 2 - 9 : 16 * 2 - 16] <= dataIn;
			8'h2d: vout_t_width         [16 * 2 - 1 : 16 * 2 -  8] <= dataIn;
			8'h2e: vout_t_height        [16 * 2 - 9 : 16 * 2 - 16] <= dataIn;
			8'h2f: vout_t_height        [16 * 2 - 1 : 16 * 2 -  8] <= dataIn;
			8'h30: alpha                [ 8 * 2 - 1 :  8 * 2 -  8] <= dataIn;
			8'h31: disp_top             [16 * 2 - 9 : 16 * 2 - 16] <= dataIn;
			8'h32: disp_top             [16 * 2 - 1 : 16 * 2 -  8] <= dataIn;
			8'h33: disp_left            [16 * 2 - 9 : 16 * 2 - 16] <= dataIn;
			8'h34: disp_left            [16 * 2 - 1 : 16 * 2 -  8] <= dataIn; 
			8'h35: source               [ 8 * 2 - 1 :  8 * 2 -  8] <= dataIn;
			8'h36: scaler_k_h           [16 * 2 - 9 : 16 * 2 - 16] <= dataIn;
			8'h37: scaler_k_h           [16 * 2 - 1 : 16 * 2 -  8] <= dataIn;
			8'h38: scaler_k_v           [16 * 2 - 9 : 16 * 2 - 16] <= dataIn;
			8'h39: scaler_k_v           [16 * 2 - 1 : 16 * 2 -  8] <= dataIn;
			
			8'h40: vin_s_width          [16 * 3 - 9 : 16 * 3 - 16] <= dataIn;
			8'h41: vin_s_width          [16 * 3 - 1 : 16 * 3 -  8] <= dataIn;
			8'h42: vin_s_height         [16 * 3 - 9 : 16 * 3 - 16] <= dataIn;
			8'h43: vin_s_height         [16 * 3 - 1 : 16 * 3 -  8] <= dataIn;
			8'h44: clipper_left         [16 * 3 - 9 : 16 * 3 - 16] <= dataIn;
			8'h45: clipper_left         [16 * 3 - 1 : 16 * 3 -  8] <= dataIn;
			8'h46: clipper_width        [16 * 3 - 9 : 16 * 3 - 16] <= dataIn;
			8'h47: clipper_width        [16 * 3 - 1 : 16 * 3 -  8] <= dataIn;
			8'h48: clipper_top          [16 * 3 - 9 : 16 * 3 - 16] <= dataIn;
			8'h49: clipper_top          [16 * 3 - 1 : 16 * 3 -  8] <= dataIn;
			8'h4a: clipper_height       [16 * 3 - 9 : 16 * 3 - 16] <= dataIn;
			8'h4b: clipper_height       [16 * 3 - 1 : 16 * 3 -  8] <= dataIn;
			8'h4c: vout_t_width         [16 * 3 - 9 : 16 * 3 - 16] <= dataIn;
			8'h4d: vout_t_width         [16 * 3 - 1 : 16 * 3 -  8] <= dataIn;
			8'h4e: vout_t_height        [16 * 3 - 9 : 16 * 3 - 16] <= dataIn;
			8'h4f: vout_t_height        [16 * 3 - 1 : 16 * 3 -  8] <= dataIn;
			8'h50: alpha                [ 8 * 3 - 1 :  8 * 3 -  8] <= dataIn;
			8'h51: disp_top             [16 * 3 - 9 : 16 * 3 - 16] <= dataIn;
			8'h52: disp_top             [16 * 3 - 1 : 16 * 3 -  8] <= dataIn;
			8'h53: disp_left            [16 * 3 - 9 : 16 * 3 - 16] <= dataIn;
			8'h54: disp_left            [16 * 3 - 1 : 16 * 3 -  8] <= dataIn;
			8'h55: source               [ 8 * 3 - 1 :  8 * 3 -  8] <= dataIn;
			8'h56: scaler_k_h           [16 * 3 - 9 : 16 * 3 - 16] <= dataIn;
			8'h57: scaler_k_h           [16 * 3 - 1 : 16 * 3 -  8] <= dataIn;
			8'h58: scaler_k_v           [16 * 3 - 9 : 16 * 3 - 16] <= dataIn;
			8'h59: scaler_k_v           [16 * 3 - 1 : 16 * 3 -  8] <= dataIn;
			
			8'h60: vin_s_width          [16 * 4 - 9 : 16 * 4 - 16] <= dataIn;
			8'h61: vin_s_width          [16 * 4 - 1 : 16 * 4 -  8] <= dataIn;
			8'h62: vin_s_height         [16 * 4 - 9 : 16 * 4 - 16] <= dataIn;
			8'h63: vin_s_height         [16 * 4 - 1 : 16 * 4 -  8] <= dataIn;
			8'h64: clipper_left         [16 * 4 - 9 : 16 * 4 - 16] <= dataIn;
			8'h65: clipper_left         [16 * 4 - 1 : 16 * 4 -  8] <= dataIn;
			8'h66: clipper_width        [16 * 4 - 9 : 16 * 4 - 16] <= dataIn;
			8'h67: clipper_width        [16 * 4 - 1 : 16 * 4 -  8] <= dataIn;
			8'h68: clipper_top          [16 * 4 - 9 : 16 * 4 - 16] <= dataIn;
			8'h69: clipper_top          [16 * 4 - 1 : 16 * 4 -  8] <= dataIn;
			8'h6a: clipper_height       [16 * 4 - 9 : 16 * 4 - 16] <= dataIn;
			8'h6b: clipper_height       [16 * 4 - 1 : 16 * 4 -  8] <= dataIn;
			8'h6c: vout_t_width         [16 * 4 - 9 : 16 * 4 - 16] <= dataIn;
			8'h6d: vout_t_width         [16 * 4 - 1 : 16 * 4 -  8] <= dataIn;
			8'h6e: vout_t_height        [16 * 4 - 9 : 16 * 4 - 16] <= dataIn;
			8'h6f: vout_t_height        [16 * 4 - 1 : 16 * 4 -  8] <= dataIn;
			8'h70: alpha                [ 8 * 4 - 1 :  8 * 4 -  8] <= dataIn;
			8'h71: disp_top             [16 * 4 - 9 : 16 * 4 - 16] <= dataIn;
			8'h72: disp_top             [16 * 4 - 1 : 16 * 4 -  8] <= dataIn;
			8'h73: disp_left            [16 * 4 - 9 : 16 * 4 - 16] <= dataIn;
			8'h74: disp_left            [16 * 4 - 1 : 16 * 4 -  8] <= dataIn;
			8'h75: source               [ 8 * 4 - 1 :  8 * 4 -  8] <= dataIn;
			8'h76: scaler_k_h           [16 * 4 - 9 : 16 * 4 - 16] <= dataIn;
			8'h77: scaler_k_h           [16 * 4 - 1 : 16 * 4 -  8] <= dataIn;
			8'h78: scaler_k_v           [16 * 4 - 9 : 16 * 4 - 16] <= dataIn;
			8'h79: scaler_k_v           [16 * 4 - 1 : 16 * 4 -  8] <= dataIn;			
			
			8'hff: chip_state  <= dataIn;  									// 0XFF代表CHIP_STATE这个物理量
	default:;
endcase

end
end

endmodule
USB_ABC
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Verilog之i2c协议
u012373020的专栏
05-06 1万+
i2c协议，使用verilog编写测试。并对i2c协议进行了详细介绍。
verilog i2c 通用控制模块
qq_39783072的博客
11-06 722
突然发现好久没写文章了，今天就写一篇关于i2c的通用控制模块。 i2c协议保护起始，数据传输，ACK或NACK，和传输终止信号。以下是对应的时序图： 在SCL为高的情况下，SDA由高跳到低，这是起始信号，之后在时钟为低电平时更新数据，在高电平时数据保持稳定，每一次传输8bit数据之后是ACK信号，在受到ACK信号后可以选择结束通信或者继续传输数据，这是基本的i2c协议。 而eeprom的i2c有些许不一样，所以在设计时应考虑加入一些冗余以兼容eeprom的读写。 eeprom的...
i2c verilog
11-07
用verilog描述的i2c代码 二线I2C CMOS串行EEPROM的设计是根据I2C协议，以及EEPROM AT24C02的datasheet来进行设计的。基于I2C的设计很多，归根到底是控制SDA线及SCL线来让设备间进行通信。它有固定的帧格式。本设计中Sda数据线与各模块是通过寄存器来进行数据的输入输出。EEPROM模块是进行行为级描述的，它是根据具体芯片来写的模拟逻辑，不可综合。EEPROM_WR是读写控制程序，是通过开关组合电路和控制时序电路组成的。开关组合电路其实就是选择在SDA及DATA上的数据，根据信号来选择输出。具体的控制时序电路就是一个状态机来完成。Signal模块是测试用的，以前只接触过一些简单的testbench,在这次实验中，由于testbench理解的不透彻，用modelsim仿真的时候地址和数据线处于不定态，但是整个的时序是正确的。
Verilog 实现 i2c 协议
qq_36525177的博客
05-16 494
应答，当 IIC 主机（不一定是发送端还是接受端）将 8 位数据或命令传出后，会将数据总线（SDA）释放，即设置为输入，然后等待从机应答（低电平 0 表示应答，1 表示非应答），此时的时钟仍然是主机提供的。在时钟（SCL）为高电平的时候，数据总线（SDA）由高到低的跳变为总线起始信号，在时钟（SCL）为高电平的时候，数据总线（SDA）由低到高的跳变为总线停止信号。在时钟（SCL）为高电平的时候，数据总线（SDA）必须保持稳定，所以数据总线（SDA）在时钟（SCL）为低电平的时候才能改变。
Verilog的I2C实现
GG的专栏
11-07 9173
I2C的Verilog实现有几个需要注意的地方：
I2C-verilog-(非常详细的i2c学习心得)
04-18
I2C-verilog-(非常详细的i2c学习心得)，总结的非常详细。可以练手
用verilog 实现的 i2c控制模块
huangzhicong3的博客
08-10 7644
verilog 实现i2c控制 i2c协议 首先要先学习一下i2c协议的基础，这里有一份官方文档（https://www.nxp.com/docs/en/user-guide/UM10204.pdf），也可以参考一些博客，总的来说i2c协议的基础原理不难，因为主要就是两根线的控制（SCL、SDA）。 i2c仿真模型（EEPROM） 当掌握了i2c协议的基础之后，建议以EEPROM为例子入手，有一篇博客介绍的很好：https://www.cnblogs.com/ninghechuan/p/9534893.ht
i2c的verilog实现
06-03
使用verilog编写的iic总线控制逻辑，里面包含了测试代码
使用Verilog设计I2C控制器
qq_28824733的博客
04-30 3309
使用Verilog设计I2C控制器
I2C 模块verilog 代码
02-14
I2C 模块verilog 代码 CPLD
i2c读写Verilog代码
04-26
包含i2c读写模块，顶层文件，仿真文件
I2C Slave Verilog
11-28
网上找的一些I2C从设备代码都没用起来，于是自己写了一个。能实现读取和写入任意一个字节的功能。功能上目前已经够用，连续读取和写入多个字节的就没有加了。
Verilog_HDL实现I2C总线功能
06-03
用Verilog实现I2C代码的具体例子，适合Verilog初学者及I2C设计人员参考
I2C的verilog源码及文档
11-04
i2c控制器的verilog源码与文档，有做i2c的朋友可以借鉴
verilogI2Cslave串并转换模块
08-09
verilog语言编写的I2Cslave串并转换模块
在FPGA中使用Verilog实现I2C通信
闲来无事搞搞机
10-29 9818
按照I2C标准的官方时序 可以看出时序看起来很简单，不过它严格的按照时序要求来传送数据，马虎不得的，特别是起始和停止的条件，起始必须要时钟线SCL为高电平时数据线SDA拉低；而停止时必须要时钟线SCL为高电平时数据线SDA拉高；中间的数据的每一位传送都是必须要求在时钟线SCL为高定平时完成； Verilog HDL程序采用基于状态机的时序设计实现，I2C速度为100KHz，本人开发
Verilog(3)I2C通信协议
m0_55542784的博客
02-26 907
I2C
verilog实现I2C控制器 （小梅哥思路）----详细解析
weixin_45614076的博客
08-26 8019
verilog实现I2C控制器 （小梅哥思路）----详细解析
Verilog-I2C 开源项目实战指南
最新发布
gitblog_00668的博客
08-16 837
Verilog-I2C 开源项目实战指南 verilog-i2cVerilog I2C interface for FPGA implementation项目地址:https://gitcode.com/gh_mirrors/ve/verilog-i2c 项目介绍 Verilog-I2C 是一个由 Alex Forencich 开发的开源项目，旨在提供一个 Verilog 实现的 I2C 总线...
Verilog | I2C详解与Verilog实现
热门推荐
qq_45776815的博客
11-28 1万+
​ IIC(Inter-Integrated Circuit)总线是一种由PHILIPS公司开发的两线式串行总线，是一种同步、半双工的通信总线，用于连接微控制器及其外围设备。I2C总线产生于在80年代，最初为音频和视频设备开发，如今主要在服务器管理中使用，其中包括单个组件状态的通信。例如管理员可对各个组件进行查询，以管理系统的配置或掌握组件的功能状态，如电源和系统风扇。可随时监控内存、硬盘、网络、系统温度等多个参数，增加了系统的安全性，方便了管理。IIC数据传输速率。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值