Synchronisatzionsprobleme zwischen 2 Modulen

[Chris (Gast)]

Hallo!


ich scheine ein leichtes synchronisationsproblem zwischen 2 modulen zu 
haben. ich konnte das ganze nicht mittels waveform testen, da dort keine 
variablen angezeigt werden.


der folgende code stammt vom submodul

sendDataYToMainModule : PROCESS(ECNN_CLK_50, sigInternalProcessingFinished)
      variable counter : integer    := 0;
      variable stepsize : integer    := 16; -- 16 bit for a pixel
      variable varECNN_Y_valid : std_logic := '0';
    
    BEGIN
      IF ECNN_CLK_50'EVENT AND ECNN_CLK_50 = '1' THEN

-- wenn die interne bildverarbeitung fertig ist, wird das signal auf '1' gesetzt, das ist das zeichen für das speichern des bildes - pixel für pixel
        IF sigInternalProcessingFinished = '1' THEN
          -- if signal is equal '1' then the main module will fetch the data    
-- ECNN_PROCESSING_FINISHED - hieran ist das main modul interessiert. wenn das signal 1 ist, schreibt das main modul die daten vom submodul direkt in den sram
          ECNN_PROCESSING_FINISHED <= sigInternalProcessingFinished;
        
-- mein bild hat 100 pixel. ich speichere jeden pixel einzeln. danach wird ein flag gesetzt - zeichen für das mainmodul, dass es nichts mehr speichern muss
          IF counter < 100 THEN          
-- das datensignal, welches zum main modul kommt ist gültig, wenn = '1'
            ECNN_Y_valid <= varECNN_Y_valid;
            IF varECNN_Y_valid = '1' THEN
                        
--ECNN_Y ist der vektor der vom mainmodul gespeichert wird
              ECNN_Y(15)  <= Y_internal(counter * stepsize + 15);
              ECNN_Y(14)  <= Y_internal(counter * stepsize + 14);
              ECNN_Y(13)  <= Y_internal(counter * stepsize + 13);
              ECNN_Y(12)  <= Y_internal(counter * stepsize + 12);
              ECNN_Y(11)  <= Y_internal(counter * stepsize + 11);
              ECNN_Y(10)  <= Y_internal(counter * stepsize + 10);
              ECNN_Y(9)  <= Y_internal(counter * stepsize + 9);
              ECNN_Y(8)  <= Y_internal(counter * stepsize + 8);
            
              ECNN_Y(7)  <= Y_internal(counter * stepsize + 7);
              ECNN_Y(6)  <= Y_internal(counter * stepsize + 6);
              ECNN_Y(5)  <= Y_internal(counter * stepsize + 5);
              ECNN_Y(4)  <= Y_internal(counter * stepsize + 4);
              ECNN_Y(3)  <= Y_internal(counter * stepsize + 3);
              ECNN_Y(2)  <= Y_internal(counter * stepsize + 2);
              ECNN_Y(1)  <= Y_internal(counter * stepsize + 1);
              ECNN_Y(0)  <= Y_internal(counter * stepsize + 0);
              
            ELSE
-- nächster pixel
              counter        := counter + 1;
              varECNN_Y_valid   := varECNN_Y_valid XOR '1';          
            END IF;
            
          ELSE  -- counter more than 100 loops
            ECNN_Y_finished      <= '1';            
          END IF;
        END IF;
      END IF;
    END PROCESS sendDataYToMainModule;

der folgende code stammt aus dem hauptmodul:

instance : sumbodul
    PORT MAP(
      ECNN_RESET => RESET,
      ECNN_CLK_50 => CLK_50,
      ECNN_U_finished => ECNN_U_finished_sig,
      ECNN_U_valid => ECNN_U_valid_sig,
      ECNN_U => ECNN_U_sig,
      ECNN_PROCESSING_FINISHED => sigStoreData,
      ECNN_Y_finished => ECNN_Y_finished_sig,
      ECNN_Y_valid => ECNN_Y_valid_sig,
      ECNN_Y => ECNN_Y_sig
  );

prototype_interact_with_sram : process(CLK_50, sigStoreData, sigStoreDummyImage)
    variable varCounter : integer := 0;
    variable varRead_write : std_logic := '0';
    variable varMem_address : std_logic_vector (17 downto 0) := "000000000000000000";
    variable varUpperBoundary : integer := constDimensionNOfNxNImage;
    
    variable varStoreDataFromBuffer   : std_logic := '0';
    variable varStoreDataToBuffer  : std_logic := '0';
      
    begin
    if (CLK_50'event and CLK_50 = '1') then
    

-- wenn das submodul das signal zum speichern sendet, wird überprüft, ob es das schon getan hat - für die initialisierung des counters etc.
      if (sigStoreData = '1' and varStoreDataFromCNNBuffer = '0') THEN
        varMem_address        := constStartMemoryAddressOfImageY;
        varStoreDataFromBuffer  := sigStoreData;
        varCounter          := 0;
        varRead_write        := '0';
      END IF;
      

-- 100 pixel werden gespeichert
      if (varCounter < 100 and varStoreDataFromCNNBuffer = '1') then
        
        CNN_DATA_ADDRESS <= varMem_address;
        
        ----------------
        -- writing modus
        ----------------
        if (varRead_write = '1') THEN       -- write        
          READ_WRITE <= '1';
          NEW_ADDR <= '1';
          
          -----  
            IF (varCounter = 5) THEN
              LEDR <= "00" & ECNN_Y_sig;
            END IF;
            -------
          
          IF (varStoreDataFromCNNBuffer = '1' and ECNN_Y_valid_sig = '1' and ECNN_Y_finished_sig = '0') THEN
            DATA_IN <= ECNN_Y_sig;
          END IF;
          
          
          varCounter := varCounter + 1;

        ----------------
        -- reading modus
        ----------------
        ELSE
          READ_WRITE <= '0';
          NEW_ADDR <= '0';
          
          if varCounter > 0 then
            varMem_address := varMem_address + "000000000000000001";
            --LEDR <= varMem_address;
          end if;
              
        end if;        
        varRead_write := not varRead_write;  
      end if;
      
    end if;
    end process prototype_interact_with_sram;

das modul für die speicherung in den sram funktioniert fehlerfrei - habe 
es ausgibig getestet. ich weiß dass das submodul vektoren mit lauter 
1ser schickt. wenn ich den sram mit einem externen programm auslese, so 
werden aber nur 0er gespeichert.
irgendwie gibt es probleme beim synchronisieren. jedoch arbeiten beide 
module mit der selben clock.
ich bin langsam etwas ratlos.

lg

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

> die speicherung in den sram funktioniert fehlerfrei...
> wenn ich den sram mit einem externen programm auslese, so
> werden aber nur 0er gespeichert.
Wie passt das zusammen?

>  READ_WRITE <= '1';
Ist das das Signal ans SRAM? Wie ist dein WR# und OE# am SRAM 
beschaltet? Darfst du dein SRAM direkt vom Schreibzustand in den 
Lesezustand umschalten?

[Chris (Gast)]

Hallo!

SRAM modul funktioniert fehlerfrei. ich verwende ein modul dass direkt 
aus einem tutorial der herstellerfirma stammt.
das umschalten zwischen read und write funktioniert ohne probleme...


>> die speicherung in den sram funktioniert fehlerfrei...
>> wenn ich den sram mit einem externen programm auslese, so
>> werden aber nur 0er gespeichert.
> Wie passt das zusammen?

also es ist so zu verstehen. ich habe im hauptmodul einige werte in den 
sram gespeichert. diese werte sind alle richtig gespeichert worden.

was ist nun mein problem?
ich schicke vom submodul lauter 1nser zum "speicherprocess".
wenn ich nun mit einem externen programm den sram auslese, so sind an 
den stellen, an denen die 1nser sein sollten, lauter 0er.

deswegen liegt die vermutung nahe, dass ich in einem der beiden obinge 
codestücke der hund begraben liegt :P

anbei die ports für das sram-modul

COMPONENT entity_sram_controller is
    PORT
    (
      CLK_50        :  IN std_logic;
            
      SRAM_DQ        :  INOUT std_logic_vector (15 downto 0);
      SRAM_ADDR      :  OUT std_logic_vector (17 downto 0);
      SRAM_UB_N      :  OUT std_logic;
      SRAM_LB_N      :  OUT std_logic;
      SRAM_WE_N      :  OUT std_logic;
      SRAM_CE_N      :  OUT std_logic;
      SRAM_OE_N      :  OUT std_logic;
      GPIO_0        :  INOUT std_logic_vector(35 downto 0);
      GPIO_1        :  INOUT std_logic_vector(35 downto 0);     



      NEW_ADDR    :  IN std_logic;
      READ_WRITE    :  IN std_logic;
      DATA_ADDRESS  :  IN std_logic_vector (17 downto 0);
      DATA_IN      :  IN std_logic_vector (15 downto 0)
    );
  END COMPONENT;

[SuperWilly (Gast)]

>SRAM modul funktioniert fehlerfrei. ich verwende ein modul dass direkt
>aus einem tutorial der herstellerfirma stammt.


Allein die Tatsache, dass das Modul aus einem Tutorial stammt, gibt
Dir die Gewissheit, dass es funktioniert ???

Hast Du das "SRAM Modul" tatsächlich mal in Hardware laufen gehabt und 
in Hardware Debugging betrieben?

Hast Du die Schaltung simuliert ?


SuperWilly

[Chris (Gast)]

Hallo!

Wie ich bereits oben geschrieben habe:
> ich habe im hauptmodul einige werte in den
sram gespeichert. diese werte sind alle richtig gespeichert worden.

ich habe schaltung für das speichern in sram also getestet - in hardware 
wie auch simuliert. beides erfolgreich.


wie auch schon vorhin geschrieben, habe ich leider mehrere variablen in 
den processen verwendet. wenn ich die in signale umwandle bekomme ich 
nicht wirklich etwas sinnvolles als resultat - aus einer simulation.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

> für das speichern in sram also getestet
Dann gib doch mal an den entsprechenden Schnittstellen bekannte Daten an 
das RAM aus.
Da z.B.:

--ECNN_Y ist der vektor der vom mainmodul gespeichert wird
              ECNN_Y(15)  <= '0';
              :
              ECNN_Y(1)  <= '1';
              ECNN_Y(0)  <= '0');

