FPGA(9) DS18b20驱动（状态机综合应用）

最新推荐文章于 2024-03-31 19:57:19 发布
最新推荐文章于 2024-03-31 19:57:19 发布
阅读量530 收藏 4
点赞数
文章标签： fpga开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51518393/article/details/123135789
版权

 

 

 

代码：

module  ds18b20_ctrl(sys_clk,sys_rst,data1_inout,data_out,sign);

    input   wire    sys_clk,sys_rst;
    
    inout   wire     data1_inout;
    
    output  wire    [15:0]      data_out;
    output  reg      sign;

//时钟定义
reg              clk_1us;
reg     [4:0]    cnt_clk1us;

//状态机系列
reg     [5:0]           state;
parameter   init             =6'b000001;
parameter   write_cmd        =6'b000010;
parameter   waite_cmd        =6'b000100;
parameter   init_again       =6'b001000;
parameter   write_cmd_again  =6'b010000;
parameter   read_cmd         =6'b100000;



parameter   WR_44CC_CMD =   16'h44cc;
parameter   WR_BECC_CMD =   16'hbecc;

reg             flag_answer_init;
reg   [19:0]    cnt_time;
reg   [4:0]     cntBit15;
reg   [15:0]    data16_temp;
reg             qout_temp;
reg             qout_en;
wire   [15:0]   dataCmd_in_temp;
wire             qin_temp;
reg     [15:0]      data16_out;

//各个状态总延时
parameter   init_time   =20'd999;
parameter   write_time  =20'd65;
parameter   waite_time  =20'd750_000;
parameter   read_time   =20'd64;

//各个状态的输出方向的改变时间
parameter   init_outend_time    =20'd499;
parameter   init_answer_time    =20'd570;
parameter   write_outend0_time  =20'd62;
parameter   write_outend1_time  =20'd5;
parameter   read_answer_time    =20'd13;
parameter   read_outend         =20'd2;

//要输入数据的具体命令
parameter   write_cmd_CCh=8'hCC;//跳过rom命令
parameter   write_cmd_44h=8'h44;//温度转换命令
parameter   write_cmd_again_CCh=8'hcc;
parameter   write_cmd_again_BEh=8'hBE;


