OpenCores
URL https://opencores.org/ocsvn/sudoku/sudoku/trunk

Subversion Repositories sudoku

[/] [sudoku/] [trunk/] [parameterized_rtl/] [sudoku.v] - Blame information for rev 7

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 7 dsheffie 
module sudoku(/*AUTOARG*/
2 
   // Outputs
3 
   outGrid, unsolvedCells, timeOut, allDone, anyChanged, anyError,
4 
   minIdx, minPoss,
5 
   // Inputs
6 
   clk, rst, clr, start, inGrid
7 
   );
8 
   function integer my_clog2;
9 
      input integer value;
10 
      begin
11 
         value = value-1;
12 
         for (my_clog2=0; value>0; my_clog2=my_clog2+1)
13 
           value = value>>1;
14 
      end
15 
   endfunction // for
16 
 
17 
   parameter DIM = 3;
18 
   localparam DIM_S = (DIM*DIM);
19 
   localparam DIM_Q = (DIM_S*DIM_S);
20 
 
21 
   localparam LG_DIM_S = my_clog2(DIM_S);
22 
   localparam LG_DIM_Q = my_clog2(DIM_Q);
23 
 
24 
   localparam PAD_WIDTH = (1<<LG_DIM_Q);
25 
   localparam PAD = PAD_WIDTH - DIM_Q;
26 
 
27 
   input clk;
28 
   input rst;
29 
   input clr;
30 
 
31 
   input start;
32 
 
33 
   input [(DIM_S*DIM_S*DIM_S -1):0] inGrid;
34 
   output [(DIM_S*DIM_S*DIM_S - 1):0] outGrid;
35 
 
36 
   /* TODO: PARAMETERIZE */
37 
   output [(LG_DIM_Q-1):0]                     unsolvedCells;
38 
   output [(LG_DIM_Q-1):0]                     minIdx;
39 
   output [(LG_DIM_S-1):0]                     minPoss;
40 
 
41 
   output         timeOut;
42 
   output         allDone;
43 
   output         anyChanged;
44 
   output         anyError;
45 
 
46 
 
47 
   wire [(DIM_S-1):0] grid2d [(DIM_Q-1):0];
48 
   wire [(DIM_S-1):0] currGrid [(DIM_Q-1):0];
49 
   wire [(DIM_Q-1):0] done;
50 
   wire [(DIM_Q-1):0] changed;
51 
   wire [(DIM_Q-1):0] error;
52 
 
53 
   assign allDone = &done;
54 
   assign anyChanged = |changed;
55 
   //assign anyError = |error;
56 
 
57 
   reg [3:0]       r_cnt;
