URL https://opencores.org/ocsvn/connect-6/connect-6/trunk

Subversion Repositories connect-6

[/] [connect-6/] [trunk/] [XILINX/] [BUILD_SCC_SRCH/] [SP6/] [CMD_Decode_simple.v] - Blame information for rev 17

Details | Compare with Previous | View Log


 
module CMD_Decode(      //      USB JTAG
                                        iRXD_DATA,oTXD_DATA,iRXD_Ready,iTXD_Done,oTXD_Start,
                                        //      AI
                                        oAI_DATA,iAI_DATA,oAI_Start,iAI_Done,oCOLOR,
                                        //      Control
                                        iCLK,iRST_n,oAI_RSTn,
                                        //Debug
                                        d_cmd
                                        );
//      USB JTAG
input [7:0] iRXD_DATA;
input iRXD_Ready,iTXD_Done;
output [7:0] oTXD_DATA;
output oTXD_Start;
//      AI
input   [63:0]   iAI_DATA;
output  [63:0]   oAI_DATA;
output reg oAI_Start;
input iAI_Done;
output [7:0] oCOLOR;
//      Control
input iCLK,iRST_n;
output oAI_RSTn;
//output oAI_RSTn =AI_RSTn; //doesn't work in synplify
//Debug
output [16:0] d_cmd ;
//      Internal Register
reg [63:0] CMD_Tmp;
reg [71:0] AI_RESULT;
reg [71:0] AI_RESULT_next;
reg [2:0] mAI_ST  /* synthesis syn_encoding = "safe,onehot" */;
reg [2:0] mAI_ST_next;
 
reg [63:0] AI_INPUT;
reg [63:0] AI_INPUT_next;
reg [16:0] AI_INPUT_MOVE;
reg [16:0] AI_INPUT_MOVE_next;
//      USB JTAG TXD Output
reg oSR_TXD_Start;
reg [7:0] oSR_TXD_DATA;
 
//
reg AI_RSTn;
assign oAI_RSTn =AI_RSTn; // this one works in synplify. see line 24
reg [16:0] move_count_me,move_count_you; //maximum no. of moves= 361
reg [16:0] move_count_me_next; //maximum no. of moves= 361
wire [16:0] move_count=(move_count_me+move_count_you) >> 2;
 
reg [7:0]        CMD;
 
reg TXD_Start;
reg TXD_Start_next;
reg rst_count;
assign oTXD_Start =TXD_Start;
assign d_cmd=AI_INPUT_MOVE;
assign oCOLOR = CMD;
 
/////////////////////////////////////////////////////////
///////         Shift Register For Command Temp /////////////
always@(posedge iCLK or negedge iRST_n)
begin
        if(!iRST_n)
        begin
        CMD_Tmp<=0;
        CMD<=0;
        move_count_you<=0;
        AI_RSTn<=1'b0;
        end
        else
        begin
                        CMD_Tmp<=CMD_Tmp;
                        CMD<=CMD;
                        move_count_you<=move_count_you;
                        AI_RSTn<=AI_RSTn;
                if(iRXD_Ready)
                begin
                        CMD_Tmp<={CMD_Tmp[55:0],iRXD_DATA};
 
 
                        if(iRXD_DATA !=8'h44 && iRXD_DATA!=8'h4C)
                        begin
 
                        move_count_you<=move_count_you+1;//4 ascii chars == 1 move
                        AI_RSTn<=1'b1;
                        end
                        else
                        begin
 
                        CMD<=iRXD_DATA;
                        move_count_you<=0;
                        AI_RSTn<=1'b0;
 
                        end
                end
                else
 
                        AI_RSTn<=1'b1;
        end
end
/////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////
////////////////        AI Control      /////////////////////
reg [3:0] wait_count;
reg [3:0] wait_count_next;
reg [3:0] NO_OF_MOVES;
reg [3:0] NO_OF_MOVES_next;
parameter state0=3'b000,state1=3'b001,state2=3'b010,state3=3'b011,state4=3'b100,state5=3'b101,state6=3'b110;
 
always@(posedge iCLK or negedge AI_RSTn)
 
