开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VHDL/FPGA/Verilog > 查看源码
control_fsm_rtl.vhd
资源名称：8051的内核(vhdl).zip　[点击查看]
上传用户：sztwq510
上传日期：2007-04-20
资源大小：209k
文件大小：97k
源码类别：

VHDL/FPGA/Verilog

开发平台：

Matlab

control_fsm_rtl.vhd：源码内容
  1. -------------------------------------------------------------------------------
  2. --                                                                           --
  3. --          X       X   XXXXXX    XXXXXX    XXXXXX    XXXXXX      X          --
  4. --          XX     XX  X      X  X      X  X      X  X           XX          --
  5. --          X X   X X  X         X      X  X      X  X          X X          --
  6. --          X  X X  X  X         X      X  X      X  X         X  X          --
  7. --          X   X   X  X          XXXXXX   X      X   XXXXXX      X          --
  8. --          X       X  X         X      X  X      X         X     X          --
  9. --          X       X  X         X      X  X      X         X     X          --
  10. --          X       X  X      X  X      X  X      X         X     X          --
  11. --          X       X   XXXXXX    XXXXXX    XXXXXX    XXXXXX      X          --
  12. --                                                                           --
  13. --                                                                           --
  14. --                       O R E G A N O   S Y S T E M S                       --
  15. --                                                                           --
  16. --                            Design & Consulting                            --
  17. --                                                                           --
  18. -------------------------------------------------------------------------------
  19. --                                                                           --
  20. --         Web:           http://www.oregano.at/                             --
  21. --                                                                           --
  22. --         Contact:       mc8051@oregano.at                                  --
  23. --                                                                           --
  24. -------------------------------------------------------------------------------
  25. --                                                                           --
  26. --  MC8051 - VHDL 8051 Microcontroller IP Core                               --
  27. --  Copyright (C) 2001 OREGANO SYSTEMS                                       --
  28. --                                                                           --
  29. --  This library is free software; you can redistribute it and/or            --
  30. --  modify it under the terms of the GNU Lesser General Public               --
  31. --  License as published by the Free Software Foundation; either             --
  32. --  version 2.1 of the License, or (at your option) any later version.       --
  33. --                                                                           --
  34. --  This library is distributed in the hope that it will be useful,          --
  35. --  but WITHOUT ANY WARRANTY; without even the implied warranty of           --
  36. --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU        --
  37. --  Lesser General Public License for more details.                          --
  38. --                                                                           --
  39. --  Full details of the license can be found in the file LGPL.TXT.           --
  40. --                                                                           --
  41. --  You should have received a copy of the GNU Lesser General Public         --
  42. --  License along with this library; if not, write to the Free Software      --
  43. --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA  --
  44. --                                                                           --
  45. -------------------------------------------------------------------------------
  46. --
  47. --
  48. --         Author:                 Helmut Mayrhofer
  49. --
  50. --         Filename:               control_fsm_rtl.vhd
  51. --
  52. --         Date of Creation:       Mon Aug  9 12:14:48 1999
  53. --
  54. --         Version:                $Revision: 1.6 $
  55. --
  56. --         Date of Latest Version: $Date: 2002/01/07 12:17:44 $
  57. --
  58. --
  59. --         Description: Decode instruction and execute it. Pure combinational
  60. --                      descripton of the finite state machine.
  61. --
  62. --
  63. --
  64. --
  65. -------------------------------------------------------------------------------
  66. architecture rtl of control_fsm is
  68.   alias CY : std_logic is psw(7);              -- carry
  69.   alias AC : std_logic is psw(6);              -- auxilary carry
  70.   alias OV : std_logic is psw(2);              -- overflow flag
  71.   alias EA:  std_logic is ie(7);               -- enable interupts
  72.   alias ES:  std_logic is ie(4);               -- enable serial interupt
  73.   alias ET1: std_logic is ie(3);               -- enable timer 1 interupt
  74.   alias EX1: std_logic is ie(2);               -- enable external 1 interupt
  75.   alias ET0: std_logic is ie(1);               -- enable timer 0 interupt
  76.   alias EX0: std_logic is ie(0);               -- enable external 0 interupt
  77.   alias PS0: std_logic is ip(4);               -- priority of serial interupt
  78.   alias PT1: std_logic is ip(3);               -- priority of timer1 interupt
  79.   alias PX1: std_logic is ip(2);               -- priority of ext1 interupt
  80.   alias PT0: std_logic is ip(1);               -- priority of timer0 interupt
  81.   alias PX0: std_logic is ip(0);               -- priority of ext0 interupt
  83.   signal state:         t_state;               -- actual state
  84.   signal s_nextstate:   t_state;               -- enable signal for state
  85.   signal s_instr_category : t_instr_category;  -- predecoded insturction
  86.   
  87.   signal s_help:        unsigned (7 downto 0); -- general help-register
  89.   signal s_bit_data :   std_logic;             -- bitdata from MUX
  90.   signal s_intpre:      std_logic;             -- an interrupt must start
  91.   signal s_intpre2:     std_logic;             -- prepare for interrupt
  92.   signal s_inthigh:     std_logic;             -- high priority int is running
  93.   signal s_intlow:      std_logic;             -- low priority int is running
  95.   signal s_tf1 :        std_logic;               -- Timer1-Overflowflag
  96.   signal s_tf0 :        std_logic;               -- Timer0-Overflowflag
  97.   signal s_ie1 :        std_logic;               -- ExtINT1-Flag
  98.   signal s_it1 :        std_logic;               -- edge-sensitive-Bit EXT1
  99.   signal s_ie0 :        std_logic;               -- ExtINT0-Flag
  100.   signal s_it0 :        std_logic;               -- edge-sensitive-Bit EXT0
  102.   signal s_ri : std_logic;                       -- serial receive-ready
  103.   signal s_ti : std_logic;                       -- serial transmit-ready
  105.   signal s_command:     std_logic_vector (7 downto 0); -- actual command
  107.   signal s_pc_inc_en  : std_logic_vector (3 downto 0);  -- pc control
  108.   signal s_regs_wr_en : std_logic_vector (2 downto 0);  -- write control
  109.   signal s_data_mux   : std_logic_vector (3 downto 0);  -- data control
  110.   signal s_bdata_mux  : std_logic_vector (3 downto 0);  -- bitdata control
  111.   signal s_adr_mux    : std_logic_vector (3 downto 0);  -- adress control
  112.   signal s_adrx_mux   : std_logic_vector (1 downto 0);  -- ext. adress control
  113.   signal s_wrx_mux    : std_logic;                      -- ext. write control
  114.   signal s_help_en    : std_logic_vector (3 downto 0);  -- helpreg control
  115.   signal s_help16_en  : std_logic_vector (1 downto 0);  -- help16 control
  116.   signal s_helpb_en   : std_logic;                      -- helpbit control
  117.   signal s_intpre2_d  : std_logic;                      -- intput of intpre2
  118.   signal s_intpre2_en : std_logic;                      -- control
  119.   signal s_intlow_d   : std_logic;                      -- input of intlow
  120.   signal s_intlow_en  : std_logic;                      -- control
  121.   signal s_inthigh_d  : std_logic;                      -- input of inthigh
  122.   signal s_inthigh_en : std_logic;                      -- control
  124. begin
  126.   -- some simple signal-assignments for outputs
  128.   pc_inc_en_o  <= s_pc_inc_en;
  129.   nextstate_o  <= s_nextstate;
  130.   adr_mux_o    <= s_adr_mux;
  131.   adrx_mux_o   <= s_adrx_mux;
  132.   wrx_mux_o    <= s_wrx_mux;
  133.   data_mux_o   <= s_data_mux;
  134.   bdata_mux_o  <= s_bdata_mux;
  135.   regs_wr_en_o <= s_regs_wr_en;
  136.   help_en_o    <= s_help_en;
  137.   help16_en_o  <= s_help16_en;
  138.   helpb_en_o   <= s_helpb_en;
  139.   inthigh_en_o <= s_inthigh_en;
  140.   intlow_en_o  <= s_intlow_en;
  141.   intpre2_en_o <= s_intpre2_en;
  142.   inthigh_d_o  <= s_inthigh_d;
  143.   intlow_d_o   <= s_intlow_d;
  144.   intpre2_d_o  <= s_intpre2_d;
  146.   -- some simple signal assignments from intputs
  148.   state      <= state_i;
  149.   s_help     <= unsigned(help_i);
  150.   s_bit_data <= bit_data_i;
  151.   s_command  <= command_i;
  152.   s_inthigh  <= inthigh_i;
  153.   s_intlow   <= intlow_i;
  154.   s_intpre   <= intpre_i;
  155.   s_intpre2  <= intpre2_i;
  156.   s_ti       <= ti_i;
  157.   s_ri       <= ri_i;
  158.   s_it0      <= it0_i;
  159.   s_ie0      <= ie0_i;
  160.   s_it1      <= it1_i;
  161.   s_ie1      <= ie1_i;
  162.   s_tf0      <= tf0_i;
  163.   s_tf1      <= tf1_i;
  165.   -- predecode instruction
  166.   s_instr_category <=
  167.     IC_ACALL          when s_command(4 downto 0) = ACALL          else
  168.     IC_ADD_A_RR       when s_command(7 downto 3) = ADD_A_RR       else
  169.     IC_ADD_A_D        when s_command             = ADD_A_D        else
  170.     IC_ADD_A_ATRI     when s_command(7 downto 1) = ADD_A_ATRI     else
  171.     IC_ADD_A_DATA     when s_command             = ADD_A_DATA     else
  172.     IC_ADDC_A_RR      when s_command(7 downto 3) = ADDC_A_RR      else
  173.     IC_ADDC_A_D       when s_command             = ADDC_A_D       else
  174.     IC_ADDC_A_ATRI    when s_command(7 downto 1) = ADDC_A_ATRI    else
  175.     IC_ADDC_A_DATA    when s_command             = ADDC_A_DATA    else
  176.     IC_AJMP           when s_command(4 downto 0) = AJMP           else
  177.     IC_ANL_A_RR       when s_command(7 downto 3) = ANL_A_RR       else
  178.     IC_ANL_A_D        when s_command             = ANL_A_D        else
  179.     IC_ANL_A_ATRI     when s_command(7 downto 1) = ANL_A_ATRI     else
  180.     IC_ANL_A_DATA     when s_command             = ANL_A_DATA     else
  181.     IC_ANL_D_A        when s_command             = ANL_D_A        else
  182.     IC_ANL_D_DATA     when s_command             = ANL_D_DATA     else
  183.     IC_ANL_C_BIT      when s_command             = ANL_C_BIT      else
  184.     IC_ANL_C_NBIT     when s_command             = ANL_C_NBIT     else
  185.     IC_CJNE_A_D       when s_command             = CJNE_A_D       else
  186.     IC_CJNE_A_DATA    when s_command             = CJNE_A_DATA    else
  187.     IC_CJNE_RR_DATA   when s_command(7 downto 3) = CJNE_RR_DATA   else
  188.     IC_CJNE_ATRI_DATA when s_command(7 downto 1) = CJNE_ATRI_DATA else
  189.     IC_CLR_A          when s_command             = CLR_A          else
  190.     IC_CLR_C          when s_command             = CLR_C          else
  191.     IC_CLR_BIT        when s_command             = CLR_BIT        else
  192.     IC_CPL_A          when s_command             = CPL_A          else
  193.     IC_CPL_C          when s_command             = CPL_C          else
  194.     IC_CPL_BIT        when s_command             = CPL_BIT        else
  195.     IC_DA_A           when s_command             = DA_A           else
  196.     IC_DEC_A          when s_command             = DEC_A          else
  197.     IC_DEC_RR         when s_command(7 downto 3) = DEC_RR         else
  198.     IC_DEC_D          when s_command             = DEC_D          else
  199.     IC_DEC_ATRI       when s_command(7 downto 1) = DEC_ATRI       else
  200.     IC_DIV_AB         when s_command             = DIV_AB         else
  201.     IC_DJNZ_RR        when s_command(7 downto 3) = DJNZ_RR        else
  202.     IC_DJNZ_D         when s_command             = DJNZ_D         else
  203.     IC_INC_A          when s_command             = INC_A          else
  204.     IC_INC_RR         when s_command(7 downto 3) = INC_RR         else
  205.     IC_INC_D          when s_command             = INC_D          else
  206.     IC_INC_ATRI       when s_command(7 downto 1) = INC_ATRI       else
  207.     IC_INC_DPTR       when s_command             = INC_DPTR       else
  208.     IC_JB             when s_command             = JB             else
  209.     IC_JBC            when s_command             = JBC            else
  210.     IC_JC             when s_command             = JC             else
  211.     IC_JMP_A_DPTR     when s_command             = JMP_A_DPTR     else
  212.     IC_JNB            when s_command             = JNB            else
  213.     IC_JNC            when s_command             = JNC            else
  214.     IC_JNZ            when s_command             = JNZ            else
  215.     IC_JZ             when s_command             = JZ             else
  216.     IC_LCALL          when s_command             = LCALL          else
  217.     IC_LJMP           when s_command             = LJMP           else
  218.     IC_MOV_A_RR       when s_command(7 downto 3) = MOV_A_RR       else
  219.     IC_MOV_A_D        when s_command             = MOV_A_D        else
  220.     IC_MOV_A_ATRI     when s_command(7 downto 1) = MOV_A_ATRI     else
  221.     IC_MOV_A_DATA     when s_command             = MOV_A_DATA     else
  222.     IC_MOV_RR_A       when s_command(7 downto 3) = MOV_RR_A       else
  223.     IC_MOV_RR_D       when s_command(7 downto 3) = MOV_RR_D       else
  224.     IC_MOV_RR_DATA    when s_command(7 downto 3) = MOV_RR_DATA    else
  225.     IC_MOV_D_A        when s_command             = MOV_D_A        else
  226.     IC_MOV_D_RR       when s_command(7 downto 3) = MOV_D_RR       else
  227.     IC_MOV_D_D        when s_command             = MOV_D_D        else
  228.     IC_MOV_D_ATRI     when s_command(7 downto 1) = MOV_D_ATRI     else
  229.     IC_MOV_D_DATA     when s_command             = MOV_D_DATA     else
  230.     IC_MOV_ATRI_A     when s_command(7 downto 1) = MOV_ATRI_A     else
  231.     IC_MOV_ATRI_D     when s_command(7 downto 1) = MOV_ATRI_D     else
  232.     IC_MOV_ATRI_DATA  when s_command(7 downto 1) = MOV_ATRI_DATA  else
  233.     IC_MOVC_A_ATDPTR  when s_command             = MOVC_A_ATDPTR  else
  234.     IC_MOVC_A_ATPC    when s_command             = MOVC_A_ATPC    else
  235.     IC_MOVX_A_ATRI    when s_command(7 downto 1) = MOVX_A_ATRI    else
  236.     IC_MOVX_A_ATDPTR  when s_command             = MOVX_A_ATDPTR  else
  237.     IC_MOVX_ATRI_A    when s_command(7 downto 1) = MOVX_ATRI_A    else
  238.     IC_MOVX_ATDPTR_A  when s_command             = MOVX_ATDPTR_A  else
  239.     IC_MOV_C_BIT      when s_command             = MOV_C_BIT      else
  240.     IC_MOV_BIT_C      when s_command             = MOV_BIT_C      else
  241.     IC_MOV_DPTR_DATA  when s_command             = MOV_DPTR_DATA  else
  242.     IC_MUL_AB         when s_command             = MUL_AB         else
  243.     IC_NOP            when s_command             = NOP            else
  244.     IC_ORL_A_RR       when s_command(7 downto 3) = ORL_A_RR       else
  245.     IC_ORL_A_D        when s_command             = ORL_A_D        else
  246.     IC_ORL_A_ATRI     when s_command(7 downto 1) = ORL_A_ATRI     else
  247.     IC_ORL_A_DATA     when s_command             = ORL_A_DATA     else
  248.     IC_ORL_D_A        when s_command             = ORL_D_A        else
  249.     IC_ORL_D_DATA     when s_command             = ORL_D_DATA     else
  250.     IC_ORL_C_BIT      when s_command             = ORL_C_BIT      else
  251.     IC_ORL_C_NBIT     when s_command             = ORL_C_NBIT     else
  252.     IC_POP            when s_command             = POP            else
  253.     IC_PUSH           when s_command             = PUSH           else
  254.     IC_RET            when s_command             = RET            else
  255.     IC_RETI           when s_command             = RETI           else
  256.     IC_RL_A           when s_command             = RL_A           else
  257.     IC_RLC_A          when s_command             = RLC_A          else
  258.     IC_RR_A           when s_command             = RR_A           else
  259.     IC_RRC_A          when s_command             = RRC_A          else
  260.     IC_SETB_C         when s_command             = SETB_C         else
  261.     IC_SETB_BIT       when s_command             = SETB_BIT       else
  262.     IC_SJMP           when s_command             = SJMP           else
  263.     IC_SUBB_A_RR      when s_command(7 downto 3) = SUBB_A_RR      else
  264.     IC_SUBB_A_D       when s_command             = SUBB_A_D       else
  265.     IC_SUBB_A_ATRI    when s_command(7 downto 1) = SUBB_A_ATRI    else
  266.     IC_SUBB_A_DATA    when s_command             = SUBB_A_DATA    else
  267.     IC_SWAP_A         when s_command             = SWAP_A         else
  268.     IC_XCH_A_RR       when s_command(7 downto 3) = XCH_A_RR       else
  269.     IC_XCH_A_D        when s_command             = XCH_A_D        else
  270.     IC_XCH_A_ATRI     when s_command(7 downto 1) = XCH_A_ATRI     else
  271.     IC_XCHD_A_ATRI    when s_command(7 downto 1) = XCHD_A_ATRI    else
  272.     IC_XRL_A_RR       when s_command(7 downto 3) = XRL_A_RR       else
  273.     IC_XRL_A_D        when s_command             = XRL_A_D        else
  274.     IC_XRL_A_ATRI     when s_command(7 downto 1) = XRL_A_ATRI     else
  275.     IC_XRL_A_DATA     when s_command             = XRL_A_DATA     else
  276.     IC_XRL_D_A        when s_command             = XRL_D_A        else
  277.     IC_XRL_D_DATA     when s_command             = XRL_D_DATA     else
  278.     IC_NOP;
  279.   
  280. ------------------------------------------------------------------------------
  281. -- purpose: main-process to control the mcu
  282. --          includes the interupt-handling and the state machine
  283. -- inputs:  state,s_help,s_ti,s_ri,s_it0,s_ie0,s_it1,s_ie1,s_tf0,s_tf1,
  284. --          s_bit_data,aludata_i,s_command,s_inthigh,
  285. --          s_intlow,acc,psw,s_intpre,s_intpre2,ie,ip
  286. -- outputs: pc_inc_en_o,s_nextstate_o,adr_mux_o,data_mux_o,bdata_mux_o
  287. --          regs_wr_en_o,help_en_o,help16_en_o,helpb_en_o,inthigh_en_o
  288. --          intlow_en_o,intpre2_en_o,inthigh_d_o,intlow_d_o,intpre2_d_o
  289. ------------------------------------------------------------------------------
  291.  p_state: process (state,s_help,s_ti,s_ri,s_it0,s_ie0,s_it1,s_ie1,s_tf0,s_tf1,
  292.                    s_bit_data,aludata_i,s_instr_category,s_inthigh,
  293.                    s_intlow,acc,psw,s_intpre,s_intpre2,ie,ip)
  294.   begin
  295.     s_data_mux   <= "0000";             -- default values
  296.     s_adr_mux    <= "0000";
  297.     s_bdata_mux  <= "0000";
  298.     alu_cmd_o    <= OFF;
  299.     s_regs_wr_en <= "000";
  300.     s_help_en    <= "0000";
  301.     s_help16_en  <= "00";
  302.     s_helpb_en   <= '0';
  303.     s_pc_inc_en  <= "0000";
  304.     s_inthigh_en <= '0';
  305.     s_intlow_en  <= '0';
  306.     s_intpre2_en <= '0';
  307.     s_inthigh_d  <= '0';
  308.     s_intlow_d   <= '0';
  309.     s_intpre2_d  <= '0';
  310.     s_adrx_mux   <= "00";
  311.     s_wrx_mux    <= '0';
  312.     s_nextstate  <= FETCH;
  314.     if state=STARTUP then
  315.       -- Power up wait cycle
  316.       NULL;
  317.     else
  318.       -- begin of starting the interrupt procedure
  319.                                                       -- saving the old adress
  320.       if (s_intpre='1' and state=FETCH) or s_intpre2='1' then
  321.         if state=FETCH then
  322.           s_intpre2_en <= '1';
  323.           s_intpre2_d <= '1';
  324.           s_regs_wr_en <= "001";            -- increment stackpointer
  325.           s_nextstate <= EXEC1;
  326.         elsif state=EXEC1 then
  327.           if (PX0 and EX0 and s_ie0)='1' then   -- external interrupt 0
  328.             s_help_en <= "0101";                -- interruptvector 0003h
  329.             s_inthigh_d <= '1';
  330.             s_inthigh_en <= '1';
  331.             if s_it0='1' then         -- interrupt is edge-sensitive
  332.               s_adr_mux <= "0001";
  333.               s_regs_wr_en <= "110";  -- reset IE0
  334.             else
  335.               NULL;
  336.             end if;
  337.           elsif (PT0 and ET0 and s_tf0)='1' then  -- timer interrupt 0
  338.             s_help_en <= "0110";                  -- interruptvector 000Bh
  339.             s_inthigh_d <= '1';
  340.             s_inthigh_en <= '1';
  341.             s_adr_mux <= "0010";
  342.             s_regs_wr_en <= "110";                -- reset TF0
  343.           elsif (PX1 and EX1 and s_ie1)='1' then  -- external interrupt 1
  344.             s_help_en <= "0111";                  -- interruptvector 0013h
  345.             s_inthigh_d <= '1';
  346.             s_inthigh_en <= '1';
  347.             if s_it1='1' then         -- interrupt is edge-sensitive
  348.               s_adr_mux <= "0011";
  349.               s_regs_wr_en <= "110";  -- reset IE1
  350.             else
  351.               NULL;
  352.             end if;
  353.           elsif (PT1 and ET1 and s_tf1)='1' then  -- timer interrupt 1
  354.             s_help_en <= "1000";                  -- interruptvector 001Bh
  355.             s_inthigh_d <= '1';
  356.             s_inthigh_en <= '1';
  357.             s_adr_mux <= "0100";
  358.             s_regs_wr_en <= "110";          -- reset TF1
  359.           elsif (PS0 and ES and (s_ri or s_ti))='1' then -- serial interrupt 0
  360.             s_help_en <= "1001";            -- interruptvector 0023h
  361.             s_inthigh_d <= '1';
  362.             s_inthigh_en <= '1';
  363.          elsif (EX0 and s_ie0)='1' then   -- external interrupt 0 low priority
  364.             s_help_en <= "0101";          -- interruptvector 0003h
  365.             s_intlow_d <= '1';
  366.             s_intlow_en <= '1';
  367.             if s_it0='1' then         -- interrupt is edge-sensitive
  368.               s_adr_mux <= "0001";
  369.               s_regs_wr_en <= "110";  -- reset IE0
  370.             else
  371.               NULL;
  372.             end if;
  373.           elsif (ET0 and s_tf0)='1' then   -- timer interrupt 0 low priority
  374.             s_help_en <= "0110";           -- interruptvector 000Bh
  375.             s_intlow_d <= '1';
  376.             s_intlow_en <= '1';
  377.             s_adr_mux <= "0010";
  378.             s_regs_wr_en <= "110";         -- reset TF0
  379.           elsif (EX1 and s_ie1)='1' then   -- external interrupt 1 low priority
  380.             s_help_en <= "0111";           -- interruptvector 0013h
  381.             s_intlow_d <= '1';
  382.             s_intlow_en <= '1';
  383.             if s_it0='1' then         -- interrupt is edge-sensitive
  384.               s_adr_mux <= "0011";
  385.               s_regs_wr_en <= "110";  -- reset IE1
  386.             else
  387.               NULL;
  388.             end if;
  389.           elsif (ET1 and s_tf1)='1' then   -- timer interrupt 1 low priority
  390.             s_help_en <= "1000";           -- interruptvector 001Bh
  391.             s_intlow_d <= '1';
  392.             s_intlow_en <= '1';
  393.             s_adr_mux <= "0100";
  394.             s_regs_wr_en <= "110";               -- reset TF1
  395.           elsif (ES and (s_ri or s_ti))='1' then -- serial int 0 low priority
  396.             s_help_en <= "1001";                 -- interruptvector 0023h
  397.             s_intlow_d <= '1';
  398.             s_intlow_en <= '1';
  399.           else
  400.             NULL;
  401.           end if;
  402.           s_nextstate <= EXEC2;
  403.         elsif state=EXEC2 then
  404.           s_adr_mux <= "0101";
  405.           s_data_mux <= "0001";         -- data = pc(7 downto 0)
  406.           s_regs_wr_en <= "101";        -- write one byte and increment SP
  407.           s_nextstate <= EXEC3;
  408.         elsif state=EXEC3 then
  409.           s_intpre2_d <= '0';
  410.           s_intpre2_en <= '1';
  411.           s_adr_mux <= "0101";
  412.           s_data_mux <= "0010";         -- data = pc(15 downto 8)
  413.           s_regs_wr_en <= "100";        -- write one byte
  414.           s_pc_inc_en <= "0011";        -- load program counter
  415.           s_nextstate <= FETCH;
  416.         else
  417.           s_nextstate <= FETCH;
  418.         end if;
  420.        -- end of starting interrupt procedure
  422.        else
  424.         case s_instr_category is
  426.           ---------------------------------------------------------------------
  428.           when IC_ACALL =>              -- ACALL addr11
  429.             if state=FETCH then
  430.               s_adr_mux <= "1111";      -- adress = sp + 1
  431.               s_data_mux <= "1110";     -- data = (pc+2)(7 downto 0)
  432.               s_regs_wr_en <= "101";    -- write one byte and increment SP
  433.               s_help16_en <= "10";      -- s_help16 = pc+2
  434.               s_pc_inc_en <= "0001";    -- increment program-counter
  435.               s_nextstate <= EXEC1;
  436.             elsif state=EXEC1 then
  437.               s_adr_mux <= "1111";       -- adress = sp + 1
  438.               s_data_mux <= "1101";      -- data = s_help16(15 downto 8)
  439.               s_regs_wr_en <= "101";     -- write one byte and increment SP
  440.               s_pc_inc_en <= "0100";     -- load PC with 11 bits (2k block)
  441.               s_nextstate <= FETCH;
  442.             end if;
  444.           ---------------------------------------------------------------------
  446.           when IC_ADD_A_RR =>           -- ADD A,Rr
  447.             if state=FETCH then
  448.               s_adr_mux <= "0110";      -- adress = RR-adress
  449.               s_nextstate <= EXEC1;
  450.             elsif state=EXEC1 then
  451.               alu_cmd_o <= ADD_ACC_RAM; -- addition command (ACC + RAM_DATA)
  452.               s_data_mux <= "0011";     -- data = aludata_i
  453.               s_regs_wr_en <= "011";    -- write ACC and CY,OV,AC
  454.               s_pc_inc_en <= "0001";    -- increment program-counter
  455.               s_nextstate <= FETCH;
  456.             end if;
  458.           ---------------------------------------------------------------------
  460.           when IC_ADD_A_D =>            -- ADD A, direct
  461.             if state=FETCH then
  462.               s_pc_inc_en <= "0001";    -- increment program-counter
  463.               s_nextstate <= EXEC1;
  464.             elsif state=EXEC1 then
  465.               s_adr_mux <= "1000";      -- adress = rom_data_i
  466.               s_nextstate <= EXEC2;
  467.             elsif state=EXEC2 then
  468.               alu_cmd_o <= ADD_ACC_RAM; -- addition command (ACC + RAM_DATA)
  469.               s_data_mux <= "0011";     -- data = aludata_i
  470.               s_regs_wr_en <= "011";    -- write ACC and CY,OV,AC
  471.               s_pc_inc_en <= "0001";    -- increment program-counter
  472.               s_nextstate <= FETCH;
  473.             end if;
  475.           ---------------------------------------------------------------------
  477.           when IC_ADD_A_ATRI =>         -- ADD A,@Ri
  478.             if state=FETCH then
  479.               s_adr_mux <= "0111";      -- address = Ri-register
  480.               s_nextstate <= EXEC1;
  481.             elsif state=EXEC1 then
  482.               alu_cmd_o <= ADD_ACC_RAM; -- addition command (ACC + RAM_DATA)
  483.               s_data_mux <= "0011";     -- data = aludata_i
  484.               s_regs_wr_en <= "011";    -- write ACC and CY,OV,AC
  485.               s_pc_inc_en <= "0001";    -- increment program-counter
  486.               s_nextstate <= FETCH;
  487.             end if;
  489.           ---------------------------------------------------------------------
  491.           when IC_ADD_A_DATA =>         -- ADD A, DATA
  492.             if state=FETCH then
  493.               s_pc_inc_en <= "0001";    -- increment program-counter
  494.               s_nextstate <= EXEC1;
  495.             elsif state=EXEC1 then
  496.               alu_cmd_o <= ADD_ACC_ROM; -- addition command (ACC + ROM_DATA_I)
  497.               s_data_mux <= "0011";     -- data = aludata_i
  498.               s_regs_wr_en <= "011";    -- write ACC and CY,OV,AC
  499.               s_pc_inc_en <= "0001";    -- increment program-counter
  500.               s_nextstate <= FETCH;
  501.             end if;
  503.           ---------------------------------------------------------------------
  505.           when IC_ADDC_A_RR =>          -- ADDC A,Rr
  506.             if state=FETCH then
  507.               s_adr_mux <= "0110";      -- adress = RR-adress
  508.               s_nextstate <= EXEC1;
  509.             elsif state=EXEC1 then
  510.               alu_cmd_o <= ADDC_ACC_RAM;  -- addition command (ACC+RAM_DATA+CY)
  511.               s_data_mux <= "0011";       -- data = aludata_i
  512.               s_regs_wr_en <= "011";      -- write ACC and CY,OV,AC
  513.               s_pc_inc_en <= "0001";      -- increment program-counter
  514.               s_nextstate <= FETCH;
  515.             end if;
  517.           ---------------------------------------------------------------------
  519.           when IC_ADDC_A_D =>           -- ADDC A, direct
  520.             if state=FETCH then
  521.               s_pc_inc_en <= "0001";    -- increment program-counter
  522.               s_nextstate <= EXEC1;
  523.             elsif state=EXEC1 then
  524.               s_adr_mux <= "1000";      -- adress = rom_data_i
  525.               s_nextstate <= EXEC2;
  526.             elsif state=EXEC2 then
  527.               alu_cmd_o <= ADDC_ACC_RAM;  -- addition command (ACC+RAM_DATA+CY)
  528.               s_data_mux <= "0011";       -- data = aludata_i
  529.               s_regs_wr_en <= "011";      -- write ACC and CY,OV,AC
  530.               s_pc_inc_en <= "0001";      -- increment program-counter
  531.               s_nextstate <= FETCH;
  532.             end if;
  534.           ---------------------------------------------------------------------
  536.           when IC_ADDC_A_ATRI =>        -- ADDC A,@Ri
  537.             if state=FETCH then
  538.               s_adr_mux <= "0111";      -- address = Ri-register
  539.               s_nextstate <= EXEC1;
  540.             elsif state=EXEC1 then
  541.               alu_cmd_o <= ADDC_ACC_RAM;  -- addition command (ACC+RAM_DATA+CY)
  542.               s_data_mux <= "0011";       -- data = aludata_i
  543.               s_regs_wr_en <= "011";      -- write ACC and CY,OV,AC
  544.               s_pc_inc_en <= "0001";      -- increment program-counter
  545.               s_nextstate <= FETCH;
  546.             end if;
  548.           ---------------------------------------------------------------------
  550.           when IC_ADDC_A_DATA =>        -- ADDC A, data
  551.             if state=FETCH then
  552.               s_pc_inc_en <= "0001";    -- increment program-counter
  553.               s_nextstate <= EXEC1;
  554.             elsif state=EXEC1 then
  555.               alu_cmd_o <= ADDC_ACC_ROM;-- addition command (ACC+ROM_DATA_I+CY)
  556.               s_data_mux <= "0011";     -- data = aludata_i
  557.               s_regs_wr_en <= "011";    -- write ACC and CY,OV,AC
  558.               s_pc_inc_en <= "0001";    -- increment program-counter
  559.               s_nextstate <= FETCH;
  560.             end if;
  562.           ---------------------------------------------------------------------
  564.           when IC_AJMP =>               -- AJMP addr11
  565.             if state=FETCH then
  566.               s_help16_en <= "10";      -- s_help16 = pc+2
  567.               s_pc_inc_en <= "0001";    -- increment program-counter
  568.               s_nextstate <= EXEC1;
  569.             elsif state=EXEC1 then
  570.               s_pc_inc_en <= "0100";    -- load PC with 11 bits (2k block)
  571.               s_nextstate <= FETCH;
  572.             end if;
  574.           ---------------------------------------------------------------------
  576.           when IC_ANL_A_RR =>           -- ANL A,Rr
  577.             if state=FETCH then
  578.               s_adr_mux <= "0110";      -- adress = RR-adress
  579.               s_nextstate <= EXEC1;
  580.             elsif state=EXEC1 then
  581.               alu_cmd_o <= AND_ACC_RAM; -- AND command (ACC ^ RAM_DATA)
  582.               s_data_mux <= "0011";     -- data = aludata_i
  583.               s_regs_wr_en <= "010";    -- write ACC
  584.               s_pc_inc_en <= "0001";    -- increment program-counter
  585.               s_nextstate <= FETCH;
  586.             end if;
  588.           ---------------------------------------------------------------------
  590.           when IC_ANL_A_D =>            -- ANL A, direct
  591.             if state=FETCH then
  592.               s_pc_inc_en <= "0001";    -- increment program-counter
  593.               s_nextstate <= EXEC1;
  594.             elsif state=EXEC1 then
  595.               s_adr_mux <= "1000";      -- address = rom_data_i
  596.               s_nextstate <= EXEC2;
  597.             elsif state=EXEC2 then
  598.               alu_cmd_o <= AND_ACC_RAM; -- AND command (ACC ^ RAM_DATA)
  599.               s_data_mux <= "0011";     -- data = aludata_i
  600.               s_regs_wr_en <= "010";    -- write ACC
  601.               s_pc_inc_en <= "0001";    -- increment program-counter
  602.               s_nextstate <= FETCH;
  603.             end if;
  605.           ---------------------------------------------------------------------
  607.           when IC_ANL_A_ATRI =>          -- ANL A,ATRi
  608.             if state=FETCH then
  609.               s_adr_mux <= "0111";       -- address = Ri-register
  610.               s_nextstate <= EXEC1;
  611.             elsif state=EXEC1 then
  612.               alu_cmd_o <= AND_ACC_RAM;  -- AND command (ACC ^ RAM_DATA)
  613.               s_data_mux <= "0011";      -- data = aludata_i
  614.               s_regs_wr_en <= "010";     -- write ACC
  615.               s_pc_inc_en <= "0001";     -- increment program-counter
  616.               s_nextstate <= FETCH;
  617.             end if;
  619.           ---------------------------------------------------------------------
  620.           when IC_ANL_A_DATA =>          -- ANL A, data
  621.             if state=FETCH then
  622.               s_pc_inc_en <= "0001";     -- increment program-counter
  623.               s_nextstate <= EXEC1;
  624.             elsif state=EXEC1 then
  625.               alu_cmd_o <= AND_ACC_ROM;   -- AND command (ACC ^ ROM_DATA_I)
  626.               s_data_mux <= "0011";       -- data = aludata_i
  627.               s_regs_wr_en <= "010";      -- write ACC
  628.               s_pc_inc_en <= "0001";      -- increment program-counter
  629.               s_nextstate <= FETCH;
  630.             end if;
  632.           ---------------------------------------------------------------------
  634.           when IC_ANL_D_A =>            -- ANL direct, A
  635.             if state=FETCH then
  636.               s_pc_inc_en <= "0001";    -- increment program-counter
  637.               s_nextstate <= EXEC1;
  638.             elsif state=EXEC1 then
  639.               s_adr_mux <= "1000";      -- adress = rom_data_i
  640.               s_nextstate <= EXEC2;
  641.             elsif state=EXEC2 then
  642.               alu_cmd_o <= AND_ACC_RAM;  -- AND command (ACC ^ RAM_DATA)
  643.               s_adr_mux <= "1000";       -- adress = rom_data_i
  644.               s_data_mux <= "0011";      -- data = aludata_i
  645.               s_regs_wr_en <= "100";     -- write one byte
  646.               s_pc_inc_en <= "0001";     -- increment program-counter
  647.               s_nextstate <= FETCH;
  648.             end if;
  650.           ---------------------------------------------------------------------
  652.           when IC_ANL_D_DATA =>         -- ANL direct, DATA
  653.             if state=FETCH then
  654.               s_pc_inc_en <= "0001";    -- increment program-counter
  655.               s_nextstate <= EXEC1;
  656.             elsif state=EXEC1 then
  657.               s_help_en <= "0001";      -- help = rom_data_i
  658.               s_adr_mux <= "1000";      -- adress = rom_data_i
  659.               s_pc_inc_en <= "0001";    -- increment program-counter
  660.               s_nextstate <= EXEC2;
  661.             elsif state=EXEC2 then
  662.               alu_cmd_o <= AND_RAM_ROM;  -- AND command (ROM_DATA_I ^ RAM_DATA)
  663.               s_adr_mux <= "1010";       -- adress = help
  664.               s_data_mux <= "0011";      -- data = aludata_i
  665.               s_regs_wr_en <= "100";     -- write one byte
  666.               s_pc_inc_en <= "0001";     -- increment program-counter
  667.               s_nextstate <= FETCH;
  668.             end if;
  670.           ---------------------------------------------------------------------
  672.           when IC_ANL_C_BIT =>          -- ANL C, bit
  673.             if state=FETCH then
  674.               s_pc_inc_en <= "0001";    -- increment program-counter
  675.               s_nextstate <= EXEC1;
  676.             elsif state=EXEC1 then
  677.               s_adr_mux <= "1000";      -- adress = rom_data_i
  678.               s_nextstate <= EXEC2;
  679.             elsif state=EXEC2 then
  680.               s_bdata_mux <= "0001";    -- bdata = s_bit_data and cy
  681.               s_regs_wr_en <= "110";    -- write one bit (automatic CY-address)
  682.               s_pc_inc_en <= "0001";    -- increment program-counter
  683.               s_nextstate <= FETCH;
  684.             end if;
  686.           ---------------------------------------------------------------------
  688.           when IC_ANL_C_NBIT =>         -- ANL C, /bit
  689.             if state=FETCH then
  690.               s_pc_inc_en <= "0001";    -- increment program-counter
  691.               s_nextstate <= EXEC1;
  692.             elsif state=EXEC1 then
  693.               s_adr_mux <= "1000";      -- adress = rom_data_i
  694.               s_nextstate <= EXEC2;
  695.             elsif state=EXEC2 then
  696.               s_bdata_mux <= "0010";    -- bdata = not (s_bit_data and cy)
  697.               s_regs_wr_en <= "110";    -- write one bit (automatic CY-address)
  698.               s_pc_inc_en <= "0001";    -- increment program-counter
  699.               s_nextstate <= FETCH;
  700.             end if;
  702.           ---------------------------------------------------------------------
  704.           when IC_CJNE_A_D =>           -- CJNE A, direct, rel
  705.             if state=FETCH then
  706.               s_pc_inc_en <= "0001";    -- increment program-counter
  707.               s_nextstate <= EXEC1;
  708.             elsif state=EXEC1 then
  709.               s_adr_mux <= "1000";      -- address = rom_data_i
  710.               s_pc_inc_en <= "0001";    -- increment program-counter
  711.               s_nextstate <= EXEC2;
  712.             elsif state=EXEC2 then
  713.               alu_cmd_o <= COMP_RAM_ACC;  -- Compare RAM_DATA/ACC operation
  714.               if unsigned(aludata_i) /= 0 then
  715.                 s_adr_mux <= "1011";      -- adress of CY
  716.                 s_bdata_mux <= "0011";    -- bdata = cby_i
  717.                 s_regs_wr_en <= "110";    -- write one bit
  718.                 s_pc_inc_en <= "0010";    -- add relativ adress to PC
  719.               else
  720.                 s_pc_inc_en <= "0001";    -- increment program-counter
  721.               end if;
  722.               s_nextstate <= FETCH;
  723.             end if;
  725.           ---------------------------------------------------------------------
  727.           when IC_CJNE_A_DATA =>        -- CJNE A, #data, rel
  728.             if state=FETCH then
  729.               s_pc_inc_en <= "0001";    -- increment program-counter
  730.               s_nextstate <= EXEC1;
  731.             elsif state=EXEC1 then
  732.               alu_cmd_o <= COMP_ROM_ACC; -- Compare ROM_DATA_I/ACC operation
  733.               s_help_en <= "0010";
  734.               s_helpb_en <= '1';         -- save new_cy_i
  735.               s_pc_inc_en <= "0001";     -- increment program-counter
  736.               s_nextstate <= EXEC2;
  737.             elsif state=EXEC2 then
  738.               if s_help /= 0 then
  739.                 s_adr_mux <= "1011";     -- adress of CY
  740.                 s_bdata_mux <= "0100";   -- bdata = s_helpb
  741.                 s_regs_wr_en <= "110";   -- write one bit
  742.                 s_pc_inc_en <= "0010";   -- add relativ adress to PC
  743.               else
  744.                 s_pc_inc_en <= "0001";   -- increment program-counter
  745.               end if;
  746.               s_nextstate <= FETCH;
  747.             end if;
  749.           ---------------------------------------------------------------------
  751.           when IC_CJNE_RR_DATA =>        -- CJNE RR, #data, rel
  752.             if state=FETCH then
  753.               s_adr_mux <= "0110";       -- address = rr-address
  754.               s_pc_inc_en <= "0001";     -- increment program-counter
  755.               s_nextstate <= EXEC1;
  756.             elsif state=EXEC1 then
  757.               alu_cmd_o <= COMP_ROM_RAM;-- Compare ROM_DATA_I/RAM_DATA operat.
  758.               s_help_en <= "0010";      -- save aludata_i
  759.               s_helpb_en <= '1';        -- save new_cy_i
  760.               s_pc_inc_en <= "0001";    -- increment program-counter
  761.               s_nextstate <= EXEC2;
  762.             elsif state=EXEC2 then
  763.               if s_help /= 0 then
  764.                 s_adr_mux <= "1011";     -- adress of CY
  765.                 s_bdata_mux <= "0100";   -- bdata = s_helpb
  766.                 s_regs_wr_en <= "110";   -- write one bit
  767.                 s_pc_inc_en <= "0010";   -- add relativ adress to PC
  768.               else
  769.                 s_pc_inc_en <= "0001";   -- increment program-counter
  770.               end if;
  771.               s_nextstate <= FETCH;
  772.             end if;
  774.           ---------------------------------------------------------------------
  776.           when IC_CJNE_ATRI_DATA =>       -- CJNE @Ri, #data, rel
  777.             if state=FETCH then
  778.               s_adr_mux <= "0111";        -- address = Ri-register
  779.               s_pc_inc_en <= "0001";      -- increment program-counter
  780.               s_nextstate <= EXEC1;
  781.             elsif state=EXEC1 then
  782.               alu_cmd_o <= COMP_ROM_RAM;  -- Compare ROM_/RAM_DATA operation
  783.               s_help_en <= "0010";        -- save aludata_i
  784.               s_helpb_en <= '1';          -- save new_cy_i
  785.               s_pc_inc_en <= "0001";      -- increment program-counter
  786.               s_nextstate <= EXEC2;
  787.             elsif state=EXEC2 then
  788.               if s_help /= 0 then
  789.                 s_adr_mux <= "1011";     -- adress of CY
  790.                 s_bdata_mux <= "0100";   -- bdata = s_helpb
  791.                 s_regs_wr_en <= "110";   -- write one bit
  792.                 s_pc_inc_en <= "0010";   -- add relativ adress to PC
  793.               else
  794.                 s_pc_inc_en <= "0001";   -- increment program-counter
  795.               end if;
  796.               s_nextstate <= FETCH;
  797.             end if;
  799.           ---------------------------------------------------------------------
  801.           when IC_CLR_A =>              -- CLR A
  802.             s_data_mux <= "0000";       -- data = 0
  803.             s_regs_wr_en <= "010";      -- write ACC
  804.             s_pc_inc_en <= "0001";      -- increment program-counter
  805.             s_nextstate <= FETCH;
  807.           ---------------------------------------------------------------------
  809.           when IC_CLR_C =>              -- CLR C
  810.             s_adr_mux <= "1011";        -- adress of CY
  811.             s_bdata_mux <= "0000";      -- bdata = 0
  812.             s_regs_wr_en <= "110";      -- write one bit
  813.             s_pc_inc_en <= "0001";      -- increment program-counter
  814.             s_nextstate <= FETCH;
  816.           ---------------------------------------------------------------------
  818.           when IC_CLR_BIT =>            -- CLR bit
  819.             if state=FETCH then
  820.               s_pc_inc_en <= "0001";    -- increment program-counter
  821.               s_nextstate <= EXEC1;
  822.             elsif state=EXEC1 then
  823.               s_adr_mux <= "1000";      -- address = rom_data_i
  824.               s_bdata_mux <= "0000";    -- bdata = 0
  825.               s_regs_wr_en <= "110";    -- write one bit
  826.               s_pc_inc_en <= "0001";    -- increment program-counter
  827.               s_nextstate <= FETCH;
  828.             end if;
  830.           ---------------------------------------------------------------------
  832.           when IC_CPL_A =>              -- CPL A
  833.             alu_cmd_o <= INV_ACC;       -- complement operation
  834.             s_data_mux <= "0011";       -- data = aludata_i
  835.             s_regs_wr_en <= "010";      -- write ACC
  836.             s_pc_inc_en <= "0001";      -- increment program-counter
  837.             s_nextstate <= FETCH;
  839.           ---------------------------------------------------------------------
  841.           when IC_CPL_C =>              -- CPL C
  842.             s_adr_mux <= "1011";        -- adress of CY
  843.             s_bdata_mux <= "0101";      -- bdata = not cy
  844.             s_regs_wr_en <= "110";      -- write one bit
  845.             s_pc_inc_en <= "0001";      -- increment program-counter
  846.             s_nextstate <= FETCH;
  848.           ---------------------------------------------------------------------
  850.           when IC_CPL_BIT =>            -- CPL bit
  851.             if state=FETCH then
  852.               s_pc_inc_en <= "0001";    -- increment program-counter
  853.               s_nextstate <= EXEC1;
  854.             elsif state=EXEC1 then
  855.               s_adr_mux <= "1000";      -- bit adress
  856.               s_nextstate <= EXEC2;
  857.             elsif state=EXEC2 then
  858.               s_adr_mux <= "1000";      -- bit adress
  859.               s_bdata_mux <= "0110";    -- bdata = not s_bit_data
  860.               s_regs_wr_en <= "110";    -- write one bit
  861.               s_pc_inc_en <= "0001";    -- increment program-counter
  862.               s_nextstate <= FETCH;
  863.            else
  864.               s_nextstate <= FETCH;
  865.             end if;
  867.           ---------------------------------------------------------------------
  869.           when IC_DA_A =>             -- DA A
  870.             alu_cmd_o <= DA;          -- DA operation
  871.             s_data_mux <= "0011";     -- data = aludata_i
  872.             s_regs_wr_en <= "111";    -- write ACC and CY (special operation)
  873.             s_pc_inc_en <= "0001";    -- increment program-counter
  874.             s_nextstate <= FETCH;
  876.           ---------------------------------------------------------------------
  878.           when IC_DEC_A =>              -- DEC A
  879.             alu_cmd_o <= DEC_ACC;       -- decrement operation
  880.             s_data_mux <= "0011";       -- data = aludata_i
  881.             s_regs_wr_en <= "010";      -- write ACC
  882.             s_pc_inc_en <= "0001";      -- increment program-counter
  883.             s_nextstate <= FETCH;
  885.           ---------------------------------------------------------------------
  887.           when IC_DEC_RR =>             -- DEC Rr
  888.             if state=FETCH then
  889.               s_adr_mux <= "0110";      -- address = rr-address
  890.               s_nextstate <= EXEC1;
  891.             elsif state=EXEC1 then
  892.               alu_cmd_o <= DEC_RAM;     -- decrement operation
  893.               s_adr_mux <= "0110";      -- address = rr-address
  894.               s_data_mux <= "0011";     -- data = aludata_i
  895.               s_regs_wr_en <= "100";    -- write one byte
  896.               s_pc_inc_en <= "0001";    -- increment program-counter
  897.               s_nextstate <= FETCH;
  898.             end if;
  900.           ---------------------------------------------------------------------
  902.           when IC_DEC_D =>              -- DEC direct
  903.             if state=FETCH then
  904.               s_pc_inc_en <= "0001";    -- increment program-counter
  905.               s_nextstate <= EXEC1;
  906.             elsif state=EXEC1 then
  907.               s_adr_mux <= "1000";      -- address = rom_data_i
  908.               s_nextstate <= EXEC2;
  909.             elsif state=EXEC2 then
  910.               s_adr_mux <= "1000";      -- address = rom_data_i
  911.               s_data_mux <= "0011";     -- data = aludata_i
  912.               s_regs_wr_en <= "100";    -- write one byte
  913.               alu_cmd_o <= DEC_RAM;     -- decrement operation
  914.               s_pc_inc_en <= "0001";    -- increment program-counter
  915.               s_nextstate <= FETCH;
  916.             end if;
  918.           ---------------------------------------------------------------------
  920.           when IC_DEC_ATRI =>           -- DEC @Ri
  921.             if state=FETCH then
  922.               s_adr_mux <= "0111";      -- address = Ri-register
  923.               s_nextstate <= EXEC1;
  924.             elsif state=EXEC1 then
  925.               alu_cmd_o <= DEC_RAM;     -- decrement operation
  926.               s_adr_mux <= "0111";      -- address = ri-address
  927.               s_data_mux <= "0011";     -- data = aludata_i
  928.               s_regs_wr_en <= "100";    -- write one byte
  929.               s_pc_inc_en <= "0001";    -- increment program-counter
  930.               s_nextstate <= FETCH;
  931.             end if;
  933.           ---------------------------------------------------------------------
  935.           when IC_DIV_AB =>             -- DIV AB
  936.             if state=FETCH then
  937.               s_adr_mux <= "1100";      -- adress of B register
  938.               alu_cmd_o <= DIV_ACC_RAM; -- divison operation
  939.               s_nextstate <= EXEC1;
  940.             elsif state=EXEC1 then
  941.               s_data_mux <= "0011";     -- data = aludata_i
  942.               s_adr_mux <= "1100";      -- adress of B register
  943.               alu_cmd_o <= DIV_ACC_RAM; -- divison operation
  944.               s_nextstate <= EXEC2;
  945.             elsif state=EXEC2 then
  946.               s_data_mux <= "0011";     -- data = aludata_i
  947.               s_adr_mux <= "1100";      -- adress of B register
  948.               s_regs_wr_en <= "111";    -- write ACC,B,OV,CY(special operation)
  949.               alu_cmd_o <= DIV_ACC_RAM; -- divison operation
  950.               s_pc_inc_en <= "0001";    -- increment program-counter
  951.               s_nextstate <= FETCH;
  952.             end if;
  954.           ---------------------------------------------------------------------
  956.           when IC_DJNZ_RR =>            -- DJNZ Rr, rel
  957.             if state=FETCH then
  958.               s_adr_mux <= "0110";      -- address = rr-address
  959.               s_help_en <= "0100";      -- save Rr-adress
  960.               s_pc_inc_en <= "0001";    -- increment program-counter
  961.               s_nextstate <= EXEC1;
  962.             elsif state=EXEC1 then
  963.               alu_cmd_o <= DEC_RAM;     -- decrement operation
  964.               if unsigned(aludata_i) /= 0 then
  965.                 s_adr_mux <= "1010";    -- address = rr-address
  966.                 s_data_mux <= "0011";   -- data = aludata_i
  967.                 s_regs_wr_en <= "100";  -- write one byte
  968.                 s_pc_inc_en <= "0010";  -- add relativ adress to PC
  969.               else
  970.                 s_adr_mux <= "1010";    -- address = rr-address
  971.                 s_data_mux <= "0011";   -- data = aludata_i
  972.                 s_regs_wr_en <= "100";  -- write one byte
  973.                 s_pc_inc_en <= "0001";  -- increment program-counter
  974.               end if;
  975.               s_nextstate <= FETCH;
  976.             end if;
  978.           ---------------------------------------------------------------------
  980.           when IC_DJNZ_D =>             -- DJNZ direct, rel
  981.             if state=FETCH then
  982.               s_pc_inc_en <= "0001";    -- increment program-counter
  983.               s_nextstate <= EXEC1;
  984.             elsif state=EXEC1 then
  985.               s_help_en <= "0001";      -- save address
  986.               s_adr_mux <= "1000";      -- address = rom_data
  987.               s_pc_inc_en <= "0001";    -- increment program-counter
  988.               s_nextstate <= EXEC2;
  989.             elsif state=EXEC2 then
  990.               alu_cmd_o <= DEC_RAM;            -- decrement operation
  991.               if unsigned(aludata_i) /= 0 then
  992.                 s_adr_mux <= "1010";           -- address = help
  993.                 s_data_mux <= "0011";          -- data = aludata_i
  994.                 s_regs_wr_en <= "100";         -- write one byte
  995.                 s_pc_inc_en <= "0010";         -- add relativ adress to PC
  996.               else
  997.                 s_adr_mux <= "1010";           -- address = help
  998.                 s_data_mux <= "0011";          -- data = aludata_i
  999.                 s_regs_wr_en <= "100";         -- write one byte
  1000.                 s_pc_inc_en <= "0001";         -- increment program-counter
  1001.               end if;
  1002.               s_nextstate <= FETCH;
  1003.             end if;
  1005.           ---------------------------------------------------------------------
  1007.           when IC_INC_A =>              -- INC A
  1008.             alu_cmd_o <= INC_ACC;       -- increment operation
  1009.             s_data_mux <= "0011";       -- data = aludata_i
  1010.             s_regs_wr_en <= "010";      -- write ACC
  1011.             s_pc_inc_en <= "0001";      -- increment program-counter
  1012.             s_nextstate <= FETCH;
  1014.           ---------------------------------------------------------------------
  1016.           when IC_INC_RR =>             -- INC Rr
  1017.             if state=FETCH then
  1018.               s_adr_mux <= "0110";      -- address = rr-address
  1019.               s_nextstate <= EXEC1;
  1020.             elsif state=EXEC1 then
  1021.               alu_cmd_o <= INC_RAM;     -- increment operation
  1022.               s_adr_mux <= "0110";      -- address = rr-address
  1023.               s_data_mux <= "0011";     -- data = aludata_i
  1024.               s_regs_wr_en <= "100";    -- write one byte
  1025.               s_pc_inc_en <= "0001";    -- increment program-counter
  1026.               s_nextstate <= FETCH;
  1027.             end if;
  1029.           ---------------------------------------------------------------------
  1031.           when IC_INC_D =>              -- INC direct
  1032.             if state=FETCH then
  1033.               s_pc_inc_en <= "0001";    -- increment program-counter
  1034.               s_nextstate <= EXEC1;
  1035.             elsif state=EXEC1 then
  1036.               s_adr_mux <= "1000";      -- address = rom_data_i
  1037.               s_nextstate <= EXEC2;
  1038.             elsif state=EXEC2 then
  1039.               alu_cmd_o <= INC_RAM;     -- increment operation
  1040.               s_adr_mux <= "1000";      -- address = rom_data_i
  1041.               s_data_mux <= "0011";     -- data = aludata_i
  1042.               s_regs_wr_en <= "100";    -- write one byte
  1043.               s_pc_inc_en <= "0001";    -- increment program-counter
  1044.               s_nextstate <= FETCH;
  1045.             end if;
  1047.           ---------------------------------------------------------------------
  1049.           when IC_INC_ATRI =>           -- INC @Ri
  1050.             if state=FETCH then
  1051.               s_adr_mux <= "0111";      -- address = Ri-register
  1052.               s_nextstate <= EXEC1;
  1053.             elsif state=EXEC1 then
  1054.               alu_cmd_o <= INC_RAM;     -- increment operation
  1055.               s_adr_mux <= "0111";      -- address = Ri-register
  1056.               s_data_mux <= "0011";     -- data = aludata_i
  1057.               s_regs_wr_en <= "100";    -- write one byte
  1058.               s_pc_inc_en <= "0001";    -- increment program-counter
  1059.               s_nextstate <= FETCH;
  1060.             end if;
  1062.           ---------------------------------------------------------------------
  1064.           when IC_INC_DPTR =>           -- INC DPTR
  1065.             if state=FETCH then
  1066.               s_adr_mux <= "1101";      -- adress of DPL
  1067.               s_nextstate <= EXEC1;
  1068.             elsif state=EXEC1 then
  1069.               alu_cmd_o <= INC_RAM;     -- increment operation
  1070.               s_help_en <= "0010";      -- help = aludata_i
  1071.               s_adr_mux <= "1101";      -- adress of DPL
  1072.               s_data_mux <= "0011";     -- data = aludata_i
  1073.               s_regs_wr_en <= "100";    -- write one byte
  1074.               s_nextstate <= EXEC2;
  1075.             elsif state=EXEC2 then
  1076.               s_adr_mux <= "1110";      -- adress of DPH
  1077.               s_nextstate <= EXEC3;
  1078.             elsif state=EXEC3 then
  1079.               if s_help=conv_unsigned(0,8) then
  1080.                 alu_cmd_o <= INC_RAM;    -- increment operation
  1081.                 s_adr_mux <= "1110";     -- adress of DPH
  1082.                 s_data_mux <= "0011";    -- data = aludata_i
  1083.                 s_regs_wr_en <= "100";   -- write one byte
  1084.               else
  1085.               end if;
  1086.               s_pc_inc_en <= "0001";     -- increment program-counter
  1087.               s_nextstate <= FETCH;
  1088.             end if;
  1090.           ---------------------------------------------------------------------
  1092.           when IC_JB =>                 -- JB bit, rel
  1093.             if state=FETCH then
  1094.               s_pc_inc_en <= "0001";    -- increment program-counter
  1095.               s_nextstate <= EXEC1;
  1096.             elsif state=EXEC1 then
  1097.               s_adr_mux <= "1000";       -- bit adress = rom_data_i
  1098.               s_pc_inc_en <= "0001";    -- increment program-counter
  1099.               s_nextstate <= EXEC2;
  1100.             elsif state=EXEC2 then
  1101.               if s_bit_data = '1' then
  1102.                 s_pc_inc_en <= "0010";  -- add relativ adress to PC
  1103.               else
  1104.                 s_pc_inc_en <= "0001";  -- increment program-counter
  1105.               end if;
  1106.               s_nextstate <= FETCH;
  1107.             end if;
  1109.           ---------------------------------------------------------------------
  1111.           when IC_JBC =>                -- JBC bit, rel
  1112.             if state=FETCH then
  1113.               s_pc_inc_en <= "0001";    -- increment program-counter
  1114.               s_nextstate <= EXEC1;
  1115.             elsif state=EXEC1 then
  1116.               s_adr_mux <= "1000";      -- bit adress = rom_data_i
  1117.               s_help_en <= "0001";      -- s_help = rom_data_i
  1118.               s_pc_inc_en <= "0001";    -- increment program-counter
  1119.               s_nextstate <= EXEC2;
  1120.             elsif state=EXEC2 then
  1121.               s_adr_mux <= "1010";       -- s_adr = s_help
  1122.               s_bdata_mux <= "0000";     -- s_bdata = 0
  1123.               s_regs_wr_en <= "110";     -- write one bit
  1124.               if s_bit_data = '1' then
  1125.                 s_pc_inc_en <= "0010";   -- add relativ adress to PC
  1126.               else
  1127.                 s_pc_inc_en <= "0001";   -- increment program-counter
  1128.               end if;
  1129.               s_nextstate <= FETCH;
  1130.             end if;
  1132.           ---------------------------------------------------------------------
  1134.           when IC_JC =>                 -- JC rel
  1135.             if state=FETCH then
  1136.               s_pc_inc_en <= "0001";    -- increment program-counter
  1137.               s_nextstate <= EXEC1;
  1138.             elsif state=EXEC1 then
  1139.               if cy = '1' then
  1140.                 s_pc_inc_en <= "0010";  -- add relativ adress to PC
  1141.               else
  1142.                 s_pc_inc_en <= "0001";  -- increment program-counter
  1143.               end if;
  1144.               s_nextstate <= FETCH;
  1145.             end if;
  1147.           ---------------------------------------------------------------------
  1149.           when IC_JMP_A_DPTR =>         -- JMP @A+DPTR
  1150.             s_pc_inc_en <= "0101";      -- PC = ACC + DPTR
  1151.             s_nextstate <= FETCH;
  1153.           ---------------------------------------------------------------------
  1155.           when IC_JNB =>                -- JNB bit, rel
  1156.             if state=FETCH then
  1157.               s_pc_inc_en <= "0001";    -- increment program-counter
  1158.               s_nextstate <= EXEC1;
  1159.             elsif state=EXEC1 then
  1160.               s_adr_mux <= "1000";       -- bit adress = rom_data_i
  1161.               s_pc_inc_en <= "0001";    -- increment program-counter
  1162.               s_nextstate <= EXEC2;
  1163.             elsif state=EXEC2 then
  1164.               if s_bit_data = '0' then
  1165.                 s_pc_inc_en <= "0010";   -- add relativ adress to PC
  1166.               else
  1167.                 s_pc_inc_en <= "0001";   -- increment program-counter
  1168.               end if;
  1169.               s_nextstate <= FETCH;
  1170.             end if;
  1172.           ---------------------------------------------------------------------
  1174.           when IC_JNC =>                -- JNC rel
  1175.             if state=FETCH then
  1176.               s_pc_inc_en <= "0001";    -- increment program-counter
  1177.               s_nextstate <= EXEC1;
  1178.             elsif state=EXEC1 then
  1179.               if cy = '0' then
  1180.                 s_pc_inc_en <= "0010";  -- add relativ adress to PC
  1181.               else
  1182.                 s_pc_inc_en <= "0001";  -- increment program-counter
  1183.               end if;
  1184.               s_nextstate <= FETCH;
  1185.             end if;
  1187.           ---------------------------------------------------------------------
  1189.           when IC_JNZ =>                -- JNZ rel
  1190.             if state=FETCH then
  1191.               s_pc_inc_en <= "0001";    -- increment program-counter
  1192.               s_nextstate <= EXEC1;
  1193.             elsif state=EXEC1 then
  1194.               if unsigned(acc) /= conv_unsigned(0,8) then
  1195.                 s_pc_inc_en <= "0010";  -- add relativ adress to PC
  1196.               else
  1197.                 s_pc_inc_en <= "0001";  -- increment program-counter
  1198.               end if;
  1199.               s_nextstate <= FETCH;
  1200.             end if;
  1202.           ---------------------------------------------------------------------
  1204.           when IC_JZ =>                 -- JZ rel
  1205.             if state=FETCH then
  1206.               s_pc_inc_en <= "0001";    -- increment program-counter
  1207.               s_nextstate <= EXEC1;
  1208.             elsif state=EXEC1 then
  1209.               if unsigned(acc) = conv_unsigned(0,8) then
  1210.                 s_pc_inc_en <= "0010";         -- add relativ adress to PC
  1211.               else
  1212.                 s_pc_inc_en <= "0001";         -- increment program-counter
  1213.               end if;
  1214.               s_nextstate <= FETCH;
  1215.             end if;
  1217.           ---------------------------------------------------------------------
  1219.           when IC_LCALL =>              -- LCALL addr16
  1220.             if state=FETCH then
  1221.               s_regs_wr_en <= "001";    -- increment stackpointer
  1222.               s_help16_en <= "01";      -- s_help16 <= pc + 3
  1223.               s_pc_inc_en <= "0001";    -- increment program-counter
  1224.               s_nextstate <= EXEC1;
  1225.             elsif state=EXEC1 then
  1226.               s_help_en <= "0001";      -- help <= rom_data_i
  1227.               s_data_mux <= "1100";     -- data <= help16(7 downto 0)
  1228.               s_adr_mux <= "0101";      -- s_adr <= sp
  1229.               s_regs_wr_en <= "101";    -- write one byte and increment SP
  1230.               s_pc_inc_en <= "0001";    -- increment program-counter
  1231.               s_nextstate <= EXEC2;
  1232.             elsif state=EXEC2 then
  1233.               s_data_mux <= "1101";     -- data = help16(15 downto 8)
  1234.               s_adr_mux <= "0101";      -- s_adr <= sp
  1235.               s_regs_wr_en <= "100";    -- write one byte
  1236.               s_pc_inc_en <= "0111";    -- load program counter
  1237.               s_nextstate <= FETCH;
  1238.             end if;
  1240.           ---------------------------------------------------------------------
  1242.           when IC_LJMP =>               -- LJMP addr16
  1243.             if state=FETCH then
  1244.               s_pc_inc_en <= "0001";    -- increment program-counter
  1245.               s_nextstate <= EXEC1;
  1246.             elsif state=EXEC1 then
  1247.               s_help_en <= "0001";      -- help = rom_data_i
  1248.               s_pc_inc_en <= "0001";    -- increment program-counter
  1249.               s_nextstate <= EXEC2;
  1250.             elsif state=EXEC2 then
  1251.               s_pc_inc_en <= "0111";    -- load program-counter
  1252.               s_nextstate <= FETCH;
  1253.             end if;
  1255.           ---------------------------------------------------------------------
  1257.           when IC_MOV_A_RR =>           -- MOV A,Rr
  1258.             if state=FETCH then
  1259.               s_adr_mux <= "0110";      -- address = rr-address
  1260.               s_nextstate <= EXEC1;
  1261.             elsif state=EXEC1 then
  1262.               s_data_mux <= "0100";     -- data = s_reg_data
  1263.               s_regs_wr_en <= "010";    -- write ACC
  1264.               s_pc_inc_en <= "0001";    -- increment program-counter
  1265.               s_nextstate <= FETCH;
  1266.             end if;
  1268.           ---------------------------------------------------------------------
  1269.           when IC_MOV_A_D =>            -- MOV A, direct
  1270.             if state=FETCH then
  1271.               s_pc_inc_en <= "0001";    -- increment program-counter
  1272.               s_nextstate <= EXEC1;
  1273.             elsif state=EXEC1 then
  1274.               s_adr_mux <= "1000";      -- address = rom_data_i
  1275.               s_nextstate <= EXEC2;
  1276.             elsif state=EXEC2 then
  1277.               s_data_mux <= "0100";     -- data = s_reg_data
  1278.               s_regs_wr_en <= "010";    -- write ACC
  1279.               s_pc_inc_en <= "0001";    -- increment program-counter
  1280.               s_nextstate <= FETCH;
  1281.             end if;
  1283.           ---------------------------------------------------------------------
  1285.           when IC_MOV_A_ATRI =>         -- MOV A,@Ri
  1286.             if state=FETCH then
  1287.               s_adr_mux <= "0111";      -- address = Ri-register
  1288.               s_nextstate <= EXEC1;
  1289.             elsif state=EXEC1 then
  1290.               s_data_mux <= "0100";     -- data = s_reg_data
  1291.               s_regs_wr_en <= "010";    -- write ACC
  1292.               s_pc_inc_en <= "0001";    -- increment program-counter
  1293.               s_nextstate <= FETCH;
  1294.             end if;
  1296.           ---------------------------------------------------------------------
  1298.           when IC_MOV_A_DATA =>         -- MOV A, #DATA
  1299.             if state=FETCH then
  1300.               s_pc_inc_en <= "0001";    -- increment program-counter
  1301.               s_nextstate <= EXEC1;
  1302.             elsif state=EXEC1 then
  1303.               s_data_mux <= "0101";     -- data = rom_data_i
  1304.               s_regs_wr_en <= "010";    -- write ACC
  1305.               s_pc_inc_en <= "0001";    -- increment program-counter
  1306.               s_nextstate <= FETCH;
  1307.             end if;
  1309.           ---------------------------------------------------------------------
  1311.           when IC_MOV_RR_A =>           -- MOV Rr,A
  1312.             s_adr_mux <= "0110";        -- address = rr-address
  1313.             s_data_mux <= "0110";       -- data = ACC
  1314.             s_regs_wr_en <= "100";      -- write one byte
  1315.             s_pc_inc_en <= "0001";      -- increment program-counter
  1316.             s_nextstate <= FETCH;
  1318.           ---------------------------------------------------------------------
  1320.           when IC_MOV_RR_D =>           -- MOV Rr, direct
  1321.             if state=FETCH then
  1322.               s_help_en <= "0100";      -- save Rr-adress in help
  1323.               s_pc_inc_en <= "0001";    -- increment program-counter
  1324.               s_nextstate <= EXEC1;
  1325.             elsif state=EXEC1 then
  1326.               s_adr_mux <= "1000";      -- address = rom_data_i
  1327.               s_nextstate <= EXEC2;
  1328.             elsif state=EXEC2 then
  1329.               s_adr_mux <= "1010";      -- address = help
  1330.               s_data_mux <= "0100";     -- data = s_reg_data
  1331.               s_regs_wr_en <= "100";    -- write one byte
  1332.               s_pc_inc_en <= "0001";    -- do nothing with program counter
  1333.               s_nextstate <= FETCH;
  1334.             end if;
  1336.           ---------------------------------------------------------------------
  1338.           when IC_MOV_RR_DATA =>        -- MOV Rr,#data
  1339.             if state=FETCH then
  1340.               s_help_en <= "0100";      -- save Rr-adress in help
  1341.               s_pc_inc_en <= "0001";    -- increment program-counter
  1342.               s_nextstate <= EXEC1;
  1343.             elsif state=EXEC1 then
  1344.               s_adr_mux <= "1010";      -- address = help
  1345.               s_data_mux <= "0101";     -- data = rom_data_i
  1346.               s_regs_wr_en <= "100";    -- write one byte
  1347.               s_pc_inc_en <= "0001";    -- do nothing with program counter
  1348.               s_nextstate <= FETCH;
  1349.             end if;
  1351.           ---------------------------------------------------------------------
  1353.           when IC_MOV_D_A =>            -- MOV direct, A
  1354.             if state=FETCH then
  1355.               s_pc_inc_en <= "0001";    -- increment program-counter
  1356.               s_nextstate <= EXEC1;
  1357.             elsif state=EXEC1 then
  1358.               s_adr_mux <= "1000";      -- address = rom_data_i
  1359.               s_data_mux <= "0110";     -- data = ACC
  1360.               s_regs_wr_en <= "100";    -- write one byte
  1361.               s_pc_inc_en <= "0001";    -- increment program-counter
  1362.               s_nextstate <= FETCH;
  1363.             end if;
  1365.             -------------------------------------------------------------------
  1367.           when IC_MOV_D_RR =>           -- MOV direct, Rr
  1368.             if state=FETCH then
  1369.               s_adr_mux <= "0110";      -- address = rr-address
  1370.               s_pc_inc_en <= "0001";    -- increment program-counter
  1371.               s_nextstate <= EXEC1;
  1372.             elsif state=EXEC1 then
  1373.               s_adr_mux <= "1000";      -- address = rom_data_i
  1374.               s_data_mux <= "0100";     -- data = s_reg_data
  1375.               s_regs_wr_en <= "100";    -- write one byte
  1376.               s_pc_inc_en <= "0001";    -- do nothing with program counter
  1377.               s_nextstate <= FETCH;
  1378.             end if;
  1380.           ---------------------------------------------------------------------
  1382.           when IC_MOV_D_D =>            -- MOV direct, direct
  1383.             if state=FETCH then
  1384.               s_pc_inc_en <= "0001";    -- increment program-counter
  1385.               s_nextstate <= EXEC1;
  1386.             elsif state=EXEC1 then
  1387.               s_adr_mux <= "1000";      -- address = rom_data_i
  1388.               s_pc_inc_en <= "0001";    -- increment program-counter
  1389.               s_nextstate <= EXEC2;
  1390.             elsif state=EXEC2 then
  1391.               s_adr_mux <= "1000";      -- address = rom_data_i
  1392.               s_data_mux <= "0100";     -- data = s_reg_data
  1393.               s_regs_wr_en <= "100";    -- write one byte
  1394.               s_pc_inc_en <= "0001";    -- increment program-counter
  1395.               s_nextstate <= FETCH;
  1396.             end if;
  1398.           ---------------------------------------------------------------------
  1400.           when IC_MOV_D_ATRI =>         -- MOV direct ,@Ri
  1401.             if state=FETCH then
  1402.               s_adr_mux <= "0111";      -- address = Ri-register
  1403.               s_pc_inc_en <= "0001";    -- increment program-counter
  1404.               s_nextstate <= EXEC1;
  1405.             elsif state=EXEC1 then
  1406.               s_adr_mux <= "1000";      -- address = rom_data_i
  1407.               s_data_mux <= "0100";     -- data = s_reg_data
  1408.               s_regs_wr_en <= "100";    -- write one byte
  1409.               s_pc_inc_en <= "0001";    -- increment program-counter
  1410.               s_nextstate <= FETCH;
  1411.             end if;
  1413.           ---------------------------------------------------------------------
  1415.           when IC_MOV_D_DATA =>         -- MOV direct, #data
  1416.             if state=FETCH then
  1417.               s_pc_inc_en <= "0001";    -- increment program-counter
  1418.               s_nextstate <= EXEC1;
  1419.             elsif state=EXEC1 then
  1420.               s_help_en <= "0001";      -- save direct adress
  1421.               s_pc_inc_en <= "0001";    -- increment program-counter
  1422.               s_nextstate <= EXEC2;
  1423.             elsif state=EXEC2 then
  1424.               s_adr_mux <= "1010";      -- address = help
  1425.               s_data_mux <= "0101";     -- data = rom_data_i
  1426.               s_regs_wr_en <= "100";    -- write one byte
  1427.               s_pc_inc_en <= "0001";    -- increment program-counter
  1428.               s_nextstate <= FETCH;
  1429.             end if;
  1431.           ---------------------------------------------------------------------
  1433.           when IC_MOV_ATRI_A =>        -- MOV @Ri,A
  1434.             s_adr_mux <= "0111";       -- address = Ri-register
  1435.             s_data_mux <= "0110";      -- data = ACC
  1436.             s_regs_wr_en <= "100";     -- write one byte
  1437.             s_pc_inc_en <= "0001";     -- increment program-counter
  1438.             s_nextstate <= FETCH;
  1440.           ---------------------------------------------------------------------
  1442.           when IC_MOV_ATRI_D =>         -- MOV @Ri, direct
  1443.             if state=FETCH then
  1444.               s_pc_inc_en <= "0001";    -- increment program-counter
  1445.               s_nextstate <= EXEC1;
  1446.             elsif state=EXEC1 then
  1447.               s_adr_mux <= "1000";      -- address = rom_data_i
  1448.               s_nextstate <= EXEC2;
  1449.             elsif state=EXEC2 then
  1450.               s_adr_mux <= "0111";      -- address = Ri-register
  1451.               s_data_mux <= "0100";     -- data = s_reg_data
  1452.               s_regs_wr_en <= "100";    -- write one byte
  1453.               s_pc_inc_en <= "0001";    -- increment program-counter
  1454.               s_nextstate <= FETCH;
  1455.             end if;
  1457.           ---------------------------------------------------------------------
  1459.           when IC_MOV_ATRI_DATA =>      -- MOV @Ri,#data
  1460.             if state=FETCH then
  1461.               s_pc_inc_en <= "0001";    -- increment program-counter
  1462.               s_nextstate <= EXEC1;
  1463.             elsif state=EXEC1 then
  1464.               s_adr_mux <= "0111";      -- address = Ri-register
  1465.               s_data_mux <= "0101";     -- data = rom_data_i
  1466.               s_regs_wr_en <= "100";    -- write one byte
  1467.               s_pc_inc_en <= "0001";    -- increment program-counter
  1468.               s_nextstate <= FETCH;
  1469.             end if;
  1471.           ---------------------------------------------------------------------
  1473.           when IC_MOVC_A_ATDPTR =>       -- MOVC A, @A+DPTR
  1474.             if state=FETCH then
  1475.               s_help16_en <= "11";       -- save PC+1 in help16
  1476.               s_pc_inc_en <= "0101";     -- PC = A+DPTR
  1477.               s_nextstate <= EXEC1;
  1478.             elsif state=EXEC1 then
  1479.               s_data_mux <= "0101";      -- data = rom_data_i
  1480.               s_regs_wr_en <= "010";     -- write ACC
  1481.               s_pc_inc_en <= "0110";     -- PC = help16
  1482.               s_nextstate <= FETCH;
  1483.             end if;
  1485.           ---------------------------------------------------------------------
  1487.           when IC_MOVC_A_ATPC =>         -- MOVC A, @A+PC
  1488.             if state=FETCH then
  1489.               s_help16_en <= "11";       -- save PC+1 in help16
  1490.               s_pc_inc_en <= "1001";     -- PC = A+PC+1
  1491.               s_nextstate <= EXEC1;
  1492.             elsif state=EXEC1 then
  1493.               s_data_mux <= "0101";      -- data = rom_data_i
  1494.               s_regs_wr_en <= "010";     -- write ACC
  1495.               s_pc_inc_en <= "0110";     -- PC = help16
  1496.               s_nextstate <= FETCH;
  1497.             end if;
  1499.           ---------------------------------------------------------------------
  1501.           when IC_MOVX_A_ATRI =>         -- MOVX A, @RI
  1502.             if state=FETCH then
  1503.               s_adrx_mux <= "10";        -- external adress = Ri
  1504.               s_nextstate <= EXEC1;
  1505.             elsif state=EXEC1 then
  1506.               s_data_mux <= "1111";      -- data = datax_i
  1507.               s_regs_wr_en <= "010";     -- write ACC
  1508.               s_pc_inc_en <= "0001";     -- increment program-counter
  1509.               s_nextstate <= FETCH;
  1510.             end if;
  1512.           ---------------------------------------------------------------------
  1514.           when IC_MOVX_A_ATDPTR =>       -- MOVX A, @DPTR
  1515.             if state=FETCH then
  1516.               s_adrx_mux <= "01";        -- external adress = DPTR
  1517.               s_nextstate <= EXEC1;
  1518.             elsif state=EXEC1 then
  1519.               s_data_mux <= "1111";      -- data = datax_i
  1520.               s_regs_wr_en <= "010";     -- write ACC
  1521.               s_pc_inc_en <= "0001";     -- increment program-counter
  1522.               s_nextstate <= FETCH;
  1523.             end if;
  1525.           ---------------------------------------------------------------------
  1527.           when IC_MOVX_ATRI_A =>       -- MOVX @RI, A
  1528.             s_adrx_mux <= "10";        -- external adress = Ri
  1529.             s_wrx_mux <= '1';
  1530.             s_pc_inc_en <= "0001";     -- increment program-counter
  1531.             s_nextstate <= FETCH;
  1533.           ---------------------------------------------------------------------
  1535.           when IC_MOVX_ATDPTR_A =>     -- MOVX @DPTR, A
  1536.             s_adrx_mux <= "01";        -- external adress = DPTR
  1537.             s_wrx_mux <= '1';
  1538.             s_pc_inc_en <= "0001";     -- increment program-counter
  1539.             s_nextstate <= FETCH;
  1541.           ---------------------------------------------------------------------
  1543.           when IC_MOV_C_BIT =>          -- MOV C, bit
  1544.             if state=FETCH then
  1545.               s_pc_inc_en <= "0001";    -- increment program-counter
  1546.               s_nextstate <= EXEC1;
  1547.             elsif state=EXEC1 then
  1548.               s_adr_mux <= "1000";      -- address = rom_data_i
  1549.               s_nextstate <= EXEC2;
  1550.             elsif state=EXEC2 then
  1551.               s_bdata_mux <= "0111";    -- bdata = s_bit_data
  1552.               s_regs_wr_en <= "110";    -- write one bit (automatic CY-address)
  1553.               s_pc_inc_en <= "0001";    -- increment program-counter
  1554.               s_nextstate <= FETCH;
  1555.             end if;
  1557.           ---------------------------------------------------------------------
  1559.           when IC_MOV_BIT_C =>          -- MOV bit,C
  1560.             if state=FETCH then
  1561.               s_pc_inc_en <= "0001";    -- increment program-counter
  1562.               s_nextstate <= EXEC1;
  1563.             elsif state=EXEC1 then
  1564.               s_adr_mux <= "1000";      -- address = rom_data_i
  1565.               s_bdata_mux <= "1000";    -- bdata = cy
  1566.               s_regs_wr_en <= "110";    -- write one bit
  1567.               s_pc_inc_en <= "0001";    -- increment program-counter
  1568.               s_nextstate <= FETCH;
  1569.             end if;
  1571.           ---------------------------------------------------------------------
  1573.           when IC_MOV_DPTR_DATA =>      -- MOV DPTR, #data16
  1574.             if state=FETCH then
  1575.               s_pc_inc_en <= "0001";    -- increment program-counter
  1576.               s_nextstate <= EXEC1;
  1577.             elsif state=EXEC1 then
  1578.               s_adr_mux <= "1110";      -- adress of DPH
  1579.               s_data_mux <= "0101";     -- data = rom_data_i
  1580.               s_regs_wr_en <= "100";    -- write one byte
  1581.               s_pc_inc_en <= "0001";    -- increment program-counter
  1582.               s_nextstate <= EXEC2;
  1583.             elsif state=EXEC2 then
  1584.               s_adr_mux <= "1101";      -- adress of DPL
  1585.               s_data_mux <= "0101";     -- data = rom_data_i
  1586.               s_regs_wr_en <= "100";    -- write one byte
  1587.               s_pc_inc_en <= "0001";    -- increment program-counter
  1588.               s_nextstate <= FETCH;
  1589.             end if;
  1591.           ---------------------------------------------------------------------
  1593.           when IC_MUL_AB =>             -- MUL AB
  1594.             if state=FETCH then
  1595.               s_adr_mux <= "1100";      -- adress of B register
  1596.               alu_cmd_o <= MUL_ACC_RAM; -- divison operation
  1597.               s_nextstate <= EXEC1;
  1598.             elsif state=EXEC1 then
  1599.               s_data_mux <= "0011";     -- data = aludata_i
  1600.               s_adr_mux <= "1100";      -- adress of B register
  1601.               alu_cmd_o <= MUL_ACC_RAM; -- divison operation
  1602.               s_nextstate <= EXEC2;
  1603.             elsif state=EXEC2 then
  1604.               s_data_mux <= "0011";    -- data = aludata_i
  1605.               s_adr_mux <= "1100";     -- adress of B register
  1606.               s_regs_wr_en <= "111";   -- write ACC,B,OV,CY (special operation)
  1607.               alu_cmd_o <= MUL_ACC_RAM; -- divison operation
  1608.               s_pc_inc_en <= "0001";    -- increment program-counter
  1609.               s_nextstate <= FETCH;
  1610.             end if;
  1612.           ---------------------------------------------------------------------
  1614.           when IC_NOP =>              -- NOP
  1615.             s_pc_inc_en <= "0001";    -- increment program-counter
  1616.             s_nextstate <= FETCH;
  1618.           ---------------------------------------------------------------------
  1620.           when IC_ORL_A_RR =>           -- ORL A,Rr
  1621.             if state=FETCH then
  1622.               s_adr_mux <= "0110";      -- address = rr-address
  1623.               s_nextstate <= EXEC1;
  1624.             elsif state=EXEC1 then
  1625.               alu_cmd_o <= OR_RAM_ACC;  -- OR command (ACC v RAM_DATA)
  1626.               s_data_mux <= "0011";     -- data = aludata_i
  1627.               s_regs_wr_en <= "010";    -- write ACC
  1628.               s_pc_inc_en <= "0001";    -- increment program-counter
  1629.               s_nextstate <= FETCH;
  1630.             end if;
  1632.           ---------------------------------------------------------------------
  1633.           when IC_ORL_A_D =>            -- ORL A, direct
  1634.             if state=FETCH then
  1635.               s_pc_inc_en <= "0001";    -- increment program-counter
  1636.               s_nextstate <= EXEC1;
  1637.             elsif state=EXEC1 then
  1638.               s_adr_mux <= "1000";      -- address = rom_data_i
  1639.               s_nextstate <= EXEC2;
  1640.             elsif state=EXEC2 then
  1641.               alu_cmd_o <= OR_RAM_ACC;  -- OR command (ACC v RAM_DATA)
  1642.               s_data_mux <= "0011";     -- data = aludata_i
  1643.               s_regs_wr_en <= "010";    -- write ACC
  1644.               s_pc_inc_en <= "0001";    -- increment program-counter
  1645.               s_nextstate <= FETCH;
  1646.             end if;
  1648.           ---------------------------------------------------------------------
  1649.           when IC_ORL_A_ATRI =>         -- ORL A,@Ri
  1650.             if state=FETCH then
  1651.               s_adr_mux <= "0111";      -- address = Ri-register
  1652.               s_nextstate <= EXEC1;
  1653.             elsif state=EXEC1 then
  1654.               alu_cmd_o <= OR_RAM_ACC;  -- OR command (ACC v RAM_DATA)
  1655.               s_data_mux <= "0011";     -- data = aludata_i
  1656.               s_regs_wr_en <= "010";    -- write ACC
  1657.               s_pc_inc_en <= "0001";    -- increment program-counter
  1658.               s_nextstate <= FETCH;
  1659.             end if;
  1661.           ---------------------------------------------------------------------
  1662.           when IC_ORL_A_DATA =>         -- ORL A, data
  1663.             if state=FETCH then
  1664.               s_pc_inc_en <= "0001";    -- increment program-counter
  1665.               s_nextstate <= EXEC1;
  1666.             elsif state=EXEC1 then
  1667.               alu_cmd_o <= OR_ROM_ACC;  -- OR command (ACC v ROM_DATA_I)
  1668.               s_data_mux <= "0011";     -- data = aludata_i
  1669.               s_regs_wr_en <= "010";    -- write ACC
  1670.               s_pc_inc_en <= "0001";    -- increment program-counter
  1671.               s_nextstate <= FETCH;
  1672.             end if;
  1674.           ---------------------------------------------------------------------
  1675.           when IC_ORL_D_A =>            -- ORL direct, A
  1676.             if state=FETCH then
  1677.               s_pc_inc_en <= "0001";    -- increment program-counter
  1678.               s_nextstate <= EXEC1;
  1679.             elsif state=EXEC1 then
  1680.               s_adr_mux <= "1000";      -- address = rom_data_i
  1681.               s_nextstate <= EXEC2;
  1682.             elsif state=EXEC2 then
  1683.               alu_cmd_o <= OR_RAM_ACC;  -- OR command (ACC v RAM_DATA)
  1684.               s_adr_mux <= "1000";      -- address = rom_data_i
  1685.               s_data_mux <= "0011";     -- data = aludata_i
  1686.               s_regs_wr_en <= "100";    -- write one byte
  1687.               s_pc_inc_en <= "0001";    -- increment program-counter
  1688.               s_nextstate <= FETCH;
  1689.             end if;
  1691.           ---------------------------------------------------------------------
  1693.           when IC_ORL_D_DATA =>         -- ORL direct, DATA
  1694.             if state=FETCH then
  1695.               s_pc_inc_en <= "0001";    -- increment program-counter
  1696.               s_nextstate <= EXEC1;
  1697.             elsif state=EXEC1 then
  1698.               s_help_en <= "0001";      -- save rom_data_i
  1699.               s_adr_mux <= "1000";
  1700.               s_pc_inc_en <= "0001";    -- increment program-counter
  1701.               s_nextstate <= EXEC2;
  1702.             elsif state=EXEC2 then
  1703.               alu_cmd_o <= OR_ROM_RAM;  -- OR command (ROM_DATA_I v RAM_DATA)
  1704.               s_adr_mux <= "1010";      -- address = help
  1705.               s_data_mux <= "0011";     -- data = aludata_i
  1706.               s_regs_wr_en <= "100";    -- write one byte
  1707.               s_pc_inc_en <= "0001";    -- increment program-counter
  1708.               s_nextstate <= FETCH;
  1709.             end if;
  1711.           ---------------------------------------------------------------------
  1713.           when IC_ORL_C_BIT =>          -- ORL C, bit
  1714.             if state=FETCH then
  1715.               s_pc_inc_en <= "0001";    -- increment program-counter
  1716.               s_nextstate <= EXEC1;
  1717.             elsif state=EXEC1 then
  1718.               s_adr_mux <= "1000";      -- address = rom_data_i
  1719.               s_nextstate <= EXEC2;
  1720.             elsif state=EXEC2 then
  1721.               s_bdata_mux <= "1001";    -- bdata = s_bit_data or cy
  1722.               s_regs_wr_en <= "110";    -- write one bit (autmatically CY)
  1723.               s_pc_inc_en <= "0001";    -- increment program-counter
  1724.               s_nextstate <= FETCH;
  1725.             end if;
  1727.           ---------------------------------------------------------------------
  1729.           when IC_ORL_C_NBIT =>         -- ORL C, /bit
  1730.             if state=FETCH then
  1731.               s_pc_inc_en <= "0001";    -- increment program-counter
  1732.               s_nextstate <= EXEC1;
  1733.             elsif state=EXEC1 then
  1734.               s_adr_mux <= "1000";      -- address = rom_data_i
  1735.               s_nextstate <= EXEC2;
  1736.             elsif state=EXEC2 then
  1737.               s_bdata_mux <= "1010";    -- bdata = not (s_bit_data or cy)
  1738.               s_regs_wr_en <= "110";    -- write one bit (autmatically CY)
  1739.               s_pc_inc_en <= "0001";    -- increment program-counter
  1740.               s_nextstate <= FETCH;
  1741.             end if;
  1743.           ---------------------------------------------------------------------
  1745.           when IC_POP =>                -- POP direct
  1746.             if state=FETCH then
  1747.               s_adr_mux <= "0101";      -- address = SP
  1748.               s_pc_inc_en <= "0001";    -- increment program-counter
  1749.               s_nextstate <= EXEC1;
  1750.             elsif state=EXEC1 then
  1751.               s_adr_mux <= "1000";      -- address = rom_data_i
  1752.               s_data_mux <= "0100";     -- data = s_reg_data
  1753.               s_regs_wr_en <= "101";    -- write one byte and decrement SP
  1754.               s_pc_inc_en <= "0001";    -- increment program-counter
  1755.               s_nextstate <= FETCH;
  1756.             end if;
  1758.           ---------------------------------------------------------------------
  1760.           when IC_PUSH =>               -- PUSH direct
  1761.             if state=FETCH then
  1762.               s_regs_wr_en <= "001";    -- increment SP
  1763.               s_pc_inc_en <= "0001";    -- increment program-counter
  1764.               s_nextstate <= EXEC1;
  1765.             elsif state=EXEC1 then
  1766.               s_adr_mux <= "1000";      -- address = rom_data_i
  1767.               s_nextstate <= EXEC2;
  1768.             elsif state=EXEC2 then
  1769.               s_adr_mux <= "0101";      -- address = SP
  1770.               s_data_mux <= "0100";     -- data = s_reg_data
  1771.               s_regs_wr_en <= "100";    -- write one byte
  1772.               s_pc_inc_en <= "0001";    -- increment program-counter
  1773.               s_nextstate <= FETCH;
  1774.             end if;
  1776.           ---------------------------------------------------------------------
  1778.           when IC_RET =>                -- RET
  1779.             if state=FETCH then
  1780.               s_adr_mux <= "0101";      -- adress = SP
  1781.               s_regs_wr_en <= "001";    -- decrement stackpointer
  1782.               s_nextstate <= EXEC1;
  1783.             elsif state=EXEC1 then
  1784.               s_help_en <= "0011";      -- save data for PC-high
  1785.               s_adr_mux <= "0101";      -- adress = SP
  1786.               s_nextstate <= EXEC2;
  1787.             elsif state=EXEC2 then
  1788.               s_regs_wr_en <= "001";    -- decrement stackpointer
  1789.               s_pc_inc_en <= "1000";    -- reload program-counter
  1790.               s_nextstate <= FETCH;
  1791.             end if;
  1793.           ---------------------------------------------------------------------
  1795.           when IC_RETI =>               -- RETI
  1796.             if state=FETCH then
  1797.               s_adr_mux <= "0101";      -- adress = SP
  1798.               s_regs_wr_en <= "001";    -- decrement stackpointer
  1799.               s_nextstate <= EXEC1;
  1800.             elsif state=EXEC1 then
  1801.               s_help_en <= "0011";      -- save data for PC-high
  1802.               s_adr_mux <= "0101";
  1803.               s_nextstate <= EXEC2;
  1804.             elsif state=EXEC2 then
  1805.               if s_inthigh='1' then     -- an high priority interrupt is ending
  1806.                 s_inthigh_en <= '1';
  1807.                 s_inthigh_d <= '0';
  1808.               elsif s_intlow='1' then   -- an low priority interrupt is ending
  1809.                 s_intlow_en <= '1';
  1810.                 s_intlow_d <= '0';
  1811.               else                      -- no interrupt was started
  1812.                 NULL;                   -- => normal RET command
  1813.               end if;
  1814.               s_regs_wr_en <= "001";    -- decrement stackpointer
  1815.               s_pc_inc_en <= "1000";    -- reload program-counter
  1816.               s_nextstate <= FETCH;
  1817.             end if;
  1819.           ---------------------------------------------------------------------
  1821.           when IC_RL_A =>               -- RL A
  1822.             alu_cmd_o <= RL_ACC;        -- rotate ACC left
  1823.             s_data_mux <= "0011";       -- data = aludata_i
  1824.             s_regs_wr_en <= "010";      -- write ACC
  1825.             s_pc_inc_en <= "0001";      -- increment program-counter
  1826.             s_nextstate <= FETCH;
  1828.           ---------------------------------------------------------------------
  1830.           when IC_RLC_A =>              -- RLC A
  1831.             alu_cmd_o <= RLC_ACC;       -- rotate ACC with CY left
  1832.             s_data_mux <= "0011";       -- data = aludata_i
  1833.             s_regs_wr_en <= "111";      -- write ACC and CY (special operation)
  1834.             s_pc_inc_en <= "0001";      -- increment program-counter
  1835.             s_nextstate <= FETCH;
  1837.           ---------------------------------------------------------------------
  1839.           when IC_RR_A =>               -- RR A
  1840.             alu_cmd_o <= RR_ACC;        -- rotate ACC right
  1841.             s_data_mux <= "0011";       -- data = aludata_i
  1842.             s_regs_wr_en <= "010";      -- write ACC
  1843.             s_pc_inc_en <= "0001";      -- increment program-counter
  1844.             s_nextstate <= FETCH;
  1846.           ---------------------------------------------------------------------
  1848.           when IC_RRC_A =>              -- RRC A
  1849.             alu_cmd_o <= RRC_ACC;       -- rotate ACC with CY right
  1850.             s_data_mux <= "0011";       -- data = aludata_i
  1851.             s_regs_wr_en <= "111";      -- write ACC and CY (special operation)
  1852.             s_pc_inc_en <= "0001";      -- increment program-counter
  1853.             s_nextstate <= FETCH;
  1855.           ---------------------------------------------------------------------
  1857.           when IC_SETB_C =>             -- SETB C
  1858.             s_adr_mux <= "1011";        -- adress of CY
  1859.             s_bdata_mux <= "1011";      -- bdata = 1
  1860.             s_regs_wr_en <= "110";      -- write one bit
  1861.             s_pc_inc_en <= "0001";      -- increment program-counter
  1862.             s_nextstate <= FETCH;
  1864.           ---------------------------------------------------------------------
  1866.           when IC_SETB_BIT =>           -- SETB bit
  1867.             if state=FETCH then
  1868.               s_pc_inc_en <= "0001";    -- increment program-counter
  1869.               s_nextstate <= EXEC1;
  1870.             elsif state=EXEC1 then
  1871.               s_adr_mux <= "1000";      -- byte adress
  1872.               s_bdata_mux <= "1011";    -- bdata = 1
  1873.               s_regs_wr_en <= "110";    -- write one bit
  1874.               s_pc_inc_en <= "0001";    -- increment program-counter
  1875.               s_nextstate <= FETCH;
  1876.             end if;
  1878.           ---------------------------------------------------------------------
  1880.           when IC_SJMP =>               -- SJMP rel
  1881.             if state=FETCH then
  1882.               s_pc_inc_en <= "0001";    -- increment program-counter
  1883.               s_nextstate <= EXEC1;
  1884.             elsif state=EXEC1 then
  1885.               s_pc_inc_en <= "0010";    -- load program-counter
  1886.               s_nextstate <= FETCH;
  1887.             end if;
  1889.           ---------------------------------------------------------------------
  1891.           when IC_SUBB_A_RR =>          -- SUBB A,Rr
  1892.             if state=FETCH then
  1893.               s_adr_mux <= "0110";      -- address = rr-address
  1894.               s_nextstate <= EXEC1;
  1895.             elsif state=EXEC1 then
  1896.               alu_cmd_o <= SUB_ACC_RAM; -- subtraction command (ACC - RAM_DATA)
  1897.               s_data_mux <= "0011";     -- data = aludata_i
  1898.               s_regs_wr_en <= "011";    -- write ACC and CY,OV,AC
  1899.               s_pc_inc_en <= "0001";    -- increment program-counter
  1900.               s_nextstate <= FETCH;
  1901.             end if;
  1903.           ---------------------------------------------------------------------
  1904.           when IC_SUBB_A_D =>           -- SUBB A, direct
  1905.             if state=FETCH then
  1906.               s_pc_inc_en <= "0001";    -- increment program-counter
  1907.               s_nextstate <= EXEC1;
  1908.             elsif state=EXEC1 then
  1909.               s_adr_mux <= "1000";      -- address = rom_data_i
  1910.               s_nextstate <= EXEC2;
  1911.             elsif state=EXEC2 then
  1912.               alu_cmd_o <= SUB_ACC_RAM; -- subtraction command (ACC - RAM_DATA)
  1913.               s_data_mux <= "0011";     -- data = aludata_i
  1914.               s_regs_wr_en <= "011";    -- write ACC and CY,OV,AC
  1915.               s_pc_inc_en <= "0001";    -- increment program-counter
  1916.               s_nextstate <= FETCH;
  1917.             end if;
  1919.           ---------------------------------------------------------------------
  1920.           when IC_SUBB_A_ATRI =>        -- SUBB A,@Ri
  1921.             if state=FETCH then
  1922.               s_adr_mux <= "0111";      -- address = Ri-register
  1923.               s_nextstate <= EXEC1;
  1924.             elsif state=EXEC1 then
  1925.               alu_cmd_o <= SUB_ACC_RAM; -- subtraction command (ACC - RAM_DATA)
  1926.               s_data_mux <= "0011";     -- data = aludata_i
  1927.               s_regs_wr_en <= "011";    -- write ACC and CY,OV,AC
  1928.               s_pc_inc_en <= "0001";    -- increment program-counter
  1929.               s_nextstate <= FETCH;
  1930.             end if;
  1932.           ---------------------------------------------------------------------
  1934.           when IC_SUBB_A_DATA =>        -- SUBB A, DATA
  1935.             if state=FETCH then
  1936.               s_pc_inc_en <= "0001";    -- increment program-counter
  1937.               s_nextstate <= EXEC1;
  1938.             elsif state=EXEC1 then
  1939.               s_data_mux <= "0011";     -- data = aludata_i
  1940.               s_regs_wr_en <= "011";    -- write ACC and CY,OV,AC
  1941.               alu_cmd_o <= SUB_ACC_ROM; -- subtraction command (ACC-ROM_DATA_I)
  1942.               s_pc_inc_en <= "0001";    -- increment program-counter
  1943.               s_nextstate <= FETCH;
  1944.             end if;
  1946.           ---------------------------------------------------------------------
  1948.           when IC_SWAP_A =>         -- SWAP A
  1949.             s_data_mux <= "0111";   -- data = acc(3 downto 0) acc(7 downto 4)
  1950.             s_regs_wr_en <= "010";  -- write ACC
  1951.             s_pc_inc_en <= "0001";  -- increment program-counter
  1952.             s_nextstate <= FETCH;
  1954.           ---------------------------------------------------------------------
  1956.           when IC_XCH_A_RR =>           -- XCH A,Rr
  1957.             if state=FETCH then
  1958.               s_adr_mux <= "0110";      -- address = rr-address
  1959.               s_data_mux <= "0110";     -- data = ACC
  1960.               s_regs_wr_en <= "100";    -- write one byte
  1961.               s_nextstate <= EXEC1;
  1962.             elsif state=EXEC1 then
  1963.               s_data_mux <= "0100";     -- data = s_reg_data;
  1964.               s_regs_wr_en <= "010";    -- write ACC
  1965.               s_pc_inc_en <= "0001";    -- increment program-counter
  1966.               s_nextstate <= FETCH;
  1967.             end if;
  1969.           ---------------------------------------------------------------------
  1971.           when IC_XCH_A_D =>            -- XCH A, direct
  1972.             if state=FETCH then
  1973.               s_pc_inc_en <= "0001";    -- increment program-counter
  1974.               s_nextstate <= EXEC1;
  1975.             elsif state=EXEC1 then
  1976.               s_adr_mux <= "1000";      -- address = rom_data_i
  1977.               s_data_mux <= "0110";     -- data = ACC
  1978.               s_regs_wr_en <= "100";    -- write one byte
  1979.               s_nextstate <= EXEC2;
  1980.             elsif state=EXEC2 then
  1981.               s_data_mux <= "0100";     -- data = s_reg_data;
  1982.               s_regs_wr_en <= "010";    -- write ACC
  1983.               s_pc_inc_en <= "0001";    -- increment program-counter
  1984.               s_nextstate <= FETCH;
  1985.             end if;
  1987.           ---------------------------------------------------------------------
  1989.           when IC_XCH_A_ATRI =>         -- XCH A,@Ri
  1990.             if state=FETCH then
  1991.               s_adr_mux <= "0111";      -- address = Ri-register
  1992.               s_data_mux <= "0110";     -- data = ACC
  1993.               s_regs_wr_en <= "100";    -- write one byte
  1994.               s_nextstate <= EXEC1;
  1995.             elsif state=EXEC1 then
  1996.               s_data_mux <= "0100";     -- data = s_reg_data;
  1997.               s_regs_wr_en <= "010";    -- write ACC
  1998.               s_pc_inc_en <= "0001";    -- increment program-counter
  1999.               s_nextstate <= FETCH;
  2000.             end if;
  2002.           ---------------------------------------------------------------------
  2004.           when IC_XCHD_A_ATRI =>        -- XCHD A,@Ri
  2005.             if state=FETCH then
  2006.               s_adr_mux <= "0111";      -- address = Ri-register
  2007.               s_help_en <= "1010";      -- s_help = acc
  2008.               s_nextstate <= EXEC1;
  2009.             elsif state=EXEC1 then
  2010.               s_adr_mux <= "0111";      -- address = Ri-register
  2011.               s_data_mux <= "1010";     -- data = acc(7..4) & s_reg_data(3..0)
  2012.               s_regs_wr_en <= "010";    -- write ACC
  2013.               s_nextstate <= EXEC2;
  2014.             elsif state=EXEC2 then
  2015.               s_adr_mux <= "0111";    -- address = Ri-register
  2016.               s_data_mux <= "1001";   -- data = s_reg_data(7..4) & s_help(3..0)
  2017.               s_regs_wr_en <= "100";  -- write one byte
  2018.               s_pc_inc_en <= "0001";  -- increment program-counter
  2019.               s_nextstate <= FETCH;
  2020.             end if;
  2022.           ---------------------------------------------------------------------
  2024.           when IC_XRL_A_RR =>           -- XRL A,Rr
  2025.             if state=FETCH then
  2026.               s_adr_mux <= "0110";      -- address = rr-address
  2027.               s_nextstate <= EXEC1;
  2028.             elsif state=EXEC1 then
  2029.               alu_cmd_o <= XOR_RAM_ACC; -- XOR command (ACC v RAM_DATA)
  2030.               s_data_mux <= "0011";     -- data = aludata_i
  2031.               s_regs_wr_en <= "010";    -- write ACC
  2032.               s_pc_inc_en <= "0001";    -- increment program-counter
  2033.               s_nextstate <= FETCH;
  2034.             end if;
  2036.           ---------------------------------------------------------------------
  2037.           when IC_XRL_A_D =>            -- XRL A, direct
  2038.             if state=FETCH then
  2039.               s_pc_inc_en <= "0001";    -- increment program-counter
  2040.               s_nextstate <= EXEC1;
  2041.             elsif state=EXEC1 then
  2042.               s_adr_mux <= "1000";
  2043.               s_nextstate <= EXEC2;
  2044.             elsif state=EXEC2 then
  2045.               alu_cmd_o <= XOR_RAM_ACC;   -- XOR command (ACC v RAM_DATA)
  2046.               s_data_mux <= "0011";       -- data = aludata_i
  2047.               s_regs_wr_en <= "010";      -- write ACC
  2048.               s_pc_inc_en <= "0001";      -- increment program-counter
  2049.               s_nextstate <= FETCH;
  2050.             end if;
  2052.           ---------------------------------------------------------------------
  2053.           when IC_XRL_A_ATRI =>         -- XRL A,@Ri
  2054.             if state=FETCH then
  2055.               s_adr_mux <= "0111";      -- address = Ri-register
  2056.               s_nextstate <= EXEC1;
  2057.             elsif state=EXEC1 then
  2058.               alu_cmd_o <= XOR_RAM_ACC; -- XOR command (ACC v RAM_DATA)
  2059.               s_data_mux <= "0011";     -- data = aludata_i
  2060.               s_regs_wr_en <= "010";    -- write ACC
  2061.               s_pc_inc_en <= "0001";    -- increment program-counter
  2062.               s_nextstate <= FETCH;
  2063.             end if;
  2065.           ---------------------------------------------------------------------
  2066.           when IC_XRL_A_DATA =>         -- XRL A, data
  2067.             if state=FETCH then
  2068.               s_pc_inc_en <= "0001";    -- increment program-counter
  2069.               s_nextstate <= EXEC1;
  2070.             elsif state=EXEC1 then
  2071.               s_data_mux <= "0011";     -- data = aludata_i
  2072.               s_regs_wr_en <= "010";    -- write ACC
  2073.               alu_cmd_o <= XOR_ROM_ACC; -- XOR command (ACC v ROM_DATA_I)
  2074.               s_pc_inc_en <= "0001";    -- increment program-counter
  2075.               s_nextstate <= FETCH;
  2076.             end if;
  2078.           ---------------------------------------------------------------------
  2079.           when IC_XRL_D_A =>            -- XRL direct, A
  2080.             if state=FETCH then
  2081.               s_pc_inc_en <= "0001";    -- increment program-counter
  2082.               s_nextstate <= EXEC1;
  2083.             elsif state=EXEC1 then
  2084.               s_adr_mux <= "1000";
  2085.               s_nextstate <= EXEC2;
  2086.             elsif state=EXEC2 then
  2087.               s_adr_mux <= "1000";
  2088.               s_data_mux <= "0011";     -- data = aludata_i
  2089.               s_regs_wr_en <= "100";    -- write one byte
  2090.               alu_cmd_o <= XOR_RAM_ACC; -- XOR command (ACC v RAM_DATA)
  2091.               s_pc_inc_en <= "0001";    -- increment program-counter
  2092.               s_nextstate <= FETCH;
  2093.             end if;
  2095.           ---------------------------------------------------------------------
  2097.           when IC_XRL_D_DATA =>         -- XRL direct, DATA
  2098.             if state=FETCH then
  2099.               s_pc_inc_en <= "0001";    -- increment program-counter
  2100.               s_nextstate <= EXEC1;
  2101.             elsif state=EXEC1 then
  2102.               s_help_en <= "0001";
  2103.               s_adr_mux <= "1000";
  2104.               s_pc_inc_en <= "0001";    -- increment program-counter
  2105.               s_nextstate <= EXEC2;
  2106.             elsif state=EXEC2 then
  2107.               s_adr_mux <= "1010";
  2108.               s_data_mux <= "0011";     -- data = aludata_i
  2109.               alu_cmd_o <= XOR_ROM_RAM; -- XOR command (ROM_DATA_I v RAM_DATA)
  2110.               s_regs_wr_en <= "100";    -- write one byte
  2111.               s_pc_inc_en <= "0001";    -- increment program-counter
  2112.               s_nextstate <= FETCH;
  2113.             end if;
  2115.           ---------------------------------------------------------------------
  2117.           when others =>
  2118.             s_nextstate <= FETCH;
  2119.         end case;
  2120.        end if;
  2121.      end if;
  2122.   end process p_state;
  2124. end rtl;