URL https://opencores.org/ocsvn/2d_game_console/2d_game_console/trunk

Subversion Repositories 2d_game_console

[/] [2d_game_console/] [trunk/] [Processor_ModelSim/] [Sprite_Shape_Reader.v] - Blame information for rev 2

Details | Compare with Previous | View Log


module Sprite_Shape_Reader(
        clock,
        reset,
        mem_grant,
        sprite_id,
        sprite_y,
        mem_q,
        V_pos,
        H_pos,
 
        mem_addr,
        mem_wren,
        mem_req,
        sprite_shape,
        level_counter,
        level_sprite_id,
        level_sprite_y,
        line_A_shape,
        line_B_shape,
        line_flag,
        EstadoAtual,
        EstadoFuturo,
        cpu_sleep
);
 
 
        input clock;
        input reset;
 
        input mem_grant;
 
        input   [9:0]            H_pos;
        input   [9:0]            V_pos;
        input   [15:0]   mem_q;
 
        input   [383:0]  sprite_id;
        input   [639:0]  sprite_y;
 
        output reg      cpu_sleep;
        output reg      mem_req;
        output reg      mem_wren;
        output reg      [6:0]            level_counter;
        output reg      [5:0]            level_sprite_id;
        output reg      [9:0]            level_sprite_y;
        output reg      [15:0]   mem_addr;
 
        output reg      [1023:0] line_A_shape;
        output reg      [1023:0] line_B_shape;
        output reg                              line_flag;
 
 
        output  [1023:0] sprite_shape;
 
        parameter       line_A  = 1'b0;
        parameter       line_B  = 1'b1;
 
        assign sprite_shape = (line_flag == line_A)? line_B_shape : line_A_shape;
 
 
        /*################################################################*/
        /*############  MAQUINA DE ESTADO                                                       ############*/
        /*############                                                                                                          ############*/
        /*############  LEITURA DOS SHAPES                                                      ############*/
        /*############  SALVOS NA DATA_SEGMENT_RAM                              ############*/
        /*################################################################*/
 
        output reg      [4:0]            EstadoAtual;
        output reg      [4:0]            EstadoFuturo;
 
        // Estados
        parameter       Reset                                           = 5'b00000;     // Reset                                                = 0
        parameter       Wait_Line                               = 5'b00001;     // Wait_Line                            = 1
        parameter       Change_Line                             = 5'b00010;     // Change_Line                          = 2
        parameter       Get_Level_Info                  = 5'b00011;     // Get_Level_Info                       = 3
        parameter       Set_Shape_Address               = 5'b00100;     // Set_Shape_Address            = 4
        parameter       Wait_Mem_1                              = 5'b00101;     // Wait_Mem_1                           = 5
        parameter       Wait_Mem_2                              = 5'b00110;     // Wait_Mem_2                           = 6
        parameter       Read_Shape                              = 5'b00111;     // Read_Shape                           = 7
        parameter       Change_Level                    = 5'b01000;     // Change_Level                 = 8
 
 
        // Decodificador de proximo estado
        always @ (*)
        begin
                case (EstadoAtual)
 
                        // Estado 0
                        Reset:
                        begin
                                if (V_pos == 31 && H_pos == 0)
                                        EstadoFuturo = Wait_Line;
                                else
                                        EstadoFuturo = Reset;
                        end
 
                        // Estado 1
                        Wait_Line:
                        begin
                                if (V_pos >= 32 && V_pos <= 511 && H_pos == 0)
                                        EstadoFuturo = Change_Line;
                                else
                                        EstadoFuturo = Wait_Line;
                        end
 
                        // Estado 2
                        Change_Line:
                        begin
                                EstadoFuturo = Get_Level_Info;
                        end
 
                        // Estado 3
                        Get_Level_Info:
                        begin
                                if ( (V_pos >= level_sprite_y-1) && (V_pos <= level_sprite_y+14) )
                                        EstadoFuturo = Set_Shape_Address;
                                else
                                        EstadoFuturo = Change_Level;
                        end
 
                        // Estado 4
                        Set_Shape_Address:
                        begin
                                if (mem_grant)
                                        EstadoFuturo = Wait_Mem_1;
                                else
                                        EstadoFuturo = Set_Shape_Address;
                        end
 
                        // Estado 5
                        Wait_Mem_1:
                        begin
                                EstadoFuturo = Wait_Mem_2;
                        end
 
                        // Estado 6
                        Wait_Mem_2:
                        begin
                                EstadoFuturo = Read_Shape;
                        end
 
                        // Estado 7
                        Read_Shape:
                        begin
                                EstadoFuturo = Change_Level;
                        end
 
                        // Estado 8
                        Change_Level:
                        begin
                                if ( (level_counter <= 63) && (V_pos <= 511) )
                                        EstadoFuturo = Get_Level_Info;
                                else if ( (level_counter > 63) && (V_pos >= 511) )
                                        EstadoFuturo = Reset;
                                else
                                        EstadoFuturo = Wait_Line;
                        end
 
                        default:
                        begin
                                EstadoFuturo = Reset;
                        end
 
                endcase
 
        end
 
 
        // Decodificador de saida
        always @ (*)
        begin
 
                // Default Assignments
                cpu_sleep = 1;
                mem_req = 0;
                mem_wren = 0;
 
 
                case (EstadoAtual)
 
                        // Estado 0
                        Reset:
                        begin
                                cpu_sleep = 0;
                        end
 
                        // Estado 1
                        Wait_Line:
                        begin
 
                        end
 
                        // Estado 2
                        Change_Line:
                        begin
 
                        end
 
                        // Estado 3
                        Get_Level_Info:
                        begin
 
                        end
 
                        // Estado 4
                        Set_Shape_Address:
                        begin
                                mem_req = 1;
                        end
 
                        // Estado 5
                        Wait_Mem_1:
                        begin
                                mem_req = 1;
                        end
 
                        // Estado 6
                        Wait_Mem_2:
                        begin
                                mem_req = 1;
                        end
 
                        // Estado 7
                        Read_Shape:
                        begin
                                mem_req = 1;
                        end
 
                        // Estado 8
                        Change_Level:
                        begin
 
                        end
 
                        default:
                        begin
 
                        end
 
                endcase
        end
 
 
        // Atualizacao de registrador de estado e logica de reset
        always @ (posedge clock)
        begin
 
                if (reset)
                begin
                        EstadoAtual     <= Reset;
                end
 
                else
                begin
                        EstadoAtual     <=      EstadoFuturo;
 
 
                        // Estado 0 = Reset
                        if (EstadoFuturo == Reset)
                        begin
                                level_counter <= 7'b0000000;
                                line_flag <= line_B;
                        end
 
 
                        // Estado 1 = Wait_Line
                        if (EstadoFuturo == Wait_Line)
                        begin
                                level_counter <= 7'b0000000;
                        end
 
 
                        // Estado 2 = Change_Line
                        if (EstadoFuturo == Change_Line)
                        begin
                                if (line_flag == line_A)
                                        line_flag <= line_B;
                                else
                                        line_flag <= line_A;
                        end
 
 
                        // Estado 3 = Get_Level_Info
                        if (EstadoFuturo == Get_Level_Info)
                        begin
                                level_sprite_id <= sprite_id[level_counter*6 +: 6];
                                level_sprite_y <= sprite_y[level_counter*10 +: 10];
                        end
 
 
                        // Estado 4 = Set_Shape_Address
                        if (EstadoFuturo == Set_Shape_Address)
                        begin
                                mem_addr <= (level_sprite_id*5'h10) + (V_pos - level_sprite_y + 1'b1);
                        end
 
 
                        // Estado 7 = Read_Shape
                        if (EstadoFuturo == Read_Shape)
                        begin
                                if(line_flag == line_A)
                                        line_A_shape[level_counter*16 +: 16] <= mem_q[15:0];
                                else
                                        line_B_shape[level_counter*16 +: 16] <= mem_q[15:0];
                        end
 
 
                        // Estado 8 = Change_Level
                        if (EstadoFuturo == Change_Level)
                        begin
                                level_counter <= level_counter + 1'b1;
                        end
 
 
                end
 
        end
 
        /*################################################################*/
        /*################################################################*/
 
 
 
