FPGA SCCB协议

已于 2022-05-23 15:14:12 修改
阅读量431 收藏 3
点赞数 1
分类专栏： FPGA 文章标签： 单片机
于 2021-10-28 20:10:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43485409/article/details/109581750
版权

FPGA SCCB

SCCB写操作与IIC写操作一致

SCCB读操作与IIC读操作区别

IIC读操作

在这里插入图片描述

SCCB读操作

在这里插入图片描述
在这里插入图片描述

与IIC代码相比增加了读中点停止状态，当写操作时，SCCB与IIC无异，读操作时在写地址状态后跳转到读中点停止状态，产生上升沿停止位，之后跳转到读开始状态（在此状态中产生起始位）。

module SCCB(
	Clk                 ,
	Rst_n               ,

	Wr                  ,
	Wr_data             ,
	Wr_data_vaule       ,
	Wr_done             ,

	Word_adrr           ,           //存储单元地址

	Device_adress       ,           //器件地址

    Read                ,
	Rd_data             ,
	Rd_data_vaule       ,
    Rd_done             ,

	Sda                 ,
	Sccb_clk
);
	input Clk;
	input Rst_n;
	input Wr;
	input Read;
	input [7:0] Device_adress; //器件地址
	input [7:0] Word_adrr; //存储单元地址

	input [7:0]Wr_data;//写入的数据

	output reg[7:0]Rd_data;//读出的数据
	output Wr_data_vaule;//写数据有效标志信号
	output reg Rd_data_vaule;//读数据有效标志信号
	inout  Sda;
	output reg Wr_done;
    output reg Rd_done;
	output  Sccb_clk;

	parameter CLK_FREQUENCY = 50_000_000;
	parameter Sccb_clk_FREQUENCY = 100_000; //sccb clk时钟频率100KHZ
	localparam COUNT_MAX = CLK_FREQUENCY/Sccb_clk_FREQUENCY;
	//独热码
	localparam      IDLE      =     10'b0_000_000_001,
                    WR_START  =     10'b0_000_000_010,
                    WR_CTRL   =     10'b0_000_000_100,//写控制 写器件地址
                    WR_ADDRE  =     10'b0_000_001_000,//写地址
                    RDMSTOP   =     10'b0_000_010_000,
                    WR_DATA   =     10'b0_000_100_000,//写数据
                    RD_START  =     10'b0_001_000_000,//读开始
                    RD_CTRL   =     10'b0_010_000_000,//读控制
                    RD_DATA   =     10'b0_100_000_000,//读数据
                    STOP      =     10'b1_000_000_000;

	reg iic_free_n;//i2c空闲标志位，低电平有效
	wire [7:0]waddress_data;//器件地址数据写
	wire [7:0]raddress_data;//器件地址数据读
	reg [15:0]iic_count; //产生i2C_CLK信号计数寄存器
	reg clk_high;
	reg clk_low;
	reg [7:0]half_clk_cnt;//计数一个状态中高低电平计数器
	reg [9:0]main_state;//主状态机状态寄存器
	reg ack;//数据接收方对发送方的响应标志位
	reg send_en;//控制Sda线输入输出开关
	reg sda_reg;//sda信号线寄存器
	reg task_en_n;//任务开始结束控制寄存器
	reg [7:0]sda_data_out;//sda待输出的数据
	reg [7:0]sda_data_in;//sda待写入的数据
	wire be_rd_data_vaule;//读数据有效前寄存器
	reg w_flag;
	reg r_flag;
    reg clk_r;

	//写/读器件地址8位
	assign waddress_data = {Device_adress[7:1],1'b0 };
	assign raddress_data = {Device_adress[7:1],1'b1 };

    assign  Sccb_clk    =   ((main_state    ==  RD_START)   ||  (main_state ==  RDMSTOP)) ? 1'b1 : clk_r;

	assign Sda = send_en?sda_reg:1'bz;

	//iic_free_n状态判断
	always @(posedge Clk or negedge Rst_n)
	if(!Rst_n)
	iic_free_n <= 1'b0;
	else	if(Wr_done  ||  Rd_done)
	iic_free_n <= 1'b0;
	else	if(Wr|Read)
	iic_free_n <= 1'b1;
	else
	iic_free_n <= iic_free_n;

	//iic_count计数
	always @(posedge Clk or negedge Rst_n)
	if(!Rst_n)
	iic_count <= 1'b0;
	else	if(iic_free_n)
	begin
		if(iic_count == COUNT_MAX - 1'b1)
		iic_count <= 16'd0;
		else
		iic_count <= iic_count + 1'b1;
	end
	else
	iic_count <= 1'b0;

	//Sccb_clk产生
	always @(posedge Clk or negedge Rst_n)
	if(!Rst_n)
	clk_r <= 1'b1;
	else if(iic_count == COUNT_MAX >> 1)
		clk_r <= 1'b0;
    else if(iic_count == 1'b0)
		clk_r <= 1'b1;
	else
	clk_r <= clk_r;

	//标志Sccb_clk高电平 clk_high产生
	always @(posedge Clk or negedge Rst_n)
	if(!Rst_n)
	clk_high <= 1'b0;
	else if(iic_count == (COUNT_MAX >> 2) )
	clk_high <= 1'b1;
	else
	clk_high <= 1'b0;

	//标志Sccb_clk低电平 clk_low产生
	always @(posedge Clk or negedge Rst_n)
	if(!Rst_n)
	clk_low <= 1'b0;
	else if(iic_count == (COUNT_MAX >> 2 ) + (COUNT_MAX >> 1) )
	clk_low <= 1'b1;
	else
	clk_low <= 1'b0;

	//sda串行收发Sccb_clk高低电平计数器
	always @(posedge Clk or negedge Rst_n)
	if(!Rst_n)
	half_clk_cnt <= 1'b0;
	else
	if((main_state == WR_CTRL) || (main_state ==WR_ADDRE)|| (main_state ==WR_DATA) || (main_state ==RD_CTRL) ||(main_state ==RD_DATA))
	begin
		if(clk_high | clk_low)
		begin
			if(half_clk_cnt == 8'd17)
			half_clk_cnt <= 8'b0;
			else
			half_clk_cnt <= half_clk_cnt + 1'b1;
		end
	   else
		half_clk_cnt <= half_clk_cnt;
	end
	else
	half_clk_cnt <= 1'b0;

	//数据接收方对发送方的响应标志位ACK
	always @(posedge Clk or negedge Rst_n)
	if(!Rst_n)
	ack <= 1'b0;
	else
	if((half_clk_cnt == 8'd16) && clk_high && (Sda == 1'b0))
	ack <= 1'b1;
	else
	if((half_clk_cnt == 8'd17 )&& clk_low)
	ack <= 1'b0;
	else
	ack <= ack;

	//输出串行数据任务
	task send_eight_data;
	if(clk_high && (half_clk_cnt == 8'd16))
		task_en_n <= 1'b1;
	else
	if(half_clk_cnt < 8'd17)
	begin
		sda_reg <= sda_data_out[7];
		if(clk_low)
		sda_data_out <= {sda_data_out[6:0],1'b0};
		else
		sda_data_out <= sda_data_out;
	end
	endtask

	//输入串行任务
	task get_eight_data;
	if(clk_low && (half_clk_cnt == 8'd15))
		task_en_n <= 1'b1;
	else
		if(half_clk_cnt < 8'd15)
		begin
			if(clk_high)
			sda_data_in <= {sda_data_in[6:0],Sda};
			else
			sda_data_in <= sda_data_in;
		end
	endtask


	always @(posedge Clk or negedge Rst_n)
	if(!Rst_n)
	begin
		sda_reg <= 1'b1;
		Wr_done <= 1'b0;
		w_flag <= 1'b0;
		r_flag <= 1'b0;
        Rd_done <= 1'b0;
	end
	else
	begin
		case(main_state)

		IDLE :
		begin
		sda_reg <= 1'b1;
		w_flag <= 1'b0;
		r_flag <= 1'b0;
		Wr_done <= 1'b0;
        Rd_done <= 1'b0;
			if(Wr)
			begin
			main_state <= WR_START;
			w_flag <= 1'b1;
			end
			else if(Read)
			begin
			main_state <= WR_START;
			r_flag <= 1'b1;
			end
            else
                main_state  <=  IDLE    ;
		end

		WR_START:
		begin
		if(clk_low)
			begin
			main_state <= WR_CTRL;
			sda_data_out <= waddress_data;
			task_en_n <= 1'b0;
			end
		else if(clk_high)
			begin
			sda_reg <= 1'b0;
			main_state <= WR_START;
			end
		else
			main_state <= WR_START;
		end

		WR_CTRL:
		begin
		if(task_en_n == 1'b0)
		send_eight_data;
		else
		if(ack == 1'b1)
			begin
			if(clk_low)
				begin
				main_state <= WR_ADDRE;
				task_en_n <= 1'b0;
				sda_data_out <= Word_adrr;
				end
			else
			main_state <= WR_CTRL;
			end
		else
		main_state <= IDLE;
		end

		WR_ADDRE:
		begin
		if(task_en_n == 1'b0)
		send_eight_data;
		else
            begin
                if(ack == 1'b1)
                    begin
                        if(clk_low && w_flag)
                        begin
                            main_state <= WR_DATA;
                            task_en_n <= 1'b0;
                            sda_data_out <= Wr_data;
                        end
                        else
                        if(clk_low && r_flag)
                        begin
                            main_state <= RDMSTOP;
                            sda_reg <= 1'b0; //产生上升沿停止位
                        end
                        else
                        main_state <= WR_ADDRE;
                    end
                else
                main_state <= IDLE;
            end
		end

        RDMSTOP:
        begin
        if(clk_low)
            main_state  <=  RD_START    ;
        else
        if(clk_high)
            begin
                sda_reg <=  1'b1;           //产生上升沿
                main_state  <=  RDMSTOP ;
            end
        else
            main_state  <=  RDMSTOP ;
        end

		WR_DATA: //10_000
		begin
		if(task_en_n == 1'b0)
		send_eight_data;
		else
            begin
                if(ack == 1'b1)
                begin
                    if(clk_low)
                    begin
                    main_state <= STOP;
                    sda_reg <= 1'b0; //上升沿停止
                    end
                    else
                    main_state <= WR_DATA;
                end
                else
                main_state <= IDLE;
            end
		end

		RD_START:
		begin
			if(clk_low)
			begin
			main_state <= RD_CTRL;
			task_en_n <= 1'b0;
			sda_data_out <= raddress_data;
			end
			else
			if(clk_high)
			begin
			main_state <= RD_START;
			sda_reg <= 1'b0;//产生下降沿起始位
			end
			else
			main_state <= RD_START;
		end

		RD_CTRL:
		begin
			if(task_en_n == 1'b0)
			send_eight_data;
			else
            begin
                if(ack == 1'b1)
                begin
                    if(clk_low)
                    begin
                    main_state <= RD_DATA;
                    task_en_n <= 1'b0;
                    end
                    else
                    main_state <= RD_CTRL;
                end
                else
                main_state <= IDLE;
            end
		end

		RD_DATA:
		begin
			if(task_en_n == 1'b0)
                get_eight_data;
			else
			begin
                sda_reg <= 1'b1; //产生NOack信号表示不读
                    if(clk_low)
                    begin
                        main_state <= STOP;
                        sda_reg <= 1'b0; //产生上升沿停止位
                    end
                    else
                        main_state <= RD_DATA;
			end
		end

		STOP:
		begin
            if(clk_high)
            begin
            sda_reg <= 1'b1; //产生上升沿停止态
            main_state <= IDLE;
                if(w_flag)
                    Wr_done <=  1'b1;
                else
                if(r_flag)
                    Rd_done <=  1'b1;
            end
            else
            main_state <= STOP;
		end



		default : main_state <= IDLE;
		endcase
	end

		//控制sda开关闭合关闭
	always @(*)  //描述组合逻辑电路
	begin
		case(main_state)
		IDLE:
		send_en = 1'b0;

		RD_START,WR_START,RDMSTOP,STOP:  //写/读开始 停止位
		send_en = 1'b1;

		RD_CTRL,WR_CTRL,WR_ADDRE,WR_DATA:
		begin
		if(half_clk_cnt < 8'd16)
		send_en = 1'b1;
		else
		send_en = 1'b0;
		end

		RD_DATA:
		begin
		if(half_clk_cnt < 8'd16)
		send_en = 1'b0;
		else
		send_en = 1'b1;
		end

		default:send_en = 1'b0;
		endcase

	end

	//写输入有效标志位
    assign Wr_data_vaule = ((main_state == WR_ADDRE) && (w_flag && clk_low) && (ack == 1'b1));

	//读数据有效标志位前寄存器
	assign be_rd_data_vaule = ((main_state == RD_DATA) && (half_clk_cnt == 8'd15) && clk_low);

	//读数据有效标志位
	always @(posedge Clk or negedge Rst_n)
	if(!Rst_n)
	Rd_data_vaule <= 1'b0;
	else if(be_rd_data_vaule)
	Rd_data_vaule <= 1'b1;
	else
	Rd_data_vaule <= 1'b0;gai

	//读出的有效数据
	always @(posedge Clk or negedge Rst_n)
	if(!Rst_n)
	Rd_data <= 8'd0;
	else if(be_rd_data_vaule)
	Rd_data <= sda_data_in;
	else
	Rd_data <= Rd_data;

endmodule

此模块在后续的系統中将会用到，所以在此不做仿真验证。

不想秃发
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
FPGA中实现SCCB协议
08-21
用Verilog语言实现sccb驱动协议，将i2c协议起始位、数据位、结束位通过状态机的不同组合，实现sccb协议的读和写操作。
基于FPGA实现OmniVision图像传感器的SCCB总线协议
10-17
基于Atera公司的FPGA芯片对OmniVision图像传感器进行图像采集前的准备工作，通过FPGA的GPIO端口模拟SCCB（串行摄像机控制总线）总线协议对传感器的寄存器进行配置，从而完成对传感器的初始化，使得摄像头得以正常运行。
【FPGA】SCCB通信协议
白码王子小张的博客
10-25 1794
SCCB协议介绍
基于FPGA的OV摄像头初始化之SCCB协议的实现
08-10
关于OV系列摄像头的初始化，最主要的还是SCCB协议的编写调试，其实也就是众所周知的IIC协议。下面介绍一下用得最多的SCCB协议2线工作模式。
【FPGA】SCCB协议+ov5640摄像头
子根的博客
09-29 870
以下都引用自原子哥：SCCB（，串行摄像头控制总线）是由OV公司定义和发展的三线式串行总线。该总线控制着OV系列摄像头大部分的功能，包括图像数据格式、分辨率以及图像处理参数等。OV公司为了减少传感器引脚的封装，现在SCCB总线大多采用两线式接口总线。（类似IIC总线）其实跟IIC差不多。
sccb.rar_SCCB_SCCB协议_VHDL SCCB _sccb vhdl_摄像头
09-20
在VHDL（Very High-Speed Integrated Circuit Hardware Description Language）中实现SCCB协议，意味着我们需要用硬件描述语言来设计一个能够处理SCCB协议的逻辑电路。VHDL是一种强大的编程语言，用于描述数字系统的...
FPGA-SCCB接口开发.docx
04-14
FPGA开发的SCCB接口的开发
SCCB总线配置的FPGA视频采集与显示系统设计
07-25
提出了一种采用Altera公司的EP2C5Q208CN作为主控芯片，OV7670模块作为视频源输入并以SDRAM作为数据缓存的方案。通过对SCCB总线配置、图像数据采集、图像数据预处理、VGA显示等模块设计，完成了视频数据的采集与图像的输出显示。
FPGA实现串口、UART、IIC、SPI和SCCB接口协议
最新发布
FBxqaOjd的博客
04-08 416
总结起来，串口（UART）、IIC、SPI和SCCB是常见的硬件接口协议，在FPGA上的实现可以通过合理的设计和编程来完成。通过了解这些接口协议的特点和应用场景，并学习FPGA的编程方法，我们可以在实际应用中灵活应用这些接口协议，并根据需要定制其他通信协议。然后，我们可以使用FPGA的时钟资源来生成串口通信所需的波特率，并通过状态机的形式实现数据的发送和接收。串口（UART）、IIC、SPI和SCCB是常见的硬件接口协议，它们在不同的应用场景和设备中发挥着重要的作用。
sccb_FPGAverilog_iicverilog_sccb硬件接口_硬件IIC实现SCCB_
10-01
硬件iic接口 用于 摄像头接口配置 例如 ov5640
SCCB
蔡工的博客
07-09 1870
https://wenku.baidu.com/view/89eaf6d6dd88d0d233d46a46.html点击打开链接
SCCB与IIC的异同及FPGA实现的注意事项
小王在努力...的博客
08-21 566
IIC接口有比较广泛的应用，而SCCB（Serial Camera Control Bus，串行摄像头控制总线）是由OV（OmniVision的简称）公司定义和发展的三线式串行总线，该总线控制着摄像头大部分的功能，包括图像数据格式、分辨率以及图像处理参数等。主要用于摄像头控制，可以说SCCB是低配版的IIC。因为IIC可以实现多主多从，IIC规范文档中有提到多主机的时钟同步、总线仲裁功能。而SCCB的文档中则没有这部分内容，因为一般来说都是单个主机控制多个摄像头，只有一主多从的功能。
调试FPGA程序
xinxiangwanji的专栏
07-13 346
对于做{FPGA的朋友来说，调试的手段要么用Debug单元，要么就是仔细分析时许上的问题。但是有很多时候要是陷入到误区里面，调试的难度就是很大了。 对于问题的定位，个人的建议如下： 要是接口上采集的数据不准确，这个是最好定位的。添加debug单元就可以在线分析。当定位到问题的原因了，那要解决就相对容易多了。比如可以添加接口的时许约束、调整Clk对数据的采集位置、在代码里面添加delay的控制等方法； 对于设计中时序设计有问题的，但是每次结果都是一样的情况。那就需要考虑fifo是不是有溢出、Ram的调度
SCCB协议
q1594的博客
05-06 3509
1.SCCB协议介绍 SCCBSerial Camera Control Bus (Serial Camera Control Bus )，为串行相机控制总线。与I2C协议极为类似。 1.SCCB 的起始信号、停止信号及数据有效性与 I2C 完全一样。 1.起始信号： 在 SCL（图中为 SIO_C） 为高电平时， SDA(图中为 SIO_D)出现一 个下降沿，则 SCCB 开始传输。 2.停止信号：在 SCL 为高电平时， SDA 出现一个上升沿，则 SCCB 停止传输。 3.数据有效性：除了开始和停止状
SCCB总线协议的详细讲解与程序实现
weixin_44509533的博客
05-11 8870
一、SCCB简介 SCCB(Serial Camera Control Bus)是OmniVision公司公布的串行相机总线协议。OV开头的相机模块例如OV7670都使用SCCB协议。鉴于它与I2C协议类似，为了方便，本文将其SIO_C线称为SCL，SIO_D线称为SDA。主要讲解两线SCCB协议的内容与程序实现（stm32平台，其他平台也可参考）。 二、电路连接图 对于两线SCCB，只需连接SIO_C和SIO_D即可。 三、协议的内容与程序实现 ②两线SCCB总线协议分析： <1>传输开始标
FPGA利用SCCB协议配置OV5640摄像头
zhangningning1996的博客
02-08 5004
FPGA利用SCCB协议配置OV5640摄像头为什么要配置摄像头配置代码测试代码总结 为什么要配置摄像头 OV5640摄像头有许多工作模式，如可以工作在1080P，720P，480P分辨率的情况下，输出的数据格式也可以是RGB，RAW格式，也可以又DVP，MIPI数据接口，那么实际中我们应该如何指定摄像头的具体工作模式，以便于我们之后的处理。所使用的方法就是SCCB协议进行配置摄像头，前面的文章中...
SCCB协议学习笔记
Dead_John
03-24 4219
SCCB协议学习笔记
详细介绍下SCCB协议
04-12
SCCB协议是一种用于I2C总线的简化版本协议，它采用了8位寄存器地址，用于控制器与一些支持SCCB协议的设备之间的通信。SCCB协议常被用于像CMOS摄像头这样的低速设备中，不同于常见的I2C协议有7位和10位的寄存器地址，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值