display: ergebnis mit '> ' prefix
[hwmod.git] / src / display.vhd
index 8fca39cc8e8372b726ad4800811dfe7ff94be4b6..d28e1580566a1c25b88f1fd07291ff0746db7851 100644 (file)
@@ -13,6 +13,7 @@ entity display is
                -- History
                d_new_eingabe : in std_logic;
                d_new_result : in std_logic;
+               d_new_bs : in std_logic;
                d_zeile : out hzeile;
                d_spalte : out hspalte;
                d_get : out std_logic;
@@ -26,14 +27,18 @@ entity display is
 end entity display;
 
 architecture beh of display is
-       type DISPLAY_STATE is (SIDLE, S_NEW_RESULT, S_NEW_INPUT, S_COUNTUP, S_GETCH,
-       S_CR1, S_NL1, S_PUTCH1, S_PUTCH2, S_WAIT, S_NOP1);
+       type DISPLAY_STATE is (SIDLE, S_NEW_BS, S_BACK, S_BLANK, S_NEW_RESULT,
+               S_ZEILEUP, S_NEW_INPUT, S_COUNTUP, S_GETCH, S_CR1, S_NL1, S_PUTCH1,
+               S_PUTCH2, S_WAIT, S_NOP1, S_READ_RESULT_0, S_READ_RESULT_1,
+               S_READ_RESULT_2, S_INIT, S_PS1_0, S_PS1_1, S_PS1_2, S_PS1_3, S_PS1_4,
+               S_PS1_5);
        signal state_int, state_next : DISPLAY_STATE;
        signal d_zeile_int, d_zeile_next : hzeile;
        signal d_spalte_int, d_spalte_next : hspalte;
        signal d_get_int, d_get_next : std_logic;
        signal command_int, command_next : std_logic_vector(7 downto 0);
        signal command_data_int, command_data_next : std_logic_vector(31 downto 0);
+       signal istate_next, istate_int : signed(4 downto 0);
 begin
        d_zeile <= d_zeile_int;
        d_spalte <= d_spalte_int;
@@ -45,7 +50,8 @@ begin
        begin
                if sys_res_n = '0' then
                        -- internal
-                       state_int <= SIDLE;
+                       state_int <= S_INIT;
+                       istate_int <= (others => '0');
                        -- out
                        d_zeile_int <= (others => '0');
                        d_spalte_int <= (others => '0');
@@ -55,6 +61,7 @@ begin
                elsif rising_edge(sys_clk) then
                        -- internal
                        state_int <= state_next;
+                       istate_int <= istate_next;
                        -- out
                        d_zeile_int <= d_zeile_next;
                        d_spalte_int <= d_spalte_next;
@@ -65,31 +72,107 @@ begin
        end process;
 
        -- next state
-       process(state_int, d_new_result, d_new_eingabe, d_done, free, d_spalte_int,
-               d_char)
+       process(state_int, d_new_result, d_new_eingabe, d_new_bs, d_done, free,
+               d_spalte_int, d_char, istate_int)
        begin
                state_next <= state_int;
+               istate_next <= istate_int;
 
                case state_int is
+                       when S_INIT =>
+                               state_next <= S_PS1_0;
+
+                       when S_PS1_0 =>
+                               istate_next <= b"01001";
+                               state_next <= S_WAIT;
+                       when S_PS1_1 =>
+                               istate_next <= b"01010";
+                               state_next <= S_WAIT;
+                       when S_PS1_2 =>
+                               istate_next <= b"01011";
+                               state_next <= S_WAIT;
+                       when S_PS1_3 =>
+                               istate_next <= b"01100";
+                               state_next <= S_WAIT;
+                       when S_PS1_4 =>
+                               istate_next <= b"01101";
+                               state_next <= S_WAIT;
+                       when S_PS1_5 =>
+                               istate_next <= b"00111";
+                               state_next <= S_WAIT;
+
                        when SIDLE =>
