UART-Transmitter in VHDL

[Volker D. (volker_d)]

Hallo,

ich versuche einen UART-Transmitter in VHDL zu beschreiben. Dazu habe 
ich ein Modul "Baudratengenerator" beschrieben der mit einer Frequenz 
von 9600Hz das nächste Datenbit an txd anlegen soll. Desweiteren habe 
ich ein Modul "Transmitter" beschrieben, der letzlich den 
UART-Transmitter realisieren soll und dabei den Baudratengenerator 
benutzt. Allerdings gibt mir die Synthese einen Fehler aus, da txd an 
den Baudratengenerator gebunden und den Transmitter gebunden ist. Wie 
kann ich das beheben? Rein logisch müsste mein Code funktionieren. Siehe 
dazu die Anhänge.

Im folgenden der Code für den Baudratengenerator:

entity Baudratengenerator is
    Port ( clk : in  STD_LOGIC;
           rst : in  STD_LOGIC;
           tick : out  STD_LOGIC);
end Baudratengenerator;

architecture Behavioral of Baudratengenerator is
signal counter : integer;
begin
  P1: Process(clk, rst)
  begin
    if clk'event and clk = '1' then
      if rst = '1' then
        tick <= '0';
        counter <= 0;
      else
        counter <= counter + 1;
        if counter = 5208 then
          tick <= '1';
          counter <= 0;
        else 
          tick <= '0';
        end if;
      end if;
    end if;
  end Process;
end Behavioral;

und hier der Code für den Transmitter

entity Transmitter is
    Port ( din : in  std_logic_vector (7 downto 0);
           send : in  STD_LOGIC;
           clk : in  STD_LOGIC;
           rst : in  STD_LOGIC;
           txd : out  STD_LOGIC);
end Transmitter;

architecture Behavioral of Transmitter is
  component Baudratengenerator is
    port ( clk : in std_logic;
         rst : in std_logic;
         tick : out std_logic);
  end component;
  signal gesendet : boolean:= false;
  signal bitcounter : integer:= 0;
  type STATE_T is (Warte, Sende); --Aufzählungstyp
  signal state : STATE_T;        --Zustandssignal
begin
ba: Baudratengenerator port map(clk=>clk, rst=>rst, tick=>txd);

FSM : process (din, send, clk, rst) is
begin
  if rst = '1' then
    state <= Warte;
  elsif clk'event and clk = '1' then
    case state is
      when Warte =>
        if send = '1' then --Transition "Taster gedrückt"
          state <= Sende;
        end if;
      when Sende =>
        if bitcounter = 0 then
          txd <= '0';  --start bit
        end if;
        if bitcounter < 8 then
          txd <= din(bitcounter); --Daten nacheinander an txd anlegen
        else
          txd <= '1'; --stopp bit
          gesendet <= true;  --Transition "Zeichen gesendet"
          bitcounter <= 0;
        end if;
        if gesendet = true then
          state <= Warte;
          gesendet <= false;
        end if;
      end case;
  end if;
end process;
end architecture;

dabei bin ich mir sicher, den Baudratengenerator richtig beschrieben zu 
haben und auch richtig im Transmitter verwendet zu haben, da es ja 
eigentlich keine andere Möglichkeit gibt.

Ich hoffe mir kann jemand weiterhelfen.
Vielen Dank im voraus.

Grüße, Volker

[Lattice User (Gast)]

Volker D. schrieb:
>
> richtig im Transmitter verwendet zu haben, da es ja
> eigentlich keine andere Möglichkeit gibt.
>

Nein hast du nicht richtig verwendet, und es gibt immer mehere 
Möglichkeiten.

Da es wohl eine Hausaufgabe ist, nur ein kurzer Tipp: Lern mal wozu 
Clockenables da sind.

[Volker D. (volker_d)]

ist denn die Einbindung über die Port map korrekt? Clockenable gibt mir 
ja eigentlich nur an, wann clock auf 1 ist.

[Volker D. (volker_d)]

