HD44780 LCD Probleme - Altera DE2-115

[Mike (Gast)]

Halle zusammen,

ich bin ziemlich neu in VHDL und FPGA und habe die Tage versucht meinen 
ersten FPGA zu programmieren. Leider hat die Freude nicht lange 
angehalten, denn irgendwie kann ich das Ding einfach nicht ansteuern.

Ich habe mit Modelsim eine Simulation gestartet (alles ok...), alle 
Settings für die IO-Pins gecheckt und das Board (DE2-115) via Control 
Panel auf Funktionen getestet. Alles vollkommen in Ordnung, in der 
Simulation werden auch alle Bits richtig gesetzt...

Es ist ein Code (denn ich hier bei mc gefunden habe), denn ich ein wenig 
modifiziert habe.

Die Funktion des Programms:
- Über 7 Switchs werden die binären Codes für die Zeichen definiert, die 
auf dem LCD angezeigt werden sollen.

Nachdem ich das Programm auf den FPGA übertragen habe, kommt nur die 
Standart-Anzeige des LCDs. Er reagiert kein bisschen auf Veränderungen 
der Switchs...

Habe dem Code einige Kommentare hinzugefügt, damit er für euch schneller 
zu verstehen ist.

Ich bin für jeden noch so kleinen Hinweis sehr dankbar...

------------------------------------------------------------------- 
--                        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,trigger2, 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);
    lcd_an                : out std_logic

    );
end lcd_control;

architecture behv of lcd_control is

type state_type is ( START, START_WAIT, FUNC_SET_WAIT, DISP_ON_WAIT,
                    DROP_E, HOLD,
                    FUNC_SET, DISP_ON, DISP_CLEAR, MODE_SET,
                    WAIT_CHAR, DISP_CLEAR_WAIT,
                    WAIT_TRIGGER_RESET,
                    CHK_CNT, LINE2, HOME);
                    
signal state, next_command : state_type;
signal char_cnt : std_logic_vector(5 downto 0);
signal wait_cnt : std_logic_vector(7 downto 0);
  
begin



    
   process(clk)      
  begin

  if trigger2='1' then      -- a switch to turn the lcd on and off
  lcd_an<='1';  
  lcd_rw<='0';           -- setting the rw permenantly to 1
   else  
  lcd_an<='0';
  end if;
  
  state <= START;

    case state is

      when START =>       
      
        lcd_e <= '1';
        lcd_rs <= '0';
        lcd_data <= X"38";                 -- set the lcd to 8 bit lenght
        wait_cnt<=X"00";
        state <= DROP_E;                   -- function of DROP_E: just sets lcd_e to '1' and state goes to next_command      
        next_command <= START_WAIT;
        
        when START_WAIT =>                 -- waiting for a few msec 
         if wait_cnt < X"10" then       
          wait_cnt <= wait_cnt +1;
          state <= START_WAIT;
        else
          state <= FUNC_SET;            
          wait_cnt <= X"00";          
        end if;
        
        
        
      when FUNC_SET =>
        lcd_e <= '1';
        lcd_rs <= '0';
        lcd_data <= X"38";
        state <= DROP_E;            
        next_command <= FUNC_SET_WAIT;
        

        when FUNC_SET_WAIT =>
         if wait_cnt < X"10" then         
          wait_cnt <= wait_cnt +1;
          state <= FUNC_SET_WAIT;
        else
          state <= DISP_ON;            
          wait_cnt <= X"00";          
        end if;
        
        
        
      when DISP_ON =>
        lcd_e <= '1';
        lcd_rs <= '0';
        lcd_data <= X"0F";                   -- set the lcd to Display on, Cursor is displayed, Blinking enable, 
        state <= DROP_E;            
        next_command <= DISP_ON_WAIT;
        
        
        when DISP_ON_WAIT =>
         if wait_cnt < X"10" then    
          wait_cnt <= wait_cnt +1;
          state <= DISP_ON_WAIT;
        else
          state <= DISP_CLEAR;        
          wait_cnt <= X"00";          
        end if;
        
        
      when DISP_CLEAR =>
      
        lcd_e <= '1';
        lcd_rs <= '0';
        lcd_data <= X"01";                -- command: clear the display 
        wait_cnt <= X"00";
        state <= DROP_E;            
        next_command <= DISP_CLEAR_WAIT;
        
      
        
      when DISP_CLEAR_WAIT =>
      
         if wait_cnt < X"10" then    
          wait_cnt <= wait_cnt +1;
          state <= DISP_CLEAR_WAIT;
        else
          state <= MODE_SET;            
          wait_cnt <= X"00";          
        end if;
        
      when MODE_SET =>
        lcd_e <= '1';
        lcd_rs <= '0';
        lcd_data <= X"06";               -- Cursor moves right, Display shift enabled.
        state <= DROP_E;
        next_command <= WAIT_CHAR;
        