-                               if d_new_eingabe = '1' then
+                               istate_next <= b"00111"; -- default: immer wieder ins SIDLE;
+                               if d_new_bs = '1' then
+                                       state_next <= S_NEW_BS;
+                               elsif d_new_eingabe = '1' then
                                        state_next <= S_NEW_INPUT;
                                end if;
                                if d_new_result = '1' then
                                        state_next <= S_NEW_RESULT;
                                end if;
+
                        when S_NEW_RESULT =>
-                               state_next <= S_CR1;
+                               state_next <= S_ZEILEUP;
                        when S_NEW_INPUT =>
                                state_next <= S_COUNTUP;
+
+                       when S_NEW_BS =>
+                               state_next <= S_BACK;
+                       when S_BACK =>
+                               if free = '0' then
+                                       state_next <= S_WAIT;
+                                       case istate_int is
+                                               when b"00111" => istate_next <= b"00001"; -- => danach S_BLANK und wieder hierher
+                                               when others => istate_next <= b"00111"; -- => danach SIDLE
+                                       end case;
+                               end if;
+                       when S_BLANK =>
+                               if free = '0' then
+                                       state_next <= S_WAIT;
+                                       istate_next <= b"00010"; -- => danach S_BACK
+                               end if;
+
+                       when S_ZEILEUP =>
+                               case istate_int is
+                                       when b"00011" =>
+                                               state_next <= S_WAIT;
+                                               istate_next <= b"01000"; -- => danach S_PS1
+                                       when others => state_next <= S_CR1;
+                               end case;
+
                        when S_CR1 =>
                                if free = '0' then
-                                       state_next <= S_NL1;
+                                       state_next <= S_WAIT;
+                                       case istate_int is
+                                               when b"00110" => istate_next <= b"00101"; -- => danach S_NL1, S_ZEILEUP, S_PS1, SIDLE
+                                               when others => istate_next <= b"00000"; -- => danach S_NL1 und S_COUNTUP
+                                       end case;
                                end if;
                        when S_NL1 =>
                                if free = '0' then
+                                       state_next <= S_WAIT;
+                                       case istate_int is
+                                               when b"00101" => istate_next <= b"00011"; -- => danach S_ZEILEUP, PS1
+                                               when others => istate_next <= b"10000"; -- => danach S_READ_RESULT_0
+                                       end case;
+                               end if;
+
+                       when S_READ_RESULT_0 =>
+                               istate_next <= b"10001";
+                               state_next <= S_WAIT;
+                       when S_READ_RESULT_1 =>
+                               istate_next <= b"10010";
+                               state_next <= S_WAIT;
+                       when S_READ_RESULT_2 =>
+                               if unsigned(d_spalte_int) /= 70 then
                                        state_next <= S_COUNTUP;
+                                       istate_next <= b"10010"; -- => wieder nach S_READ_RESULT_2
+                               else
+                                       state_next <= S_WAIT;
+                                       istate_next <= b"00110"; -- => danach S_CR1 und d_spalte_next clearen und d_zeile_next inkrementieren
                                end if;
+
                        when S_COUNTUP =>
                                state_next <= S_GETCH;
                        when S_GETCH =>
@@ -108,12 +191,26 @@ begin
                                end if;
                        when S_NOP1 =>
                                if free = '1' then
-                                       state_next <= SIDLE;
-                                       --if unsigned(d_spalte_int) = 71 then
-                                       --      state_next <= SIDLE;
-                                       --else
-                                       --      state_next <= S_COUNTUP;
-                                       --end if;
+                                       case istate_int is
+                                               when b"00000" => state_next <= S_NL1;
+                                               when b"00001" => state_next <= S_BLANK;
+                                               when b"00010" => state_next <= S_BACK;
+                                               when b"00011" => state_next <= S_ZEILEUP;
+                                               when b"00110" => state_next <= S_CR1;
+                                               when b"00101" => state_next <= S_NL1;
+
+                                               when b"10000" => state_next <= S_READ_RESULT_0;
+                                               when b"10001" => state_next <= S_READ_RESULT_1;
+                                               when b"10010" => state_next <= S_READ_RESULT_2;
+
+                                               when b"01000" => state_next <= S_PS1_0;
+                                               when b"01001" => state_next <= S_PS1_1;
+                                               when b"01010" => state_next <= S_PS1_2;
+                                               when b"01011" => state_next <= S_PS1_3;
+                                               when b"01100" => state_next <= S_PS1_4;
+                                               when b"01101" => state_next <= S_PS1_5;
+                                               when others => state_next <= SIDLE;
+                                       end case;
                                end if;
                end case;
        end process;
