Bonjour à tous !!

Je me permets de me retourner vers vous aujourd'hui après plusieurs à chercher les solutions sans succès. 

En effet je suis dans un projet plutôt matériel où il faut mettre en place un dispositif de datation utilisant une carte CPLD. 

L'une des fonctions à réaliser est la description d'un SPI. Il s'agit décrire le SPI de telle en sorte qu'on puisse avoir à la sortie 4 états (00, 01,10 et 11) et ce en fonction de deux entrées qui sont le CS et le CLOCK. Pour cela, j'utilise le verilog comme langage. 

Le problème est que je n'arrive pas à décompte le nombre de bit afin de pouvoir changer ma sortie. Je reste bloquer dans le troisième état où je suis supposer compter jusqu'à trois pour passer à l'état suivant et compter jusqu'à 12 et refaire la boucle. 

Je vous joins la description et le chronogramme où j'ai forcé les entrées. 

Voici la description 

`timescale 1ns / 1ps
//////////////////////////////////////////////////////////////////////////////////
// Company: 
// Engineer: 
// 
// Create Date:    17:16:35 12/27/2019 
// Design Name: 
// Module Name:    Projet_Tech_SPI 
// Project Name: 
// Target Devices: 
// Tool versions: 
// Description: 
//
// Dependencies: 
//
// Revision: 
// Revision 0.01 - File Created
// Additional Comments: 
//
//////////////////////////////////////////////////////////////////////////////////
module Projet_Tech_SPI(
     CLK_SPI,
     CS_SPI,
	  reset,
	  Count_Bit,
	  //Count_DateBit, 
	  //Count_DataBit, 
     SPI_Select
    ); 

//------------- Déclaration des entrées -----------------------------
input   CLK_SPI, CS_SPI, reset;
//------------- Déclaration des sorties ----------------------------
output   [1:0] SPI_Select;
output 	Count_Bit;
//output   [1:0] Count_DateBit;
//output   [3:0] Count_DataBit;

//------------- Les ports d'entrées -------------------
wire    CLK_SPI, CS_SPI;
//------------- Les ports de sorties ------------------
reg     [1:0] SPI_Select;
reg	  [3:0] Count_Bit;
//reg     [1:0] Count_DateBit;
//reg     [3:0] Count_DataBit;

//------------- Les constantes internes --------------------------- 
reg i = 0;
assign CS_SPI = i;
parameter SIZE = 4;
parameter Idle = 4'b0001, Trans_FlagBit = 4'b0010, Trans_DateBit = 4'b0100, Trans_DataBit = 4'b1000 ;

//-------------Variables internes---------------------------
reg   [SIZE-1:0]          state        ;// Seq part of the FSM
reg   [SIZE-1:0]          next_state   ;// combo part of FSM
//----------Code startes Here------------------------
//assign next_state = fsm_function(state, Idle, Trans_FlagBit, Trans_DateBit, Trans_DataBit);


//---------- Logique séquentielle -----------------------------
always @ (posedge CLK_SPI)
begin : MEF_Seq
   if (reset == 1'b1) begin 
     state <=  #1  Idle;
   end else begin
     state <=  #1  next_state;
   end
end
//---------- Fin logique séquentielle -----------------------------

always @(state or next_state or CLK_SPI or CS_SPI)
begin : MEF_SPI
next_state = 4'b0001;
i=0;
//Count_Bit <=4'b0011;
//Count_DateBit <= 2'b11;
//Count_DataBit <= 4'b1111;

case(state)
	Idle 			  : if(CS_SPI == 1'b0) begin
						 next_state = Idle;
						 end else if (CS_SPI == 1'b1 ) begin
						 next_state = Trans_FlagBit;
						 end 
						 
	Trans_FlagBit : if(CS_SPI == 1'b1) begin
						 next_state = Trans_DateBit;
						 Count_Bit =4'b0011;
						 //i = 0;
						 //i=3;
						 //SPI_Select = 1;
						 end
						  
	Trans_DateBit : if(CS_SPI == 1'b0 && Count_Bit != 4'b0000) begin
						 next_state = Trans_DateBit;
						 //Count_Bit <= Count_Bit -1;
						 //SPI_Select = 1;
						 //Count_DateBit <= Count_DataBit +1;
						 //i= i-1 
						 end else if(CS_SPI == 1'b1 && Count_Bit == 4'b0000) begin 
						 next_state = Trans_DataBit;
						 Count_Bit <=4'b1100;
						 //i=12;
						 //SPI_Select = 2; 
						 end
						 
	Trans_DataBit : if(CS_SPI == 0 && Count_Bit != 4'b0000) begin
						 next_state = Trans_DataBit ;
						 //Count_Bit <= Count_Bit -1;
						 //i = i-1;
						 //assign CS_SPI = i;
						 //SPI_Select = 2;
						 end else if(CS_SPI == 0 && Count_Bit == 4'b0000) begin
						 next_state = Trans_FlagBit;
						 i = 1;
						 //SPI_Select = 0;
						end 
						
	//default  	 : next_state = Idle;
	
	endcase; 
end
 



//---------- La logique de sortie -----------------------------
always @ (posedge CLK_SPI)
begin : Sorie_Logiq
if (reset == 1'b1) begin
  SPI_Select <= #1 2'b11;
end
else begin
  case(state)
    Idle : begin
						SPI_Select <= #1 2'b11;

               end
   Trans_FlagBit : begin
                   SPI_Select <= #1 2'b00;
						 //Count_Bit <=4'b0011;
						 
                end
   Trans_DateBit : begin
						SPI_Select <= #1 2'b01;
						Count_Bit <= Count_Bit -1;
						//Count_Bit <=4'b0011;

                end
	Trans_DataBit : begin
						SPI_Select <= #1 2'b10;
						//Count_Bit <= Count_Bit -1;
						//Count_Bit <=4'b1100;

                end
   default : begin
						SPI_Select <= #1 2'b11;

                  end
  endcase
end
end // End Of Block OUTPUT_LOGIC

endmodule

Voici le chronogramme 

Je reste très attentif à vos réactions et à des éventuelle précisions.

C'est vraiment urgent et je vous remercie d'avance