[VDHL][GAL] Sequentieel programmeren lukt niet.

[Verwijderd]

Momenteel ben ik bezig met een project om mijn waterkoelinstallatie te laten bewaken door een µC. Een GAL22V10 wil ik hiervoor gebruiken.
Maar nu is er een (simpel ?) fout in mijn programma, maar het lukt niet om ze eruit te halen.

code:

MODULE PROJECT
TITLE  'Project ISP Tim Dehoucke'


       JEDEC DEVICE 'P22V10C';

        !pomp           pin 4;
        !pc             pin 6;
        !pcuit          pin 7;
        pomprls         pin 25 istype 'reg';
        pcrls           pin 24 istype 'reg';

        clock           pin 2;


        MODE = [pomprls, pcrls];

        S0 = 0; S1 = 1; S2 = 2; S3 = 3;

EQUATIONS
      

       
STATE_DIAGRAM MODE

     State S0:
               pomprls := 0; pcrls := 0;
               if (pomp) then S2;
               else if (pc) then S0;
                 
     State S1: 
               pomprls := 0; pcrls := 0;

               if (pomp) then S0;
               
                
     State S2:
               pomprls := 1; pcrls := 0;

               if (pomp) then S0;
               else if (pc) then S3;
               
     State S3:
               pomprls := 1; pcrls := 1;
               if (pomp) then S0
               if (pc) then S0;
               
              

END

Fout:
Zodra ik in state S3 zit (pomp en pc draaien) dan kan ik de pc niet meer uitzetten. Dus de lijn " if (pc) then S0;" werkt niet. Idem voor State 1, ik kan niet meer terug naar S0.

[Rukapul]

Kun je eens een statemachine tekenen, want er lijkt iets niet te kloppen. Je kunt bijvoorbeeld nooit in S1 geraken. Wat is de beginstate?
De naamgeving 'pomp' en 'pc' is eigenlijk ook een beetje verwarrend als je 'not pomp' en 'not pc' bedoelt.

Wat betreft het niet werken van de transitie 'if (pc) then S0' is het noodzakelijk te weten wat er aan de lijn '(not)-pc' hangt. De aan/uit schakelaar?

Tevens is het zo dat als 'pomp' true is en 'pc' true, dat je vanuit S3 naar S0 gaat en direct naar S2 gevolgd door een transitie naar S3.

[Goodielover]

Volgens mij moet het zo zijn:

Als dit goed is zat je er nogal naast. Ik heb pomp en pc als toggle sigalen gezien, maar dat lijkt me niet waarschijnlijk.

Je info is wat beperkt dus ik kan er goed naast zitten.
Lees verder bovenstaande info even door van de vorige poster.

code:

STATE_DIAGRAM MODE

     State S0:
               pomprls := 0; pcrls := 0;
               if (pomp) then S2;
               if (pc) then S1;
                 
     State S1: 
               pomprls := 0; pcrls := 1;
               if (pomp) then S3;
               if (pc) then S0;
                
     State S2:
               pomprls := 1; pcrls := 0;
               if (pomp) then S0;
               if (pc) then S3;
               
     State S3:
               pomprls := 1; pcrls := 1;
               if (pomp) then S1;
               if (pc) then S2;

END

[ Voor 7% gewijzigd door Goodielover op 11-05-2003 21:32 ]

[Verwijderd]

Dat klopt hetgeen je zegt, maar praktisch gezien mag S1 zich niet voordoen: de pc mag niet draaien zonder dat de waterpomp draait; daarom heb ik S1 weggelaten

[Rukapul]

Ga je hier nog meer informatie verschaffen over de inputsignalen, want zonder dat valt het gedrag van de schakeling niet fatsoenlijk te bepalen.

Overigens lijkt er sowieso nog een bug in het stage diagram te zitten: "State S2 - if (pomp) then S0;" keert onnodig terug naar state S0 lijkt het terwijl het best in state S2 mag blijven. Sterker nog: onder de aanname dat !pc indirect beinvloed wordt door pomprls (relais?) lijkt dit alleen te werken onder de aanname van een langzame clock en een snel schakelend relais.

De bug die jij beschrijft kan hiermee samenhangen aangezien je als het ware door een toestand heen kan schieten, omdat je een in een state komt als een bepaalde input true is, maar de state ook weer verlaat als die input nog steeds (of weer) true is. (Heb je dit in praktijk ondervonden of dmv een similator?).

De state machine van bovenstaande poster is btw non-deterministisch (als pomp en pc true zijn in S0 dan zijn er twee doel-states bijvoorbeeld).

[Rotjeknor]

Het eerste wat me opvalt is dat je totaal niet rekening houdt met ongedefinieerde vars. Wat doe je als een var in een state net niet doet wat ie zou moeten doen? Ik zou dat eerst eens goed maken, zorg ervoor dat je een idle/ reset state hebt, dat je van daaruit weer de boel van voor af aan kan gaan regelen.

[Ralluph]

Zoals de bovenstaande posts al suggereren, lijkt het mij verstandig om eerst eens een state-diagram te tekenen.

Ten tweede, in je topic staat VDHL, maar ik neem aan dat je VHDL bedoelt.