begin
        if(!AI_RSTn)
        begin
                mAI_ST<= state0;
                wait_count <=0;
                move_count_me<=0;
                AI_RESULT<=0;
                TXD_Start<=1'b0;
                NO_OF_MOVES<=0;
                AI_INPUT<=0;
                AI_INPUT_MOVE<=0;
 
        end
        else
        begin
                mAI_ST<=mAI_ST_next;
                wait_count <=wait_count_next;
                move_count_me<=move_count_me_next;
                AI_RESULT<=AI_RESULT_next;
                TXD_Start<=TXD_Start_next;
                NO_OF_MOVES<=NO_OF_MOVES_next;
                AI_INPUT<=AI_INPUT_next;
                AI_INPUT_MOVE<=AI_INPUT_MOVE_next;
 
        end
end
 
 
always@*//(mAI_ST,move_count,iTXD_Done,TXD_Start,iAI_Done,iAI_DATA)
begin
        mAI_ST_next<=mAI_ST;
        wait_count_next<=wait_count;
        move_count_me_next<=move_count_me;
        AI_RESULT_next<=AI_RESULT;
        TXD_Start_next<=TXD_Start;
        NO_OF_MOVES_next<=NO_OF_MOVES;
        AI_INPUT_next <=AI_INPUT;
        AI_INPUT_MOVE_next<=AI_INPUT_MOVE;
                        case(mAI_ST)
 
 
                state0: begin
                                        if( (CMD        == 8'h44) && (move_count ==0))
                                                begin
                                                mAI_ST_next             <=      state1;
                                                AI_INPUT_next<=CMD_Tmp;
                                                AI_INPUT_MOVE_next<=move_count;
                                                end
                                        else if ( (CMD        == 8'h4C) && (move_count ==1))
                                                begin
                                                mAI_ST_next     <=      state4;
                                                AI_INPUT_next<=CMD_Tmp;
                                                AI_INPUT_MOVE_next<=move_count;
                                                end
 
                                        else
                                                mAI_ST_next     <=      state0;
 
 
 
                                end
                state1: begin
                                        mAI_ST_next     <=      state2;
                                end
                state2: begin
                                        if(iAI_Done == 1'b1)
                                        begin
                                                mAI_ST_next     <=      state3;
                                                NO_OF_MOVES_next<=4;
                                                AI_RESULT_next[63:0]<=iAI_DATA;
                                                //AI_RESULT_next[63:0]<=CMD_Tmp;loop back 
 
                                        end
                                        else begin
                                                mAI_ST_next     <=      state2;
                                        end
 
 
                                end
                state3: begin
 
                                        if(iTXD_Done == 1'b1 && TXD_Start ==1'b0)
                                        begin
                                                if(wait_count==NO_OF_MOVES) begin
                                                mAI_ST_next     <=      state4;
                                                wait_count_next<=0;
                                                TXD_Start_next  <=1'b0;
                                                end
                                                else begin
                                                mAI_ST_next     <=      state3;
                                                TXD_Start_next  <=1'b1;
                                                wait_count_next<=wait_count+1;
                                                AI_RESULT_next<={AI_RESULT[63:0],8'h0};
                                                move_count_me_next<=move_count_me+1;
                                                end
                                        end
                                        else    begin
                                                TXD_Start_next  <=1'b0;
                                                end
 
                                end
                state4: begin
                                        //move_count % 4  == 0 means dark's turn, (move_count % 4  == 1 ) means light's turn
                                        if((((move_count % 4)  == 3 ) && (CMD ==8'h44))|| (((move_count % 4)  == 1 ) && (CMD ==8'h4C)))
                                                begin
                                        //if(((move_count ==1|| move_count ==5|| move_count ==9) && (CMD ==8'h4C)))
                                                mAI_ST_next     <=      state5;
                                                AI_INPUT_next<=CMD_Tmp;
                                                AI_INPUT_MOVE_next<=move_count;
                                                end
                                        else
                                                mAI_ST_next     <=      state4;
 
                                end
                state5: begin
                                        mAI_ST_next     <=      state6;
                                        AI_INPUT_next<=CMD_Tmp;
                                end
                state6: begin
                                        if(iAI_Done == 1'b1) begin
                                                mAI_ST_next     <=      state3;
                                                AI_RESULT_next[63:0]<=iAI_DATA;
                                                //AI_RESULT_next[63:0]<=CMD_Tmp; loop back 
                                                NO_OF_MOVES_next<=8 ;
                                                end
 
                                        else begin
                                                mAI_ST_next     <=      state6;
                                                AI_RESULT_next<=0;
                                                NO_OF_MOVES_next<=NO_OF_MOVES;
                                        end
 
                                end
                        default:mAI_ST_next <= mAI_ST;
                        endcase
 
 
end
 
assign oTXD_DATA = AI_RESULT[71:64];
 
assign oAI_DATA = AI_INPUT;
 
always@(mAI_ST)
begin
                        case(mAI_ST)
 
 
                state0: begin
 
                                        oAI_Start       <=1'b0;
                                        //oAI_DATA<=0;
 
 
                                end
                state1: begin
                                        oAI_Start       <=1'b1;
                                        //oAI_DATA<=CMD_Tmp[63:0];
 
 
                                //end
                                end
                state2: begin
 
                                        oAI_Start       <=1'b0;
                                        //oAI_DATA<=0;
                                //end 
                                end
                state3: begin
                                        oAI_Start       <=1'b0;
                                        //oAI_DATA<=0;
 
                                //end
                                end
                state4: begin
                                        oAI_Start       <=1'b0;
                                        //oAI_DATA<=CMD_Tmp[63:0];
 
 
                                end
                state5: begin
                                        oAI_Start       <=1'b1;
                                        //oAI_DATA<=CMD_Tmp[63:0];
 
 
                                //end
                                end
                state6: begin
                                        oAI_Start       <=1'b0;
                                        //oAI_DATA<=CMD_Tmp[63:0];
 
 
                                //end
                                end
                        default:begin
                                        oAI_Start       <=1'b0;
                                        //oAI_DATA<=CMD_Tmp[63:0];
                                end
                        endcase
 
 
end
endmodule

Browse

Tools

Subversion Repositories connect-6

[/] [connect-6/] [trunk/] [XILINX/] [BUILD_SCC_SRCH/] [SP6/] [CMD_Decode_simple.v] - Blame information for rev 17

Line No.	Rev	Author	Line
1	17	sumanta.ch
2			`module CMD_Decode( // USB JTAG`
3			`iRXD_DATA,oTXD_DATA,iRXD_Ready,iTXD_Done,oTXD_Start,`
4			`// AI`
5			`oAI_DATA,iAI_DATA,oAI_Start,iAI_Done,oCOLOR,`
6			`// Control`
7			`iCLK,iRST_n,oAI_RSTn,`
8			`//Debug`
9			`d_cmd`
10			`);`
11			`// USB JTAG`
12			`input [7:0] iRXD_DATA;`
13			`input iRXD_Ready,iTXD_Done;`
14			`output [7:0] oTXD_DATA;`
15			`output oTXD_Start;`
16			`// AI`
17			`input [63:0] iAI_DATA;`
18			`output [63:0] oAI_DATA;`
19			`output reg oAI_Start;`
20			`input iAI_Done;`
21			`output [7:0] oCOLOR;`
22			`// Control`
23			`input iCLK,iRST_n;`
24			`output oAI_RSTn;`
25			`//output oAI_RSTn =AI_RSTn; //doesn't work in synplify`
26			`//Debug`
27			`output [16:0] d_cmd ;`
28			`// Internal Register`
29			`reg [63:0] CMD_Tmp;`
30			`reg [71:0] AI_RESULT;`
31			`reg [71:0] AI_RESULT_next;`
32			`reg [2:0] mAI_ST /* synthesis syn_encoding = "safe,onehot" */;`
33			`reg [2:0] mAI_ST_next;`
34
35			`reg [63:0] AI_INPUT;`
36			`reg [63:0] AI_INPUT_next;`
37			`reg [16:0] AI_INPUT_MOVE;`
38			`reg [16:0] AI_INPUT_MOVE_next;`
39			`// USB JTAG TXD Output`
40			`reg oSR_TXD_Start;`
41			`reg [7:0] oSR_TXD_DATA;`
42
43			`//`
44			`reg AI_RSTn;`
45			`assign oAI_RSTn =AI_RSTn; // this one works in synplify. see line 24`
46			`reg [16:0] move_count_me,move_count_you; //maximum no. of moves= 361`
47			`reg [16:0] move_count_me_next; //maximum no. of moves= 361`
48			`wire [16:0] move_count=(move_count_me+move_count_you) >> 2;`
49
50			`reg [7:0] CMD;`
51
52			`reg TXD_Start;`
53			`reg TXD_Start_next;`
54			`reg rst_count;`
55			`assign oTXD_Start =TXD_Start;`
56			`assign d_cmd=AI_INPUT_MOVE;`
57			`assign oCOLOR = CMD;`
58
59			`/////////////////////////////////////////////////////////`
60			`/////// Shift Register For Command Temp /////////////`
61			`always@(posedge iCLK or negedge iRST_n)`
62			`begin`
63			`if(!iRST_n)`
64			`begin`
65			`CMD_Tmp<=0;`
66			`CMD<=0;`
67			`move_count_you<=0;`
68			`AI_RSTn<=1'b0;`
69			`end`
70			`else`
71			`begin`
72			`CMD_Tmp<=CMD_Tmp;`
73			`CMD<=CMD;`
74			`move_count_you<=move_count_you;`
75			`AI_RSTn<=AI_RSTn;`
76			`if(iRXD_Ready)`
77			`begin`
78			`CMD_Tmp<={CMD_Tmp[55:0],iRXD_DATA};`
79
80
81			`if(iRXD_DATA !=8'h44 && iRXD_DATA!=8'h4C)`
82			`begin`
83
84			`move_count_you<=move_count_you+1;//4 ascii chars == 1 move`
85			`AI_RSTn<=1'b1;`
86			`end`
87			`else`
88			`begin`
89
90			`CMD<=iRXD_DATA;`
91			`move_count_you<=0;`
92			`AI_RSTn<=1'b0;`
93
94			`end`
95			`end`
96			`else`
97
98			`AI_RSTn<=1'b1;`
99			`end`
100			`end`
101			`/////////////////////////////////////////////////////////`
102			`/////////////////////////////////////////////////////////`
103			`//////////////// AI Control /////////////////////`
104			`reg [3:0] wait_count;`
105			`reg [3:0] wait_count_next;`
106			`reg [3:0] NO_OF_MOVES;`
107			`reg [3:0] NO_OF_MOVES_next;`
108			`parameter state0=3'b000,state1=3'b001,state2=3'b010,state3=3'b011,state4=3'b100,state5=3'b101,state6=3'b110;`
109
110			`always@(posedge iCLK or negedge AI_RSTn)`
111
112			`begin`
113			`if(!AI_RSTn)`
114			`begin`
115			`mAI_ST<= state0;`
116			`wait_count <=0;`
117			`move_count_me<=0;`
118			`AI_RESULT<=0;`
119			`TXD_Start<=1'b0;`
120			`NO_OF_MOVES<=0;`
121			`AI_INPUT<=0;`
122			`AI_INPUT_MOVE<=0;`
123
124			`end`
125			`else`
126			`begin`
127			`mAI_ST<=mAI_ST_next;`
128			`wait_count <=wait_count_next;`
129			`move_count_me<=move_count_me_next;`
130			`AI_RESULT<=AI_RESULT_next;`
131			`TXD_Start<=TXD_Start_next;`
132			`NO_OF_MOVES<=NO_OF_MOVES_next;`
133			`AI_INPUT<=AI_INPUT_next;`
134			`AI_INPUT_MOVE<=AI_INPUT_MOVE_next;`
135
136			`end`
137			`end`
138
139
140			`always@*//(mAI_ST,move_count,iTXD_Done,TXD_Start,iAI_Done,iAI_DATA)`
141			`begin`
142			`mAI_ST_next<=mAI_ST;`
143			`wait_count_next<=wait_count;`
144			`move_count_me_next<=move_count_me;`
145			`AI_RESULT_next<=AI_RESULT;`
146			`TXD_Start_next<=TXD_Start;`
147			`NO_OF_MOVES_next<=NO_OF_MOVES;`
148			`AI_INPUT_next <=AI_INPUT;`
149			`AI_INPUT_MOVE_next<=AI_INPUT_MOVE;`
150			`case(mAI_ST)`
151
152
153			`state0: begin`
154			`if( (CMD == 8'h44) && (move_count ==0))`
155			`begin`
156			`mAI_ST_next <= state1;`
157			`AI_INPUT_next<=CMD_Tmp;`
158			`AI_INPUT_MOVE_next<=move_count;`
159			`end`
160			`else if ( (CMD == 8'h4C) && (move_count ==1))`
161			`begin`
162			`mAI_ST_next <= state4;`
163			`AI_INPUT_next<=CMD_Tmp;`
164			`AI_INPUT_MOVE_next<=move_count;`
165			`end`
166
167			`else`
168			`mAI_ST_next <= state0;`
169
170
171
172			`end`
173			`state1: begin`
174			`mAI_ST_next <= state2;`
175			`end`
176			`state2: begin`
177			`if(iAI_Done == 1'b1)`
178			`begin`
179			`mAI_ST_next <= state3;`
180			`NO_OF_MOVES_next<=4;`
181			`AI_RESULT_next[63:0]<=iAI_DATA;`
182			`//AI_RESULT_next[63:0]<=CMD_Tmp;loop back`
183
184			`end`
185			`else begin`
186			`mAI_ST_next <= state2;`
187			`end`
188
189
190			`end`
191			`state3: begin`
192
193			`if(iTXD_Done == 1'b1 && TXD_Start ==1'b0)`
194			`begin`
195			`if(wait_count==NO_OF_MOVES) begin`
196			`mAI_ST_next <= state4;`
197			`wait_count_next<=0;`
198			`TXD_Start_next <=1'b0;`
199			`end`
200			`else begin`
201			`mAI_ST_next <= state3;`
202			`TXD_Start_next <=1'b1;`
203			`wait_count_next<=wait_count+1;`
204			`AI_RESULT_next<={AI_RESULT[63:0],8'h0};`
205			`move_count_me_next<=move_count_me+1;`
206			`end`
207			`end`
208			`else begin`
209			`TXD_Start_next <=1'b0;`
210			`end`
211
212			`end`
213			`state4: begin`
214			`//move_count % 4 == 0 means dark's turn, (move_count % 4 == 1 ) means light's turn`
215			`if((((move_count % 4) == 3 ) && (CMD ==8'h44))\|\| (((move_count % 4) == 1 ) && (CMD ==8'h4C)))`
216			`begin`
217			`//if(((move_count ==1\|\| move_count ==5\|\| move_count ==9) && (CMD ==8'h4C)))`
218			`mAI_ST_next <= state5;`
219			`AI_INPUT_next<=CMD_Tmp;`
220			`AI_INPUT_MOVE_next<=move_count;`
221			`end`
222			`else`
223			`mAI_ST_next <= state4;`
224
225			`end`
226			`state5: begin`
227			`mAI_ST_next <= state6;`
228			`AI_INPUT_next<=CMD_Tmp;`
229			`end`
230			`state6: begin`
231			`if(iAI_Done == 1'b1) begin`
232			`mAI_ST_next <= state3;`
233			`AI_RESULT_next[63:0]<=iAI_DATA;`
234			`//AI_RESULT_next[63:0]<=CMD_Tmp; loop back`
235			`NO_OF_MOVES_next<=8 ;`
236			`end`
237
238			`else begin`
239			`mAI_ST_next <= state6;`
240			`AI_RESULT_next<=0;`
241			`NO_OF_MOVES_next<=NO_OF_MOVES;`
242			`end`
243
244			`end`
245			`default:mAI_ST_next <= mAI_ST;`
246			`endcase`
247
248
249			`end`
250
251			`assign oTXD_DATA = AI_RESULT[71:64];`
252
253			`assign oAI_DATA = AI_INPUT;`
254
255			`always@(mAI_ST)`
256			`begin`
257			`case(mAI_ST)`
258
259
260			`state0: begin`
261
262			`oAI_Start <=1'b0;`
263			`//oAI_DATA<=0;`
264
265
266			`end`
267			`state1: begin`
268			`oAI_Start <=1'b1;`
269			`//oAI_DATA<=CMD_Tmp[63:0];`
270
271
272			`//end`
273			`end`
274			`state2: begin`
275
276			`oAI_Start <=1'b0;`
277			`//oAI_DATA<=0;`
278			`//end`
279			`end`
280			`state3: begin`
281			`oAI_Start <=1'b0;`
282			`//oAI_DATA<=0;`
283
284			`//end`
285			`end`
286			`state4: begin`
287			`oAI_Start <=1'b0;`
288			`//oAI_DATA<=CMD_Tmp[63:0];`
289
290
291			`end`
292			`state5: begin`
293			`oAI_Start <=1'b1;`
294			`//oAI_DATA<=CMD_Tmp[63:0];`
295
296
297			`//end`
298			`end`
299			`state6: begin`
300			`oAI_Start <=1'b0;`
301			`//oAI_DATA<=CMD_Tmp[63:0];`
302
303
304			`//end`
305			`end`
306			`default:begin`
307			`oAI_Start <=1'b0;`
308			`//oAI_DATA<=CMD_Tmp[63:0];`
309			`end`
310			`endcase`
311
312
313			`end`
314			`endmodule`