Advertisement
madegoff

Zustandsautomat(?)

Jun 4th, 2023 (edited)
655
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
VHDL 21.50 KB | None | 0 0
  1. --------------------------------------------------------------------------------
  2. --  UART einer EIA-232-Schnittstelle des HWPR-Prozessorsystems.
  3. --------------------------------------------------------------------------------
  4. --  Datum:      ??.??.2013
  5. --  Version:    ?.?
  6. --------------------------------------------------------------------------------
  7.  
  8. library ieee;
  9. use ieee.std_logic_1164.all;
  10.  
  11. library work;
  12.     use work.ArmTypes.all;
  13.     use work.ArmConfiguration.all;
  14.  
  15. --------------------------------------------------------------------------------
  16. --  Funktionsweise der Schnittstellenkomponente zum Datenbus:
  17. --  Das Interface verfuegt ueber 4 sichbare Register:
  18. --      Senderegister       (RS232_TRM_REG)
  19. --      Empfangsregister    (RS232_RCV_REG)
  20. --  Statusregister      (RS232_STAT_REG)
  21. --  Steuerregister      (RS232_CTRL_REG)
  22. --------------------------------------------------------------------------------
  23. --  Das Ansprechen der Register erfolgt entweder Wort- oder Byteweise,
  24. --  tatsaechlich wird aber immer nur das nur das niederwertigste Byte eines
  25. --  Zugriffs beruecksichtigt.
  26. --  In das Sendregegister sollte nur geschrieben werden, beim Lesen werden
  27. --  Nullen ausgegeben. Empfangs- und Statusregister koennen nur gelesen
  28. --  werden, Schreiboperationen sind wirkungslos.
  29. --  Das Schreiben eines Datums vom Datenbus ins Senderegister wird als
  30. --  Sendebefehl interpretiert, das Lesen eines Datums aus dem Empfangs-
  31. --  register als Leseoperation.
  32. --------------------------------------------------------------------------------
  33. --  Interpretation des Statusregister:
  34. --  Bit 0 zeigt an, dass ein neues Datum gelesen wurde und im Empfangs-
  35. --  register liegt. Eine Leseoperation auf dem Empfangsregister setzt das
  36. --  Bit zurueck. Bit 4 zeigt an, dass das Sendemodul mit der aktuellen
  37. --  Uebertragung beschaeftigt ist, eine Schreiboperation auf das Sende-
  38. --  register bleibt waehrenddessen wirkungslos. Ist das Bit = 0 und erfolgt
  39. --  ein Schreibzugriff auf das Senderegister, wird das Bit im gleichen Takt
  40. --  neu gesetzt.
  41. --
  42. --  Das Steuerregister hat vorlaeufig keine besondere Wirkung, kann aber
  43. --  beschrieben werden.
  44. --------------------------------------------------------------------------------    
  45.  
  46. entity ArmRS232Interface is
  47.     port(
  48.         SYS_CLK     : in std_logic;
  49.         SYS_RST     : in std_logic;
  50. --  Schnittstelle zum Datenbus
  51.         RS232_CS    : in std_logic;
  52.         RS232_DnRW  : in std_logic;
  53.         RS232_DMAS  : IN std_logic_vector(1 downto 0);
  54.         RS232_DA    : in std_logic_vector(3 downto 0);
  55.         RS232_DDIN  : in std_logic_vector(31 downto 0);
  56.         RS232_DDOUT : out std_logic_vector(31 downto 0);
  57.         RS232_DABORT    : out std_logic;
  58.         RS232_IRQ   : out std_logic;
  59. --  Serielle Empfangs- und Sendeleitungen
  60.         RS232_RXD   : in std_logic;
  61.         RS232_TXD   : out std_logic
  62.         );
  63. end entity ArmRS232Interface;
  64.  
  65. architecture behave of ArmRS232Interface is
  66. --------------------------------------------------------------------------------
  67. --  Lokale Schnittstellensignale zum Datenbus zur Realisierung der
  68. --  Tristate-Ausgaenge.
  69. --------------------------------------------------------------------------------
  70.     signal DABORT_INTERNAL  : std_logic;    
  71.     signal DDOUT_INTERNAL   : std_logic_vector(31 downto 0);
  72.  
  73. --------------------------------------------------------------------------------
  74. --  Definition der lokalen, am Datenbus adressierbaren Register der
  75. --  seriellen Schnittstelle. Sie werden Ausschliesslich im Block
  76. --  INTERFACE_COMMUNICATION beschrieben!
  77. --------------------------------------------------------------------------------
  78.     type RS232_REGISTER_SET_LOCAL_TYPE is array ( 0 to 2 ) of std_logic_vector(7 downto 0);
  79.     signal REGISTER_SET : RS232_REGISTER_SET_LOCAL_TYPE := (others => (others => '0'));
  80.  
  81. --------------------------------------------------------------------------------
  82. --  Aliase fuer den Zugriff auf die 4 Register der RS232-Schnittstelle.
  83. --  RS232_CTRL_REG ist aktuell funktionslos, liefert beim Lesen immer
  84. --  0 und Schreibzugriff haben keine Wirkung -> Beschreibung als Konstante.
  85. --------------------------------------------------------------------------------
  86.     alias RS232_RCV_REG : std_logic_vector(7 downto 0) is REGISTER_SET(0);
  87.     alias RS232_TRM_REG : std_logic_vector(7 downto 0) is REGISTER_SET(1);
  88.     alias RS232_STAT_REG    : std_logic_vector(7 downto 0) is REGISTER_SET(2);
  89.     constant RS232_CTRL_REG : std_logic_vector(7 downto 0) := (others => '0');
  90.  
  91. --------------------------------------------------------------------------------
  92. --  Signale fuer die Kommunikation zwischen den 3 Bloecken im Modul.
  93. --------------------------------------------------------------------------------
  94. --  Signale vom RS232-Receiver zur Busschnittstelle INTERFACE_COMMUNICATION
  95.     signal DATA_RECEIVED    : std_logic;
  96.     signal RECEIVER_DATA    : std_logic_vector(7 downto 0);
  97. --------------------------------------------------------------------------------
  98. --  Steuer- und Statussignale zwischen RS232-Transmitter und
  99. --  Busschnittstelle. Der Transmitter liest zusaetzlich Daten aus dem
  100. --  lokalen Register RS232_TRM_REG.
  101. --------------------------------------------------------------------------------
  102.     signal START_TRANSMISSION   : std_logic;
  103.     signal TRANSMITTER_BUSY     : std_logic;
  104. --------------------------------------------------------------------------------
  105. begin
  106. --------------------------------------------------------------------------------
  107. --  Kommunikationsschnittstelle, stellt die Verbindung zwischen Datenbus
  108. --  und den RS232-Komponenten her.
  109. --------------------------------------------------------------------------------
  110.  
  111. INTERFACE_COMMUNICATION : block is
  112.     begin
  113. --------------------------------------------------------------------------------
  114. --  Data Abort, wenn eine Wortzugriff mit nicht ausgerichteter Adresse
  115. --  erfolgt oder ein Bytezugriff auf die nicht verwendeten hochwertigen
  116. --  24 Registerbits erfolgt.
  117. --------------------------------------------------------------------------------
  118.         DABORT_INTERNAL <= '1' when ((RS232_DMAS /= DMAS_BYTE) and (RS232_DMAS /= DMAS_WORD)) or RS232_DA(1 downto 0) /= "00" else '0';
  119. --  Daten- und Abortsignale werden nur getrieben, wenn das Modul tatsaechlich aktiv sein soll
  120.         RS232_DABORT    <= DABORT_INTERNAL when RS232_CS = '1' else 'Z';
  121.         RS232_DDOUT <= DDOUT_INTERNAL when RS232_CS = '1' and RS232_DnRW = '0' else (others => 'Z');
  122.  
  123. --------------------------------------------------------------------------------
  124. --  Interrupt ist bis auf weiteres direkt Bit 0 des Statusregistes, maskiert
  125. --  wird ausschliesslich in Software durch das CPSR-IRQ-Maskenbit
  126. --------------------------------------------------------------------------------
  127.         RS232_IRQ <= RS232_STAT_REG(0);
  128.  
  129. --------------------------------------------------------------------------------
  130. --  Die vier Register der RS232-Schnittstelle liegen an 4 Adressen
  131. --  hintereinander. Die Adressbits (3:2) waehlen das Register aus.
  132. --------------------------------------------------------------------------------
  133.         GET_REGISTER : process(RS232_DA(3 downto 2), REGISTER_SET)
  134.         begin
  135.             case RS232_DA(3 downto 2) IS
  136.                 when "00" =>
  137.                     DDOUT_INTERNAL <= X"000000" & RS232_RCV_REG;
  138.                 when "01" =>
  139.                     DDOUT_INTERNAL <= (others => '0');
  140.  
  141.                 when "10" =>
  142.                     DDOUT_INTERNAL <= X"000000" & RS232_STAT_REG;
  143.                 when others =>  
  144.                     DDOUT_INTERNAL <= (others => '0');
  145.             end case;
  146.         end process GET_REGISTER;  
  147.  
  148. --------------------------------------------------------------------------------
  149. --  Schreibzugriffe vom Datenbus auf das Register RS232_TRM_REG setzen
  150. --  dessen Inhalt und veranlassen das Senden des neuen Datums ueber die
  151. --  TXD-Leitung.
  152. --------------------------------------------------------------------------------
  153.         SET_REGISTER : process(SYS_CLK, REGISTER_SET, START_TRANSMISSION)
  154.         begin
  155.             REGISTER_SET        <= REGISTER_SET;
  156.             START_TRANSMISSION  <= START_TRANSMISSION;
  157.  
  158.             if SYS_CLK'event and SYS_CLK = '1' then
  159.                 if(SYS_RST = '1') then
  160.                     REGISTER_SET        <= (others => (others => '0'));
  161.                     START_TRANSMISSION  <= '0';
  162.                 else
  163.                     START_TRANSMISSION      <= '0';
  164.                     RS232_STAT_REG(7 downto 5)  <= "000";
  165.                     RS232_STAT_REG(3 downto 1)  <= "000";
  166.                     RS232_STAT_REG(4)       <= TRANSMITTER_BUSY or START_TRANSMISSION;
  167. --  Gueltiger Schreibzugriff auf das Transmissionsregister loest die Uebertragung aus          
  168.                     if(RS232_DnRW = '1' and RS232_CS = '1' and DABORT_INTERNAL = '0' and RS232_DA(3 downto 2) = "01" and START_TRANSMISSION = '0')then
  169.                         if(TRANSMITTER_BUSY = '0')then
  170.                             RS232_TRM_REG       <= RS232_DDIN(7 downto 0);
  171.                             START_TRANSMISSION  <= '1';
  172.                             RS232_STAT_REG(4)   <= '1';
  173.                         end if;
  174.                     end if;
  175. --------------------------------------------------------------------------------
  176. --  Gueltiger Lesezugriff auf das Empfangsregister, setzt die Anzeige fuer
  177. --  ein empfangenes Datum zurueck. Sollte im gleichen Takt erneut ein Datum
  178. --  empfangen worden sein, bleibt das Bit gesetzt (naechster Abschnitt).
  179. --------------------------------------------------------------------------------
  180.                     if(RS232_DnRW = '0' and RS232_CS = '1' and DABORT_INTERNAL = '0' and RS232_DA(3 downto 2) = "00")then
  181.                         RS232_STAT_REG(0)   <= '0';
  182.                     end if;
  183. --------------------------------------------------------------------------------
  184. --  Empfaenger zeigt an, dass ein neues Datum empfangen wurde, das
  185. --  entsprechende Statusbit wird gesetzt.
  186. --------------------------------------------------------------------------------
  187.                     if(DATA_RECEIVED = '1')then
  188.                         RS232_RCV_REG       <= RECEIVER_DATA;
  189.                         RS232_STAT_REG(0)   <= '1';
  190.                 end if;
  191.             end if;
  192.         end if;
  193.     end process SET_REGISTER;
  194. end block INTERFACE_COMMUNICATION;
  195.  
  196.  
  197. --------------------------------------------------------------------------------
  198. --  Block, der das Verhalten eines RS232-Empfaengers beschreibt.
  199. --------------------------------------------------------------------------------
  200. RS232_RECEIVER : block is
  201. --------------------------------------------------------------------------------
  202. --  Exklusive Typen und Signale des Empfaengers. Alle Ausgangssignale, die
  203. --  die Statemachine setzt, werden durch einen zusaetzlichen Prozess
  204. --  registriert.
  205. --  Die Statemachine liest ein von ihr direkt oder indirekt gesetztes Signal
  206. --  ausschliesslich auf dem Umweg ueber das Register wieder ein, um
  207. --  asynchrone Rueckkopplungen zu vermeiden.
  208. --------------------------------------------------------------------------------
  209.         type RS232_RCV_STATE_TYPE is (RCV_IDLE, RCV_READ_BIT, RCV_STOPP);
  210.         signal RCV_STATE, RCV_NEXT_STATE : RS232_RCV_STATE_TYPE := RCV_IDLE;
  211.         constant DATA_REG_INIT_VALUE    : std_logic_vector(7 downto 0) := "10000000";
  212.         signal RCV_DATA, RCV_DATA_REG   : std_logic_vector(7 downto 0) := DATA_REG_INIT_VALUE;
  213. --  Flipflop zum Aufsynchronisieren des Eingangssignals
  214.         signal DATA_IN_BIT_REG      : std_logic := '1';
  215.         signal SET_DATA, SET_DATA_REG   : std_logic;
  216.         signal DATA_RECEIVED_REG    : std_logic := '1';
  217.         signal WSG_DELAY, WSG_DELAY_REG : std_logic_vector(31 downto 0);
  218.         signal WSG_START, WSG_START_REG : std_logic := '0';
  219. --  WSG_WAIT wird von der Statemachine nur gelesen
  220.         signal WSG_WAIT         : std_logic;
  221.     begin
  222.         WSG : entity work.ArmWaitStateGenAsync(BEHAVE)
  223.         generic map(
  224.             COUNT_VALUE_WIDTH => 32
  225.         )
  226.         port map(
  227.             SYS_CLK     => SYS_CLK,
  228.             SYS_RST     => SYS_RST,
  229.             WSG_COUNT_INIT  => WSG_DELAY_REG,
  230.             WSG_START   => WSG_START_REG,
  231.             WSG_WAIT    => WSG_WAIT        
  232.         );  
  233.  
  234. --  Setzen des Zustandsregisters
  235.         SET_RCV_STATE_REG : process(SYS_CLK) is
  236.         begin
  237.             if SYS_CLK'event and SYS_CLK = '1' then
  238.                 if SYS_RST = '1' then
  239.                     RCV_STATE <= RCV_IDLE;
  240.                 else
  241.                     RCV_STATE <= RCV_NEXT_STATE;
  242.                 end if;
  243.             end if;
  244.         end process SET_RCV_STATE_REG;
  245.  
  246. --------------------------------------------------------------------------------
  247. --  Setzen der Synchronisationsregister, nur aus formalen Gruenden geschieht
  248. --  dies nicht in einem Prozess mit dem Zustandsregister.
  249. --------------------------------------------------------------------------------
  250.         SET_DATA_REGISTERS : process(SYS_CLK) is
  251.         begin
  252.             if SYS_CLK'event and SYS_CLK = '1' then
  253.                 if SYS_RST = '1' then
  254.                     DATA_IN_BIT_REG     <= '1';
  255.                     WSG_DELAY_REG       <= std_logic_vector(RS232_START_DELAY);
  256.                     RCV_DATA_REG        <= (others => '0');
  257.                     DATA_RECEIVED_REG   <= '0';
  258.                     WSG_START_REG       <= '0';
  259.                     SET_DATA_REG        <= '0';
  260.  
  261.                 else
  262.                     DATA_IN_BIT_REG     <= RS232_RXD;
  263.                     WSG_DELAY_REG       <= WSG_DELAY;
  264.                     RCV_DATA_REG        <= RCV_DATA;
  265.                     DATA_RECEIVED_REG   <= '0';
  266.                     WSG_START_REG       <= WSG_START;
  267.                     SET_DATA_REG        <= SET_DATA;
  268.                     if SET_DATA_REG = '1' then
  269.                         RECEIVER_DATA       <= RCV_DATA_REG(7 downto 0);
  270.                         DATA_RECEIVED_REG   <= '1';
  271.                     end if;
  272.  
  273.                 end if;
  274.             end if;
  275.         end process SET_DATA_REGISTERS;
  276.  
  277. --------------------------------------------------------------------------------
  278. --  DATA_RECEIVED zeigt der Kommunkationsschnittstelle an, dass ein neues
  279. --  Datum empfangen wurde.
  280. --------------------------------------------------------------------------------
  281.         DATA_RECEIVED <= DATA_RECEIVED_REG;
  282.    
  283. --------------------------------------------------------------------------------
  284. --  Kern der FSM: Ermittlung des Nachfolgezustandes und Setzen der
  285. --  Ausgangssignale, die dann in SET_DATA_REGISTERS in Register geschrieben
  286. --  werden.
  287. --------------------------------------------------------------------------------
  288.     SET_OUTPUTS_AND_NEXT_STATE : process(RCV_STATE,DATA_IN_BIT_REG,WSG_WAIT, RCV_DATA_REG) IS
  289.     begin
  290. --------------------------------------------------------------------------------
  291. --  Ausgangssignale die durch die FSM gesetzt und in jedem Zustand definiert
  292. --  werden muessen:
  293. --      RCV_NEXT_STATE
  294. --      WSG_START
  295. --      RCV_DATA    
  296. --      WSG_DELAY
  297. --      SET_DATA
  298. --------------------------------------------------------------------------------
  299.  
  300. --  Defaultwerte:      
  301.         RCV_NEXT_STATE  <= RCV_STATE;
  302.         WSG_START   <= '0';
  303.         RCV_DATA    <= RCV_DATA_REG;
  304.         WSG_DELAY   <= std_logic_vector(RS232_DELAY);
  305.         SET_DATA    <= '0';
  306.  
  307.         case RCV_STATE is
  308.             when RCV_IDLE =>            
  309.                 if( DATA_IN_BIT_REG = '1' )then
  310.                     RCV_NEXT_STATE  <= RCV_IDLE;
  311.                     WSG_START   <= '0';
  312.                 else
  313. --  Beginn eines Startbits erkannt -> Beginn des Lesevorgangs                  
  314.                     RCV_NEXT_STATE  <= RCV_READ_BIT;
  315.                     WSG_START   <= '1';
  316.                 end if;
  317.                 RCV_DATA    <= DATA_REG_INIT_VALUE;
  318. --------------------------------------------------------------------------------
  319. --  START_DELAY entspricht der 1,5-fachen Zeichendauer, sodass die
  320. --  Empfangsleitung ca. in der Mitte des ersten Datenbits wieder abgetastet
  321. --  wird.  
  322. --------------------------------------------------------------------------------
  323.                 WSG_DELAY   <= std_logic_vector(RS232_START_DELAY);
  324.                 SET_DATA    <= '0';
  325.  
  326.             when RCV_READ_BIT =>
  327.                 if( WSG_WAIT = '1' )then
  328.                     RCV_NEXT_STATE  <= RCV_READ_BIT;
  329.                     WSG_START   <= '0';
  330.                     RCV_DATA    <= RCV_DATA_REG;
  331.                 else
  332.                     RCV_DATA(7 downto 0)    <= DATA_IN_BIT_REG & RCV_DATA_REG(7 downto 1);
  333.                     WSG_START       <= '1';
  334. --------------------------------------------------------------------------------
  335. --  RCV_DATA_REG wurde mit einer 1 im MSB initialisiert, die jetzt ganz
  336. --  nach rechts geschoben wurde -> Schieberegister als Zaehler.
  337. --------------------------------------------------------------------------------
  338.                     if RCV_DATA_REG(0) = '1' then
  339.                         RCV_NEXT_STATE  <= RCV_STOPP;
  340.                     else
  341.                         RCV_NEXT_STATE  <= RCV_READ_BIT;
  342.                     end if;
  343.                 end if;
  344.                 WSG_DELAY   <= std_logic_vector(RS232_DELAY);
  345.                 SET_DATA    <= '0';
  346.  
  347.             when RCV_STOPP =>
  348.                 RCV_DATA <= RCV_DATA_REG;
  349.                 if( WSG_WAIT = '1' ) then
  350.                     RCV_NEXT_STATE  <= RCV_STOPP;
  351.                     WSG_START   <= '0';
  352.                     SET_DATA    <= '0';
  353.                     RCV_DATA    <= RCV_DATA_REG;
  354.                 else                    
  355.                     if(DATA_IN_BIT_REG = '1')then
  356.                         RCV_NEXT_STATE  <= RCV_IDLE;
  357.                         WSG_START   <= '0';
  358.                         SET_DATA    <= '1';
  359.                     else
  360. --------------------------------------------------------------------------------
  361. --  0 wird als Startsignal des naechsten Datensatzes interpretiert,
  362. --  das aktuelle Datum aber nicht in der Kommunikationsschnittstelle
  363. --  bekannt gemacht da ein korrektes Stoppbit fehlt.                    
  364. --------------------------------------------------------------------------------
  365.                         RCV_NEXT_STATE <= RCV_READ_BIT;
  366.                         WSG_START   <= '1';
  367.                         SET_DATA    <= '0';
  368.                     end if;
  369.                 end if;
  370.                 WSG_DELAY <= std_logic_vector(RS232_DELAY);
  371.  
  372.             when others =>
  373.                 RCV_NEXT_STATE <= RCV_IDLE;
  374.                 WSG_START <= '0';
  375.                 RCV_DATA <= DATA_REG_INIT_VALUE;
  376.                 WSG_DELAY <= std_logic_vector(RS232_START_DELAY);
  377.                 SET_DATA <= '0';
  378.         end case;
  379.     end process SET_OUTPUTS_AND_NEXT_STATE;
  380. end block RS232_RECEIVER;
  381.  
  382. -------------------------------------------------------------------------------
  383. -------------------------------------------------------------------------------
  384. --  Block, der einen RS232-Sender beschreibt und von Ihnen zu ergaenzen
  385. --  ist. Veraendern Sie die Vorgaben ausserhalb des Blocks _nicht_.
  386. -------------------------------------------------------------------------------
  387. -------------------------------------------------------------------------------
  388.  
  389. -- RS232_TRM_REG ist 8 Bit gross
  390. RS232_TRANSMITTER : block is
  391.  
  392. --Zustaende des Transmitters--
  393. type RS232_TRM_STATE_TYPE is (TRM_IDLE, TRM_START, TRM_READ_BIT, TRM_STOPP);
  394. --am anfang Zustand IDLE (untaetig)--
  395. signal TRM_STATE, TRM_NEXT_STATE : RS232_TRM_STATE_TYPE := TRM_IDLE;
  396.  
  397. --Signale fuer Zustandsuebergaenge--
  398. signal first_bit_sent, data_sent, last_bit_sent : std_logic;
  399.  
  400.     begin
  401.  
  402.     --Zustandsuebergang--
  403.     SET_TRM_STATE : process(SYS_CLK) is
  404.         begin
  405.             if SYS_CLK'event and SYS_CLK = '1' then --die Zeilen sind aus dem SET_RCV_STATE_REG entnommen , aber hier: muss alles auch
  406.                 if SYS_RST = '1' then               --taktsynchton erfolgen, und wie genau? hat RST auch darauf einfluss?
  407.                     TRM_STATE <= TRM_IDLE;          -- und warum ist das ein register in RCV und nicht ein normale beschreibung
  408.                 else                                -- des zustandsueberganges?
  409.                     TRM_STATE <= TRM_NEXT_STATE;
  410.                 end if;
  411.             end if;
  412.         end process SET_TRM_STATE;
  413.  
  414.     --Zustandsberechnung--
  415.     SET_NEXT_STATE : process(TRM_STATE, START_TRANSMISSION, last_bit_sent, first_bit_sent, data_sent) IS
  416.     begin
  417.  
  418.         case TRM_STATE is
  419.             when TRM_IDLE =>            
  420.                 if( START_TRANSMISSION = '1' )then
  421.                     TRM_NEXT_STATE  <= TRM_START;
  422.                     --WSG_START   <= '0';--
  423.                 end if;
  424.             when TRM_START =>
  425.                 if( first_bit_sent )then
  426.                     TRM_NEXT_STATE  <= TRM_READ_BIT;
  427.                 end if;
  428.             when TRM_READ_BIT =>
  429.                 if( data_sent)then
  430.                     TRM_NEXT_STATE  <= TRM_STOPP;
  431.                 end if;
  432.             when TRM_STOPP =>
  433.                 if(last_bit_sent)then
  434.                     TRM_NEXT_STATE  <= TRM_IDLE;
  435.                 end if;
  436.         end case;
  437.  
  438.     end process SET_NEXT_STATE;
  439.  
  440.     SET_OUTPUTS : process() IS
  441.     begin
  442.  
  443.         case TRM_STATE is
  444.  
  445.             when TRM_START =>
  446.                 TRANSMITTER_BUSY <= '1';
  447.                 --senden des ersten Bits (LSB) RS232_TRM_REG(0)--
  448.                 first_bit_sent <= '1';
  449.             when TRM_READ_BIT =>
  450.                 --schieberegister irgendwie benutzen fuer RS232_TRM_REG(6 downto 1)--
  451.                 data_sent <= '1';
  452.             when TRM_STOPP =>
  453.                 --senden des letzten Bits (MSB) RS232_TRM_REG(7)--
  454.                 last_bit_sent <= '1';
  455.                 TRANSMITTER_BUSY <= '0';
  456.  
  457.     end process SET_OUTPUTS;
  458.  
  459. end block RS232_TRANSMITTER;
  460.  
  461. end architecture behave;
  462.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement