基于FPGA的ds18b20温度传感器设计程序
基于FPGA的DS18B20控制程序设计及其Verilog实现 (一)
(2012-05-20 22:20:41)
转载▼
标签：
杂谈
一，总体介绍
DS18B20是一个1-wire总线，12bit的数字温度传感器，其详细的参数这里不做具体的介绍，只讨论其基于Verilog的控制程序的设计。
实际上，对DS18B20的控制，主要是实现1-wire总线的初始化，读，写等操作，然后再根据DS18B20的控制要求，实现对其控制的verilog逻辑。
在1-Wire总线上，有一个master，可以有1个或者多个slave。而对于FPGA+DS18B20的温度测试设计来讲，需要在FPGA上实现一个1-Wire总线的master。DS18B20作为1-wire总线的slave设备存在，可以有一个或者多个，不过为了简化程序，例程里假定只存在一个DS18B2020。
1-Wire总线的操作形式上相对简单，但操作本身相对却又比较复杂。用Verilog做控制程序设计时，可以采用多层次嵌套的状态机来实现。
二，FPGA +DS18B20的硬件设计
硬件的设计非常简单，只需要将DS18B20的DQ与FPGA的一个IO连接，并加4.7K左右的上拉电阻就可以了。VDD和VPU可以为3.0~5.0V。这里我们参照FPGA本身的IO电压，选择3.3V。
另外要注意的一点是，由于DQ的数据是双向的，所以FPGA的该IO要设定为inout类型。
三，1-Wire总线的基本操作及Verilog实现。
根据1-Wire总线的特点，可以把1-Wire总线的操作归结为初始化，单bit读操作，单bit写操作等最基础的几种。下面分别是几种基本操作的介绍和verilog实现。由于DS18B20的时序操作的最小单位基本上是1us，所以在该设计中，全部采用1MHz的时钟。
1. 初始化
初始化实际上就是1-wire总线上的Reset操作。由master发出一定长度的初始化信号。Slave看到该初始化信号后，在一定时间内发出规定长度的响应信号，然后初始化操作就结束了。
我们用一个简单的状态机来实现对DS18B20初始化的操作。根据初始化的时序要求，设计一个有3个状态的简单的状态机，这三个状态分别是RST_IDLE，RST_MINIT和RST_SINIT。系统初始化时，处于RST_IDLE状态，当RST_EN信号有效时，进入RST_MINIT状态，由master发出初始化信号。当master的初始化信号发出一定时间以后，直接进入RST_SINIT状态。在RST_SINIT状态时，master去观察slave是否输出了正确的状态：如果slave没有输出正确的状态，则状态机重新回到RST_MINIT状态，由master重新发出初始化信号；如果slave输出了正确的状态，则意味着初始化正确完成，状态机回到RST_IDLE状态，整个初始化过程完成（这个文章里涉及到比较多的状态机，但状态机的转换都很简单，所以不会给出状态机的状态转换图，仅仅会用文字做简单叙述，有疑问的地方，可以仔细阅读相关代码）。
wire RST_EN;
wire RST_OVER;
parameterRST_IDLE = 3'b001, //IDLE 状态
RST_MINIT =3'b010, //master 初始化操作
RST_SINIT =3'b100; //slave 初始化应答
reg [2:0]RSTSM, RSTSMNXT;
wirePHASE_RST_IDLE = RSTSM[0];
wirePHASE_RST_MINIT = RSTSM[1];
wirePHASE_RST_SINIT = RSTSM[2];
wirePHASENXT_RST_IDLE = RSTSMNXT[0];
always@(posedge CLK1MHZ or negedge RESET)
begin
if(~RESET)
RSTSM <=RST_IDLE;
else
RSTSM <=RSTSMNXT;
end
reg [9:0]MASTER_CNT; //用来控制master发出初始化信号的长度
always@(posedge CLK1MHZ or negedge RESET)
begin
if(~RESET)
MASTER_CNT<= 10'b0;
elseif(~PHASE_RST_MINIT)
MASTER_CNT<= 10'b0;
else
MASTER_CNT<= MASTER_CNT + 10'b1;
end
reg [9:0]SLAVE_CNT; //用来判断slave是否在恰当时间返回初始化结束的信号
always@(posedge CLK1MHZ or negedge RESET)
begin
if(~RESET)
SLAVE_CNT<= 10'b0;
elseif(~PHASE_RST_SINIT)
SLAVE_CNT<= 10'b0;
else
SLAVE_CNT<= SLAVE_CNT + 10'b1;
end
regSLAVE_IS_INIT; //采集并保存slave发出的初始化结束信号
always@(posedge CLK1MHZ or negedge RESET)
begin
if(~RESET)
SLAVE_IS_INIT<= 1'b1;
elseif(SLAVE_CNT == 10'd70)
SLAVE_IS_INIT<= DQ_IN;
elseif(PHASE_RST_MINIT)
SLAVE_IS_INIT<= 1'b1;
else
SLAVE_IS_INIT<= SLAVE_IS_INIT;
end
always @(RSTSMor RST_EN or MASTER_CNT or SLAVE_CNT or SLAVE_IS_INIT ) begin
case(RSTSM)
RST_IDLE:
if(RST_EN)
RSTSMNXT =RST_MINIT;
else
RSTSMNXT =RST_IDLE;
RST_MINIT:
if(MASTER_CNT== 10'd500)
RSTSMNXT =RST_SINIT;
else
RSTSMNXT =RST_MINIT;
RST_SINIT:
if( (SLAVE_CNT== 10'd500) & ~SLAVE_IS_INIT)
RSTSMNXT =RST_IDLE;
elseif((SLAVE_CNT == 10'd500) & SLAVE_IS_INIT)
RSTSMNXT =RST_MINIT;
else
RSTSMNXT =RST_SINIT;
default:
RSTSMNXT =RST_IDLE;
endcase
end
assignRST_OVER = PHASE_RST_SINIT & PHASENXT_RST_IDLE; //初始化完成标志信号
2. 单bit读操作
在1-wire总线上，读数据的操作实际上是按bit来完成的。每次master可以从slave读回一个bit的数据。读回的数据可能是1或者0。
需要注意的是，对于master来讲，无论读回来的数据是1还是0，其本身的操作及时序都是一样的，没有差异。
仍然用一个简单的状态机来实现对DS18B20的单bit读操作。设计一个有5个状态的简单的状态机，这五个状态分别是RD_IDLE，RD_MPL，RD_MSAP，RD_WAIT和RD_OVER。系统初始化时，处于RD_IDLE状态，当RDBEGIN信号有效时，进入RD_MPL状态，由master发出读信号。3us以后，进入RD_MSAP状态(master在该状态结束的前一个us读取DQ上的值作为读bit的结果)，在11us以后，进入RD_WAIT状态，而在读bit开始后的59us，系统进入RD_OVER状态，意味着读bit操作结束。RD_OVER状态是为了符合1-Wire总线的操作规范（在每个操作之间至少有1us的总线空闲时间）而存在的。
wire RDBEGIN ;
parameterRD_IDLE = 5'b00001, //resister pullup, larger than 1us
RD_MPL =5'b00010, //master pull low, larger than 1us
RD_MSAP =5'b00100, //ds18b20 pull low(read 0) or resister pullup(read 1), master sampledata, near 15us
RD_WAIT =5'b01000, //ds18b20 pull low(read 0) or resister pullup(read 1)
RD_OVER =5'b10000; //resister pullup, larger than 1us
reg [4:0]RDSM, RDSMNXT;
wirePHASE_RD_IDLE = RDSM[0];
wirePHASE_RD_MPL = RDSM[1];
wirePHASE_RD_MSAP = RDSM[2];
wirePHASE_RD_OVER = RDSM[4];
reg [5:0]RD_CNT;
always@(posedge CLK1MHZ or negedge RESET)
begin
if(~RESET)
RD_CNT <=6'b0;
elseif(~PHASE_RD_IDLE)
RD_CNT <=RD_CNT + 6'b1;
else
RD_CNT <=6'b0;
end
always@(posedge CLK1MHZ or negedge RESET)
begin
if(~RESET)
RDSM <=RD_IDLE;
else
RDSM <=RDSMNXT;
end
always @(RDSMor RDBEGIN or RD_CNT) begin
case(RDSM)
RD_IDLE:
if(RDBEGIN)
RDSMNXT =RD_MPL;
else
RDSMNXT =RD_IDLE;
RD_MPL:
if(RD_CNT ==6'd3)
RDSMNXT =RD_MSAP;
else
RDSMNXT =RD_MPL;
RD_MSAP:
if(RD_CNT ==6'd14)
RDSMNXT =RD_WAIT;
else
RDSMNXT =RD_MSAP;
RD_WAIT:
if(RD_CNT ==6'd59)
RDSMNXT =RD_OVER;
else
RDSMNXT =RD_WAIT;
RD_OVER:
if(RD_CNT ==6'd61)
RDSMNXT =RD_IDLE;
else
RDSMNXT =RD_OVER;
default:
RDSMNXT =RD_IDLE;
endcase
end
regRD_BIT_DATA; //读bit操作获得的数据
always@(posedge CLK1MHZ or negedge RESET)
begin
if(~RESET)
RD_BIT_DATA<= 1'b0;
else if(PHASE_RD_MSAP & (RD_CNT == 6'd13) )
RD_BIT_DATA<= DQ;
elseif(PHASE_RD_IDLE)
RD_BIT_DATA<= 1'b0;
else
RD_BIT_DATA<= RD_BIT_DATA;
end
3. 单bit写操作
在1-Wire总线上，写数据的操作也是按bit来完成的。每次master可以向slave写入一个bit的数据。写数据可能是1或者0。
需要注意的是，对于master来讲，写数据不同的时候（1或者0），其本身的操作及时序是有差别的。
对DS18B20的单bit写操作可以用一个有4个状态的简单的状态机来实现。这三个状态分别是WD_IDLE，WD_MPL，WD_OUT，和RD_OVER。系统初始化时，处于WD_IDLE状态，当WDBEGIN信号有效时，进入WD_MPL状态，由master发出写信号。9us以后，进入WD_MOUT状态(master将要写到slave的数据放到DQ上)，而在写bit开始后的59us，系统进入RD_OVER状态，意味着写bit操作结束。WD_OVER状态是为了符合1-Wire总线的操作规范（在每个操作之间至少有1us的总线空闲时间）而存在的。
wire WDBEGIN;//单bit写操作开始信号
wireWD_DATA_OUT; //要写入到slave的值
parameterWD_IDLE = 4'b0001, //resister pullup, no time request
WD_MPL =4'b0010, //master pull low, larger than 1us, use 10us.
WD_MOUT =4'b0100, //master pull low(write 0) or resister pull up(write 1), use 50us.
WD_OVER =4'b1000; //resister pullup, larger than 1us
reg [3:0]WDSM, WDSMNXT;
wirePHASE_WD_IDLE = WDSM[0];
wirePHASE_WD_MPL = WDSM[1];
wirePHASE_WD_MOUT = WDSM[2];
wirePHASE_WD_OVER = WDSM[3];
wirePHASENXT_WD_MOUT = WDSMNXT[2];
reg [5:0]WD_CNT;
always@(posedge CLK1MHZ or negedge RESET)
begin
if(~RESET)
WD_CNT <=6'b0;
elseif(~PHASE_WD_IDLE)
WD_CNT <=WD_CNT + 6'b1;
else
WD_CNT <=6'b0;
end
always@(posedge CLK1MHZ or negedge RESET)
begin
if(~RESET)
WDSM <=WD_IDLE;
else
WDSM <=WDSMNXT;
end
always @(WDSMor WDBEGIN or WD_CNT) begin
case(WDSM)
WD_IDLE:
if(WDBEGIN)
WDSMNXT =WD_MPL;
else
WDSMNXT =WD_IDLE;
WD_MPL:
if(WD_CNT ==6'd9)
WDSMNXT =WD_MOUT;
else
WDSMNXT =WD_MPL;
WD_MOUT:
if(WD_CNT ==6'd59)
WDSMNXT =WD_OVER;
else
WDSMNXT =WD_MOUT;
WD_OVER:
if(WD_CNT ==6'd61)
WDSMNXT =WD_IDLE;
else
WDSMNXT =WD_OVER;
default:
WDSMNXT =WD_IDLE;
endcase
end
always@(posedge CLK1MHZ or negedge RESET)
begin
if(~RESET)
DQ_OUT <=1'b0;
elseif(PHASENXT_WD_MOUT )
begin
DQ_OUT <=WD_DATA_OUT;
elseif(PHASE_WD_IDLE)
DQ_OUT <=1'b1;
else
DQ_OUT <=DQ_OUT;
end
三，1-Wire总线上按Byte读写的Verilog实现及DS18B20的Byte操作
上面用简单状态机实现了1-Wire总线上单bit数据的读写操作。在此基础上，可以通过状态机嵌套的方法实现按Byte的读写操作。实现Byte读写控制的状态机，控制8bit数据的读写操作，而每一bit的读写操作则通过嵌套单bit数据读写的状态机来实现。
1. 按Byte读操作
从DS18B20的datasheet上我们可以看到，1-Wire总线在发送或者接收数据的时候，LSB的数据在前，MSB的数据在后。所以对于Byte数据的读操作，只要依次在总线上读取8bit数据，并按照bit0~bit7的顺序将其存储到一个8bits的寄存器里即可。
通常情况下，设计状态机的时候，都会设计一个默认的初始状态（也可以称之为IDLE状态）。在这里每个bit数据的读操作可以设定为一个状态。这样，整个状态机就需要九个状态。在我们的设计中，九个状态分别是RBD_IDLE，RBD_BIT0 ~RBD_BIT7，其中 RBD_IDLE是IDLE状态，RBD_BIT0~RBD_BIT7分别是读取bit0~bit7数据的状态。
状态机在系统复位或者操作完成以后，进入RBD_IDLE状态。当读Byte数据的使能信号（RBDBEGIN）有效时，状态机进入RBD_BIT0，并调用1-Wire总线单bit读操作的状态机实现单bit的读操作，读取bit0的数据。为了在状态机进入RBD_BIT0的时候，正确调用单bit读操作的状态机，就要在RBD_BIT0状态下，使能RDBEGIN信号（单bit读操作的使能信号，详见上文）。在读完bit0的数据后（单bit读操作状态机回到IDLE状态），状态机需要进入RBD_BIT1状态，读取bit1的数据。也就是说，状态机从RBD_BIT0进入到RBD_BIT1的条件是bit0读操作结束（即其状态机回到IDLE状态），这个条件可以用单bit读操作状态机的PHASE_RD_OVER生成。上述的操作就实现了两个状态机的嵌套，顶层状态机（Byte读操作状态机）的信号触发底层状态机（单bit读操作状态机）进入工作状态，当底层状态机完成工作进入IDLE状态时，触发顶层状态机进入下一个状态。
从RBD_BIT0到RBD_BIT7的操作是相同的，依次读取8bit的数据。不过读完bit7的数据后，状态机要转回到RBD_IDLE状态。另外就是在单bit读的过程中，要根据Byte读状态机的状态，将读到的单bit数据写入对应的寄存器中。
下面是verilog的实现：
reg [7:0] RD_BYTE_DATA; //Byte读数据结果
wire RBDBEGIN ; // Byte读使能信号
reg PHASE_RD_OVER_Q;
always @(posedge CLK1MHZ or negedge RESET)
begin
if(~RESET)
PHASE_RD_OVER_Q <= 1'b0;
else
PHASE_RD_OVER_Q <= PHASE_RD_OVER;
end
wire RD_BIT_OVER = PHASE_RD_OVER &PHASE_RD_OVER_Q; //单bit读操作结束信号
parameter RBD_IDLE = 9'b0_0000_0001,
RBD_BIT0 = 9'b0_0000_0010,
RBD_BIT1 = 9'b0_0000_0100,
RBD_BIT2 = 9'b0_0000_1000,
RBD_BIT3 = 9'b0_0001_0000,
RBD_BIT4 = 9'b0_0010_0000,
RBD_BIT5 = 9'b0_0100_0000,
RBD_BIT6 = 9'b0_1000_0000,
RBD_BIT7 = 9'b1_0000_0000;
reg [8:0] RBDSM, RBDSMNXT;
always @(posedge CLK1MHZ or negedge RESET)
begin
if(~RESET)
RBDSM <= RBD_IDLE;
else
RBDSM <= RBDSMNXT;
end
always @(RBDSM or RBDBEGIN or RD_BIT_OVER) begin
case(RBDSM)
RBD_IDLE:
if(RBDBEGIN)
RBDSMNXT = RBD_BIT0;
else
RBDSMNXT = RBD_IDLE;
RBD_BIT0:
if(RD_BIT_OVER)
RBDSMNXT = RBD_BIT1;
else
RBDSMNXT = RBD_BIT0;
RBD_BIT1:
if(RD_BIT_OVER)
RBDSMNXT = RBD_BIT2;
else
RBDSMNXT = RBD_BIT1;
RBD_BIT2:
if(RD_BIT_OVER)
RBDSMNXT = RBD_BIT3;
else
RBDSMNXT = RBD_BIT2;
RBD_BIT3:
if(RD_BIT_OVER)
RBDSMNXT = RBD_BIT4;
else
RBDSMNXT = RBD_BIT3;
RBD_BIT4:
if(RD_BIT_OVER)
RBDSMNXT = RBD_BIT5;
else
RBDSMNXT = RBD_BIT4;
RBD_BIT5:
if(RD_BIT_OVER)
RBDSMNXT = RBD_BIT6;
else
RBDSMNXT = RBD_BIT5;
RBD_BIT6:
if(RD_BIT_OVER)
RBDSMNXT = RBD_BIT7;
else
RBDSMNXT = RBD_BIT6;
RBD_BIT7:
if(RD_BIT_OVER)
RBDSMNXT = RBD_IDLE;
else
RBDSMNXT = RBD_BIT7;
default:
RBDSMNXT = RBD_IDLE;
endcase
end
always @(posedge CLK1MHZ or negedge RESET)
begin
if(~RESET)
RD_BYTE_DATA <= 8'b0;
else if(PHASE_RD_MSAP & (RD_CNT == 6'd13) )
begin
case(RBDSM)
9'b0_0000_0010:
RD_BYTE_DATA[0] <= DQ;
9'b0_0000_0100:
RD_BYTE_DATA[1] <= DQ;
9'b0_0000_1000:
RD_BYTE_DATA[2] <= DQ;
9'b0_0001_0000:
RD_BYTE_DATA[3] <= DQ;
9'b0_0010_0000:
RD_BYTE_DATA[4] <= DQ;
9'b0_0100_0000:
RD_BYTE_DATA[5] <= DQ;
9'b0_1000_0000:
RD_BYTE_DATA[6] <= DQ;
9'b1_0000_0000:
RD_BYTE_DATA[7] <= DQ;
default:
RD_BYTE_DATA <= RD_BYTE_DATA;
endcase
end
else
RD_BYTE_DATA <= RD_BYTE_DATA;
end
2. 按Byte写操作
按Byte写操作的状态机与按Byte读操作的状态机的控制原理基本上是相同的。只不过在这里要嵌套的是单bit写操作的状态机。另外就是在单bit写操作的时候，要把对应bit的数据放到DQ总线上。
限于篇幅，状态机的实现不再给出，可自行参照Byte读操作的状态机做修改。
3. DS18B20的Byte操作
DS18B20的控制主要包括初始化，ROM命令和功能命令等。初始化的控制方式前面已经讨论过了。这里主要讨论一下ROM命令和功能命令。实际上不管是ROM命令还是功能命令，都可以归结为一个字节的命令（Byte写操作）加上0或者多个的Byte读/写操作。所以我们完全可以用上面所述的Byte读写状态机来实现ROM和功能命令。
对于只有一个单Byte写操作的命令，我们直接引用单Byte写操作的状态机就可以实现了。
而对于如读ROM数据的操作，则是一个Byte的写命令操作加上连续多个Byte的读数据的操作。在实现的时候，我们完全可以依照Byte读写操作状态机嵌套单bit读写操作状态机的方法，设计一个多BYTE读写操作的状态机，嵌套单Byte读写状态机。
下面是从DS18B20读出9Byte数据的状态机的verilog实现：
reg [7:0] TMP_LSB;
reg [7:0] TMP_MSB;
reg [7:0] USERBYTE1;
reg [7:0] USERBYTE2;
reg [7:0] CFGREG;
reg [7:0] RESERVED5;
reg [7:0] RESERVED6;
reg [7:0] RESERVED7;
reg [7:0] REGCRC;
wire RDSPAD_EN; //读DS18B20 rom数据使能信号
wire BYTE_READ_OVER = RD_BIT_OVER &PHASE_RBD_BIT7; //Byte读操作结束信号。
wire BYTE_WRITE_OVER = WD_BIT_OVER &PHASE_WBD_BIT7; //Byte 写操作结束信号。
parameter RDSPAD_IDLE = 11'b000_0000_0001,
RDSPAD_CMD = 11'b000_0000_0010, //读ROM命令
RDSPAD_BYTE1 = 11'b000_0000_0100, // 读ROM Byte 1
RDSPAD_BYTE2 = 11'b000_0000_1000,
RDSPAD_BYTE3 = 11'b000_0001_0000,
RDSPAD_BYTE4 = 11'b000_0010_0000,
RDSPAD_BYTE5 = 11'b000_0100_0000,
RDSPAD_BYTE6 = 11'b000_1000_0000,
RDSPAD_BYTE7 = 11'b001_0000_0000,
RDSPAD_BYTE8 = 11'b010_0000_0000,
RDSPAD_BYTE9 = 11'b100_0000_0000;
reg [10:0] RDSPADSM, RDSPADSMNXT;
wire PHASE_RDSPAD_IDLE = RDSPADSM[0];
wire PHASE_RDSPAD_CMD = RDSPADSM[1];
wire PHASE_RDSPAD_BYTE1 = RDSPADSM[2];
wire PHASE_RDSPAD_BYTE2 = RDSPADSM[3];
wire PHASE_RDSPAD_BYTE3 = RDSPADSM[4];
wire PHASE_RDSPAD_BYTE4 = RDSPADSM[5];
wire PHASE_RDSPAD_BYTE5 = RDSPADSM[6];
wire PHASE_RDSPAD_BYTE6 = RDSPADSM[7];
wire PHASE_RDSPAD_BYTE7 = RDSPADSM[8];
wire PHASE_RDSPAD_BYTE8 = RDSPADSM[9];
wire PHASE_RDSPAD_BYTE9 = RDSPADSM[10];
wire PHASENXT_RDSPAD_IDLE = RDSPADSMNXT[0];
wire PHASENXT_RDSPAD_CMD = RDSPADSMNXT[1];
wire PHASENXT_RDSPAD_BYTE1 = RDSPADSMNXT[2];
wire PHASENXT_RDSPAD_BYTE2 = RDSPADSMNXT[3];
wire PHASENXT_RDSPAD_BYTE3 = RDSPADSMNXT[4];
wire PHASENXT_RDSPAD_BYTE4 = RDSPADSMNXT[5];
wire PHASENXT_RDSPAD_BYTE5 = RDSPADSMNXT[6];
wire PHASENXT_RDSPAD_BYTE6 = RDSPADSMNXT[7];
wire PHASENXT_RDSPAD_BYTE7 = RDSPADSMNXT[8];
wire PHASENXT_RDSPAD_BYTE8 = RDSPADSMNXT[9];
wire PHASENXT_RDSPAD_BYTE9 = RDSPADSMNXT[10];
always @(posedge CLK1MHZ or negedge RESET)
begin
if(~RESET)
RDSPADSM <= RDSPAD_IDLE;
else
RDSPADSM <= RDSPADSMNXT;
end
always @( RDSPADSM or RDSPAD_EN or BYTE_READ_OVER orBYTE_WRITE_OVER) begin
case(RDSPADSM)
RDSPAD_IDLE:
if(RDSPAD_EN)
RDSPADSMNXT = RDSPAD_CMD;
else
RDSPADSMNXT = RDSPAD_IDLE;
RDSPAD_CMD:
if(BYTE_WRITE_OVER)
RDSPADSMNXT = RDSPAD_BYTE1;
else
RDSPADSMNXT = RDSPAD_CMD;
RDSPAD_BYTE1:
if(BYTE_READ_OVER)
RDSPADSMNXT = RDSPAD_BYTE2;
else
RDSPADSMNXT = RDSPAD_BYTE1;
RDSPAD_BYTE2:
if(BYTE_READ_OVER)
RDSPADSMNXT = RDSPAD_BYTE3;
else
RDSPADSMNXT = RDSPAD_BYTE2;
RDSPAD_BYTE3:
if(BYTE_READ_OVER)
RDSPADSMNXT = RDSPAD_BYTE4;
else
RDSPADSMNXT = RDSPAD_BYTE3;
RDSPAD_BYTE4:
if(BYTE_READ_OVER)
RDSPADSMNXT = RDSPAD_BYTE5;
else
RDSPADSMNXT = RDSPAD_BYTE4;
RDSPAD_BYTE5:
if(BYTE_READ_OVER)
RDSPADSMNXT = RDSPAD_BYTE6;
else
RDSPADSMNXT = RDSPAD_BYTE5;
RDSPAD_BYTE6:
if(BYTE_READ_OVER)
RDSPADSMNXT = RDSPAD_BYTE7;
else
RDSPADSMNXT = RDSPAD_BYTE6;
RDSPAD_BYTE7:
if(BYTE_READ_OVER)
RDSPADSMNXT = RDSPAD_BYTE8;
else
RDSPADSMNXT = RDSPAD_BYTE7;
RDSPAD_BYTE8:
if(BYTE_READ_OVER)
RDSPADSMNXT = RDSPAD_BYTE9;
else
RDSPADSMNXT = RDSPAD_BYTE8;
RDSPAD_BYTE9:
if(BYTE_READ_OVER)
RDSPADSMNXT = RDSPAD_IDLE;
else
RDSPADSMNXT = RDSPAD_BYTE9;
default:
RDSPADSMNXT = RDSPAD_IDLE;
endcase
end
//采集并保存TMP_LSB
always @(posedge CLK1MHZ or negedge RESET)
begin
if(~RESET)
TMP_LSB <= 8'b0;
else if(PHASENXT_RDSPAD_BYTE2 & BYTE_READ_OVER)
TMP_LSB <= RD_BYTE_DATA;
else
TMP_LSB <= TMP_LSB;
end
//采集并保存 TMP_MSB
always @(posedge CLK1MHZ or negedge RESET)
begin
if(~RESET)
TMP_MSB <= 8'b0;
else if(PHASENXT_RDSPAD_BYTE3 & BYTE_READ_OVER)
TMP_MSB <= RD_BYTE_DATA;
else
TMP_MSB <= TMP_MSB;
end
//采集并保存 USERBYTE1
always @(posedge CLK1MHZ or negedge RESET)
begin
if(~RESET)
USERBYTE1 <= 8'b0;
else if(PHASENXT_RDSPAD_BYTE4 & BYTE_READ_OVER)
USERBYTE1 <= RD_BYTE_DATA;
else
USERBYTE1 <= USERBYTE1;
End
//采集并保存USERBYTE2
always @(posedge CLK1MHZ or negedge RESET)
begin
if(~RESET)
USERBYTE2 <= 8'b0;
else if(PHASENXT_RDSPAD_BYTE5 & BYTE_READ_OVER)
USERBYTE2 <= RD_BYTE_DATA;
else
USERBYTE2 <= USERBYTE2;
end
//采集并保存 CFGREG
always @(posedge CLK1MHZ or negedge RESET)
begin
if(~RESET)
CFGREG <= 8'b0;
else if(PHASENXT_RDSPAD_BYTE6 & BYTE_READ_OVER)
CFGREG <= RD_BYTE_DATA;
else
CFGREG <= CFGREG;
end
//采集并保存 RESERVED5
always @(posedge CLK1MHZ or negedge RESET)
begin
if(~RESET)
RESERVED5 <= 8'b0;
else if(PHASENXT_RDSPAD_BYTE7 & BYTE_READ_OVER)
RESERVED5 <= RD_BYTE_DATA;
else
RESERVED5 <= RESERVED5;
end
//采集并保存 RESERVED6
always @(posedge CLK1MHZ or negedge RESET)
begin
if(~RESET)
RESERVED6 <= 8'b0;
else if(PHASENXT_RDSPAD_BYTE8 & BYTE_READ_OVER)
RESERVED6 <= RD_BYTE_DATA;
else
RESERVED6 <= RESERVED6;
end
//采集并保存 RESERVED7
always @(posedge CLK1MHZ or negedge RESET)
begin
if(~RESET)
RESERVED7 <= 8'b0;
else if(PHASENXT_RDSPAD_BYTE9 & BYTE_READ_OVER)
RESERVED7 <= RD_BYTE_DATA;
else
RESERVED7 <= RESERVED7;
end
//采集并保存 REGCRC
always @(posedge CLK1MHZ or negedge RESET)
begin
if(~RESET)
REGCRC <= 8'b0;
else if(PHASENXT_RDSPAD_IDLE & BYTE_READ_OVER)
REGCRC <= RD_BYTE_DATA;
else
REGCRC <= REGCRC;
end
下图是从示波器上抓出的单Byte读操作的DQ上的波形。
三，DS18B20的温度测量控制
在该系统中，1-Wire总线上只存在1个DS18B20，在控制DS18B20进行温度测量的时候，根据1-Wire总线的特性和DS18B20的控制要求，可以采用相对简单的控制流程。
我们用状态机来实现这个控制流程。从控制流程图可以看到，系统从空闲状态到读出温度数据，总共有8个大的步骤。而其中2和6，3和7是相同的，用状态机实现的时候，可以用同一个状态表示2和6，用同一个状态表示3和7。这样整个状态机就只需要6个状态。下面表格是状态机所有状态的定义：
| 状态名称 |
含义 |
| TTST_IDLE |
系统空闲状态 |
| TTST_RST |
总线初始化 |
| TTST_SKPROM |
SKIP ROM 命令 |
| TTST_CONVERT |
温度转换命令 |
| TTST_WOVER |
等待温度转换结束 |
| TTST_GETDATA |
读取温度数据 |
为了区分2和6以及3和7。用IS_CONVERT信号表示总线初始化和SKIPROM命令是用来执行CONVERT命令的。用~IS_CONVERT信号表示总线初始化和SKIPROM命令是用来读取温度数据的。在状态机进入TTST_IDLE状态时，令IS_CONVERT为1并保持，当状态机进入TTST_WOVER状态时，令IS_CONVERT为0并保持。
用TEST_EN信号作为温度测量的开始信号，这个信号至少保持1个时钟周期（CLK1MHZ），如果TEST_EN的长度超过了一次测试所需要的总的时间，则在一次测试完成以后，就直接开始进行第二次测量。
用RST_OVER信号作为总线初始化的结束和下一个状态的开始的标志信号。
用WBD_OVER信号作为命令（SKIPROM，CONVERT）结束和下一个状态开始的标志信号。
用RD_BIT_DATA & PHASE_RD_OVER表示等待温度转换结束和下一个状态开始的信号（详细的原因可参照DS18B20 datasheet的相关部分）。
用BYTE_READ_OVER &PHASENXT_RDSPAD_IDLE表示读取温度数据结束的信号（该两个信号的与表示读DS18B20 9ByteROM数据状态机完成工作并进入IDLE状态）。
下面是verilog的实现：
reg IS_CONVERT;
parameter TTST_IDLE = 6'b00_0001,
TTST_RST = 6'b00_0010,
TTST_SKPROM = 6'b00_0100,
TTST_CONVERT = 6'b00_1000,
TTST_WOVER = 6'b01_0000,
TTST_GETDATA = 6'b10_0000;
reg [5:0] TTSTSM, TTSTSMNXT;
wire PHASE_TTST_IDLE = TTSTSM[0];
wire PHASE_TTST_RST = TTSTSM[1];
wire PHASE_TTST_SKPROM = TTSTSM[2];
wire PHASE_TTST_CONVERT = TTSTSM[3];
wire PHASE_TTST_WOVER = TTSTSM[4];
wire PHASE_TTST_GETDATA = TTSTSM[5];
wire PHASENXT_TTST_IDLE = TTSTSMNXT[0];
always @(posedge CLK1MHZ or negedge RESET)
begin
if(~RESET)
TTSTSM <= TTST_IDLE;
else
TTSTSM <= TTSTSMNXT;
end
always @(posedge CLK1MHZ or negedge RESET)
begin
if(~RESET)
IS_CONVERT <= 1'b1;
else if(PHASE_TTST_IDLE)
IS_CONVERT <= 1'b1;
else if(PHASE_TTST_WOVER)
IS_CONVERT <= 1'b0;
else
IS_CONVERT <= IS_CONVERT;
end
always @(TTSTSM or TEST_EN or RST_OVER or IS_CONVERTor WBD_OVER or RD_BIT_DATA or PHASE_RD_OVER or PHASE_RD_OVER or BYTE_READ_OVERor PHASENXT_RDSPAD_IDLE ) begin
case(TTSTSM)
TTST_IDLE:
if(TEST_EN)
TTSTSMNXT = TTST_RST;
else
TTSTSMNXT = TTST_IDLE;
TTST_RST:
if(RST_OVER)
TTSTSMNXT = TTST_SKPROM;
else
TTSTSMNXT = TTST_RST;
TTST_SKPROM:
if(WBD_OVER)
if(IS_CONVERT)
TTSTSMNXT = TTST_CONVERT;
else
TTSTSMNXT = TTST_GETDATA;
else
TTSTSMNXT = TTST_SKPROM;
TTST_CONVERT:
if(WBD_OVER)
TTSTSMNXT = TTST_WOVER;
else
TTSTSMNXT = TTST_CONVERT;
TTST_WOVER:
if(RD_BIT_DATA & PHASE_RD_OVER)
TTSTSMNXT = TTST_RST;
else
TTSTSMNXT = TTST_WOVER;
TTST_GETDATA:
if(BYTE_READ_OVER & PHASENXT_RDSPAD_IDLE )
TTSTSMNXT = TTST_IDLE;
else
TTSTSMNXT = TTST_GETDATA;
default:
TTSTSMNXT = TTST_IDLE;
endcase
end
assign WD_DATA_OUT = PHASE_TTST_SKPROM ? 8'hcc :(PHASE_TTST_CONVERT ? 8'h44 : ( PHASE_RDSPAD_CMD ? 8'hbe : 8'h00) );
四，DQ总线的控制
1-Wire总线只有一根信号线，是双向的，带上拉电阻的。在FPGA中做DQ的逻辑如下，至于这么做的原因，不再做叙述。当弄懂了1-Wire总线的规范和DS18B20的基本操作的话，很容易就理解了。
wire DQ, DQ_OUT, DQ_IN, DQ_OUT_EN;
assign DQ = DQ_OUT_EN ? DQ_OUT : 1'bz;
assign DQ_IN = DQ;
wire RD_DQ_OUT = ~PHASE_RD_MPL;
wire RD_DQ_OUT_EN = PHASE_RD_MPL ;
wire WD_DQ_OUT = 1’b0;
wire WD_DQ_OUT_EN = PHASE_WD_MPL | (~WD_BIT_DATA& PHASE_WD_MOUT);
wire DQ_RST_OUT = ~ PHASE_RST_MINIT;
wire DQ_RST_EN = PHASE_RST_MINIT;
assign DQ_OUT = RD_DQ_OUT & RD_DQ_OUT_EN |WD_DQ_OUT & WD_DQ_OUT_EN | DQ_RST_OUT & DQ_RST_EN;
assign DQ_OUT_EN = RD_DQ_OUT_EN | WD_DQ_OUT_EN |DQ_RST_EN;