Ten derde, probeer eerst eens of je je Finite State Machine (FSM) in een mooie behavioural description kunt klussen. Doe dit met behulp van twee processen, eentje die afhankelijk is van de ingangssignalen en die de next_state definieert, en eentje die de current_state update op de klok en eventueel de reset. Zo krijg je veel meer inzicht hoe zoiets werkt. Google eventueel op 'vhdl "state machnine" tutorial'. Ik heb zelf geen ervaring met de notatie die jij gebruikt, maar echt helder ziet het er niet uit. Ik neem aan dat dit pas vanaf VHDL93 mag.

[toevoeging]
Als je problemen hebt met debuggen in welke state je blijft hangen èn je hebt nog extra uitgangen beschikbaar, dan is het verrot handig om de states naar een uitgang te gooien. Wellicht kun je zelfs een mooie state-to-BCD converter bouwen om de huidige toestand netjes decimaal te visualiseren

[ Voor 19% gewijzigd door Ralluph op 12-05-2003 10:48 ]

[Verwijderd]

Ralluph schreef op 12 May 2003 @ 10:44:
Ten tweede, in je topic staat VDHL, maar ik neem aan dat je VHDL bedoelt.

Juist, was verward met een pc-winkel

Rukapul schreef op 12 May 2003 @ 02:23:
...

Is het wel mogelijk dat, door pomp, in te drukken hij automatisch de verschillende states doorloopt?

Ralluph schreef op 12 May 2003 @ 10:44:
...

Ten derde, probeer eerst eens of je je Finite State Machine (FSM) in een mooie behavioural description kunt klussen. Doe dit met behulp van twee processen, eentje die afhankelijk is van de ingangssignalen en die de next_state definieert, en eentje die de current_state update op de klok en eventueel de reset. Zo krijg je veel meer inzicht hoe zoiets werkt. Google eventueel op 'vhdl "state machnine" tutorial'. Ik heb zelf geen ervaring met de notatie die jij gebruikt, maar echt helder ziet het er niet uit. Ik neem aan dat dit pas vanaf VHDL93 mag.
...

Bedankt voor je reply;

Kun je jouw uitleg staven met een voorbeeld? Want nu heb ik moeite om te begrijpen hoe je uitleg zich vertaald in code.
Ik moet dus mijn state-registers via de clock laten setten?


-----
De reden voor !pomp en !pc (inverterend dus) is omdat ik de schakelaars via pull-ups verbonden heb aan de GAL; zijn ze open, dan staat er 5V op de ingang.

[ Voor 30% gewijzigd door Verwijderd op 12-05-2003 15:55 ]

[Ralluph]

Verwijderd schreef op 12 mei 2003 @ 15:37:
Bedankt voor je reply;

Kun je jouw uitleg staven met een voorbeeld? Want nu heb ik moeite om te begrijpen hoe je uitleg zich vertaald in code.
Ik moet dus mijn state-registers via de clock laten setten?

Hier is een voorbeeld van een simpele state machine:

vhdl:

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity fsm IS
  PORT(
    reset : in std_logic;
    clk   : in std_logic;
    I     : in std_logic;
    D     : out std_logic
  );
end fsm;

architecture behaviour of fsm is
  type st_type is (s1,s2,s3);
  signal current_state : st_type;
  signal next_state: st_type;

begin
  seq: process (clk, reset)
  begin
      if (reset='1') then
        current_state <= s1;
      elsif rising_edge(clk) then
        current_state <= next_state;
      end if;
  end process;

  comb: process(current_state,I)
  begin
    D <= '0'; -- default value
    next_state <= current_state;
    case current_state is
      when s1 =>
        D <= '1';
        if (I='1') then
          next_state <= s2;
        else
          next_state <= s1;
        end if;
      when s2 =>
        D <= '0';
        if (I='1') then
          next_state <= s3;
        else
          next_state <= s2;
        end if;
      when s3 =>
        D <= '0';
        if (I='1') then
          next_state <= s1;
        else
          next_state <= s3;
        end if;
    end case;
  end process;
end behaviour;

Ik heb dit even snel overgenomen van deze link: http://pages.cpsc.ucalgary.ca/~costi/421/VHDLfsm.pdf, die ik heel eenvoudig heb gevonden door te googlen op 'vhdl fsm example'. Het stelt verder niets voor, je moet zelf nadenken hoe je je eigen functie in zo een structuur kunt passen.

Je ziet hier twee processen, eentje die afhankelijk is van de klok en de reset, en die het resetten en het doorvoeren van de state transities doorvoert. De andere bepaalt de nieuwe toestand op basis van de huidige toestand en de ingangssignalen. Een leuk detail is dat de reset hier asynchroon is, d.w.z. onafhankelijk van de klok. De state-transisties vinden plaats op een opgaande klokflank.

Ik stel voor dat je zelf nog wat verder zoekt op google, dit is veel vaker gedaan en er zijn zodoende erg veel voorbeelden op het internet te vinden.
Hoe je bij jouw ontwikkelomgeving de juiste pinnetjes aan de juiste pootjes knoopt kun je vast in de handleiding of de help vinden, net als wat je allemaal moet configureren wil dit netjes worden gesynthetiseerd.

[ Voor 4% gewijzigd door Ralluph op 12-05-2003 22:54 . Reden: typo ]