endmodule

Browse

Tools

Subversion Repositories 2d_game_console

[/] [2d_game_console/] [trunk/] [Processor_ModelSim/] [Sprite_Shape_Reader.v] - Blame information for rev 2

Line No.	Rev	Author	Line
1	2	lucas.vbal	`module Sprite_Shape_Reader(`
2			`clock,`
3			`reset,`
4			`mem_grant,`
5			`sprite_id,`
6			`sprite_y,`
7			`mem_q,`
8			`V_pos,`
9			`H_pos,`
10
11			`mem_addr,`
12			`mem_wren,`
13			`mem_req,`
14			`sprite_shape,`
15			`level_counter,`
16			`level_sprite_id,`
17			`level_sprite_y,`
18			`line_A_shape,`
19			`line_B_shape,`
20			`line_flag,`
21			`EstadoAtual,`
22			`EstadoFuturo,`
23			`cpu_sleep`
24			`);`
25
26
27			`input clock;`
28			`input reset;`
29
30			`input mem_grant;`
31
32			`input [9:0] H_pos;`
33			`input [9:0] V_pos;`
34			`input [15:0] mem_q;`
35
36			`input [383:0] sprite_id;`
37			`input [639:0] sprite_y;`
38
39			`output reg cpu_sleep;`
40			`output reg mem_req;`
41			`output reg mem_wren;`
42			`output reg [6:0] level_counter;`
43			`output reg [5:0] level_sprite_id;`
44			`output reg [9:0] level_sprite_y;`
45			`output reg [15:0] mem_addr;`
46
47			`output reg [1023:0] line_A_shape;`
48			`output reg [1023:0] line_B_shape;`
49			`output reg line_flag;`
50
51
52			`output [1023:0] sprite_shape;`
53
54			`parameter line_A = 1'b0;`
55			`parameter line_B = 1'b1;`
56
57			`assign sprite_shape = (line_flag == line_A)? line_B_shape : line_A_shape;`
58
59
60			`/################################################################/`
61			`/############ MAQUINA DE ESTADO ############/`
62			`/############ ############/`
63			`/############ LEITURA DOS SHAPES ############/`
64			`/############ SALVOS NA DATA_SEGMENT_RAM ############/`
65			`/################################################################/`
66
67			`output reg [4:0] EstadoAtual;`
68			`output reg [4:0] EstadoFuturo;`
69
70			`// Estados`
71			`parameter Reset = 5'b00000; // Reset = 0`
72			`parameter Wait_Line = 5'b00001; // Wait_Line = 1`
73			`parameter Change_Line = 5'b00010; // Change_Line = 2`
74			`parameter Get_Level_Info = 5'b00011; // Get_Level_Info = 3`
75			`parameter Set_Shape_Address = 5'b00100; // Set_Shape_Address = 4`
76			`parameter Wait_Mem_1 = 5'b00101; // Wait_Mem_1 = 5`
77			`parameter Wait_Mem_2 = 5'b00110; // Wait_Mem_2 = 6`
78			`parameter Read_Shape = 5'b00111; // Read_Shape = 7`
79			`parameter Change_Level = 5'b01000; // Change_Level = 8`
80
81
82			`// Decodificador de proximo estado`
83			`always @ (*)`
84			`begin`
85			`case (EstadoAtual)`
86
87			`// Estado 0`
88			`Reset:`
89			`begin`
90			`if (V_pos == 31 && H_pos == 0)`
91			`EstadoFuturo = Wait_Line;`
92			`else`
93			`EstadoFuturo = Reset;`
94			`end`
95
96			`// Estado 1`
97			`Wait_Line:`
98			`begin`
99			`if (V_pos >= 32 && V_pos <= 511 && H_pos == 0)`
100			`EstadoFuturo = Change_Line;`
101			`else`
102			`EstadoFuturo = Wait_Line;`
103			`end`
104
105			`// Estado 2`
106			`Change_Line:`
107			`begin`
108			`EstadoFuturo = Get_Level_Info;`
109			`end`
110
111			`// Estado 3`
112			`Get_Level_Info:`
113			`begin`
114			`if ( (V_pos >= level_sprite_y-1) && (V_pos <= level_sprite_y+14) )`
115			`EstadoFuturo = Set_Shape_Address;`
116			`else`
117			`EstadoFuturo = Change_Level;`
118			`end`
119
120			`// Estado 4`
121			`Set_Shape_Address:`
122			`begin`
123			`if (mem_grant)`
124			`EstadoFuturo = Wait_Mem_1;`
125			`else`
126			`EstadoFuturo = Set_Shape_Address;`
127			`end`
128
129			`// Estado 5`
130			`Wait_Mem_1:`
131			`begin`
132			`EstadoFuturo = Wait_Mem_2;`
133			`end`
134
135			`// Estado 6`
136			`Wait_Mem_2:`
137			`begin`
138			`EstadoFuturo = Read_Shape;`
139			`end`
140
141			`// Estado 7`
142			`Read_Shape:`
143			`begin`
144			`EstadoFuturo = Change_Level;`
145			`end`
146
147			`// Estado 8`
148			`Change_Level:`
149			`begin`
150			`if ( (level_counter <= 63) && (V_pos <= 511) )`
151			`EstadoFuturo = Get_Level_Info;`
152			`else if ( (level_counter > 63) && (V_pos >= 511) )`
153			`EstadoFuturo = Reset;`
154			`else`
155			`EstadoFuturo = Wait_Line;`
156			`end`
157
158			`default:`
159			`begin`
160			`EstadoFuturo = Reset;`
161			`end`
162
163			`endcase`
164
165			`end`
166
167
168			`// Decodificador de saida`
169			`always @ (*)`
170			`begin`
171
172			`// Default Assignments`
173			`cpu_sleep = 1;`
174			`mem_req = 0;`
175			`mem_wren = 0;`
176
177
178			`case (EstadoAtual)`
179
180			`// Estado 0`
181			`Reset:`
182			`begin`
183			`cpu_sleep = 0;`
184			`end`
185
186			`// Estado 1`
187			`Wait_Line:`
188			`begin`
189
190			`end`
191
192			`// Estado 2`
193			`Change_Line:`
194			`begin`
195
196			`end`
197
198			`// Estado 3`
199			`Get_Level_Info:`
200			`begin`
201
202			`end`
203
204			`// Estado 4`
205			`Set_Shape_Address:`
206			`begin`
207			`mem_req = 1;`
208			`end`
209
210			`// Estado 5`
211			`Wait_Mem_1:`
212			`begin`
213			`mem_req = 1;`
214			`end`
215
216			`// Estado 6`
217			`Wait_Mem_2:`
218			`begin`
219			`mem_req = 1;`
220			`end`
221
222			`// Estado 7`
223			`Read_Shape:`
224			`begin`
225			`mem_req = 1;`
226			`end`
227
228			`// Estado 8`
229			`Change_Level:`
230			`begin`
231
232			`end`
233
234			`default:`
235			`begin`
236
237			`end`
238
239			`endcase`
240			`end`
241
242
243			`// Atualizacao de registrador de estado e logica de reset`
244			`always @ (posedge clock)`
245			`begin`
246
247			`if (reset)`
248			`begin`
249			`EstadoAtual <= Reset;`
250			`end`
251
252			`else`
253			`begin`
254			`EstadoAtual <= EstadoFuturo;`
255
256
257			`// Estado 0 = Reset`
258			`if (EstadoFuturo == Reset)`
259			`begin`
260			`level_counter <= 7'b0000000;`
261			`line_flag <= line_B;`
262			`end`
263
264
265			`// Estado 1 = Wait_Line`
266			`if (EstadoFuturo == Wait_Line)`
267			`begin`
268			`level_counter <= 7'b0000000;`
269			`end`
270
271
272			`// Estado 2 = Change_Line`
273			`if (EstadoFuturo == Change_Line)`
274			`begin`
275			`if (line_flag == line_A)`
276			`line_flag <= line_B;`
277			`else`
278			`line_flag <= line_A;`
279			`end`
280
281
282			`// Estado 3 = Get_Level_Info`
283			`if (EstadoFuturo == Get_Level_Info)`
284			`begin`
285			`level_sprite_id <= sprite_id[level_counter*6 +: 6];`
286			`level_sprite_y <= sprite_y[level_counter*10 +: 10];`
287			`end`
288
289
290			`// Estado 4 = Set_Shape_Address`
291			`if (EstadoFuturo == Set_Shape_Address)`
292			`begin`
293			`mem_addr <= (level_sprite_id*5'h10) + (V_pos - level_sprite_y + 1'b1);`
294			`end`
295
296
297			`// Estado 7 = Read_Shape`
298			`if (EstadoFuturo == Read_Shape)`
299			`begin`
300			`if(line_flag == line_A)`
301			`line_A_shape[level_counter*16 +: 16] <= mem_q[15:0];`
302			`else`
303			`line_B_shape[level_counter*16 +: 16] <= mem_q[15:0];`
304			`end`
305
306
307			`// Estado 8 = Change_Level`
308			`if (EstadoFuturo == Change_Level)`
309			`begin`
310			`level_counter <= level_counter + 1'b1;`
311			`end`
312
313
314			`end`
315
316			`end`
317
318			`/################################################################/`
319			`/################################################################/`
320
321
322
323			`endmodule`