hdlc_recv.v

hdlc_receive_code.rar

                                   
                                  end
                          default:

                                  begin
                                            flagdetc_next_state = idle;
                                  end
                     endcase
                end

/**************************************************************************/
                  ////**   State Machine end  **//
/**************************************************************************/


/**************************************************************************/
                  ///***  byte_reset counter  ***///
/**************************************************************************/
         always @(posedge ihdlc_RXCLK or negedge ihdlc_RESET)
                begin
                     if(!ihdlc_RESET)
                               begin
                                              byte_rst_counter[2:0] <= 3'b0;
                               end
                     else
                               begin
                                   if(byte_rst_counter_start)
                                              byte_rst_counter[2:0] <= byte_rst_counter[2:0] + 1;
                                   else 
                                              byte_rst_counter[2:0] <= 3'b0;
                               end
                end


         always @(posedge ihdlc_RXCLK or negedge ihdlc_RESET)
                begin
                     if(!ihdlc_RESET)
                               begin
                                              byte_rst_counter_start <= 1'b0;
                               end
                     else
                               begin
                                   if(byte_rst_counter[2:0]==3'b111)  
                                              byte_rst_counter_start <= 1'b0;
                                   else if(flag_7e)
                                              byte_rst_counter_start <= 1'b1;
                               end
                end
/**************************************************************************/
                  ///***  bit_counter & byte_counter  ***///
/**************************************************************************/

         always @(posedge ihdlc_RXCLK  or negedge ihdlc_RESET)    // bit_counter
                begin
                    if(!ihdlc_RESET)
                           begin
                                bit_counter[3:0]  <= 4'b0;
                           end 
                    else
                           begin
                               if(flag_7e||shifter1[7:0]==8'b1111_1111)  
                                       begin   
                                                    bit_counter[3:0]  <= 4'b0;
                                       end
                                else
                                       begin
                                          if(bit_counter!=4'b1111)
                                                begin
                                                     if(delete_zero_wire!=1'b1)
                                                     bit_counter[3:0]  <= bit_counter[3:0] + 1;
                                                end
                                          else
                                                begin
                                                      if(delete_zero_wire!=1'b1)
                                                     bit_counter[3:0]  <= 4'b1000;
                                                end
                                       end
                           end 
                end


         always @(posedge ihdlc_RXCLK  or negedge ihdlc_RESET)   // byte_counter
                begin
                    if(!ihdlc_RESET)
                           begin
                                byte_counter[6:0] <= 7'b0;
                           end 
                    else
                           begin
                                 if(byte_rst_counter[2:0]==3'b111)
                                          begin
                                                              byte_counter[6:0] <= 7'b0;
                                          end
                                 else
                                          begin
                                             if(bit_counter==4'b1111&&delete_zero!=1'b1)
                                                  begin
                                                       if(byte_counter[6:0]!=7'b111_1111)
                                                              byte_counter[6:0] <= byte_counter[6:0] + 1;
                                                       else
                                                              byte_counter[6:0] <= byte_counter[6:0] ;
                                                  end
                                          end

                           end 
                end


/**************************************************************************/
                      ///***  TXData Status   ***///
/**************************************************************************/
          always @(byte_counter[6:0] or error_flag or frame_end or error_wire)
               begin
                             if(frame_end)
                                      begin
                                          if(error_flag||error_wire)
                                                            ohdlc_TXDS_tmp[2:0]  =  3'b000;  // illegal frame_end
                                          else if(byte_counter>64)
                                                            ohdlc_TXDS_tmp[2:0]  =  3'b001;  // long frame_end
                                          else if(byte_counter<4)  
                                                            ohdlc_TXDS_tmp[2:0]  =  3'b010;  // short frame_end
                                          else if(byte_counter!=0)
                                                            ohdlc_TXDS_tmp[2:0]  =  3'b011;  // normal frame_end
                                          else              
                                                            ohdlc_TXDS_tmp[2:0]  =  3'b111;  // unvalued data
                                      end
                             else 
                                      begin
                                          if(!error_flag)
                                               begin
                                                 if(byte_counter==1)
                                                            ohdlc_TXDS_tmp[2:0]  =  3'b110;  // first byte
                                                 else if(byte_counter==2)  
                                                            ohdlc_TXDS_tmp[2:0]  =  3'b101;  // second byte
                                                 else if(byte_counter!=0)
                                                            ohdlc_TXDS_tmp[2:0]  =  3'b100;  // other byte
                                                 else              
                                                            ohdlc_TXDS_tmp[2:0]  =  3'b111;  // unvalued data
                                              end
                                          else
                                                            ohdlc_TXDS_tmp[2:0]  =  3'b111;  // unvalued data
                                      end
               end


           always @(posedge ihdlc_RXCLK or negedge ihdlc_RESET)
                  begin
                       if(!ihdlc_RESET)
                              begin
                                              ohdlc_TXDS <= 3'b111;
                              end
                       else
                              begin
                                   if(byte_rst_counter_start!=1'b1||flag_7e) 
                                              ohdlc_TXDS <= ohdlc_TXDS_tmp;
                              end
                  end
/**************************************************************************/
                      ///***  Output CLK Generator   ***///
/**************************************************************************/
           always @(posedge ihdlc_RXCLK or negedge ihdlc_RESET)
                  begin
                       if(!ihdlc_RESET)
                              begin
                                              ohdlc_TXCLK <= 1'b1;
                              end
                       else
                              begin
                                    if(bit_counter[3:0]==4'b1111||ohdlc_TXDS_tmp==3'b111||error||error_flag)
                                         begin
                                              ohdlc_TXCLK <= 1'b1;
                                         end
                                    else if((bit_counter[3:0]==4'b1100||byte_rst_counter[2:0]==3'b100)&&ohdlc_TXDS_tmp!=3'b111)
                                         begin
                                              ohdlc_TXCLK <= 1'b0;
                                         end
                                    else      ohdlc_TXCLK <= ohdlc_TXCLK;
                                     
                              end
                  end

/**************************************************************************/
                      ///***  output Data load   ***///
/**************************************************************************/
          always @(posedge ihdlc_RXCLK or negedge ihdlc_RESET)
                begin
                      if(!ihdlc_RESET)
                                    begin
                                              ohdlc_TXD[7:0]  <= 8'b0;
                                    end
                      else
                                    begin
                                         if(bit_counter[3:0]==4'b1111)
                                              ohdlc_TXD[7:0]  <= shifter2[7:0];
                                    end
                end
/**************************************************************************/
                      ///***  frame_end signal generator   ***///
/**************************************************************************/
          always @(shifter1[7:0] or bit_counter[3:0])
                 begin
                         begin
                           if(shifter1[7:0]==8'h7e&&bit_counter[3:0]==4'b1111)
                                   begin
                                         frame_end  = 1'b1;
                                   end
                           else
                                   begin
                                         frame_end  = 1'b0;
                                   end
                        end
                 
                 end

/**************************************************************************/
                      ///***  error_flag generater   ***///
/**************************************************************************/
          always @(posedge ihdlc_RXCLK or negedge ihdlc_RESET)
                 begin
                       if (!ihdlc_RESET)
                              begin
                                                  error_flag <= 1'b0 ;
                              end
                       else
                              begin
                                 if(byte_rst_counter[2:0]==3'b111)
                                        begin
                                                  error_flag <= 1'b0 ;
                                        end      
                                  else
                                        begin
                                           if(error_wire&&byte_counter[6:0]!=7'b0) 
                                                  error_flag <= 1'b1;
                                           else if(error_wire&&bit_counter[3:0]==4'b1101) //for test
                                                  error_flag <= 1'b1;                     // for test
                                           else 
                                                  error_flag <= error_flag;
                                        end
                              end
                 end

endmodule