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

Subversion Repositories connect-6

[/] [connect-6/] [trunk/] [BUILD_SCC/] [DE2/] [CMD_Decode_simple.v] - Blame information for rev 4

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 =AI_RSTn;
//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;
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;
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;
 
 
always@(posedge iCLK or negedge AI_RSTn)
 
begin
        if(!AI_RSTn)
        begin
                mAI_ST<=0;
                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)
 
 
                        0:       begin
                                        if( (CMD        == 8'h44) && (move_count ==0))
                                                begin
                                                mAI_ST_next             <=      1;
                                                AI_INPUT_next<=CMD_Tmp;
                                                AI_INPUT_MOVE_next<=move_count;
                                                end
                                        else if ( (CMD        == 8'h4C) && (move_count ==1))
                                                begin
                                                mAI_ST_next     <=      4;
                                                AI_INPUT_next<=CMD_Tmp;
                                                AI_INPUT_MOVE_next<=move_count;
                                                end
 
                                        else
                                                mAI_ST_next     <=      0;
 
 
 
                                end
                        1:      begin
                                        mAI_ST_next     <=      2;
                                end
                        2:      begin
                                        if(iAI_Done == 1'b1)
                                        begin
                                                mAI_ST_next     <=      3;
                                                NO_OF_MOVES_next<=4;
                                                AI_RESULT_next[63:0]<=iAI_DATA;
 
                                        end
                                        else begin
                                                mAI_ST_next     <=      2;
                                        end
 
 
                                end
                        3:      begin
 
                                        if(iTXD_Done == 1'b1 && TXD_Start ==1'b0)
                                        begin
                                                if(wait_count==NO_OF_MOVES) begin
                                                mAI_ST_next     <=      4;
                                                wait_count_next<=0;
                                                TXD_Start_next  <=1'b0;
                                                end
                                                else begin
                                                mAI_ST_next     <=      3;
                                                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
                                                TXD_Start_next  <=1'b0;
 
                                end
                        4:      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     <=      5;
                                                AI_INPUT_next<=CMD_Tmp;
                                                AI_INPUT_MOVE_next<=move_count;
                                                end
                                        else
                                                mAI_ST_next     <=      4;
 
                                end
                        5:      begin
                                        mAI_ST_next     <=      6;
                                        AI_INPUT_next<=CMD_Tmp;
                                end
                        6:      begin
                                        if(iAI_Done == 1'b1) begin
                                                mAI_ST_next     <=      3;
                                                AI_RESULT_next[63:0]<=iAI_DATA;
                                                NO_OF_MOVES_next<=8 ;
                                                end
 
                                        else begin
                                                mAI_ST_next     <=      6;
                                                AI_RESULT_next<=0;
                                                NO_OF_MOVES_next<=NO_OF_MOVES;
                                        end
 
                                end
                        default:mAI_ST_next <= mAI_ST_next;
                        endcase
 
 
end
 
assign oTXD_DATA = AI_RESULT[71:64];
assign oAI_DATA = AI_INPUT;
 
always@(mAI_ST)
begin
                        case(mAI_ST)
 
 
                        0:       begin
 
                                        oAI_Start       <=1'b0;
                                        //oAI_DATA<=0;
 
 
                                end
                        1:      begin
                                        oAI_Start       <=1'b1;
                                        //oAI_DATA<=CMD_Tmp[63:0];
 
 
                                //end
                                end
                        2:      begin
 
                                        oAI_Start       <=1'b0;
                                        //oAI_DATA<=0;
                                //end 
                                end
                        3:      begin
                                        oAI_Start       <=1'b0;
                                        //oAI_DATA<=0;
 
                                //end
                                end
                        4:      begin
                                        oAI_Start       <=1'b0;
                                        //oAI_DATA<=CMD_Tmp[63:0];
 
 
                                end
                        5:      begin
                                        oAI_Start       <=1'b1;
                                        //oAI_DATA<=CMD_Tmp[63:0];
 
 
                                //end
                                end
                        6:      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/] [BUILD_SCC/] [DE2/] [CMD_Decode_simple.v] - Blame information for rev 4

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