Beschreibung eines Srams Fehler in VHDL-Code?

[Mike (Gast)]

Hallo zusammen,

ich schreibe gerade an einem VHDL-Code, der das SRAM auf meinem Altera 
DE2-115 beschreiben soll und später die gespeicherten Daten auf das LCD 
senden soll.

Alles klappt auch soweit, wenn ich einen statischen Buchstaben in das 
Sram einlese, bei einem Satz funktioniert es leider nicht mehr und ich 
weiß nicht, wo der Fehler liegt.

architecture behv of lcd_control is

...

SUBTYPE ascii1 IS STD_LOGIC_VECTOR(7 DOWNTO 0);
TYPE charArray IS array(1 to 27) OF ascii1;

constant satz1: charArray         := (X"48", X"65", X"6c", X"6c", X"6f", X"20", X"57", X"6f", X"72", X"6c", X"72", X"6c", X"64", X"20", X"20", X"20", X"20", X"20", X"20", X"20", X"20", X"20", X"20", X"20", X"20", X"20", X"20" );


...

-- das funktioniert, das Zeichen wird auf den LCD-Screen angezeigt

sram_data(7 downto 0) <=  satz1(3);-- plus 8 bit zahl;

-- **********************************************************************
-- (das funktioniert leider nicht, obwohl der Counter counter_buch hochgezählt wird)

sram_data(7 downto 0) <=  satz1(counter_buch);-- plus 8 bit zahl;

Weiß jemand, warum das mit der variable nicht funktioniert?
Danke an alle hilfreichen Antworten...

LG

Mike

[Klaus (Gast)]

Mike schrieb:
> funktioniert es leider nicht mehr

Mike schrieb:
> warum das mit der variable nicht funktioniert?