//时钟设置(50分频，1us)
always@(posedge sys_clk or negedge  sys_rst)
begin
    if(!sys_rst)
        begin
            clk_1us<=1'b0;
            cnt_clk1us<=5'd0;
        end
    else    if(cnt_clk1us==5'd24)
        begin
            clk_1us<=~clk_1us;
            cnt_clk1us<=5'd0;
        end
    else
        begin
            clk_1us<=clk_1us;
            cnt_clk1us=cnt_clk1us+1'b1;
        end
end

//全体状态机
always@(posedge clk_1us or negedge  sys_rst)
begin
    if(!sys_rst)
        state<=init;
    else    case(state)
        init:
            if((flag_answer_init==1'b1)&&(cnt_time==init_time))
                state<=write_cmd;
            else
                state<=state;
        write_cmd:
            if((cntBit15==5'd15)&&(cnt_time==write_time))
                state<=waite_cmd;
            else
                state<=state;
        waite_cmd:
            if(cnt_time==waite_time)
                state<=init_again;
            else
                state<=state;
        init_again:
            if((flag_answer_init==1'b1)&&(cnt_time==init_time))
                state<=write_cmd_again;
            else
                state<=state;
        write_cmd_again:
            if((cntBit15==5'd15)&&(cnt_time==write_time))
                state<=read_cmd;
            else
                state<=state;
        read_cmd:
            if((cntBit15==5'd15)&&(cnt_time==read_time))
                state<=init;
            else
                state<=state;
        default:
                state<=init;
        endcase
end

//Bit15计数
always@(posedge clk_1us or negedge  sys_rst)
begin
    if(!sys_rst)
        cntBit15<=5'd0;
    else    case(state)
        init:
        cntBit15<=cntBit15;
        write_cmd:
            if((cntBit15==5'd15)&&(cnt_time==write_time))
                cntBit15<=5'd0;
            else    if(cnt_time==write_time)
                cntBit15<=cntBit15+1'b1;
            else
                cntBit15<=cntBit15;
        waite_cmd:
            cntBit15<=cntBit15;
        init_again:
            cntBit15<=cntBit15;
        write_cmd_again:
            if((cntBit15==5'd15)&&(cnt_time==write_time))
                cntBit15<=5'd0;
            else    if(cnt_time==write_time)
                cntBit15<=cntBit15+1'b1;
            else
                cntBit15<=cntBit15;
        read_cmd:
            if((cntBit15==5'd15)&&(cnt_time==read_time))
                cntBit15<=5'd0;
            else    if(cnt_time==read_time)
                cntBit15<=cntBit15+1'b1;
            else
                cntBit15<=cntBit15;
        default:
                cntBit15<=cntBit15;
        endcase
end
//全体计数
always@(posedge clk_1us or negedge  sys_rst)
begin
    if(!sys_rst)
        cnt_time<=20'd0;
    else    case(state)
        init:
            if(cnt_time==init_time)
                cnt_time<=20'd0;
            else
                cnt_time<=cnt_time+1'b1;
        write_cmd:
            if((cnt_time==write_time))
                cnt_time<=20'd0;
            else
                cnt_time<=cnt_time+1;
        waite_cmd:
            if(cnt_time==waite_time)
                cnt_time<=20'd0;
            else
                cnt_time<=cnt_time+1'b1;
        init_again:
            if(cnt_time==init_time)
                cnt_time<=20'd0;
            else
                cnt_time<=cnt_time+1'b1;
        write_cmd_again:
            if((cnt_time==write_time))
                cnt_time<=20'd0;
            else
                cnt_time<=cnt_time+1;
        read_cmd:
            if(cnt_time==read_time)
                cnt_time<=20'd0;
            else
                cnt_time<=cnt_time+1'b1;
        default:
                cnt_time<=20'd0;
        endcase
end

// //cntBit15
// always@(posedge clk_1us or negedge  sys_rst)
// begin
    // if(!sys_rst)
        // cntBit15<=5'd0;
    // else    if(((state==write_cmd||state==write_cmd_again)&&(cntBit15==5'd15&&cnt_time==write_time))||((state==read_cmd)&&(cntBit15==5'd15&&cnt_time==read_time)))
        // cntBit15<=5'd0;
    // else    if(((state==write_cmd||state==write_cmd_again)&&(cnt_time==write_time))||(state==read_cmd&&cnt_time==read_time))
        // cntBit15<=cntBit15+1'b1;
    // else
        // cntBit15<=cntBit15;
// end

//flag_answer_init
always@(posedge clk_1us or negedge  sys_rst)
begin
    if(!sys_rst)
        flag_answer_init<=1'b0;
    else    if((state==init||state==init_again)&&(data1_inout==1'b0)&&(cnt_time==init_answer_time))
        flag_answer_init<=1'b1;
    else    if(cnt_time==init_time)
        flag_answer_init<=1'b0;
    else
        flag_answer_init<=flag_answer_init;
end

//读数据
always@(posedge clk_1us or negedge  sys_rst)
begin
    if(!sys_rst)
        data16_temp<=16'd0;
    else    if((state==read_cmd)&&(cnt_time==read_answer_time))
        data16_temp[cntBit15]<=data1_inout;
    else
        data16_temp<=data16_temp;
end

//数据完整输出
always@(posedge clk_1us or negedge  sys_rst)
begin
    if(!sys_rst)
        data16_out<=16'd0;
    else    if((cntBit15==5'd15)&&(cnt_time==read_time-4)&&(state==read_cmd)&&(data16_temp[14]==1'b0))
        data16_out<=data16_temp[10:0];
    else    if((cntBit15==5'd10)&&(cnt_time==read_time-4)&&(state==read_cmd)&&(data16_temp[14]==1'b1))
        data16_out<=~data16_temp[10:0]+1;
    else
        data16_out<=data16_out;
end

//符号输出
always@(posedge clk_1us or negedge  sys_rst)
begin
    if(!sys_rst)
        sign<=1'b0;
    else    if(cntBit15==5'd15&&(state==read_cmd-4)&&data16_temp[13]==1'b1&&cnt_time==read_time)
        sign<=1'b1;
    else    if(cntBit15==5'd15&&(state==read_cmd-4)&&data16_temp[13]==1'b0&&cnt_time==read_time)
        sign<=1'b0;
    else
        sign<=sign;
end



// //下面是管理单总线的输入还是输出
// always@(posedge clk_1us or negedge  sys_rst)
// begin
    // if(!sys_rst)
        // begin
            // qout_en<=1'b0;
            // qout_temp<=1'b0;
        // end
    // else    case(state)
        // init:
            // if(cnt_time<init_outend_time)
                // begin
                    // qout_en<=1'b1;
                    // qout_temp<=1'b0;
                // end
            // else
                // begin
                    // qout_en<=1'b0;
                    // qout_temp<=1'b0;
                // end
        // write_cmd:
            // // if(qin_temp==1'b1)
                // // begin
                    // // if((cnt_time<write_outend1_time)||cnt_time==write_time)
                    // // begin
                        // // qout_en<=1'b1;
                        // // qout_temp<=1'b0;
                    // // end
                    // // else
                    // // begin
                        // // qout_en<=1'b0;
                        // // qout_temp<=1'b0;
                    // // end
                // // end
            // // else
                // // begin
                    // // if((cnt_time<write_outend0_time)||cnt_time==write_time)
                    // // begin
                        // // qout_en<=1'b1;
                        // // qout_temp<=1'b0;
                    // // end
                    // // else
                    // // begin
                        // // qout_en<=1'b0;
                        // // qout_temp<=1'b0;
                    // // end
                // // end
            // if(cnt_time > 20'd62)
                // begin
                    // qout_temp  <=  1'b0;
                    // qout_en   <=  1'b0;
                // end
            // else    if(cnt_time <= 20'd2)
                // begin
                    // qout_temp  <=  1'b0;
                    // qout_en   <=  1'b1;
                // end
            // else    if(WR_44CC_CMD[cntBit15] == 1'b0)
                // begin
                    // qout_temp  <=  1'b0;
                    // qout_en   <=  1'b1;
                // end
            // else    if(WR_44CC_CMD[cntBit15] == 1'b1)
                // begin
                    // qout_temp  <=  1'b0;
                    // qout_en   <=  1'b0;
                // end
        // waite_cmd:
                // begin
                    // qout_en<=1'b1;
                    // qout_temp<=1'b1;
                // end
        // init_again:
            // if((cnt_time<init_outend_time))
                // begin
                    // qout_en<=1'b1;
                    // qout_temp<=1'b0;
                // end
            // else
                // begin
                    // qout_en<=1'b0;
                    // qout_temp<=1'b0;
                // end
        // write_cmd_again:
            // //if(qin_temp==1'b1)
                // // begin
                    // // if((cnt_time<write_outend1_time)||cnt_time==write_time)
                    // // begin
                        // // qout_en<=1'b1;
                        // // qout_temp<=1'b0;
                    // // end
                    // // else
                    // // begin
                        // // qout_en<=1'b0;
                        // // qout_temp<=1'b0;
                    // // end
                // // end
            // // else
                // // begin
                    // // if((cnt_time<write_outend0_time)||cnt_time==write_time)
                    // // begin
                        // // qout_en<=1'b1;
                        // // qout_temp<=1'b0;
                    // // end
                    // // else
                    // // begin
                        // // qout_en<=1'b0;
                        // // qout_temp<=1'b0;
                    // // end
                // // end
            // if(cnt_time > 20'd62)
                // begin
                    // qout_temp  <=  1'b0;
                    // qout_en   <=  1'b0;
                // end
            // else    if(cnt_time <= 20'd2)
                // begin
                    // qout_temp  <=  1'b0;
                    // qout_en   <=  1'b1;
                // end
            // else    if(WR_BECC_CMD[cntBit15] == 1'b0)
                // begin
                    // qout_temp  <=  1'b0;
                    // qout_en   <=  1'b1;
                // end
            // else    if(WR_BECC_CMD[cntBit15] == 1'b1)
                // begin
                    // qout_temp  <=  1'b0;
                    // qout_en   <=  1'b0;
                // end
        // read_cmd:
            // if(cnt_time<read_outend)
                // begin
                    // qout_en<=1'b1;
                    // qout_temp<=1'b0;
                // end
            // else
                // begin
                    // qout_en<=1'b0;
                    // qout_temp<=1'b0;
                // end
        // default:
                // begin
                    // qout_en<=qout_en;
                    // qout_temp<=qout_temp;
                // end
        // endcase
// end

//下面是管理单总线的输入还是输出
always@(posedge clk_1us or negedge  sys_rst)
begin
    if(!sys_rst)
        begin
            qout_en<=1'b0;
            qout_temp<=1'b0;
        end
    else    case(state)
        init:
            if(cnt_time<init_outend_time)
                begin
                    qout_en<=1'b1;
                    qout_temp<=1'b0;
                end
            else
                begin
                    qout_en<=1'b0;
                    qout_temp<=1'b0;
                end
        write_cmd:
                begin
                    if(WR_44CC_CMD[cntBit15]==1'b0)
                    begin
                        if(cnt_time<=write_outend0_time)
                        begin
                            qout_en<=1'b1;
                            qout_temp<=1'b0;
                        end
                        else
                        begin
                            qout_en<=1'b0;
                            qout_temp<=1'b0;
                        end
                    end
                    else    if(WR_44CC_CMD[cntBit15]==1'b1)
                    begin
                        if(cnt_time<=write_outend1_time)
                        begin
                            qout_en<=1'b1;
                            qout_temp<=1'b0;
                        end
                        else
                        begin
                            qout_en<=1'b0;
                            qout_temp<=1'b0;
                        end
                    end
                    else
                    begin
                        qout_en<=1'b0;
                        qout_temp<=1'b0;
                    end
            end
        waite_cmd:
                begin
                    qout_en<=1'b1;
                    qout_temp<=1'b1;
                end
        init_again:
            if((cnt_time<init_outend_time))
                begin
                    qout_en<=1'b1;
                    qout_temp<=1'b0;
                end
            else
                begin
                    qout_en<=1'b0;
                    qout_temp<=1'b0;
                end
        write_cmd_again:
                begin
                    if(WR_BECC_CMD[cntBit15]==1'b0)
                    begin
                        if(cnt_time<=write_outend0_time)
                        begin
                            qout_en<=1'b1;
                            qout_temp<=1'b0;
                        end
                        else
                        begin
                            qout_en<=1'b0;
                            qout_temp<=1'b0;
                        end
                    end
                    else    if(WR_BECC_CMD[cntBit15]==1'b1)
                    begin
                        if(cnt_time<=write_outend1_time)
                        begin
                            qout_en<=1'b1;
                            qout_temp<=1'b0;
                        end
                        else
                        begin
                            qout_en<=1'b0;
                            qout_temp<=1'b0;
                        end
                    end
                    else
                    begin
                        qout_en<=1'b0;
                        qout_temp<=1'b0;
                    end
            end
        read_cmd:
            if(cnt_time<read_outend)
                begin
                    qout_en<=1'b1;
                    qout_temp<=1'b0;
                end
            else
                begin
                    qout_en<=1'b0;
                    qout_temp<=1'b0;
                end
        default:
                begin
                    qout_en<=qout_en;
                    qout_temp<=qout_temp;
                end
        endcase
end
assign  data1_inout=(qout_en==1'b1)? qout_temp:1'bz;
assign  data_out=data16_out*625/10;


endmodule

 

梦灵-影
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
FPGA驱动DS18b20的设计（与仿真）
08-25
彻底感受到fpga功能的强大，虽然在处理乘除法的能力上fpga能力赶不上单片机，但是fpga完全可以构造出一个能力很强大的cpu，这就需要我们开动脑筋努力创造了，往后在EDA上还是要多花些功夫才行啊，呵呵！
FPGA驱动DS18B20_Verilog
06-08
在Verilog语言下用FPGA驱动DS18B20，带数码管显示，带LED报警，有报警值调整功能。这个是本人调过的，原版调通代码没改的，绝对能跑通。建议用QuatusII全编译后看一下RTL图就能理解程序是怎么工作的。
基于FPGA与DS18B20温度传感器的通信实现（一）
最新发布
m0_45161011的博客
03-31 185
本次设计中，我们选择使用FPGA作为主控芯片，以及DS18B20温度传感器作为外设。FPGA具有可编程性强、低功耗等特点，非常适合用于嵌入式系统的开发。DS18B20是一种数字温度传感器，采用单总线通信方式，具有高精度和可靠性。
基于FPGA的ds18b20温度传感器设计程序
liyaoyao_yy的专栏
11-20 1万+
end                else if (step == 46)               begin                  bit_valid                     step                         state                       else if (step == 47)
FPGA驱动DS18B20进行温度测量
2301_78782773的博客
10-14 393
使用fpga驱动DS18B20进行温度测量
【NiosII训练】第四篇、FPGA驱动DS18B20
大屁桃的博客
12-16 1038
第一部分、前言 1、闲话 还是一样，这个设计也是我们《SOPC技术及应用》课程结束的期末作业。我自己的是老师题库里的第五题、驱动AD9854这个模块《【NiosII训练】第一篇、FPGA驱动AD9854基础篇：https://blog.csdn.net/Learning1232/article/details/111193587》，想回去看的铁子们可以回去看。 这一题是我们班同学的，报酬是给我买零食，然后，我就答应了。。。。题目要求如下： 第二部分、题目要求 1、图片 2、文字 使用FP.
FPGA DS18B20驱动
u013749478的博客
07-12 694
#FPGA DS18B20驱动 #好用的话点个赞 /*============================================================================ * * LOGIC CORE: DS18B20温度采集程序 * MODULE NAME: DS18B20() * COMPANY: * author: LLW * Website: * REVISION HISTOR
【FPGA】ds18b20温度传感器
热门推荐
weixin_45888898的博客
02-10 1万+
文章目录一、ds18b20温度传感器二、看ds18b20手册找关键1.引脚说明2.最高位字节和最低位字节数据3.ds18b20暂存器数据4.需要的命令5.主状态机6.从状态机7.初始化时序8.写时隙9.读时隙10.关键时间参数11.低字节先发三、状态机设计1.主状态机1.初始化阶段2.发送命令阶段3.读取数据阶段2.从状态机3.状态图四、代码部分1.==ds18b20_driver.v==2.==ds18b20_ctrl.v==3.==top.v==4.==seg_driver==五、仿真验证六、上板验证七
DS18B20 FPGA
qq_34244712的博客
11-09 3157
最近，写了好几个关于通信的，只要原理理解对了，你按照时序要求，写就好了。可是有些时候，我们对通讯的时序会理解的不对。这个时候多写几个通讯时序，就慢慢熟悉了。 你的DQ数据线要设置为:inout,千万别忘记了 写程序之前，还是先介绍一下ds18b20的时序图: ds18b20的经典通讯过程如下: 我们就可以按照这个通讯方式去写程序:只要按照这个步骤，一步一步的写就可以了: 首先任何的通...
FPGA DS18B20
demon_yq的专栏
05-15 1263
module DS18B20Verlog( RESET,    Fresh,   TempCLK1, TempCLK2,   DQ, EOC, PDATA ); input RESET;  input Fresh; input TempCLK1; input TempCLK2; inout DQ; output EOC; output [7:0]
定时器加状态转移图方式实现DS18B20
暖暖_的_纠结的博客
04-23 1649
我们知道，DS18B20 是单总线时序通讯，采用严格的信号时序，以保证数据的完整性。因此如果采用操作系统，逻辑读取DS18B20为了避免时序被操作系统的任务调度，或者其他中断打乱，我们都会采用临界区的形式保护时序。 正常情况下，DS18B20通信的时间并不长，也就几十us。时间长的是18b20的转换过程（750ms）。 那么我们可以再和18B20通讯时关闭中断，通讯完毕立马开启中断，转换的过程可以不用管（时序要求再通讯部分）。这样就可以既不影响18b20数据的读取，一起不影响任务的调度。 但是这样的话，我
Verilog DS18B20
09-19
FPGA 或者CPLD 驱动DS18B20 Verilog代码，三个状态机实现，结构简单稳定
【NiosII训练】第四篇、FPGA驱动DS18B20.zip
12-15
博主在这篇文章中所用资料、演示视频以及自己的工程资料都放在这里。文章网址(https://blog.csdn.net/learning1232/category_10614317.html)
STM32单片机HAL库CubeMX单总线 驱动DS18B20 定时器中断方式 可移植
03-12
1、单总线驱动 2、定时器控制时序无需CPU干扰 3、可移植性强，单独的.c .h文件 4、可扩展性强，可自行增加ROM识别 5、CubeMx生成，HAL库可移植，采用结构体定义 6、状态机思想，完全自创，仅提供思路，不喜勿喷
ds18b20_rk3399添加DS18B20驱动_shoremml_
10-04
rk3399 平台下添加DS18B20 驱动，应用程序读取温度数据 包含dts修改 Kconfig 和Makefile修改
FPGA之DS18B20
08-10
以下程序，只考虑外接一个DS18B20，因为开发板上就挂了一个。只读取温度16位值，没有读取其他寄存器值。需要其他操作，可以在程序的基础上改改就行了。也很简单的。主要是底层的驱动，发数据和读数据，复位和读取...
DS18B20 FPGA逻辑 verilog语言，经调试稳定可用
07-20
时钟40Mhz
基于FPGA驱动DS18B20
jynyyhd的博客
09-12 1106
若S=1，则为负数。但UART和SPI、IIC不同的是，它是异步通信接口，异步通信中的接收方并不知道数据什么时候会到达，所以双方收发端都要有各自的时钟，在数据传输过程中是不需要时钟的，发送方发送的时间间隔可以不均匀，接受方是在数据的起始位和停止位的帮助下实现信息同步的。在不发送或者不接收数据的情况下，rx和tx处于空闲状 态，此时rx和tx线都保持高电平，如果有数据帧传输时，首先会有一个起始位，然后是8bit的数据位，接着有1bit的停止位，然后rx和tx继续进入空闲状态，然后等待下一次的数据传输。
FPGA+DS18B20
12-21
在FPGA上使用DS18B20可以实现数字温度测量系统，并通过数码管显示和蜂鸣器报警来展示温度信息。 以下是一个基于FPGA和DS18B20的数字温度测量系统的示例代码： ```verilog module DS18B20( input wire clk, input...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

梦灵-影

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

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

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

打赏作者

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

抵扣说明：

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

余额充值