58 
   assign timeOut = (r_cnt == 4'b1111);
59 
   always@(posedge clk)
60 
     begin
61 
        if(rst)
62 
          begin
63 
             r_cnt <= 4'd0;
64 
          end
65 
        else
66 
          begin
67 
             r_cnt <= start ? 4'd0 : (|changed ? 4'd0 : r_cnt + 4'd1);
68 
          end
69 
     end // always@ (posedge clk)
70 
 
71 
   minPiece #(.DIM(DIM)) mP0
72 
     (
73 
      .minPoss(minPoss),
74 
      .minIdx(minIdx),
75 
      .clk(clk),
76 
      .rst(rst),
77 
      .inGrid(outGrid)
78 
      );
79 
 
80 
 
81 
   genvar         i, j;
82 
   genvar         ii,jj;
83 
 
84 
   generate
85 
      for(i=0;i<DIM_Q;i=i+1)
86 
        begin: unflatten
87 
           assign grid2d[i] = inGrid[(DIM_S*(i+1))-1:(DIM_S*i)];
88 
        end
89 
   endgenerate
90 
 
91 
   wire [(LG_DIM_Q-1):0] w_unSolvedCells;
92 
   reg [(LG_DIM_Q-1):0]  r_unSolvedCells;
93 
   always@(posedge clk)
94 
     begin
95 
        if(rst)
96 
          begin
97 
             r_unSolvedCells <= DIM_Q;
98 
          end
99 
        else
100 
          begin
101 
             r_unSolvedCells <= start ? DIM_Q : w_unSolvedCells;
102 
          end
103 
     end // always@ (posedge clk)
104 
   assign unsolvedCells = r_unSolvedCells;
105 
 
106 
 
107 
   wire [(PAD_WIDTH-1):0]  w_pad_in;
108 
   generate
109 
      begin: padding
110 
         if(PAD > 0)
111 
           begin
112 
              assign w_pad_in = { {PAD{1'b0}}, (~done)};
113 
           end
114 
         else
115 
           begin
116 
              assign w_pad_in = ~done;
117 
           end
118 
      end
119 
  endgenerate
120 
 
121 
   ones_count #(.LG_IN_WIDTH(LG_DIM_Q)) oc1 (.in(w_pad_in), .out(w_unSolvedCells));
122 
 
123 
   wire [(DIM_S*(DIM_S-1)-1):0] w_rows [(DIM_Q-1):0];
124 
   wire [(DIM_S*(DIM_S-1)-1):0] w_cols [(DIM_Q-1):0];
125 
   wire [(DIM_S*(DIM_S-1)-1):0] w_sqrs [(DIM_Q-1):0];
126 
 
127 
   generate
128 
      for(i=0;i<DIM_Q;i=i+1)
129 
        begin: pieces
130 
           piece # (.DIM_S(DIM_S))
131 
           pg (
132 
               // Outputs
133 
               .changed                 (changed[i]),
134 
               .done                    (done[i]),
135 
               .curr_value                      (currGrid[i]),
136 
               .error                     (error[i]),
137 
               // Inputs
138 
               .clk                             (clk),
139 
               .rst                             (rst),
140 
               .clr                               (clr),
141 
               .start                   (start),
142 
               .start_value                     (grid2d[i]),
143 
               .my_row                  (w_rows[i]),
144 
               .my_col                  (w_cols[i]),
145 
               .my_square                       (w_sqrs[i])
146 
               );
147 
        end // block: pieces
148 
    endgenerate
149 
 
150 
 
151 
   generate
152 
      for(i=0;i<DIM_S;i=i+1)
153 
        begin: col_outer
154 
           for(ii=0;ii<DIM_S;ii=ii+1)
155 
             begin: gen_cols
156 
                for(jj=0;jj<DIM_S;jj=jj+1)
157 
                  begin: gen_col_elem
158 
                     if(i > jj)
159 
                       begin
160 
                          assign w_cols[i*DIM_S+ii][(DIM_S*(jj+1)-1):DIM_S*jj] = currGrid[DIM_S*(jj)+ii];
161 
                       end
162 
 
163 
                     else if(jj > i)
164 
                       begin
165 
                          assign w_cols[i*DIM_S+ii][ (DIM_S*(jj)-1):DIM_S*(jj-1)] = currGrid[ DIM_S*(jj) + ii];
166 
                       end
167 
                  end
168 
             end // block: gen_cols
169 
        end // block: col_outer
170 
   endgenerate
171 
 
172 
 
173 
   generate
174 
      for(i=0;i<DIM_S;i=i+1)
175 
        begin: row_outer
176 
           for(ii=0;ii<DIM_S;ii=ii+1)
177 
             begin: rows_cols
178 
                for(jj=0;jj<DIM_S;jj=jj+1)
179 
                  begin: gen_row_elem
180 
                     if(ii > jj)
181 
                       begin
182 
                          assign w_rows[i*DIM_S+ii][(DIM_S*(jj+1)-1):DIM_S*jj] = currGrid[DIM_S*(i)+jj];
183 
                       end
184 
 
185 
                     else if(jj > ii)
186 
                       begin
187 
                          assign w_rows[i*DIM_S+ii][ (DIM_S*(jj)-1):DIM_S*(jj-1)] = currGrid[ DIM_S*(i)+jj];
188 
                       end
189 
                  end
190 
             end
191 
        end
192 
   endgenerate
193 
 
194 
 
195 
   generate
196 
      for(i=0;i<DIM_S;i=i+1)
197 
        begin: outer_y_sqr
198 
           for(j=0;j<DIM_S;j=j+1)
199 
             begin: outer_x_sqr
200 
                for(ii=DIM*(i/DIM); ii < DIM*((i/DIM)+1); ii=ii+1)
201 
                  begin: inner_y_sqr
202 
                     for(jj=DIM*(j/DIM); jj < DIM*((j/DIM)+1); jj=jj+1)
203 
                       begin: inner_x_sqr
204 
                          if((i*DIM_S + j) > (ii*DIM_S + jj))
205 
                            begin
206 
                               assign w_sqrs[i*DIM_S+j][(DIM_S*((ii-(DIM*(i/DIM)))*DIM + (jj-(DIM*(j/DIM)))+1) - 1):(DIM_S*((ii-(DIM*(i/DIM)))*DIM + (jj-(DIM*(j/DIM)))))] = currGrid[DIM_S*(ii)+jj];
207 
                            end
208 
 
209 
                          else if((i*DIM_S + j) < (ii*DIM_S + jj))
210 
                            begin
211 
                               assign w_sqrs[i*DIM_S+j][(DIM_S*((ii-(DIM*(i/DIM)))*DIM + (jj-(DIM*(j/DIM))-1)+1) - 1):(DIM_S*((ii-(DIM*(i/DIM)))*DIM + (jj-(DIM*(j/DIM))-1)))] = currGrid[DIM_S*(ii)+jj];
212 
                            end
213 
                       end
214 
                  end
215 
             end
216 
        end // block: outer_y_sqr
217 
   endgenerate
218 
 
219 
  generate
220 
     for(i=0;i<DIM_Q;i=i+1)
221 
       begin: outGridGen
222 
          assign outGrid[(DIM_S*(i+1)-1):(DIM_S*i)] = currGrid[i];
223 
 
224 
       end
225 
  endgenerate
226 
 
227 
 
228 
   wire [(DIM_Q-1):0] c_rows [(DIM_S-1):0];
229 
   wire [(DIM_Q-1):0] c_cols [(DIM_S-1):0];
230 
   wire [(DIM_Q-1):0] c_grds [(DIM_S-1):0];
231 
 
232 
   wire [(3*DIM_S - 1):0] w_correct;
233 
 
234 
   generate
235 
      for(ii=0;ii<DIM_S;ii=ii+1)
236 
        begin: row_check
237 
           for(jj=0;jj<DIM_S;jj=jj+1)
238 
             begin: row_elem_check
239 
                assign c_rows[jj][(DIM_S*(ii+1)-1):DIM_S*ii] = currGrid[(DIM_S*jj) + ii];
240 
             end
241 
        end
242 
   endgenerate
243 
 
244 
   generate
245 
      for(ii=0;ii<DIM_S;ii=ii+1)
246 
        begin: col_check
247 
           for(jj=0;jj<DIM_S;jj=jj+1)
248 
             begin: col_elem_check
249 
                assign c_cols[jj][(DIM_S*(ii+1)-1):DIM_S*ii] = currGrid[DIM_S*ii + jj];
250 
             end
251 
        end
252 
   endgenerate
253 
 
254 
   genvar iii,jjj;
255 
   generate
256 
      for(ii=0; ii < DIM; ii=ii+1)
257 
        begin: grd_check_y
258 
           for(jj = 0; jj < DIM; jj=jj+1)
259 
             begin: grd_check_x
260 
                for(iii=DIM*ii; iii < DIM*(ii+1); iii=iii+1)
261 
                  begin: gg_y
262 
                     for(jjj=DIM*jj; jjj < DIM*(jj+1); jjj=jjj+1)
263 
                       begin: gg_x
264 
                          assign c_grds[DIM*ii+jj][DIM_S*(DIM*(iii-DIM*ii) + (jjj-DIM*jj)+1)-1:DIM_S*(DIM*(iii-DIM*ii) + (jjj-DIM*jj))] = currGrid[DIM_S*iii + jjj];
265 
                       end
266 
                  end
267 
             end
268 
        end
269 
   endgenerate
270 
 
271 
   generate
272 
      for(ii=0;ii<DIM_S;ii=ii+1)
273 
        begin: checks
274 
           checkCorrect #(.DIM_S(DIM_S)) cC_R
275 
             (.y(w_correct[0*(DIM_S) + ii]), .in(c_rows[ii]));
276 
           checkCorrect #(.DIM_S(DIM_S)) cC_C
277 
             (.y(w_correct[1*(DIM_S) + ii]), .in(c_cols[ii]));
278 
           checkCorrect #(.DIM_S(DIM_S)) cC_G
279 
             (.y(w_correct[2*(DIM_S) + ii]), .in(c_grds[ii]));
280 
        end
281 
   endgenerate
282 
 
283 
 
284 
   assign anyError = ~(&w_correct);
285 
 
286 
endmodule

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.