Mike schrieb:
> -- (das funktioniert leider nicht,

Das sind alles keine Fehlerbeschreibungen. WAS funktioniert nicht, 
bzw. welches Verhalten beobachtest du stattdessen?


Und wo kommt counter_buch  her? Signalquelle und Deklaration bitte.

[August (Gast)]

bau dir mal ein array mit einer zweier potenz (in diesem fall eine 
erweiterung auf 32 element) und dann ein std logic vector mit 5 bits für 
den zugriff und teste das nochmal.

[Duke Scarring (Gast)]

Mike schrieb:
> ich schreibe gerade an einem VHDL-Code, der das SRAM auf meinem Altera
> DE2-115 beschreiben soll und später die gespeicherten Daten auf das LCD
> senden soll.
Hast Du auch eine Testbench dazu?

Duke

[Mike (Gast)]

Sorry, meine Fehlerbeschreibung war wirklich etwas ungenau. Hier ein 
Auszug meines Codes, habe die problematische Stelle mit einem Kommentar 
versehen.

Ziel meines Codes: Einlesen von verschiedenen Buchstaben in das SRAM und 
im 2. Schritt auslesen und auf dem LCD anzeigen.

------------------------------------------------------------------- 
--                        ASCII HEX TABLE
--  Hex            Low Hex Digit
-- Value  0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
------\----------------------------------------------------------------
--H  2 |  SP  !   "   #   $   %   &   '   (   )   *   +   ,   -   .   /
--i  3 |  0   1   2   3   4   5   6   7   8   9   :   ;   <   =   >   ?
--g  4 |  @   A   B   C   D   E   F   G   H   I   J   K   L   M   N   O
--h  5 |  P   Q   R   S   T   U   V   W   X   Y   Z   [   \   ]   ^   _
--   6 |  `   a   b   c   d   e   f   g   h   i   j   k   l   m   n   o
--   7 |  p   q   r   s   t   u   v   w   x   y   z   {   |   }   ~ DEL
-----------------------------------------------------------------------

LIBRARY IEEE;
USE  IEEE.STD_LOGIC_1164.all;
USE  IEEE.STD_LOGIC_ARITH.all;
USE  IEEE.STD_LOGIC_UNSIGNED.all;


entity lcd_control is
  port
  (
    trigger, sw_an, reset, clk   : in  std_logic;
    ascii                     : in  std_logic_vector(7 downto 0);
    lcd_rs, lcd_e, lcd_rw       : out std_logic;
    lcd_data                 : out std_logic_vector(7 downto 0);
    led_test1                   : out std_logic := '0';
    lcd_an                      : out std_logic;
    
    sram_adress             : out std_logic_vector(19 downto 0);
    sram_data             : inout std_logic_vector(15 downto 0);
    sram_chip_enable         : out std_logic;
    sram_write_enable_input     : out std_logic;
    sram_output_enable_input    : out std_logic;
    sram_lower_byte             : out std_logic;
    sram_upper_byte             : out std_logic;
    sram_power                  : out std_logic; 
    sram_nc                     : out std_logic
    
    );
end lcd_control;

architecture behv of lcd_control is

type state_type is (RESET1, RESET2, RESET3, 
                    DROP_E, HOLD,
                    FUNC_SET, DISP_ON, DISP_CLEAR, MODE_SET,
                    WAIT_CHAR, DISP_CLEAR_WAIT,
                    WAIT_TRIGGER_RESET,
                    CHK_CNT, LINE2, HOME);
                    
type state_type_sram is ( SET_ADRESS, SET_DATA);
signal state_ram  : state_type_sram := SET_ADRESS;
signal state_ram_next : state_type_sram;

signal state, next_command, satz_1, satz_2, satz_3 : state_type;
signal char_cnt                   : std_logic_vector(5 downto 0);
signal counter_buch               : integer range 1 to 99 := 1;
signal wait_cnt, pause, pause2    : std_logic_vector(24 downto 0);
signal ascii_sig                  : std_logic_vector(7 downto 0);
signal satz1ende              : std_logic := '1';

signal schreibeprozess_ende       : std_logic :='0';
signal sram_adress_counter       : std_logic_vector(19 downto 0) := "00000000000000000001";
signal up_or_low             : std_logic;
signal esgehtlos                  : std_logic;


SUBTYPE ascii1 IS STD_LOGIC_VECTOR(7 DOWNTO 0);
TYPE charArray IS array(1 to 27) OF ascii1;
constant satz1: charArray         := (X"48", X"65", X"6c", X"6c", X"6f", X"20", X"57", X"6f", X"72", X"6c", X"72", X"6c", X"64", X"20", X"20", X"20", X"20", X"20", X"20", X"20", X"20", X"20", X"20", X"20", X"20", X"20", X"20" );
signal leerzeichen : std_logic_vector(7 DOWNTO 0) := "00000000";  
  
begin
   lcd_rw<='0';
  
  process   
  begin
  wait until rising_edge(clk);
  
  if schreibeprozess_ende= '0' then -- Beginn des Scheibeprozesses auf das SRAM
    
    if counter_buch < 28 then

        case state_ram is
        
          when SET_ADRESS =>
      
            sram_adress<= sram_adress_counter;
            
            sram_write_enable_input<= '1';
            sram_chip_enable<= '0';
            sram_output_enable_input<='0';
            sram_data(7 downto 0) <=  satz1(counter_buch); 

-- HIER IST DAS PROBLEM. BEI DER ZUWEISUNG "<= SATZ1(3)" SCHREIBT ER DEN 3 BUCHSTABEn VON SATZ1 IN DEN SPEICHER, DAS ZEICHEN WIR AUCH ERFOLGREICH BEIM AUSLESEN AUF DAS LCD GESCHRIEBEN
-- BEI SATZ1(COUNTER_BUCH) WERDEN NUR LEERZEICHEN IN DEN SPEICHER GESCHRIEBEN UND AUF DEM LCD ANGEZEIGT, OBWOHL DER COUNTER LAUT MODELSIM HOCHGEZAEHLT WIRD.
 
            sram_data(15 downto 8) <= leerzeichen(7 downto 0);
            sram_lower_byte<='1';
            sram_upper_byte<='1';
            

            if wait_cnt < X"2710" then      
              wait_cnt <= wait_cnt +1;
              state_ram <= SET_ADRESS;
            else
              wait_cnt <= "0000000000000000000000000";
              counter_buch<= counter_buch+1;
              sram_adress_counter<= sram_adress_counter + 1; 
              state_ram <= SET_DATA;
                             -- wait counter reset
            end if;
                
                
          when SET_DATA =>
      
            sram_write_enable_input<= '0';
            sram_lower_byte<='0';
            sram_upper_byte<='0';
            
            if wait_cnt < X"2710" then      -- warten für 10000 Cycle, 200 ms 
              wait_cnt <= wait_cnt +1;
              state_ram <= SET_DATA;
            else
              wait_cnt <= "0000000000000000000000000";

              state_ram <= SET_ADRESS;
                             -- wait counter reset
            end if;
            
          end case;
 
    else

--- Beginn des Ausleseprozesses und weiterleitung der Daten an das LCD...

[Mike (Gast)]

@ August:

Was genau soll das in dem Falle bringen? Vielleicht erklärst du mir 
deinen Vorschlag noch ein wenig genauer, denn ich möchte doch ein 
8Bit-Zeichen einlesen und kein 5 Bit...

@Duke,

Sorry Duke, keine Testbench vorhanden...


Aber rein theoretisch sollte doch eine Variabel in dem Array in einer 
Signalzuweisung funktionieren, oder?

LG

Mike...

[Pako (Gast)]

Mike schrieb:
> -- BEI SATZ1(COUNTER_BUCH) WERDEN NUR LEERZEICHEN IN DEN SPEICHER GESCHRIEBEN 
UND AUF DEM LCD ANGEZEIGT, OBWOHL DER COUNTER LAUT MODELSIM HOCHGEZAEHLT WIRD.

Meinst Du mit "Leerzeichen" x"00" oder x"20"?

[Mike (Gast)]

das weiß ich nicht genau, es wir halt nur Leerzeichen auf dem LCD 
angezeigt. Wenn ich dem SRAm ein statisches X"48" für alle 
Speicherplätze zuweise, dann wird dieses Zeichen beim Ausleseprozess 
auch vom LCD angezeigt...

[Duke Scarring (Gast)]

Mike schrieb:
> Sorry Duke, keine Testbench vorhanden...
Sehr schade. Das ist wie Autofahren ohne Airbag und ohne 
Sicherheitsgurt.

Mit Testbench kann man so ein Problem leicht im Simulator 
nachvollziehen.
Ich empfehle Dir dringend Dich dem Thema Simulation zu widmen.

Duke

[Lupensucher (Gast)]

signal counter_buch               : integer range 1 to 99 := 1;

die range für den counter ist größer als das rom-array? (1 ... 27) was 
dieser counter addressiert. daren könnte die synthese scheitern da die 
bitvektoren unterschiedliche breite haben, besser beides auf 0 .. 26 
schreiben. Noch besser könnte 0 ... 31 sein.

Schau mal im synthesereport, was das synthesetool an diese Stelle sagt

MfG,

[O_- (Gast)]

Mike schrieb:
> @ August:
>
> Was genau soll das in dem Falle bringen? Vielleicht erklärst du mir
> deinen Vorschlag noch ein wenig genauer, denn ich möchte doch ein
> 8Bit-Zeichen einlesen und kein 5 Bit...
>

die 5bit sind für die adressierung von 2^5 = 32 elementen

signal address : std_ulogic_vector(4 downto 0);
signal my_array : t_array_type(0 to 31);

-- read 
output_data <= my_array(to_integer(unsigned(my_addr)));

-- write
my_array(to_integer(unsigned(my_addr))) <= input_data;

solltest du weniger als 32 elemente haben, dann musste du die eben mit 
platzhaltern füllen. sollte dein adresszeiger mehr als 5 bit haben (zB 
wenn du den irgendwo anders zum zählen benutzt, dann musst du beim 
read/write eben mit einer range arbeiten.

[SuperWilly (Gast)]

>> Sorry Duke, keine Testbench vorhanden...
>Sehr schade. Das ist wie Autofahren ohne Airbag und ohne
>Sicherheitsgurt.

Das ist sogar Autofahren mit geschlossenen Augen -


VG, SuperWilly

[Lupensucher (Gast)]

ich seh grad August als weiterem leser ist das selbe aufgefallen. Sollte
es wirklich ein problem mit synthesegerechten Code sei hilft dir eine 
simu nicht weiter, ein Blick in den Synthesereport dagegen schon. Bitte 
mal als File-anhängsel hier posten.

[Pako (Gast)]

Mike schrieb:
> das weiß ich nicht genau, es wir halt nur Leerzeichen auf dem LCD
> angezeigt. Wenn ich dem SRAm ein statisches X"48" für alle
> Speicherplätze zuweise, dann wird dieses Zeichen beim Ausleseprozess
> auch vom LCD angezeigt...

Das Problem könnte ja auch gaaanz wo anders liegen, z.B. bei Timing 
Constrains des LCDs, aber das siehst Du nicht, wenn die Daten statisch 
anliegen (immer nur x"48"). Erst dann, wenn sie sich ändern, kommt 
nichts sinnvolles mehr bei raus.

[Mike (Gast)]

Leider hat das Anpassen der Variabel Counter_buch nichts gebracht, aber 
ich weiß nun, wo mein wirkliches Problem liegt bzw. warum nur 
Leerzeichen ausgegeben werden.

Im 2. Schritt versuche ich die Daten wieder auszulesen, was aber nicht 
klappt, weil ich im Leseprozess des SRAMS und beim Schreibprozess beim 
LCD folgendes deklarieren:


lcd_data <= sram_data(7 downto 0);

Da sram_data(7 downto 0) den Wert das letzte Element meines Arrays (in 
dem Fall ein x"20") nach dem Schreibeprozess in das SRAM noch 
beinhaltet, wird dieses Element dann Zeilenweise auf das Display 
gedruckt.

Daher 2 mögliche Fehlerquellen: Es werden keine Daten ins SRAM 
geschrieben, oder der Ausleseprozess aus dem SRAM funzt nicht (was ich 
viel eher vermute).

Habe mal den kompletten Quellcode und das Datenblatt des SRAMs mal 
hinzugefügt und bei der Programmierung den READ CYCLE #1 auf Seite 11 
genommen.

@ O_-
tnx, hab ich nun verstanden, wird implementiert und getestet...

P.s.: Ich weiß, stylistisch ist der Code nicht vom feinsten....

------------------------------------------------------------------- 
--                        ASCII HEX TABLE
--  Hex            Low Hex Digit
-- Value  0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
------\----------------------------------------------------------------
--H  2 |  SP  !   "   #   $   %   &   '   (   )   *   +   ,   -   .   /
--i  3 |  0   1   2   3   4   5   6   7   8   9   :   ;   <   =   >   ?
--g  4 |  @   A   B   C   D   E   F   G   H   I   J   K   L   M   N   O
--h  5 |  P   Q   R   S   T   U   V   W   X   Y   Z   [   \   ]   ^   _
--   6 |  `   a   b   c   d   e   f   g   h   i   j   k   l   m   n   o
--   7 |  p   q   r   s   t   u   v   w   x   y   z   {   |   }   ~ DEL
-----------------------------------------------------------------------

LIBRARY IEEE;
USE  IEEE.STD_LOGIC_1164.all;
USE  IEEE.STD_LOGIC_ARITH.all;
USE  IEEE.STD_LOGIC_UNSIGNED.all;


entity lcd_control is
  port
  (
    trigger, sw_an, reset, clk   : in  std_logic;
    ascii                     : in  std_logic_vector(7 downto 0);
    lcd_rs, lcd_e, lcd_rw       : out std_logic;
    lcd_data                 : out std_logic_vector(7 downto 0);
    led_test1                   : out std_logic := '0';
    lcd_an                      : out std_logic;
    
    sram_adress             : out std_logic_vector(19 downto 0);
    sram_data             : inout std_logic_vector(15 downto 0);
    sram_chip_enable         : out std_logic;
    sram_write_enable_input     : out std_logic;
    sram_output_enable_input    : out std_logic;
    sram_lower_byte             : out std_logic;
    sram_upper_byte             : out std_logic;
    sram_power                  : out std_logic; 
    sram_nc                     : out std_logic
    
    );
end lcd_control;

architecture behv of lcd_control is

type state_type is (RESET1, RESET2, RESET3, 
                    DROP_E, HOLD,
                    FUNC_SET, DISP_ON, DISP_CLEAR, MODE_SET,
                    WAIT_CHAR, DISP_CLEAR_WAIT,
                    WAIT_TRIGGER_RESET,
                    CHK_CNT, LINE2, HOME);
                    
type state_type_sram is ( SET_ADRESS, SET_DATA);
signal state_ram  : state_type_sram := SET_ADRESS;
signal state_ram_next : state_type_sram;

                    
                    
signal state, next_command, satz_1, satz_2, satz_3 : state_type;
signal char_cnt                   : std_logic_vector(5 downto 0);
signal counter_buch               : integer range 0 to 31 := 0;
signal wait_cnt, pause, pause2    : std_logic_vector(24 downto 0);
signal ascii_sig                  : std_logic_vector(7 downto 0);
signal satz1ende              : std_logic := '1';

signal schreibeprozess_ende       : std_logic :='0';
signal sram_adress_counter       : std_logic_vector(19 downto 0) := "00000000000000000001";
signal up_or_low             : std_logic;
signal esgehtlos                  : std_logic;


SUBTYPE ascii1 IS STD_LOGIC_VECTOR(7 DOWNTO 0);
TYPE charArray IS array(0 to 31) OF ascii1;
constant satz1: charArray         := (X"48", X"65", X"6c", X"6c", X"6f", X"20", X"57", X"6f", X"72", X"6c", X"72", X"6c", X"64", X"20", X"20", X"20", X"20", X"20", X"20", X"20", X"20", X"20", X"20", X"20", X"20", X"20", X"20", X"20", X"20",X"20",X"20", X"20" );
signal leerzeichen : std_logic_vector(7 DOWNTO 0) := "00000000";  
  
begin
   lcd_rw<='0';
  
   process   -- Das ist die State Machine f?rs LCD
  begin
  wait until rising_edge(clk);
  
  if schreibeprozess_ende= '0' then
    
    if counter_buch < 28 then

        case state_ram is
        
          when SET_ADRESS =>
      
            sram_adress<= sram_adress_counter;
            
            sram_write_enable_input<= '1';
            sram_chip_enable<= '0';
            sram_output_enable_input<='0';
            sram_data(7 downto 0) <=  satz1(counter_buch);-- plus 8 bit zahl;
            sram_data(15 downto 8) <= leerzeichen(7 downto 0);
            sram_lower_byte<='1';
            sram_upper_byte<='1';
            

            if wait_cnt < X"2710" then      -- warten für 10000 Cycle, 200 ms 
              wait_cnt <= wait_cnt +1;
              state_ram <= SET_ADRESS;
            else
              wait_cnt <= "0000000000000000000000000";
              counter_buch<= counter_buch+1;
              sram_adress_counter<= sram_adress_counter + 1; 
              state_ram <= SET_DATA;
                             -- wait counter reset
            end if;
                
                
          when SET_DATA =>
      
            sram_write_enable_input<= '0';
            sram_lower_byte<='0';
            sram_upper_byte<='0';
            
            if wait_cnt < X"2710" then      -- warten für 10000 Cycle, 200 ms 
              wait_cnt <= wait_cnt +1;
              state_ram <= SET_DATA;
            else
              wait_cnt <= "0000000000000000000000000";

              state_ram <= SET_ADRESS;
                             -- wait counter reset
            end if;
            
          end case;
 
    else
    schreibeprozess_ende <= '1';
    sram_adress_counter<= "00000000000000000000";
    counter_buch<= 1;
  end if;  
  
  else      
      if sw_an = '1' then
        lcd_an<='1';
       else
        lcd_an<='0';
       end if;    
          
      if (reset = '0') then
      
        state <= RESET1;
        next_command <= RESET2;              
        wait_cnt <= "0000000000000000000000000";
        lcd_data <= X"38"; -- 111000 - 8 bit - 2 Zeilen
        char_cnt <= "000000";
        lcd_e<='0';
        
      elsif reset = '1' then
        state <= RESET1;

        case state is
        
          when RESET1 =>                  -- erstes Kommando an LCD, mind. 16ms nach Einschalten
          
            lcd_rs <= '0';
            sram_write_enable_input<='1';
            lcd_data <= X"38"; -- 111000 - 8 bit - 2 Zeilen
            lcd_e <= '0';
            led_test1<='1';
            wait_cnt <= "0000000000000000000000000";
            pause <= "0000000000000000000000000";

            
            if wait_cnt < X"F4240" then      -- warten für 10000 Cycle, 200 ms 
              wait_cnt <= wait_cnt +1;
              state <= RESET1;
             else
              state <= DROP_E;            -- Kommando an LCD
              next_command <= RESET2;
              wait_cnt <= "0000000000000000000000000";            -- wait counter reset
            end if;
            
          when RESET2 =>
           
            lcd_rs <= '0';
            lcd_data <= X"38";
            lcd_e <= '0';
            
            if wait_cnt < X"F4240" then      -- Warteschleife für 200 ms --989680 --F4240
              wait_cnt <= wait_cnt +1;
              state <= RESET2;
            else
              state <= DROP_E;            
              next_command <= RESET3;
              wait_cnt <= "0000000000000000000000000";          
            end if;
            
          when RESET3 =>
          
            lcd_rs <= '0';
            lcd_data <= X"38";
            lcd_e <= '0';
            
            if wait_cnt < X"F4240" then      -- Warteschleife für 200 ms
              wait_cnt <= wait_cnt +1;
              state <= RESET3;
            else
              state <= DROP_E;            
              next_command <= FUNC_SET;
              wait_cnt <= "0000000000000000000000000";          
            end if;
            
          when FUNC_SET =>
            lcd_rs <= '0';
            lcd_data <= X"38";
            lcd_e <= '0';
            
            if wait_cnt < X"F4240" then      -- Warteschleife für 200 ms
              wait_cnt <= wait_cnt +1;
              state <= FUNC_SET;
            else
              state <= DROP_E;            
              next_command <= DISP_ON;
              wait_cnt <= "0000000000000000000000000";          
            end if;      
      
            
          when DISP_ON =>
            lcd_rs <= '0';
            lcd_data <= X"0F";
            lcd_e <= '0';
            
            if wait_cnt < X"F4240" then      -- Warteschleife für 200 ms
              wait_cnt <= wait_cnt +1;
              state <= DISP_ON;
            else
              state <= DROP_E;            
              next_command <= DISP_CLEAR;
              wait_cnt <= "0000000000000000000000000";          
            end if;  
            
            
            
          when DISP_CLEAR =>
          
            lcd_rs <= '0';
            lcd_data <= X"01";
            lcd_e <= '0';
            wait_cnt <= "0000000000000000000000000";
            state <= DROP_E;            
            next_command <= DISP_CLEAR_WAIT;
            

          when DISP_CLEAR_WAIT =>
            if wait_cnt < X"F4240" then      -- clk period 1msec, warte 3 msec
              wait_cnt <= wait_cnt +1;
              state <= DISP_CLEAR_WAIT;
            else
              state <= MODE_SET;            -- Kommando an LCD
              wait_cnt <= "0000000000000000000000000";          
            end if;
            
          when MODE_SET =>
            lcd_rs <= '0';
            lcd_data <= X"06";
            lcd_e <= '0';
          --  counter_buch<=1;
            char_cnt<="000000";
            
            if wait_cnt < X"F4240" then      -- Warteschleife für 200 ms
              wait_cnt <= wait_cnt +1;
              state <= MODE_SET;
            else
              state <= DROP_E;            
              next_command <= WAIT_CHAR;
              wait_cnt <= "0000000000000000000000000";  
              esgehtlos<='1';
        
            end if;  
            
    ---------------- Initialisierung beendet, Arbeitsloop -------------------------------------------

    --   WAIT_CHAR -> DROP_E -> HOLD -> WAIT_TRIGGER_RESET -> CHK_CNT -> LINE2 -> DROP_E -> HOLD -> |
    --                                                                |                              |
    --        ^                                                       -> HOME  -> DROP_E -> HOLD -> |
    --        |                                                       |                              |
    --        |                                                       v                             v
    --        |----------------------------------------<<-------------------------------------------|

    -------------------------------------------------------------------------------------------------
            
            when WAIT_CHAR =>
          
            if pause < X"F4240" then      -- warten für 10000 Cycle, 200 ms 
              pause <= pause +1;
              state <= WAIT_CHAR;
              
              elsif char_cnt < X"1B" then
              
              pause <= "0000000000000000000000000";            -- wait counter reset
              
              lcd_rs<='1';
               lcd_data <= sram_data(7 downto 0);
            
              sram_chip_enable<='0';
                sram_output_enable_input<='0';
              sram_lower_byte<='0';
                 sram_upper_byte<='0';
              
              
              
              char_cnt <= char_cnt +1;
              counter_buch<= counter_buch+1;
              
              lcd_e <= '0';
              state <= DROP_E;
              next_command <= WAIT_TRIGGER_RESET;
              
              
    --          elsif pause2 < X"1C9C380" then      -- warten für 10000 Cycle, 200 ms 
      --         pause2 <= pause2 +1;
        --       state <= WAIT_CHAR;
  
  
              else
              
            --  counter_buch<=1;
              state <= DROP_E;
              next_command <= DISP_CLEAR;
              char_cnt <= "000000";
            --  pause2<="0000000000000000000000000";


              end if;      
                            
          when WAIT_TRIGGER_RESET =>
            if trigger = '0' then
              state <= WAIT_TRIGGER_RESET;
            else

              state<=DROP_E;
              next_command <= CHK_CNT;
            end if;
            
          when CHK_CNT =>
            if char_cnt = X"11" then
             state <= DROP_E;
             next_command <= LINE2;
             
            elsif char_cnt = X"20" then
              state <= HOME;
            else
              state <= WAIT_CHAR;
            end if;
            
            when LINE2 =>
            lcd_rs <= '0';
            lcd_data <= X"C0";
            lcd_e <= '0';          
            state <= DROP_E;
            next_command <= WAIT_CHAR;
            
          when HOME =>
            lcd_rs <= '0';
            lcd_data <= X"80";  -- Befehl Cursor wieder auf Start setzten
            char_cnt <= "000000";
            lcd_e <= '0';
            state <= DROP_E;
            next_command <= WAIT_CHAR;
                  
          when DROP_E =>  
          
          lcd_e<='1';
           if wait_cnt < X"F4240" then      -- warten für 10000 Cycle, 200 ms 
            wait_cnt <= wait_cnt +1;
            state<=DROP_E;
            
            sram_adress<= "00000000000000100010"; -- <=sram_adress_counter;
            else
            wait_cnt<="0000000000000000000000000";
            
            if esgehtlos = '1' then 
            sram_adress_counter<=sram_adress_counter+1;
            end if;

            state <= HOLD; 
            end if; 

          when HOLD =>
            state <= next_command;
          
        end case;
      end if;
    end if;
  end process;
  

end behv;

[Duke Scarring (Gast)]

Mike schrieb:
> USE  IEEE.STD_LOGIC_ARITH.all;
> USE  IEEE.STD_LOGIC_UNSIGNED.all;
Erstmal ersetzt man die Libs mit der folgenden:

use IEEE.NUMERIC_STD.ALL;

Beitrag "IEEE.STD_LOGIC_ARITH.ALL obsolete"

Zweitens: Mach Dir eine Testbench. Du hast hier ein Display und ein 
SRAM. Das ist evtl. noch überschaubar. Das nächste Projekt dann nicht 
mehr.
Hier ist Deine Testbench noch trivial. Für den Anfang reichen ein paar 
Stimuli.


Lupensucher schrieb:
> Sollte
> es wirklich ein problem mit synthesegerechten Code sei hilft dir eine
> simu nicht weiter,
Ja und wenn es funktionaler Fehler ist, hilft Dir der Sysnthesereport 
auch nicht weiter.
Ich mache 99,9% funktionale Fehler. Bei Dir scheint das ja anders zu 
sein...

So. Los geht's mit der Testbench:

$ vlib work
$ vcom lcd_control.vhd
$ vcom lcd_control_tb.vhd
$ vsim -gui lcd_control_tv
# ** Warning: (vsim-8683) Uninitialized out port /lcd_control_tb/dut/sram_power has no driver.
# ** Warning: (vsim-8683) Uninitialized out port /lcd_control_tb/dut/sram_nc has no driver.
> add wave *
> run 20 ms

Das sieht ma die ganze Zeit was am SRAM wackeln, aber nicht am Display.
Kurzer Blick in den Code. "trigger" is offenbar low aktiv.
Um mir nicht selber ins Knie zu schiessen, haben alle meine low aktiven 
Signale ein _n als Suffix --> trigger_n

Trotzdem scheint da nix weiter loszugehen...

Ah, reset ist offenbar auch low aktiv...

So und wenn man jetz noch länger als 200 ms simuliert sieht man auch 
was:

Nämlich hübsche Glitches auf der enable-Leitung vom LCD...

Ergo, solange die Simulation nicht ungefähr so aussieht wie die 
Diagramme im Datenblatt, braucht man gar nicht erst auf der Hardware 
anzufangen.

Duke

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

Mike schrieb:
> Habe mal den kompletten Quellcode und das Datenblatt des SRAMs mal
> hinzugefügt
Und dann ellenlange, ewige Scrollerei, statt das zu tun, was im 
Eingabefeld empfohlen wird:

Antwort schreiben
Wichtige Regeln - erst lesen, dann posten!
  * Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Duke Scarring schrieb:
> So und wenn man jetz noch länger als 200 ms simuliert sieht man auch
> was:
> Nämlich hübsche Glitches auf der enable-Leitung vom LCD...
Böse Sache...

Mike schrieb:
> if (reset = '0') then
>       ...
>  elsif reset = '1' then
>       ...
Was sollte reset denn sonst noch werden können ausser '0' und '1'?

Dieser reset ist 1. unnötig und hat 2. seinen Namen nicht verdient, 
weil ja sogar schreibeprozess_ende eine höhere Priorität hat...   :-o

> if wait_cnt < X"F4240" then      -- Warteschleife für 200 ms
Warum verwendest du nicht einen Integer für wait_cnt und lässt dir den 
Vergleichswert vom Synthesizer berechnen?

constant onems : integer := 50000; -- Anzahl Takte für 1 Millisekunde bei 50MHz (auch das könnte man ausrechnen lassen)
  :
  :
  if wait_cnt < (200 * onems) then 
     :
     wait_cnt <= 0;
  :

Und wie gesagt: nimm die numeric_std.
http://www.lothar-miller.de/s9y/archives/14-Numeric_Std.html

Und wenn dir das zu umständlich ist, dann schreib wenigstens:

  wait_cnt <= (others =>'0');

[Lupensucher (Gast)]

Duke Scarring schrieb:
>Lupensucher schrieb:
>> Sollte
>> es wirklich ein problem mit synthesegerechten Code sei hilft dir eine
>> simu nicht weiter,
>Ja und wenn es funktionaler Fehler ist, hilft Dir der Sysnthesereport
>auch nicht weiter.
>Ich mache 99,9% funktionale Fehler. Bei Dir scheint das ja anders zu
>sein...

Was willst Du? Mit verhaltens-Simu kann mensch nicht alle Fehler 
erfassen, den hier genannten bspw. nicht. Ist auch nicht der einzige im 
Code.  Und gerade bei Anfängern ist mindestens ein Synthesefehler im 
Code. Dazu kommt meist ein weiterer im UCF. Und dann noch zwei in der 
Beschaltung.

Ich bin ja nicht gegen behavorioul Simulation, aber manche Fehler findet 
man auch durch konzentriertes Code-Review. Und  systematische 
Fehlersuche: Was sind die möglichen Fehlerquellen? welches Vorgehen ist 
bei welcher Fehlerquelle angetan? Wie erreiche ich 100% Testabdeckung? 
Wie kann ich die Simulation erweitern um auch synthesefehler zu 
erkennen. Und wenn man den fehler gefunden hat, wie und wo ändere ich 
den Code um den Fehler rauszukicken?

Merke: Simu ist täglich Brot aber kein Allheilmittel.

MfG

[Robert K. (Firma: Medizintechnik) (robident)]

Duke Scarring schrieb:
>> Sorry Duke, keine Testbench vorhanden...
>
> Sehr schade. Das ist wie Autofahren ohne Airbag und ohne
>
> Sicherheitsgurt.

eher wie Fahren ohne Navi, Plan oder Routenkarte.

[Mike (Gast)]

Hallo zusammen,


nach ein paar Änderungen bin ich nun weiter im Code und habe ein paar 
konkrete Fragen an euch:

1. Wenn ich meine Librarys mit der "use IEEE.NUMERIC_STD.ALL;" ersetze, 
dann bekomme  ich bei der Codezeile "wait_cnt <= wait_cnt +1;" folgende 
Fehlermeldung:

Error (10327): VHDL error at lcd_control_e_invers.vhd(101): can't 
determine definition of operator ""+"" -- found 0 possible definitions

KAnn mir das einer genauer erklären?

2.

In meinem Code habe ich 2 Schritte. Schritt 1 ist das Schreiben meines 
Arrays ins SRAM und Schritt 2 ist das Auslesen des SRAMS und das Senden 
des Inhalts an das LCD.

Ich habe nun den ersten Schritt herausgenommen d.h. ich definiere meine 
16Bit Variabel "sram_data" als IN und lese die auf dem SRAM vorhanden 
Daten aus. Mein LCD gibt nun lauter schwarzer Zeichen aus, was ja einem 
x"FF" entspricht. Ich denke nun mal, dass das Auslesen des SRAMS 
funktioniert?!

Wenn ich aber "sram_data" als "INOUT" definiere, geht es wieder nicht 
bzw. beinhaltet die Variabel "sram_data" immer noch das letzte Zeichen 
meines Arrays im Einleseprozesses in Schritt 1.


Habe nun den geänderten Sourcecode als text-datei angehängt.


*****************************
Kommentare zu den Kommentaren:

@ Pako:

Das dirkekte Auslesen des Arrays über das LCD funktioniert einwandfrei. 
Denke also nicht, dass es Timing-Probleme
beim LCD-Code gibt.

@ Duke:
Vielen Dank fürs Simulieren und das Thema Testbench muss ich auch bald 
angehen. Ansonsten wird das in Zukufkt sehr schwierig...
Zitat: Das sieht ma die ganze Zeit was am SRAM wackeln, aber nicht am 
Display.

Was genau wackelt da am SRAM? Hab da deinen Punkt nicht ganz verstanden.
Enable-Signal ist gefixt, war ein Fehler im Source-Code... Falsche 1 am 
falschen Ort..

@ Lothar:
Jep, wird in Zukuft nicht mehr gepostet.

Reset kann raus, habe ich nur beim Zusammenfügen des Codes vergessen 
herauszunehmen.

Wegen den numeric_std siehe meine Frage etwas weiter oben..

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

Mike schrieb:
>       code.txt
Und jetzt wäre es toll, wenn du statt eines *.txt Files ein *.vhdl File 
posten würdest. Von wegen Syntax-Highlighting und so....

Mike schrieb:
> 1. Wenn ich meine Librarys mit der "use IEEE.NUMERIC_STD.ALL;" ersetze,
> dann bekomme  ich bei der Codezeile "wait_cnt <= wait_cnt +1;" folgende
> Fehlermeldung:
> Error (10327): VHDL error at lcd_control_e_invers.vhd(101): can't
> determine definition of operator ""+"" -- found 0 possible definitions

   signal wait_cnt    : std_logic_vector(24 downto 0);
       :
       wait_cnt <= wait_cnt +1;

Der Synthesizer findet in der numeric_std keine Rechenregel zur Addition 
eines Integers (die Zahl 1) und eines std_logic_vector (wait_cnt).

> KAnn mir das einer genauer erklären?
Ja. Mit uneingeschränkten Vektoren rechnet man nicht!
In die Praxis umgesetzt: man rechnet nicht mit std_logic_vector, sondern 
mit den Datentypen unsigned, signed oder integer.

Sieh dir einfach den Link da noch mal genauer an...
Lothar Miller schrieb:
> Und wie gesagt: nimm die numeric_std.
> http://www.lothar-miller.de/s9y/archives/14-Numeric_Std.html

Zum Hintergrund:
Beitrag "IEEE.STD_LOGIC_ARITH.ALL obsolete"

[Mike (Gast)]

@lothar, danke für die Erklärung...

Ich habe nun mal auch die Warnungen von Quartus zu meinem Code 
hinzugefügt. Nach ein paar Recherchen sieht es wohl aus, als wenn der 
Fehler bei der Handhabung meines INOUT Port liegt.

Vielleicht kann ja jemand über die Warnungen schauen?! Vielleicht kann 
er das Problem durch Expertise und Erfahrung schneller erkennen als 
ich...

Vielen, vielen Dank an alle hilfreichen Antworten...

LG

Mike

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

Mike schrieb:
> Nach ein paar Recherchen sieht es wohl aus, als wenn der
> Fehler bei der Handhabung meines INOUT Port liegt.
>>> Pin sram_data[0] has a permanently enabled output enable
Ja, nun, der Port wird niemals hochohmig, und kann deshalb auch niemals 
etas einlesen. Hier:
   lcd_data <= sram_data(7 downto 0);
Wird also nur genau das zurückgelesen, was irgendwann mal hier auf den 
Porttreiber geschrieben wurde:
   sram_data(7 downto 0) <=  satz1(counter_buch);
Und bestenfalls gibt es noch einen Buskonflikt, weil das FPGA den Bus 
nie freigibt (mit others => 'Z') und gleichzeitig das externe RAM auf 
den Bus losgelassen wird:
   sram_output_enable_input <= '0';

Bevor du das RAM auf den Bus lässt, musst du die Ausgangstreiber im FPGA 
abschalten. So etwa:

   sram_data(7 downto 0) <= deinedatenzumram when sram_output_enable_input='1' else (others=>'Z');

BTW: das hier ist sehr, sehr unglücklich
   sram_output_enable_input <= '0';
denn ein normaler Mensch denkt, irgenwas sei aktiv oder ein oder 
selektiert, wenn eine 1 da steht.

[Mike (Gast)]

Genau DAS ist mein Problem. Das LCD gibt das letzte Zeichen raus, was 
ich eingelesen habe.

Das heißt, sram_data muss hochohmig sein, damit ich etwas vom Sram lesen 
kann?

Wenn du es sagst, wird das schon richtig sein, aber dennoch die Frage: 
Wie kann das Sinn machen, zumal ja über diese 8-Bit-Leitungen die Daten 
eingelesen werden sollen...

Wegen:    sram_output_enable_input <= '0';

Das heißt, ich sollte low_active_Signale besser als not definieren, um 
spätere Missverständnisse zu vermeiden?

Vielen Dank, endlich komm ich der Sache näher...

[Duke Scarring (Gast)]

Mike schrieb:
> Was genau wackelt da am SRAM? Hab da deinen Punkt nicht ganz verstanden.
> Enable-Signal ist gefixt, war ein Fehler im Source-Code... Falsche 1 am
> falschen Ort..

Mike schrieb:
> Genau DAS ist mein Problem. Das LCD gibt das letzte Zeichen raus, was
> ich eingelesen habe.

Eigne Dir das Simulieren an!
Dein SRAM wird Zeichen für Zeichen ausgelesen, da ist Dein Display noch 
gar nicht mit dem Reset fertig...

Duke

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

Mike schrieb:
> Wenn du es sagst, wird das schon richtig sein
So ein wenig Fatalismus liebe ich... ;)

