Retorno del estado inactivo

¿Qué tan complicado es su estado "inactivo"?

Si es relativamente simple, quizás sería mejor simplemente replicarlo; en otras palabras, tienen estados separados idle1 , idle2 , etc., uno para cada uno de los estados activos.

La pregunta no está clara, pero asumiendo que desea que todos los estados que no sean inactivos sean persistentes, e inactivo para volver a cualquier estado persistente, el siguiente enfoque lo logrará sin agregar muchos estados adicionales ...

type state_type is (idle, state1, state2, state3, state4);
signal state, saved_state : state_type;
signal reset, leave_idle, suspend, proceed : boolean;
procedure start_calculation;

process(clock)
begin
   if rising_edge(clock) then
      if reset then
         state       <= idle;
         saved_state <= state1;
      else
         -- default assignments : save current state
         saved_state <= state;

         -- main state machine
         case state is

         when idle =>
            -- override default assignment here; last assignment wins
            saved_state <= saved_state;
            if leave_idle then
               state <= saved_state;
            end if;

         when state1 =>
            if suspend then
               state <= idle;
            elsif proceed then
               start_calculation;
               state <= state2;
            -- else remain here
            end if;

         -- when state2 => 
         -- etcetera

         when others =>
            state <= idle;
         end case;
      end if;
   end if;
end process;

Guardaría el estado anterior al mismo tiempo que guarda su estado actual. Por ejemplo, defina dos señales del mismo tipo de máquina de estado:

 type states is (idle, state1, ... other states);

  signal current_state  : state;
  signal previous_state : state;

En la máquina de tu estado, cada vez que current_state cambie a un estado diferente, establece previous_state en current_state .

Esto hace que previous state siempre esté un paso por detrás de current state .

Luego, en tu estado inicial, solo establece current_state en previous_state cuando quieras volver a donde estabas.

  example_state_machine : process (clk, rst)
  begin 
    if rst = '1' then
      current_state  <= idle;
      previous_state <= state1; -- set this to the state you want to go to after first idle
    elsif clk'event and clk = '1' then  -- rising clock edge
      case current is
        when idle =>
          if (something = '1') then
            current_state  <= previous_state;
            previous_state <= current_state;
          else
            current_state <= idle;
          end if;
        when state1 =>
          if (something = '1') then
            current_state  <= state2;
            previous_state <= current_state;
          elsif something_else = '1' then
            current_state  <= idle;
            previous_state <= current_state;
          else
            current_state <= state1;
          end if;
          -- ... rest of states
        when others => null;
      end case;
    end if;
  end process;