ich galube, ich weiß jetzt, was ich falsch gemacht habe. Im Transmitter 
selber, wird der Baudratengenerator gar nicht eingebunden, sondern nur 
der Transmitter beschrieben. Das heißt also, dass beim Transmitter die 
Component Baudratengenerator und die dazugehörige Port map entfernt 
wird. In einem dritten VHDL-Modul, was ich dann z.B. UART nennen kann, 
wird der Transmitter und der Baudratengenerator über die Port maps 
verbunden und gegebenenfalls ein Signal zum verdrahten eingeführt. Bin 
ich damit auf dem richtigen Weg?

[Schlumpf (Gast)]

Die Synthese hat schon recht, wenn sie meckert.
Was wolltest du erreichen? Einen "tick", der vom Baudratengenerator 
kommt und ein "txd", welches das eigentliche Datum darstellt.
Soweit ist der Gedanke korrekt. Aber was würde passieren, wenn du für 
den Baudratengenerator und den eigentlichen Sender zwei reale Bauelemnte 
hättest und deren Ausgänge, so wie du es gemacht hast, einfach 
zusammenschaltest?

Richtig: Das kann nicht gehen! Sagt der eine "1" und der andere "0", 
dann hättest du einen Kurzschluss. Und genau das erkennt die Synthese 
und meckert (zurecht)

Es kann immer nur einen geben (wie beim Highlander), der direkt auf ein 
Signal treibt.

Was du eigentlich brauchst, ist eine Art Steuereingang für den 
Transmitter, über den der Baudratengenerator ihm sagt: "so, jetzt bitte 
nächstes Bit ausgeben" und der Transmitter muss dann so geschrieben 
werden, dass er immer brav wartet, bis er vom Baudratengenerator die 
Erlaubnis bekommt, das nächste Bit zu senden.

[Schlumpf (Gast)]

Volker D. schrieb:
> Bin ich damit auf dem richtigen Weg?

Exakt! ;-)

[Volker D. (volker_d)]

danke für die Antwort. Die Erklärung klingt logisch (einen Kurzschluss 
möchte ich natürlich nicht beschreiben). Ich versuch es dann erst mal 
weiter und wenn weitere Probleme auftreten meld ich mich wieder.

Grüße, Volker

[Volker D. (Gast)]

hallo,

ich denke, ich habe den UART-Transmitter jetzt richtig beschrieben. Den 
Baudratengenerator habe ich so gelassen, wie in meinem ersten Post. Im 
folgenden der überarbeitete Transmitter und die Gesamtschaltung. Ich 
würd mich freuen, wenn jemand schauen könnte, ob die Codes so korrekt 
sind.

Transmitter:

entity Transmitter is
    Port ( din : in  std_logic_vector (7 downto 0);
           send : in  STD_LOGIC;
           clk : in  STD_LOGIC;
           rst : in  STD_LOGIC;
           txd : out  STD_LOGIC);
end Transmitter;

architecture Behavioral of Transmitter is
  signal gesendet : boolean:= false;
  signal bitcounter : integer:= 0;
  type STATE_T is (Warte, Sende); --Aufzählungstyp
  signal state : STATE_T;        --Zustandssignal
begin

FSM : process (din, send, clk, rst) is
begin
  if rst = '1' then
    state <= Warte;
    bitcounter <= 0;
  elsif clk'event and clk = '1' then
    case state is
      when Warte =>
        gesendet <= false;
        if send = '1' then --Transition "Taster gedrückt"
          state <= Sende;
        end if;
      when Sende =>
        if bitcounter = 0 then
          txd <= '0';  --start bit
        elsif bitcounter < 9 then
          txd <= din(bitcounter - 1); --Daten nacheinander an txd anlegen
        elsif bitcounter = 9 then
          txd <= '1'; --stopp bit
          gesendet <= true;  --Transition "Zeichen gesendet"
        end if;
        bitcounter <= bitcounter + 1;
        if gesendet = true then
          bitcounter <= 0;
          state <= Warte;
        end if;
      end case;
  end if;
end process;
end architecture;

und die Gesamtschaltung:

entity UART_Transmitter is
    Port ( din : in  std_logic_vector (7 downto 0);
           send : in  STD_LOGIC;
           clk : in  STD_LOGIC;
           rst : in  STD_LOGIC;
           txd : out  STD_LOGIC;
           tick : out  STD_LOGIC);
end UART_Transmitter;