> Das heißt, sram_data muss hochohmig sein, damit ich etwas vom Sram lesen
> kann?
Ja. Es darf nur 1 Teilnehmer auf dem Datenbus aktiv sein. Alles andere 
nennt man Buskollision. Und Kollisionen haben schon im Volksmund nicht 
umsonst einen negativen Touch...

[Mike (Gast)]

@Godfather of VDHL, eine (hoffendlich) letzte Frage habe ich zu dem 
Thema "bidirectional bus" ;-)

Ich habe diesen Code bei Altera auf der Seite gefunden, wo über 2 DFF (a 
und b) der Input-Wert und der Out-Wert als Buffer zwischen gespeichert 
werden.

Warum wird der Wert nicht direkt über "inp" oder "outp" abgegriffen, 
sondern der "Umweg" über "a" und "b"?

LIBRARY ieee;
USE ieee.std_logic_1164.ALL;

ENTITY bidir IS
    PORT(
        bidir   : INOUT STD_LOGIC_VECTOR (7 DOWNTO 0);
        oe, clk : IN STD_LOGIC;
        inp     : IN STD_LOGIC_VECTOR (7 DOWNTO 0);
        outp    : OUT STD_LOGIC_VECTOR (7 DOWNTO 0));
END bidir;

ARCHITECTURE maxpld OF bidir IS
SIGNAL  a  : STD_LOGIC_VECTOR (7 DOWNTO 0);  -- DFF that stores 
                                             -- value from input.
SIGNAL  b  : STD_LOGIC_VECTOR (7 DOWNTO 0);  -- DFF that stores 
BEGIN                                        -- feedback value.
    PROCESS(clk)
    BEGIN
    IF clk = '1' AND clk'EVENT THEN  -- Creates the flipflops
        a <= inp;                    
        outp <= b;                  
        END IF;
    END PROCESS;    
    PROCESS (oe, bidir)          -- Behavioral representation 
        BEGIN                    -- of tri-states.
        IF( oe = '0') THEN
            bidir <= "ZZZZZZZZ";
            b <= bidir;
        ELSE
            bidir <= a; 
            b <= bidir;
        END IF;
    END PROCESS;
END maxpld;