集成电路技术分享 - Powered by Discuz! Archiver

VVIC 发表于 2010-6-26 01:54:46

fpga新手请教，verilog代码问题~~~

本帖最后由 fpgaw 于 2010-7-13 13:40 编辑

记得在书上看到过这样一段代码：
task shift_in;
output shift;
   begin
         @(posedge scl) shift=sda;
         @(posedge scl) shift=sda;
         @(posedge scl) shift=sda;
         @(posedge scl) shift=sda;
         @(posedge scl) shift=sda;
         @(posedge scl) shift=sda;
         @(posedge scl) shift=sda;
         @(posedge scl) shift=sda;
                  @(negedge scl)
            begin
               #`timeslice;
               out_flag=1;
               sda_buf=0;
            end
            @(negedge scl)
            #`timeslice out_flag=0;
end
endtask
这是在不可综合的行为模块中的代码，我想请问这段代码的执行是串行还是并行呢？？这段代码的如果把赋值号改成非阻塞式的应该就是并行执行的吧~~shift到shift都应该是相同的值了。
谢谢各位高手帮忙解答

HANG 发表于 2010-6-26 03:54:22

我个人理解是这时阻塞非阻塞结果一致。 
你还是仿真一下看看。

interig 发表于 2010-6-26 04:28:00

仿真看一下不就知道了嘛，呵呵

interi 发表于 2010-6-26 05:36:01

我仿真过的，结果是这几条语句是同时执行的，但是我觉得奇怪，为什么在夏老实书上182页的一个行为模块里它似乎又是按节拍来执行的~~糊涂了

CHANG 发表于 2010-6-26 06:05:37

这个应该是I2C模块模型的一个TASK, 是8位数据接收的任务模块, 是串行输入, 并且有起始位和停止位 
 
这个模块中在每个SCL 的上升沿收集一次数据. 加上停止位,共9bit 
 
仿真的时候注意一下技巧,代码没问题的

HDL 发表于 2010-6-26 06:55:01

恩恩，楼上说的对，我也仿真过了，代码确实没有问题 
但是我想把类似语句借用到我的模块里就发生时序不对的问题了 
这几个语句是并行执行的~~

AAT 发表于 2010-6-26 07:02:24

那把你模块里的代码贴出来看看， 
有些时候不起眼的地方的区别， 
影响却很大

FFT 发表于 2010-6-26 08:56:02

恩恩，好的~~我写了个SPI的从模块，受单片机控制，现在只想最先实现对16位数据的收发，写先写地址，再读写数据，地址的首位表示读或者写，但是我的时序老是有问题，请各位高手指教~~！！ 
module my_spi_sm( 
                                reset,             //system reset 
        ste,               //enable the spi_sm to work 
        sclk,             
                                simo,                  
                                somi, 
                                crdata, 
                                cwdata, 
                                caddr 
                  ); 
input         reset,sclk,ste; 
input                simo; 
output         somi; 
input  crdata; 
output cwdata; 
output caddr; 
 
reg ff; 
reg somi; 
reg data_in; 
reg data_out; 
 
 
reg data_write; 
reg crnw;                   //read/1 or write/0 enable 
reg caddrh; 
reg caddrl; 
reg caddrh_ready; 
reg caddrl_ready; 
reg cdatah_ready; 
reg cdatal_ready; 
reg main_state; 
reg sh8in_state; 
reg sh8out_state; 
 
