history: maximal 70 zeichen eingabe

[hwmod.git] / src / history.vhd

diff --git a/src/history.vhd b/src/history.vhd
index 2f3c2dd0334bd8986e53fa2464c846b673d77859..76c4bf70bec70ce1bda69440fa83136f5576ec86 100644 (file)
--- a/src/history.vhd
+++ b/src/history.vhd
@@ -17,6 +17,7 @@ entity history is
                -- Display
                d_new_eingabe : out std_logic;
                d_new_result : out std_logic;
+               d_new_bs : out std_logic;
                d_zeile : in hzeile;
                d_spalte : in hspalte;
                d_get : in std_logic;
@@ -33,12 +34,14 @@ end entity history;
 
 architecture beh of history is
        type HISTORY_STATE is (SIDLE, S_S_INIT, S_S_WRITE, S_S_BS, S_S_DONE, S_S_FIN,
-               S_D_INIT, S_D_WAIT, S_D_WRITE);
+               S_D_INIT, S_D_WRITE);
        signal state_int, state_next : HISTORY_STATE;
+       signal was_bs_int, was_bs_next : std_logic;
        signal s_done_int, s_done_next : std_logic;
        signal s_cnt_int, s_cnt_next : hspalte;
        signal d_new_eingabe_int, d_new_eingabe_next : std_logic;
        signal d_new_result_int, d_new_result_next : std_logic;
+       signal d_new_bs_int, d_new_bs_next: std_logic;
        signal d_done_int, d_done_next : std_logic;
        signal d_char_int, d_char_next : hbyte;
 
@@ -52,6 +55,7 @@ begin
        s_done <= s_done_int;
        d_new_eingabe <= d_new_eingabe_int;
        d_new_result <= d_new_result_int;
+       d_new_bs <= d_new_bs_int;
        d_done <= d_done_int;
        d_char <= d_char_int;
 
@@ -62,11 +66,13 @@ begin
                if sys_res_n = '0' then
                        -- internal
                        state_int <= SIDLE;
+                       was_bs_int <= '0';
                        -- out
                        s_done_int <= '0';
                        s_cnt_int <= (0 => '1', others => '0');
                        d_new_result_int <= '0';
                        d_new_eingabe_int <= '0';
+                       d_new_bs_int <= '0';
                        d_done_int <= '0';
                        d_char_int <= (others => '0');
 
@@ -78,11 +84,13 @@ begin
                elsif rising_edge(sys_clk) then
                        -- internal
                        state_int <= state_next;
+                       was_bs_int <= was_bs_next;
                        -- out
                        s_done_int <= s_done_next;
                        s_cnt_int <= s_cnt_next;
                        d_new_result_int <= d_new_result_next;
                        d_new_eingabe_int <= d_new_eingabe_next;
+                       d_new_bs_int <= d_new_bs_next;
                        d_done_int <= d_done_next;
                        d_char_int <= d_char_next;
 
@@ -95,19 +103,19 @@ begin
        end process;
 
        -- next state
-       process(state_int, d_get, do_it, s_take, s_backspace)
+       process(state_int, d_get, do_it, s_take, s_backspace, was_bs_int)
        begin
                state_next <= state_int;
 
                case state_int is
                        when SIDLE =>
                                -- S_S_FIN: tmp..
-                               if d_get = '1' then
-                                       state_next <= S_D_INIT;
+                               if s_take = '1' then
+                                       state_next <= S_S_INIT;
                                elsif do_it = '1' then
                                        state_next <= S_S_FIN;
-                               elsif s_take = '1' then
-                                       state_next <= S_S_INIT;
+                               elsif d_get = '1' then
+                                       state_next <= S_D_INIT;
                                end if;
                        when S_S_INIT =>
                                if s_backspace = '1' then
@@ -115,7 +123,9 @@ begin
                                else
                                        state_next <= S_S_WRITE;
                                end if;
