Adaptation SystemC en VHDL

Recherche :

Mot : Pseudo : Filtrer
Bas de page
Auteur	Sujet : Adaptation SystemC en VHDL

Gefroren

Bonjour,

Dans le cadre d'un projet, je dois adapter un code en SystemC donné en VHDL. Ce code permet de résoudre un Sudoku. Le code fait appel à de la récursion qui n'est pas synthétisable du coup faut transformer en faisant des boucles le code de façon à enlever toutes traces de récursivité. Le problème c'est que j'y arrive pas :cry:
J'ai essayé plein de trucs mais à chaque fois j'ai des résultats étranges (genre la grille est remplie qu'avec des 5 des 6 et des 8...). Voilà la fonction :

Code :

/// solves the puzzle with bruteforce. called recursively
void solve_bruteforce(size_t r, size_t c)
{
//puzzle already solved
if( this->done )
return;
// matrix completely filled. The puzzle is solved
if( r==this->n )
{
this->done=true;
return;
}
debug_out(r,c);
//Move to the next row
if( c==this->n )
{
this->solve_bruteforce(r+1,0);
}
else if( this->array[r][c]==0 )
{ //Empty position
size_t i;
for(i=1; i<=this->n; ++i)
{
//We have already used this number in this row/column/square
if( is_set( row_mask[r], i) ||
is_set( col_mask[c], i) ||
is_set( sqr_mask[c/this->b + this->b*(r/this->b)], i) )
continue;
do_set(row_mask[r], i);
do_set(col_mask[c], i);
do_set(sqr_mask[c/this->b + this->b*(r/this->b)], i);
this->array[r][c]=i;
this->solve_bruteforce(r,c+1);
if( this->done )
return;
this->array[r][c]=0;
do_unset(row_mask[r], i);
do_unset(col_mask[c], i);
do_unset(sqr_mask[c/this->b + this->b*(r/this->b)], i);
}
}
else
{ //Position already filled
this->solve_bruteforce(r,c+1);
}
}

Les fonctions is_set, do_set et do_unset sont des fonctions qui permettent respectivement de savoir si un bit est à 1, de le mettre à 1 et de le mettre à 0. b est la longueur d'un petit carré.
Ca serait cool de me dire comment je dois faire ou du moins comment je dois m'y prendre...

Merci d'avance.

Publicité

h3bus

Troll Inside

Quelle expérience as-tu avec VHDL?

La description fonctionnelle est très mal adaptée à une implémentation hadware.

Dans ce cas je génèrerai deux blocs séquencés, un générant une solution, l'autre vérifiant la solution. Ces blocs accédant à une SRAM (un tableau sera très certainement implémenté en SRAM si chaque accès est correctement séquencé)

En tous les cas ce n'est pas évident à faire...

Message édité par h3bus le 08-03-2012 à 13:41:02

---------------
sheep++

Gefroren

Salut, merci pour la réponse rapide.
En fait là est le problème, j'ai été parachuté dans une FAC allemande où les mecs font du VHDL depuis 5 ans ou plus alors que moi que depuis l'an passé... (différence de système de formation des ingénieurs...). Du coup je me retrouve avec ce projet à faire et je suis paumé.
Le truc le plus dur que j'ai réussi à faire en VHDL c'est une FIFO.

h3bus

Troll Inside

Pour l'instant le problème n'est pas le VHDL mais la représentation hardware du circuit et les machines d'état à réaliser.

Je te conseille de décomposer ton algorithme en machines d'état, puis de coucher sur une feuilles des modules simples hardware qui s'interfacent avec tes machines d'état.

C'est une gymnastique complètement différente de la programmation itérative.

Essaie d'oublier le concept de variable pour voir ça comme des registres, les boucles doivent être implémentées avec des machine d'état et des compteurs.
Pour le tableau représentant le sodoku, tu peux voir ça comme une zone mémoire qui n'a qu'une interface d'écriture et une de lecture.

ça ne t'aide pas beaucoup, je sais, essaie de ne traiter qu'une partie du problème pour commencer.

Je vais essayer d'y réfléchir de mon côté mais je ne te donnerai pas la solution, d'abord parce que je ne connais pas la technique et peut me planter, et aussi par ce que c'est contraire aux règle du forum.

Bon courage, n'hésite pas à poster ton avancement même si tu penses que c'est naze, on pourra te réorienter si tu ne sembles pas être dans la bonne voie!

Message édité par h3bus le 09-03-2012 à 12:54:19

---------------
sheep++

Gefroren

Ok, merci

Il faut quand même qui je signale que le bout de code que j'ai présenté n'est qu'un petit morceau de ce qu'on nous a donné. Cette fonction est également accompagné d'une machine d'états.

En gros voilà comment ça fonctionne. La machine est composée de 4 états : WAITING, READING, WORKING et WRITING.
Dans le WAITING sont faîtes toutes les inits, si l'ordre donné n'est pas trop grand ou pas trop petit on passe au READING.
Au READING, si les données d'entrées sont trop grandes on les met à 0, si tous les "is_set" sont à 1 dans ce cas là on retourne au WAITING sinon on remplit la grille (avec les do_set). Tout cela ce fait avec des compteurs sur les lignes et les colonnes. Si le compteurs des lignes est à n (nombre total de ligne) on passe au WORKING.
Le WORKING lance l'algorithme que je dois adapter, tout simplement. Et on passe automatiquement au WRITING.
Au WRITING on écrit le tout en mémoire.

La plateforme de test étant déjà disponible pour le code en SystemC, je bosse directement sur le code source en essayant de remplacer les appels récursifs par des boucles. A chaque que je teste, ça marche pas du tout : Soit la grille bouge pas, soit c'est la grille de base sans les 9, soit y'a que des 5 des 8 et des 9... Bref un chouïa énervant.

h3bus

Troll Inside

Vu l'algo tu ne pourras surement pas te passer des appels récursifs.
Bien sûr il ne faut pas les utiliser tel quels, mais les implémenter avec une pile (une LIFO, t'as fait une FIFO c'est presque le même chose).

La machine d'état principale que tu décrit ne pose pas de soucis, tu dois juste l'interfacer avec la machine d'état de résolution.

---------------
sheep++

Gefroren

Suite à ce que tu m'as dit, j'ai fait une machine d'états de l'algo, dis-moi ce que t'en penses :

L'état IDLE, rien à dire^^
EMPTY_CASE c'est la où on cherche les cases vides, typiquement la condition if(array[r][c] == 0), si oui état suivant, si non soit c'est que tout est fini soit on incrémente les colonnes (je sais pas encore exactement comment je vais faire pour ça)
FILL on remplit la case (do_set...),
TEST on regarde si y'a un conflit, si oui on remet le 0 (do_unset) et on revient. Et dès qu'il n'y a plus conflit ni 0, valid passe à 1 et on ajoute un étage à la pile.
SOLVE c'est juste un état ou un flag passe à 1 pour dire que c'est résolu.
Je vois bien qu'il faut utiliser la LIFO mais je sais pas concrètement comment : Tu vois en C, c'est facile mais là je vois pas trop comment on fait pour en utiliser à l'intérieur d'une machine d'états.

h3bus

Troll Inside

Les choses commencent à se poser.

Une petite remarque avant de passer à la LIFO, l'état TEST est complexe, il nécessite à lui seul un parcours du tableau pour vérifier la validité des valeurs en place. Cela dit je te conseille de mettre ça de côté, je vois plusieurs implémentation pour cette fonction, plus ou moins compliquées et rapides.

Concernant la LIFO, je perçois son utilisation ainsi:
- Dans l'état FILL on met dans la LIFO la case qu'on a remplie (r et c) et la valeur de la case
- Dans l'état TEST, si on détecte que le tableau est faux, on dépile la dernière valeurs mise dans la LIFO et:
. Si la valeur est 9 (en gros on a tout essayé de 0 à 9) on fait un unset puis on dépile la valeur suivante et ainsi de suite jusqu'à avoir trouvé une case < 9. ensuite on passe à FILL qui va y incrémenter la case
. Si la valeur est < 9 on passe à FILL qui va y incrémenter la case

Par ce procédé on implémente mode de fonctionnement récursif, avec des machines d'état et une lifo

Du coup il faudrait un autre état après test, disons UNSET pour réaliser cet algorithme.

Un petit détail, 0 ne représente pas une case vide (car 0 est une valeur possible d'une case). Il faut donc une valeur qui représente une case vide, 10 par exemple...

Voilà, je reviens de soirée un petit peu arrosée, excuse l'éventuel manque de clarté de mes propos

Message édité par h3bus le 23-03-2012 à 01:21:06

---------------
sheep++

Gefroren

Bon, en fait 0 représente bel et bien une case vide puisque sinon on aurait 10 valeurs différentes (de 0 à 9) à remplir dans 9 cases (ça devait être du fait de l' "arrosage" )

Je me suis donc lancé dans un premier essai de description VHDL, ça doit être horrible syntaxiquement mais bon... Je vais mettre aussi le code de la pile, on sait jamais.

Code :

library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.numeric_std.all;
 
 
entity brute_force is
    port (
    a_reset_l       : in  std_logic;
    clk             : in  std_logic;
    start_h         : in  std_logic;
    order           : in  std_logic_vector( 3 downto 0);
    data_o          : out std_logic_vector( 7 downto 0);
    );
end entity brute_force;
 
architecture rtl_vhdl of brute_force is
 
--Functions The sames functions which are made in the systemc file(Masking)
 
function is_set(mask:integer; pos:integer) return std_logic_vector is--With this function I can know if a bit is '1'
    variable mk:std_logic_vector((TO_INTEGER(UNSIGNED(order))-1) downto 0);
    variable temp1: std_logic_vector ((TO_INTEGER(UNSIGNED(order))-1) downto 0);
    variable temp2: UNSIGNED ((TO_INTEGER(UNSIGNED(order))-1) downto 0);
   begin   
   
    temp1:=std_logic_vector(TO_UNSIGNED(mask,(TO_INTEGER(UNSIGNED(order)))));--I convert a integer '1' into a vector of 49 bits
    temp2:=(TO_UNSIGNED(1,(TO_INTEGER(UNSIGNED(order)))));--convert the value of mask into a vector of 49 bits
   
    mk:= temp1 and std_logic_vector(temp2 rol pos);
    return mk;
end is_set;
 
 
function do_set(mask: integer; pos: integer) return integer is--With this procedure I can set a bit in the position indicated by pos.
    variable temp1: UNSIGNED ((TO_INTEGER(UNSIGNED(order))-1) downto 0);
    variable mask1:integer;
    begin
        temp1:=(TO_UNSIGNED(mask,(TO_INTEGER(UNSIGNED(order)))));
        mask1:=TO_INTEGER((temp1 or (temp1 rol pos)));
    return mask1;
end do_set;
 
function do_unset(mask: integer ;  pos: integer ) return integer is
    variable temp2: UNSIGNED ((TO_INTEGER(UNSIGNED(order))-1) downto 0);
    variable mask2:integer;
begin
    temp2:=(TO_UNSIGNED(mask,(TO_INTEGER(UNSIGNED(order)))));--With this function I clear set a bit in the position indicated by pos.
    mask2:=TO_INTEGER((temp2 and (not(temp2 rol pos))));
    return mask2;
end do_unset;
 
component LIFO
            
         data_i   : in  std_logic_vector(7 downto 0);
         data_o  : out std_logic_vector(7 downto 0); 
         Rd,Wr     : in  std_logic;             
         Empty,Full: out std_logic;     
         Clk       : in  std_logic
         size           : in integer);
end component;
 
type mask is array (integer range<> ) of integer;
signal row_mask : mask(0 to (TO_INTEGER(UNSIGNED(order))-1));
signal col_mask : mask(0 to (TO_INTEGER(UNSIGNED(order))-1));
signal sqr_mask : mask(0 to (TO_INTEGER(UNSIGNED(order))-1));
 
 
type State is (IDLE, EMPTY_CASE, FILL, TEST,UNSET, SOLVE)
 
signal b : integer;--number of blocks
signal row :integer;
signal col : integer;
signal n : integer;--
signal zero : std_logic_vector(48 downto 0) := (others=>'0');
signal sqr_index : integer;
type sudoku is array (integer range<> ) of integer;
signal matrix_sudoku : sudoku(0 to 2400);
 
signal State: State;
signal State: NextState;
signal valid:std_logic;
signal found:std_logic;
signal conflict:std_logic;
signal allFilled:std_logic;
signal start:std_logic;
signal LIFO_out:std_logic_vector(7 downto 0);
signal i:integer := '0'; 
signal LIFO_FULL:std_logic;
signal LIFO_EMPTY:std_logic;
 
begin
    process(clk, a_reset_l)
    begin
        if (a_reset_l = '0') then
            state <= waiting;
        elsif (clk'event and clk='1') then
            state <= next_state;
        end if;
    end process;
   
    process(State, NextState, start, found, col, row, valid, conflict, LIFO_out, allFiled)
   
    b <= TO_INTEGER(UNSIGNED(order));
    n <= b*b;
    col <= '0';
    row <= '0';
    begin
        case state is
            when IDLE =>
                if(start/= '0') then NextState <= EMPTY_CASE;
                else NextState <= IDLE;
                end if;
           
           when EMPTY_CASE =>
                
                if(matrix_sudoku(row*b + col) = 0) then
                    found <= '1';
                else col <= col + '1';
                end if;
                
                if(found = '1') then NextState <= FILL;
                elsif(col = n) then row <= row + '1';
                                    col <= '0';
                elsif(row = n or LIFO_FULL = '1') then allFiled <= '1';
                                    NextState <= SOLVE;
                end if;
                
           
           when FILL =>
                i <= i + '1';
                if( i < n)
                    if((is_set(row_mask(row),i) or is_set(col_mask(col),i) or
                    is_set(sqr_mask(sqr_index),i)) \= zero) then valid <= '1';
                    else conflict <= '1';
                    end if;
                
                    row_mask(row)<= do_set(row_mask(row),i);
                    col_mask(col)<=do_set(col_mask(col),i);
                    sqr_mask(sqr_index)<=do_set(sqr_mask(sqr_index),i);
                    matrix_sudoku(row*b + col)<= i;
                    LIFO port map(data_i => matrix_sudoku(row*b + col), data_o =>LIFO_out,
                                Full => LIFO_FULL, Empty =>LIFO_EMPTY,
                                Rd => '0', Wr => '1', Clk => clk, size => n);
                    if(col < n) then col <= col + '1';
                    end if;
                    if(valid = '1' and LIFO_FULL = '1') then NextState <= EMPTY_CASE; 
                    elsif(conflict = '1') then NextState <= TEST;   
                    end if;
                else NextState <= SOLVE;
                end if;
           
           when TEST =>
                LIFO port map(data_i => matrix_sudoku(row*b + col), data_o =>LIFO_out,
                                Full => LIFO_FULL, Empty =>LIFO_EMPTY,
                                Rd => '0', Wr => '1', Clk => clk, size => n);
                if( TO_INTEGER(UNSIGNED(LIFO_out) = n)) then NextState <= UNSET;
                else NextState <= FILL;
                        valid <= '1';
                end if;
                
            when UNSET =>
                matrix_sudoku(row*b + col)<= 0;
                row_mask(row)<= do_unset(row_mask(row),i);
                col_mask(col)<=do_unset(col_mask(col),i);
                sqr_mask(sqr_index)<=do_unset(sqr_mask(sqr_index),i);
                NextState <= TEST;
               
            when SOLVE =>
                NextState <= IDLE;
           
            when others =>
                NextState<=IDLE;
        end case;
       
    end process; 
end process;
end architecture;

Evidemment comme cet un premier essai, je pense qu'il y a beaucoup d'erreur. Ca serait cool que tu me dises ce que t'en pense. Notamment sur l'utilisation de la pile comme composant (je savais pas comment faire autrement) ou la boucle for que j'ai enlevé et puis même sur les fonctions de masques je suis franchement pas sûr de moi au niveau de l'implémentation de ces fonctions.

Code :

entity lifo is
port(data_i : in std_logic_vector(7 downto 0); -- input vector
data_o : out std_logic_vector(7 downto 0); -- output vector
Rd,Wr : in std_logic; -- read,write control signals
Empty,Full: out std_logic; -- condition signals
Clk : in std_logic
size : in integer);
generic(n: NATURAL:= size*size); -- LifO size
end lifo;
architecture behavioral of lifo is
TYPE StorageT is array(0 to n-1) of std_logic_vector(15 downto 0);
signal lifo: StorageT; -- LifO memory
signal last: integer range -1 to n-1;
begin
process (Clk)
begin
if (Clk = '1') AND (Wr = '1') then -- write operation
if (last=n-1) then NULL; -- lifo already full
else
if (last=n-2) then Full <= '1'; end if;
if (last=-1 ) then Empty <= '0'; end if;
lifo(last+1) <= data_in;
last <= last+1;
end if;
elsif (Clk = '1') AND (Rd = '1') then -- read operation
if (last=-1) then NULL; -- lifo already empty
else
data_out <= lifo(last);
last <= last-1; Full <= '0';
if (last = -1) then Empty <= '1'; end if;
end if;
end if;
end process;
end behavioral;

Voilà le code de la pile, là je sais pas tellement quoi mettre au niveau de la taille de la pile. C'est dommage qu'il n'y ait pas de balise VHDL... J'espère que cela va être suffisamment lisible. Merci pour tout en tout cas et pour une fin de soirée je trouve tes propos relativement clairs

Message édité par Gefroren le 28-03-2012 à 16:06:28

h3bus

Troll Inside

Bon le code de la pile devrait synthétiser.

Pour le reste ça va pas passer!

Notamment tu ne peux pas instancier ta LIFO dans un process, il faut l'instancier dans l'architecture. La machine d'état gère ensuite les signaux d'interface.

Je pige pas des masses pourquoi tu n'as pas choisit un tableau à deux dimensions pour le sudoku.

En ce qui concerne la taille de la pile, en toute logique c'est le nombre de case de ton sudoku.

Pense à cadencer tes process sur une horloge.

Je vois pas mal d'erreur das le code, sans avoir regardé l'algorithmique. Tu pense encore trop itératif, n'oublie pas qu'à chaque coup d'horloge, tout le contenu du process est exécuté, et de manière parallèle.

---------------
sheep++

Publicité

Gefroren

Ah ben si déjà la pile ça va, c'est déjà bien. Je savais que l'autre partie ne pouvais pas passer, c'était un premier essai.

Ok merci pour la LIFO, j'ai corrigé le problème.

L'histoire du tableau à une dimension ne vient pas de moi. On nous a dit que les tableaux à deux dimensions n'étaient pas synthétisables et que du coup il fallait changer celui pour le rendre 1D, voilà pourquoi.

La grosse machine d'états est cadencée par une horloge qui se trouve ligne 91, je suppose que tu l'as vu, du coup je vois pas trop ce que tu veux dire en fait. Faut pas que je rajoute une horloge quand même, ou alors des conditions de front montant??

h3bus

Troll Inside

Oops j'avais pas vu effectivement ta machine d'état est cadencée, mais pas le reste (il y a beaucoup de boucle combinatoires, il faudrait cadencer le process complet ou utiliser des next_xxx pour beacoup de signaux);

Un petit conseil utilise rising_edge(clk) au lieu de (clk'event and clk='1').

Ta FIFO n'est pas sur front montant, il faut corriger ça (actuellement tu infère une latch, ce qui est dangereux)

---------------
sheep++

Gefroren

Je m'execute, tient pourquoi c'est mieux le rising edge plus que le clk'event and clk='1' ?

Simple precision : Par next_xxx tu entends les signaux temporaires qu'on utilise pendant le process et qu'on affecte a la fin c'est ca??
(dsl pour l'orthographe mais clavier allemand...)

h3bus

Troll Inside

L'avantage n'est pas gigantesque, mais c'est une bonne habitude à prendre:
http://vhdlguru.blogspot.se/2010/0 [...] k-and.html

Effectivement par next_xxx j'entends bien le signal combinatoire qui entre dans la bascule.
Mais il est plus facilement maintenable, plus simple, et comporte moins de ligne de code de tout simplement cadencer (en entourant le fonctionnel du if rst then ... elsif rising_edge then ... end if) le process qui te fait tous tes calculs... Enfin quand tu l'aura simplifié ce sera plus simple

Message édité par h3bus le 27-03-2012 à 15:18:41

---------------
sheep++

Gefroren

Bon j'ai essayé de tout cadencer, j'ai donc mis des blocs if reset ... aux endroits où j'appelais des fonctions. Pour le reset je savais pas trop, donc lorsque le reset passe à un on retourne à l'IDLE. Voilà dis moi ce que t'en pense.

Code :

library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.numeric_std.all;
 
 
entity brute_force is
    port (
    a_reset_l       : in  std_logic;
    clk             : in  std_logic;
    start_h         : in  std_logic;
    order           : in  std_logic_vector( 3 downto 0);
    data_o          : out std_logic_vector( 7 downto 0);
    );
end entity brute_force;
 
architecture rtl_vhdl of brute_force is
 
 
--Functions The sames functions which are made in the systemc file(Masking)
 
function is_set(mask:integer; pos:integer) return std_logic_vector is--With this function I can know if a bit is '1'
    variable mk:std_logic_vector((TO_INTEGER(UNSIGNED(order))-1) downto 0);
    variable temp1: std_logic_vector ((TO_INTEGER(UNSIGNED(order))-1) downto 0);
    variable temp2: UNSIGNED ((TO_INTEGER(UNSIGNED(order))-1) downto 0);
   begin   
   
    temp1:=std_logic_vector(TO_UNSIGNED(mask,(TO_INTEGER(UNSIGNED(order)))));--I convert a integer '1' into a vector of 49 bits
    temp2:=(TO_UNSIGNED(1,(TO_INTEGER(UNSIGNED(order)))));--convert the value of mask into a vector of 49 bits
   
    mk:= temp1 and std_logic_vector(temp2 rol pos);
    return mk;
end is_set;
 
 
function do_set(mask: integer; pos: integer) return integer is--With this procedure I can set a bit in the position indicated by pos.
    variable temp1: UNSIGNED ((TO_INTEGER(UNSIGNED(order))-1) downto 0);
    variable mask1:integer;
    begin
        temp1:=(TO_UNSIGNED(mask,(TO_INTEGER(UNSIGNED(order)))));
        mask1:=TO_INTEGER((temp1 or (temp1 rol pos)));
    return mask1;
end do_set;
 
function do_unset(mask: integer ;  pos: integer ) return integer is
    variable temp2: UNSIGNED ((TO_INTEGER(UNSIGNED(order))-1) downto 0);
    variable mask2:integer;
begin
    temp2:=(TO_UNSIGNED(mask,(TO_INTEGER(UNSIGNED(order)))));--With this function I clear set a bit in the position indicated by pos.
    mask2:=TO_INTEGER((temp2 and (not(temp2 rol pos))));
    return mask2;
end do_unset;
 
component LIFO
            
         data_i   : in  std_logic_vector(7 downto 0);
         data_o  : out std_logic_vector(7 downto 0); 
         Rd,Wr     : in  std_logic;             
         Empty,Full: out std_logic;     
         Clk       : in  std_logic
         size           : in integer);
end component;
 
 
 
type mask is array (integer range<> ) of integer;
signal row_mask : mask(0 to (TO_INTEGER(UNSIGNED(order))-1));
signal col_mask : mask(0 to (TO_INTEGER(UNSIGNED(order))-1));
signal sqr_mask : mask(0 to (TO_INTEGER(UNSIGNED(order))-1));
 
 
type State is (IDLE, EMPTY_CASE, FILL, TEST,UNSET, SOLVE)
 
signal b : integer;--number of blocks
signal row :integer;
signal col : integer;
signal n : integer;--
signal zero : std_logic_vector(48 downto 0) := (others=>'0');
signal sqr_index : integer;
type sudoku is array (integer range<> ) of integer;
signal matrix_sudoku : sudoku(0 to 2400);
 
signal State: State;
signal State: NextState;
signal valid:std_logic;
signal found:std_logic;
signal conflict:std_logic;
signal allFilled:std_logic;
signal start:std_logic;
signal LIFO_out:std_logic_vector(7 downto 0);
signal i:integer := '0'; 
signal LIFO_FULL:std_logic;
signal LIFO_EMPTY:std_logic;
signal LIFO_read:std_logic;
signal LIFO_write:std_logic;
signal is_set_row:std_logic;
signal is_set_col:std_logic;
signal is_set_sqr:std_logic;
 
LIFO port map(data_i => matrix_sudoku(row*b + col), 
              data_o =>LIFO_out,
              Full => LIFO_FULL, 
              Empty =>LIFO_EMPTY,
              Rd => LIFO_read, 
              Wr => LIFO_write, 
              Clk => clk, 
              size => n);
                                
begin
    process(clk, a_reset_l)
    begin
        if (a_reset_l = '0') then
            State <= IDLE;
        elsif (rising_edge(clk)) then
            State <= NextState;
        end if;
    end process;
   
    process(State, NextState, start, found, col, row, valid, conflict, LIFO_out, allFiled)
   
    b <= TO_INTEGER(UNSIGNED(order));
    n <= b*b;
    col <= '0';
    row <= '0';
    begin
        case state is
            when IDLE =>
                if(start/= '0') then NextState <= EMPTY_CASE;
                else NextState <= IDLE;
                end if;
           
           when EMPTY_CASE =>
                
                if(matrix_sudoku(row*b + col) = 0) then
                    found <= '1';
                else col <= col + '1';
                end if;
                
                if(found = '1') then NextState <= FILL;
                elsif(col = n) then row <= row + '1';
                                    col <= '0';
                elsif(row = n or LIFO_FULL = '1') then allFiled <= '1';
                                    NextState <= SOLVE;
                end if;
                
           
           when FILL =>
                i <= i + '1';
                if( i < n)
                    if (a_reset_l = '1') then
                        State <= IDLE;
                    elsif (rising_edge(clk)) then
                        is_set_row <= is_set(row_mask(row),i);
                        is_set_col <= is_set(col_mask(col),i);
                        is_set_sqr <= is_set(sqr_mask(sqr_index),i);
                    end if;
                    
                    if( (is_set_row or is_set_col or is_set_sqr) \= zero) then valid <= '1';
                    else conflict <= '1';
                    end if;
                
                    if (a_reset_l = '1') then
                        State <= IDLE;
                    elsif (rising_edge(clk)) then
                        row_mask(row)<= do_set(row_mask(row),i);
                        col_mask(col)<=do_set(col_mask(col),i);
                        sqr_mask(sqr_index)<=do_set(sqr_mask(sqr_index),i);
                        matrix_sudoku(row*b + col)<= i;
                    end if;
                    
                    LIFO_read <= '0';
                    LIFO_write <= '1';
                    
                    if(col < n) then col <= col + '1';
                    end if;
                    
                    if(valid = '1' and LIFO_FULL = '1') then NextState <= EMPTY_CASE; 
                                                             data_o <= LIFO_out;
                    elsif(conflict = '1') then NextState <= TEST;   
                    end if;
                else NextState <= SOLVE;
                end if;
           
           when TEST =>
                LIFO_read <= '1';
                LIFO_write <= '0';
                if( TO_INTEGER(UNSIGNED(LIFO_out) = n)) then NextState <= UNSET;
                else NextState <= FILL;
                        valid <= '1';
                end if;
                
            when UNSET =>
                    if (a_reset_l = '1') then
                        State <= IDLE;
                    elsif (rising_edge(clk)) then
                        matrix_sudoku(row*b + col)<= 0;
                        row_mask(row)<= do_unset(row_mask(row),i);
                        col_mask(col)<=do_unset(col_mask(col),i);
                        sqr_mask(sqr_index)<=do_unset(sqr_mask(sqr_index),i);
                    end if;
                
                NextState <= TEST;
               
            when SOLVE =>
                NextState <= IDLE;
           
            when others =>
                NextState<=IDLE;
        end case;
       
    end process; 
end process;
end architecture;

Message édité par Gefroren le 28-03-2012 à 16:05:55

h3bus

Troll Inside

C'est trop compliqué pour que je t'indique ou sont les soucis, problème par problème.

Je te conseille de commencer par faire un seul petit bout simple (et sans utiliser les fonctions), je t'aiderai à corriger et améliorer la syntaxe puis on rajoutera petit bout par petit bout.

Dis toi bien que si ça ne synthétise pas, il y a un soucis (et là ça va pas synthétiser).

Donc simplifie, poste un code (utilise les balise de code "ada", de mémoire ça marche sur HFR et c'est très proche de VHDL), mais seulement si ça synthétise (ou si tu ne sais pas pourquoi ça ne synthétise pas) à partir de là je pourrai t'aider.

Courage, ce que tu essaies de faire est compliqué, même pour un as du VHDL, mais avec de la méthode tu vas y arriver.

Message édité par h3bus le 27-03-2012 à 19:48:41

---------------
sheep++

Gefroren

Arf... Ok, merci pour ton aide en tout cas.
Il y a un écueil à tout ça, c'est que ce projet je dois le rendre avant le 1er avril et donc bon je pense que ça va être short. De plus vu que je suis en stage en même temps en ce moment j'ai pas le temps d'aller à la FAC, du coup je dois bosser de chez moi. Le truc c'est qu'ici ils utilisent ICPRO sous Solaris et que c'est super super lent, alors en SSH chez moi c'est juste pas possible.
Tout ce que je t'ai montré, je l'ai fait direct avec Notepad, sinon c'est trop trop long. Du coup je peux pas tester, ou alors je dois prévoir la demi-heure juste pour un test.
Enfin bref c'est pas grave j'ai déjà pas mal de choses à expliquer et mon Belegarbeit (genre de rapport) sera convenablement fourni (sauf que y'aura pas de simulation, bien entendu)
En tout cas tu m'as vachement aidé, et je te remercie pour ça.

Au fait les balises Ada, ça marche pas non plus.

h3bus

Troll Inside

Cf bbcode, bon c'est pas idéal mais ça marchotte...

Code :

process(clk, rst_n)
begin
  if then
end process;

Ah mais laisse tomber pour le premier avril c'est infaisable si tu n'y passe pas plus de temps.

Tu peux toujours télécharger chez toi l'ide altera ou xilinx, il y a des version gratuites et tu pourras synthétiser et simuler.
Je voies bien que tu n'a pas pu tester pour l'instant, même si c'est très dur de faire ça pour le 1er, ça vaut le coup de s'y pencher plus tard, surtout si tu penses faire du HDL ou du design électronique plus tard!

---------------
sheep++

FORUM HardWare.fr

Programmation

Divers

Adaptation SystemC en VHDL

Sujets relatifs
Adaptation auto. Page Web / Résolution	question sur la description structurelle en vhdl
SystemC	[VHDL] Question concernant les case avec des if
VHDL - Contrôleur de feux	[VHDL/Verilog] Les FPGA et leur programmation
Problème de gestion de la liaison série RS232 en VHDL	programmer en SystemC
Adaptation d'un code Javascript	[Resolu]Adaptation programme Windows vers Linux
Plus de sujets relatifs à : Adaptation SystemC en VHDL

Page générée en 0.203 secondes