---------------- initialization done, Loop of writing begins -------------------------------------------

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

-------------------------------------------------------------------------------------------------
        
      when WAIT_CHAR =>
        if trigger = '0' then               -- trigger is set to a switch
            
          lcd_e <= '1';
          lcd_rs <= '1';
          lcd_data <= ascii;                -- ascii is defined through 7 switchs
          char_cnt <= char_cnt +1;          -- a counter for the written letters
          state <= DROP_E;
          next_command <= WAIT_TRIGGER_RESET;
        else
          next_command <= WAIT_CHAR;
        end if;
        
      when WAIT_TRIGGER_RESET =>              -- loop, waiting for an change at the switch
        if trigger = '0' then
           state <= WAIT_TRIGGER_RESET;
        else
          state <= CHK_CNT;
        end if;
        
      when CHK_CNT =>                         -- checking if the first line is full of letters, 
        if char_cnt = X"10" then
          state <= LINE2;                
        elsif char_cnt = X"20" then
          state <= HOME;                     -- clears the display 
        else
          state <= WAIT_CHAR;
        end if;
        
        
      when LINE2 =>                            -- starts writing at the secound line
        lcd_e <= '1';
        lcd_rs <= '0';
        lcd_data <= X"C0";                    -- sets the DDRAM-Adress to '1000000'
        state <= DROP_E;
        next_command <= WAIT_CHAR;
        
      when HOME =>
         lcd_e <= '1';
        lcd_rs <= '0';
        lcd_data <= X"80";                    -- sets the DDRAM-adress to '0000000'
        char_cnt <= "000000";
        state <= DROP_E;
        next_command <= WAIT_CHAR;
              
      when DROP_E =>      
        lcd_e <= '1';
        state <= HOLD;
      
      when HOLD =>
        state <= next_command;
      
    end case;

  end process;
  

end behv;

[Duke Scarring (Gast)]

Mike schrieb:
> USE  IEEE.STD_LOGIC_ARITH.all;
> USE  IEEE.STD_LOGIC_UNSIGNED.all;
Siehe: Beitrag "IEEE.STD_LOGIC_ARITH.ALL obsolete"

Mike schrieb:
> Modelsim eine Simulation gestartet
Kannst Du uns auch die Testbench zur Verfügung stellen?
Dann läßt sich das Problem leichter nachvollziehen.

Duke

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

> [QUOTE]...[/QUOTE]
Nimm statt "QOUTE" besser mal "vhdl", dann klappt das mit dem 
Syntax-Higlighting besser. So also (ohne Leerzeichen):
[ vhdl ]...[ /vhdl ]

[Mike (Gast)]

Hi Duke...

Wollt gerade die Simalation unter "File"--> "Export"--> "Waveform" 
exportieren, nur ist "Waveform" nicht auswählbar. Und als Image ist das 
Wavebild zu klein.

Was mach ich bei meinem Export-Versuch falsch?

[PittyJ (Gast)]

Diese Clock
   clk     : in  std_logic;
wie schnell ist sie getaktet?
Der DE2-115 läuft mit 50MHz. Die Wartezeit muss aber mehrere 
Millisekunden sein.
Da kommt man doch mit einem 8-Bit Wartezähler
  signal wait_cnt : std_logic_vector(7 downto 0);
gar nicht weit?

Bei mir mußte ich gerade die Reset- und Schreib-Zeiten sehr genau 
einhalten.

Ausserdem fehlt mir so etwas wie
if rising_edge(clk)

Wo wird das gemacht?

[Mike (Gast)]

Hey PittyJ,

oh man, klar... Die Clock läuft mit 50 Mhz, da war meine Wartezeit wohl 
etwas kurz. Habe das nun den Zähler (vielleicht nicht auf die feine Art) 
auf 500.000 "Warte-Takte" anstatt 56 gesetzt, aber dennoch tun sich 
nichts auf der Anzeige.

Brauche ich denn die rising_edge(clk) für meinen Fall überhaupt?

Danke schonmal für die schnelle Unterstützung...

[Duke Scarring (Gast)]

Mike schrieb:
> Wollt gerade die Simalation unter "File"--> "Export"--> "Waveform"
> exportieren, nur ist "Waveform" nicht auswählbar. Und als Image ist das
> Wavebild zu klein.
Ich wollte eigentlich nicht die Waveforms haben, sondern die Testbench, 
die die Stimuli erzeugt. Wie erzeugst Du die Stimuli?