-                       when S_S_WRITE | S_S_BS =>
+                       when S_S_WRITE =>
+                               state_next <= S_S_DONE;
+                       when S_S_BS =>
                                state_next <= S_S_DONE;
                        when S_S_FIN =>
                                if do_it = '0' then
@@ -127,8 +137,6 @@ begin
                                end if;
 
                        when S_D_INIT =>
-                               state_next <= S_D_WAIT;
-                       when S_D_WAIT =>
                                state_next <= S_D_WRITE;
                        when S_D_WRITE =>
                                if d_get = '0' then
@@ -139,12 +147,16 @@ begin
 
        -- out
        process(state_int, s_cnt_int, d_spalte, data_out, s_char, address_int,
-               data_in_int)
+               data_in_int, d_new_result_int, d_new_eingabe_int, d_new_bs_int,
+               was_bs_int, s_take)
+               variable addr_tmp : std_logic_vector(H_RAM_WIDTH - 1 downto 0);
        begin
                s_done_next <= '0';
                s_cnt_next <= s_cnt_int;
-               d_new_result_next <= '0';
-               d_new_eingabe_next <= '0';
+               was_bs_next <= was_bs_int;
+               d_new_result_next <= d_new_result_int;
+               d_new_eingabe_next <= d_new_eingabe_int;
+               d_new_bs_next <= '0';
                d_done_next <= '0';
                d_char_next <= (others => '0');
                finished_next <= '0';
@@ -154,31 +166,53 @@ begin
 
                case state_int is
                        when SIDLE =>
-                               null;
+                               -- TODO: tmp fix
+                               d_new_result_next <= '0';
                        when S_S_INIT =>
                                null;
                        when S_S_WRITE =>
-                               wr_next <= '1';
-                               address_next <= '0' & s_cnt_int;
-                               data_in_next <= s_char;
-                               s_cnt_next <= std_logic_vector(unsigned(s_cnt_int) + 1);
+                               -- nur bei < 71 weiter machen
+                               -- TODO: '/=' billiger als '<' ?
+                               if unsigned(s_cnt_int) /= 71 then
+                                       wr_next <= '1';
+                                       address_next <= s_cnt_int;
+                                       data_in_next <= s_char;
+                                       s_cnt_next <= std_logic_vector(unsigned(s_cnt_int) + 1);
+                               else
+                                       -- was_bs hier missbrauchen, um ein d_new_eingabe zu verhindern
+                                       was_bs_next <= '1';
+                               end if;
                        when S_S_BS =>
+                               -- ab 1 darf nicht mehr dekrementiert werden
+                               if unsigned(s_cnt_int) /= 1 then
+                                       addr_tmp := std_logic_vector(unsigned(s_cnt_int) - 1);
+                                       d_new_bs_next <= '1';
+                               else
+                                       addr_tmp := s_cnt_int;
+                               end if;
+                               s_cnt_next <= addr_tmp;
+               
                                wr_next <= '1';
-                               address_next <= '0' & std_logic_vector(unsigned(s_cnt_int) - 1);
+                               address_next <= addr_tmp;
                                data_in_next <= (others => '0');
-                               s_cnt_next <= std_logic_vector(unsigned(s_cnt_int) - 1);
+                               was_bs_next <= '1';
                        when S_S_FIN =>
                                finished_next <= '1';
                                s_cnt_next <= (0 => '1', others => '0');
                                d_new_result_next <= '1';
                        when S_S_DONE =>
                                s_done_next <= '1';
-                               d_new_eingabe_next <= '1';
+                               if was_bs_int = '0' then
+                                       d_new_eingabe_next <= '1';
+                               end if;
+                               if s_take = '0' then
+                                       was_bs_next <= '0';
+                               end if;
 
                        when S_D_INIT =>
-                               address_next <= '0' & d_spalte;
-                       when S_D_WAIT =>
-                               null;
+                               address_next <= d_spalte;
+                               d_new_eingabe_next <= '0';
+                               d_new_result_next <= '0';
                        when S_D_WRITE =>
                                d_char_next <= data_out;
                                d_done_next <= '1';