architecture Behavioral of UART_Transmitter is
component Baudratengenerator is
  port ( clk : in std_logic;
       rst : in std_logic;
       tick : out std_logic);
end component;

component Transmitter is
  port ( din : in std_logic_vector (7 downto 0);
       send : in std_logic;
       clk : in std_logic;
       rst : in std_logic;
       txd : out std_logic);
end component;

signal sw : std_logic;

begin
tick <= sw;

ba : Baudratengenerator port map (clk=>clk, rst=>rst, tick=>sw);
tr : Transmitter port map (din=>din, send=>send, clk=>sw, rst=>rst, txd=>txd);

end Behavioral;

vielen Dank im voraus.

Grüße, Volker

[Volker D. (Gast)]

im Anhang noch die Gesamtschaltung. Hatte ich vorhin vergessen.

Grüße

[bko (Gast)]

In der Sensivity-Liste brauchts nur clk und rst.
>FSM : process (din, send, clk, rst) is
FSM : process ( clk, rst) is

Und hier machst du einen asyncronen Reset,
>FSM : process (din, send, clk, rst) is
>begin
>  if rst = '1' then
Wenn das Signal "rst" eine asyncrone Quelle hat (z.B.: Taster)
das sollte man "rst" einsyncronisieren:
Beitrag "Detailfrage Reset"
sonst sind hier "manchmal gehts nicht" vorprogrammiert.

Und wenn das Ziel ein FPGA ist dann auch mal
 Xilinx- WP272 und den Rest von oben durchlesen.

Und hier vermute ich einen abgeleiteten Takt:
>ba : Baudratengenerator port map (clk=>clk, rst=>rst, tick=>sw);
>tr : Transmitter port map (din=>din, send=>send, clk=>*sw*, rst=>rst, >txd=>txd);

Da Zitiere ich das  Lothar Miller-Postulat:
"Ein Design (insbesondere ein Anfängerdesign) hat genau 1 Takt, der 
immer
auf dieselbe Flanke aktiv ist."
Beitrag "Re: Fehler durch Signalabgreifen"

Besser ists mit einem clock-enable zu arbeiten, hier mit Beispiel:
http://www.mikrocontroller.net/articles/Taktung_FPGA/CPLD

[Duke Scarring (Gast)]

Volker D. schrieb:
> Ich
> würd mich freuen, wenn jemand schauen könnte, ob die Codes so korrekt
> sind.
Wenn Du noch eine Testbench dazu machst, schau ich mir das Ganze mal im 
Simulator an.

Duke

[Uwe (Gast)]

Naja man sampled aber bei der Asynchronen Schnittstelle zwischen der 
positiven und der negativen Taktflanke also in der mite eines Taktes. 
Deshalb solle die Taktfrequenz schon mndestens Doppelt so hoch sein.
Moderne und alte UARTs arbeiten normalerweise mit 16fach höheren Takt.
Da kann man dann auch noch sowas wie ne Fehlererkennung einbauen wie nen 
Equivalent oder der vier mittleren Pegel.

[Volker D. (Gast)]

Danke an alle die geholfen. Die Aufgabe habe ich korrekt gelöst (habe 
ich gestern vorgestellt).Grüße, Volker

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

Volker D. schrieb:
> Die Aufgabe habe ich korrekt gelöst
Ich hätte da (mit sehr hoher Wahrscheinlichkeit) einen grundlegenden 
Denkfehler gefunden:
Volker D. schrieb:
>         if counter = 5208 then
Dir ist schon klar, dass dein Zähler hier die Frequenz um 5209 teilt 
(und nicht um 5208, was einen kleineren Fehler in der Baudrate 
darstellen würde)?

Logisch macht das hier den Kohl nicht fett, aber was, wenn deine 
Taktfrequenz 96kHz gewesen wäre? Dann würde es schon was ausmachen, ob 
du durch 10 oder durch 11 teilst...

Uwe schrieb:
> Naja man sampled aber bei der Asynchronen Schnittstelle zwischen der
> positiven und der negativen Taktflanke also in der mite eines Taktes.
Naja, das betrifft aber nur den Empfänger. Der hier beschriebene 
Sender kann von einem Oversampling nicht profitieren...