@@ -129,22 +226,69 @@ begin
                command_data_next <= command_data_int;
 
                case state_int is
-                       when SIDLE =>
-                               null;
-                       when S_NEW_INPUT =>
-                               null;
-                       when S_NEW_RESULT =>
+                       when S_INIT => null;
+
+                       -- TODO: coole farben
+                       when S_PS1_0 =>
+                               command_next <= COMMAND_SET_CHAR;
+                               command_data_next <= x"ffffff" & x"28"; -- '('
+                       when S_PS1_1 =>
+                               command_next <= COMMAND_SET_CHAR;
+                               -- d_zeile/2, zehnerstelle
+                               command_data_next <= x"ffffff" & x"78"; -- 'x'
+                       when S_PS1_2 =>
+                               command_next <= COMMAND_SET_CHAR;
+                               -- d_zeile/2, einerstelle
+                               command_data_next <= x"ffffff" & x"79"; -- 'y'
+                       when S_PS1_3 =>
+                               command_next <= COMMAND_SET_CHAR;
+                               command_data_next <= x"ffffff" & x"29"; -- ')'
+                       when S_PS1_4 =>
+                               command_next <= COMMAND_SET_CHAR;
+                               command_data_next <= x"ffffff" & x"24"; -- '$'
+                       when S_PS1_5 =>
+                               command_next <= COMMAND_SET_CHAR;
+                               command_data_next <= x"ffffff" & x"20"; -- ' '
+
+                       when SIDLE => null;
+                       when S_NEW_RESULT => null;
+                       when S_NEW_INPUT => null;
+
+                       when S_NEW_BS =>
+                               -- underflow check schon im history modul
+                               d_spalte_next <= std_logic_vector(unsigned(d_spalte_int) - 1);
+                       when S_BACK =>
+                               -- einen schritt zurueck, +6 wegen $PS1
+                               command_next <= COMMAND_SET_CURSOR_COLUMN;
+                               command_data_next <= x"ffffff" & '0' & std_logic_vector(unsigned(d_spalte_int) + 6);
+                       when S_BLANK =>
+                               command_next <= COMMAND_SET_CHAR;
+                               command_data_next <= x"ffffff" & x"20"; -- white space
+
+                       when S_ZEILEUP =>
                                d_spalte_next <= (others => '0');
                                case d_zeile_int is
-                                       when "11111" => d_zeile_next <= "00000";
+                                       -- 49 * 2 + 1
+                                       when "1100010" => d_zeile_next <= (others => '0');
                                        when others => d_zeile_next <= std_logic_vector(unsigned(d_zeile_int) + 1);
                                end case;
+
                        when S_CR1 =>
                                command_next <= COMMAND_SET_CHAR;
                                command_data_next <= x"ffffff" & x"0d"; -- carrige return
                        when S_NL1 =>
                                command_next <= COMMAND_SET_CHAR;
                                command_data_next <= x"ffffff" & x"0a"; -- newline
+
+                       -- TODO: coole farben
+                       when S_READ_RESULT_0 =>
+                               command_next <= COMMAND_SET_CHAR;
+                               command_data_next <= x"ffffff" & x"3e"; -- '>'
+                       when S_READ_RESULT_1 =>
+                               command_next <= COMMAND_SET_CHAR;
+                               command_data_next <= x"ffffff" & x"20"; -- ' '
+                       when S_READ_RESULT_2 => null;
+
                        when S_COUNTUP =>
                                d_get_next <= '1';
                                d_spalte_next <= std_logic_vector(unsigned(d_spalte_int) + 1);