Duke

[PittyJ (Gast)]

>>Brauche ich denn die rising_edge(clk) für meinen Fall überhaupt?

Also ich mache nur Prozesse, die von einer rising_edge abhängen. 
Zumindest, wenn ich etwas synthetisieren möchte.

Die Profis hier schaffen das wohl auch ohne, nur wir als Anfänger 
sollten das beachten. Auch in sämtlicher einschlägiger Literatur habe 
ich das so gesehen.

[PittyJ (Gast)]

Noch ein Tipp:
Versuche es auf dem Board erst einmal mit einer blinkenden LED.
Da bekommt man schon ein Gefühl, wir groß die Zähler sein müssen, hat 
nur 2 States und nur eine Ausgabeleitung. Und trotzdem gibt es da noch 
genug Fallstricke für Neulinge.

[Mike (Gast)]

naja, ich habe das File mit ModelSim von Altera simuliert und mir die 
Wave angeschaut, ob das Programm irgendwo nicht das macht, was es 
eigentlich soll...

Wenn du mir genau beschreibst, wie ich die Testbench auslesen und zu 
Verfügung stellen kann, dann kann ich sie hier natürlich noch posten...

(Sorry, ist alles noch relativ neu für mich... )

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

Mike schrieb:
> oh man, klar... Die Clock läuft mit 50 Mhz, da war meine Wartezeit wohl
> etwas kurz.
Genau sowas sollte man mit einer Testbench aber herausfinden...

Mike schrieb:
> wie ich die Testbench auslesen und zu Verfügung stellen kann,
Eine Testbench liest du nicht aus, sondern du schreibst sie passend zu 
deinem Projekt...
Das wichtigste Merkmal einer Testbench: sie hat keine Ports nach 
aussen, also keine Ein- oder Ausgnänge.

Sieh dir mal das da mit der blinkenden LED und der passenden Testbench 
an:
http://www.lothar-miller.de/s9y/archives/80-Hello-World!.html

[Mike (Gast)]

Ok, ich habe nun mein Problem gelöst, an dem ich seit Tagen dran bin.

Problem
NR.1: Ich habe die Zeit aus dem Datenblatt nicht eingehalten.

Nr.2: In vielen Programmen und Beispielen haben ich im Code gesehen, 
dass das enable-Bit von 0 auf 1 wechseln muss, damit das LCD die Daten 
verarbeitet.
Ich dachte, dass das in jedem LCD HD44780 so Standart ist... Anscheinend 
nicht...

In meinem Datenblatt des LCDs steht nämlich folgendes:

Chip enable signal H, H --> L

Nachdem ich mein enable-Signal im Code invertiert habe, klappt jetzt 
alles...

Meine letzte Frage:
Was genau bedeutet "H, H" ? Ist damit gemeint, dass das chip enable 
signal zwei Clock-Zyklen auf H sein udn dann auf L fallen muss, damit 
das LCD meine Daten verarbeitet?


Vielen Dank für die vielen (sehr hilfreichen) Antworten...

[Duke Scarring (Gast)]

Mike schrieb:
> Was genau bedeutet "H, H" ?
Kannst Du uns den Link zum Datenblatt mal geben?

Duke

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

Mike schrieb:
> Nr.2: In vielen Programmen und Beispielen haben ich im Code gesehen,
> dass das enable-Bit von 0 auf 1 wechseln muss, damit das LCD die Daten
> verarbeitet.
> Ich dachte, dass das in jedem LCD HD44780 so Standart ist... Anscheinend
> nicht...
Üblicherweise werden die Daten bei der fallenden Flanke übernommen 
(z.B. auch bei SRAMs usw...), und deshalb bei den meisten 
Softwarelösungen der Enable-Pin bei stabil anliegenden Daten einmal 
komplett getoggelt. Die Softies haben dann auch kein Problem, weil 
sowieso immer alles nacheinander passiert:
1. Daten anlegen
2. Enable auf High
3. Enable auf Low
4. Weiter bei 1.
Du hast bei der Hardware aber den "Vorteil", dass du alles 
gleichzeitig machen kannst. Das wird dir noch öfter zu denken geben... 
;-)

[Mike (Gast)]

Hey Duke,

Datenblatt hier gerade hochgeladen...

LG Mike

[Duke Scarring (Gast)]

Mike schrieb:
> Chip enable signal H, H --> L
Sieht in der Tat etwas ominös aus.
Weiter hinten sind ja aber die konkreten Timings angegeben (230 ns/500 
ns).

Duke