assign caddr=caddrl_ready?{1'b1,caddrh,caddrl}:16'h0000; 
assign cwdata=cdatal_ready?data_write:16'h0000; 
 
//-----------------------------parameters-------------------------------------------------- 
parameter 
        idle                    =7'b0000001, 
        write_addrh =7'b0000010, 
        write_addrl =7'b0000100, 
        write_datah =7'b0001000, 
        write_datal =7'b0010000, 
        read_datah  =7'b0100000, 
        read_datal  =7'b1000000; 
 
parameter 
                         sh8in_bit7=8'b00000001, 
                         sh8in_bit6=8'b00000010, 
                         sh8in_bit5=8'b00000100, 
                         sh8in_bit4=8'b00001000, 
                         sh8in_bit3=8'b00010000, 
                         sh8in_bit2=8'b00100000, 
                         sh8in_bit1=8'b01000000, 
                         sh8in_bit0=8'b10000000; 
                        
parameter 
                          sh8out_bit7=8'b00000001, 
                         sh8out_bit6=8'b00000010, 
                         sh8out_bit5=8'b00000100, 
                         sh8out_bit4=8'b00001000, 
                         sh8out_bit3=8'b00010000, 
                         sh8out_bit2=8'b00100000, 
                         sh8out_bit1=8'b01000000, 
                         sh8out_bit0=8'b10000000; 
                                   
 
 
//--------------------------main state machine---------------------------------------- 
 
always@(posedge sclk or posedge reset) 
        if(reset) 
                 begin 
                            ff  <= 0; 
                               caddrh <= 0; 
                         caddrl <= 0; 
                   caddrh_ready <= 0; 
                   caddrl_ready <= 0; 
                   cdatah_ready <= 0; 
                   cdatal_ready <= 0;    
                                          
                     main_state <=idle; 
                 end                
        else 
                begin 
                                casex(main_state) 
                                 idle: begin                                                                 
                          ff <=0; 
                                              caddrh_ready <= 0; 
                                                           caddrl_ready <= 0; 
                                                           cdatah_ready <= 0; 
                                                           cdatal_ready <= 0; 
                                           if(ste==0) 
                                                                                 begin 
                                                      main_state <=write_addrh; 
                                                      sh8in_state<=sh8in_bit7; 
                                                            end 
                              else 
                                                      main_state <=idle; 
                                  end 
                                 write_addrh: 
                                                     if(ff==0) 
                                                                     shift8_in; 
                                                     else 
                                                              begin 
                                                                                     crnw <=data_in; 
                                                                        caddrh<=data_in; 
                                                                             caddrh_ready <=1; 
                                                                               main_state <=write_addrl; 
                                                                                                   ff <=0; 
                                                                         end 
                                 write_addrl: 
                                                                 if(ff==0) 
                                                                                 shift8_in; 
                                                                 else 
                                                                                 begin 
                                                                                         ff <=0; 
                                                                                         caddrl_ready <=1; 
                                                                                   caddrl <=data_in; 
                                                                                         if(crnw==1) 
                                                                                                 begin 
                                                                                                         main_state<=read_datah; 
                                                                                                         sh8out_state<=sh8out_bit7; 
                                                                                                         data_out<=crdata; 
                                                                                                 end 
                                                                                         else   
                                                                                                         begin 
                                                                                                         main_state<=write_datah; 
                                                                                                         end 
                                                                                 end 
                                
                                 write_datah: 
                                                                 if(ff==0) 
                                                                                 shift8_in; 
                                                                 else 
                                                                         begin 
                                                                                data_write<=data_in; 
                                                                                cdatah_ready<=1;                                                                                 
                                                                                 main_state<=write_datal; 
                                                                                 ff<=0; 
                                                                         end 
                                 write_datal: 
                                                                 if(ff==0) 
                                                                                 shift8_in; 
                                                                 else 
                                                                         begin 
                                                                                 data_write<=data_in; 
                                                                                 cdatal_ready<=1; 
                                                                                 main_state<=idle; 
                                                                                 ff<=0; 
                                                                         end 
                                         read_datah: 
                                                                 if(ff==0) 
                                                                                 shift8_out; 
                                                                 else 
                                                                         begin 
                                                                                 data_out<=crdata; 
                                                                                 main_state<=read_datal; 
                                                                                 ff<=0; 
                                                                         end 
                                 read_datal: 
                                                                 if(ff==0) 
                                                                                 shift8_out; 
                                                                 else 
                                                                         begin 
                                                                                 main_state<=idle; 
                                                                                 ff<=0; 
                                                                         end 
                          default: main_state<=idle; 
                  endcase 
                end 
                                                                                 
                                                                 
                     
//--------------------------shift in bit by bit----------------------------------------                                        
        task shift8_in; 
                        begin 
                                casex(sh8in_state) 
                                sh8in_bit7: if(!sclk) 
                                                begin 
                                                        data_in<=simo; 
                                                        sh8in_state<=sh8in_bit6; 
                                                end 
                                else 
                                                        sh8in_state<=sh8in_bit7;          
                         sh8in_bit6:  if(!sclk) 
                                                begin 
                                                        data_in<=simo; 
                                                        sh8in_state<=sh8in_bit5; 
                                                end 
                                else 
                                                sh8in_state<=sh8in_bit6; 
                         sh8in_bit5: if(!sclk) 
                                                begin 
                                                        data_in<=simo; 
                                                        sh8in_state<=sh8in_bit4; 
                                                end 
                                else 
                                                        sh8in_state<=sh8in_bit5; 
                         sh8in_bit4: if(!sclk) 
                                                begin 
                                                        data_in<=simo; 
                                                        sh8in_state<=sh8in_bit3; 
                                                end 
                                else 
                                                        sh8in_state<=sh8in_bit4; 
                         sh8in_bit3: if(!sclk) 
                                                begin 
                                                        data_in<=simo; 
                                                        sh8in_state<=sh8in_bit2; 
                                                end 
                                else 
                                                 sh8in_state<=sh8in_bit3; 
                         sh8in_bit2: if(!sclk) 
                                                begin 
                                                        data_in<=simo; 
                                                        sh8in_state<=sh8in_bit1; 
                                                end 
                                else 
                                                 sh8in_state<=sh8in_bit2;        
                        sh8in_bit1: if(!sclk) 
                                                begin 
                                                        data_in<=simo; 
                                                        sh8in_state<=sh8in_bit0; 
                                                end 
                                else 
                                                sh8in_state<=sh8in_bit1;    
            sh8in_bit0: if(!sclk) 
                                                begin 
                                                        data_in<=simo; 
                                            sh8in_state<=sh8in_bit7; 
                                            ff<=1; 
                                                end 
                                else 
                                                sh8in_state<=sh8in_bit0; 
                        default: 
                                                begin 
                                                ff<=0; 
                                                sh8in_state<=sh8in_bit7; 
                                                end 
                        endcase 
                end 
        endtask 
        
//--------------------------shift out bit by bit----------------------------------------                           
        task shift8_out; 
                        begin 
                                casex(sh8out_state) 
                          sh8out_bit7: 
                                                  if(sclk) 
                                                          begin 
                                                                  somi<=data_out; 
                                                                  sh8out_state<=sh8out_bit6; 
                                                          end 
                                                  else 
                                                                   sh8out_state<=sh8out_bit7; 
                         sh8out_bit6: 
                                                  if(sclk) 
                                                          begin 
                                                                  somi<=data_out; 
                                                                  sh8out_state<=sh8out_bit5; 
                                                          end 
                                                  else 
                                                                   sh8out_state<=sh8out_bit6; 
                          sh8out_bit5: 
                                                  if(sclk) 
                                                          begin 
                                                                  somi<=data_out; 
                                                                  sh8out_state<=sh8out_bit4; 
                                                          end 
                                                  else 
                                                                   sh8out_state<=sh8out_bit5; 
                           sh8out_bit4: 
                                                  if(sclk) 
                                                          begin 
                                                                  somi<=data_out; 
                                                                  sh8out_state<=sh8out_bit3; 
                                                          end 
                                                  else 
                                                                   sh8out_state<=sh8out_bit4; 
                           sh8out_bit3: 
                                                  if(sclk) 
                                                          begin 
                                                                  somi<=data_out; 
                                                                  sh8out_state<=sh8out_bit2; 
                                                          end 
                                                  else 
                                                                   sh8out_state<=sh8out_bit3; 
                           sh8out_bit2: 
                                                  if(sclk) 
                                                          begin 
                                                                  somi<=data_out; 
                                                                  sh8out_state<=sh8out_bit1; 
                                                          end 
                                                  else 
                                                                   sh8out_state<=sh8out_bit2; 
                            sh8out_bit1: 
                                                  if(sclk) 
                                                          begin 
                                                                  somi<=data_out; 
                                                                  sh8out_state<=sh8out_bit0; 
                                                          end 
                                                  else 
                                                                   sh8out_state<=sh8out_bit1; 
                            sh8out_bit0: 
                                                  if(sclk) 
                                                          begin 
                                                                  somi<=data_out;        
                                                                  sh8out_state<=sh8out_bit7; 
                                                                  ff<=1;                
                                                          end 
                                                  else 
                                                                   sh8out_state<=sh8out_bit0; 
                        
                                        default: 
                                                begin 
                                                ff<=0; 
                                                sh8out_state<=sh8out_bit7; 
                                                end 
                        endcase 
                end 
        endtask                         
 
 
endmodule

AAT 发表于 2010-6-26 09:04:56

楼主，无论什么语句，只要在begin-end中的语句都是顺序执行的。behavior里面根据我的经验是不用<=这样的表达式，因为很容易混淆，而且也完全没有必要。 
你的task里面用=和用<=的区别对于task本身来讲区别不大，因为都可以通过这个task接受到一个有效的byte,但是如果同时其他信号有用到你sample的值，比如在第一个clk之后sample shift,如果用=（立即update值），那么就可以sample到第一个sda值，而如果用<=（等待delta时间update值）,就无法sample到。 
你可加一段debug程序： 
initial 
   begin 
       @(posedge clk) sample = shift   // 有可能要加条件以使得和task里面第一个clk同时发生 
       $display(......); 
   end 
看看结果

VVIC 发表于 2010-6-26 09:21:31

非常感谢 !!

页: [1] 2

fpga论坛|fpga设计论坛's Archiver

fpga新手请教，verilog代码问题~~~