oder kürzer:

--ECNN_Y ist der vektor der vom mainmodul gespeichert wird
              ECNN_Y  <= x"1234";

Was ist denn das hier für eine haarsträubende Muxerei:

              ECNN_Y(15)  <= Y_internal(counter * stepsize + 15);
              :
              ECNN_Y(0)  <= Y_internal(counter * stepsize + 0);

wie breit ist dein Y_internal ?
Wenn counter ein uneingeschränkter Integer ist, dann muß das ein 
megamäßiger Monstermux sein... :-o
Was sagt eigentlich deine Synthese zu solchen Konstrukten?
Wie schnell ist dein Design?


BTW:
Wie geht das, dass du aus dem SRAM mit einem externen Programm etwas 
auslesen kannst?

[Chris (Gast)]

hallo!

alsooo :)

ich verarbeite intern ein bild, dass in y_internal gespeichert ist.
es handelt sich also um einen vektor der 1600 lang ist. da ich immer nur 
16 bit zum sram schicke, muss ich diese 16bit erstmal selektieren. das 
mache ich über diese methode.

externes programm...
ich verwende das altera de2 board, welches software für das auslesen und 
manipulieren jedes bausteins zur verfügung stellt. dazu muss man eine 
.sof datei vom hersteller auf das board synthetisieren und laufen 
lassen. das externe programm - (sprich auf dem rechner) "kommuniziert" 
dann mit dem board. damit ist es dann ein leichtes den sraminhalt 
auszulesen.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

> vektor der 1600 lang... muss ich diese 16bit erstmal selektieren.
Mit einem Multiplexer wirst du da kaum Freude haben...

Warum machst du es nicht mit einem Schieberegister?
Die ersten 16 Bit ausgeben, danach das Scheiberegister um 16 bit 
weiterschieben, dann wieder die ersten 16 Bit ausgeben, dann das 
Schieberegister....

Schieben geht in einem FPGA ruckzuck, ein 16 Bit breiter 100:1 Mux 
(16*100=1600) braucht da schon signifikant länger. Wahrscheinlich zu 
lang, aber das solltest du in der Timing-Analyse sehen. Zumindest sollte 
dir eine Zahl ausgegeben werden, wie schnell das Design überhaupt 
getaktet werden kann.

[Chris (Gast)]

danke für den tipp!

nun ich bin ja noch beim lernen.
das problem hab ich übrigens gelöst, es gab ein paar verzögerungen beim 
setzen der variablen...