elevator_ctrl.vhd

------------------------------------------------------------------------
-- elevator_ctrl.vhd
-- 三层电梯主控制器状态机
--
-- 功能: SCAN 调度算法，控制电梯上下运行、开关门、楼层计数
-- 标准: VHDL-93, Quartus II 9.1 兼容
-- 风格: 双进程（时序寄存器 + 组合逻辑）
-- 复位: 异步低电平有效 (rst_n)
------------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity elevator_ctrl is
  port(
    clk_1hz       : in  std_logic;                     -- 1Hz 节拍时钟
    rst_n         : in  std_logic;                     -- 异步复位（低电平有效）

    -- 来自 request_handler 的请求信号
    req_up        : in  std_logic_vector(2 downto 0);  -- 上行请求 [1F, 2F, 未用]
    req_dn        : in  std_logic_vector(2 downto 0);  -- 下行请求 [未用, 2F, 3F]
    req_go        : in  std_logic_vector(2 downto 0);  -- 轿厢目标 [1F, 2F, 3F]
    any_request   : in  std_logic;                     -- 任意请求有效标志

    -- 来自 door_controller 的状态信号
    door_closed   : in  std_logic;                     -- 门已完全关闭
    door_opened   : in  std_logic;                     -- 门已完全打开

    -- 报警信号
    alarm_active  : in  std_logic;                     -- 报警有效

    -- 输出到各模块的控制信号
    current_floor : out std_logic_vector(1 downto 0);  -- 当前楼层 "00"=1F "01"=2F "10"=3F
    direction     : out std_logic;                     -- 运动方向 '0'=上 '1'=下
    motor_en      : out std_logic;                     -- 电机使能
    door_open_cmd : out std_logic;                     -- 开门命令
    door_close_cmd: out std_logic;                     -- 关门命令
    clear_req     : out std_logic_vector(2 downto 0);  -- 请求清除（到达楼层对应位为1）
    state_out     : out std_logic_vector(3 downto 0)   -- 状态编码（调试用）
  );
end entity elevator_ctrl;

architecture rtl of elevator_ctrl is

  ---------------------------------------------------------------
  -- 状态定义
  ---------------------------------------------------------------
  constant S_IDLE          : std_logic_vector(3 downto 0) := "0000";  -- 空闲等待
  constant S_DOOR_OPENING  : std_logic_vector(3 downto 0) := "0001";  -- 开门中
  constant S_DOOR_OPEN     : std_logic_vector(3 downto 0) := "0010";  -- 门开等待10秒
  constant S_DOOR_CLOSING  : std_logic_vector(3 downto 0) := "0011";  -- 关门中
  constant S_CHECK_REQ     : std_logic_vector(3 downto 0) := "0100";  -- 检查请求决定方向
  constant S_MOVING_UP     : std_logic_vector(3 downto 0) := "0101";  -- 上升中
  constant S_MOVING_DOWN   : std_logic_vector(3 downto 0) := "0110";  -- 下降中
  constant S_ARRIVED       : std_logic_vector(3 downto 0) := "0111";  -- 到达目标层
  constant S_RETURN_HOME   : std_logic_vector(3 downto 0) := "1000";  -- 返回1楼
  constant S_ALARM         : std_logic_vector(3 downto 0) := "1001";  -- 报警

  -- 门开等待时间常量（由 door_controller 自主管理，此处不再使用）
  -- constant DOOR_WAIT_MAX : std_logic_vector(3 downto 0) := "1001";

  ---------------------------------------------------------------
  -- 内部寄存器信号
  ---------------------------------------------------------------
  signal current_state : std_logic_vector(3 downto 0);  -- 当前状态
  signal floor_reg     : std_logic_vector(1 downto 0);  -- 楼层寄存器
  signal dir_reg       : std_logic;                     -- 方向寄存器 '0'=上 '1'=下

  ---------------------------------------------------------------
  -- 组合逻辑到寄存器的中间信号
  ---------------------------------------------------------------
  signal next_state    : std_logic_vector(3 downto 0);
  signal next_floor    : std_logic_vector(1 downto 0);
  signal next_dir      : std_logic;

  ---------------------------------------------------------------
  -- 请求聚合信号（组合逻辑）
  -- req_any(i): 第i层是否有任何类型请求
  ---------------------------------------------------------------
  signal req_any : std_logic_vector(2 downto 0);

  -- 当前楼层上方/下方是否有请求
  signal req_above : std_logic;
  signal req_below : std_logic;

  -- 当前楼层是否需要停靠（考虑运行方向）
  signal need_stop : std_logic;

begin

  ---------------------------------------------------------------
  -- 请求聚合（组合逻辑）
  -- req_any(0) = 1楼所有请求 OR
  -- req_any(1) = 2楼所有请求 OR
  -- req_any(2) = 3楼所有请求 OR
  ---------------------------------------------------------------
  req_any(0) <= req_up(0) or req_dn(0) or req_go(0);
  req_any(1) <= req_up(1) or req_dn(1) or req_go(1);
  req_any(2) <= req_up(2) or req_dn(2) or req_go(2);

  ---------------------------------------------------------------
  -- 上方/下方请求检测（基于 floor_reg）
  ---------------------------------------------------------------
  -- 当前楼层上方是否有请求
  req_above <= '1' when (floor_reg = "00" and (req_any(1) = '1' or req_any(2) = '1')) else
               '1' when (floor_reg = "01" and req_any(2) = '1') else
               '0';

  -- 当前楼层下方是否有请求
  req_below <= '1' when (floor_reg = "10" and (req_any(1) = '1' or req_any(0) = '1')) else
               '1' when (floor_reg = "01" and req_any(0) = '1') else
               '0';

  ---------------------------------------------------------------
  -- 到达停靠判定（考虑方向）
  -- 上行时：内选 + 同方向外呼 + 顶楼下行外呼
  -- 下行时：内选 + 同方向外呼 + 底楼上行外呼
  ---------------------------------------------------------------
  process(floor_reg, dir_reg, req_up, req_dn, req_go)
  begin
    need_stop <= '0';  -- 默认值
    case floor_reg is
      when "00" =>  -- 1楼
        -- 1楼是底楼，只有上行外呼，任何方向到达都需停靠
        if req_go(0) = '1' or req_up(0) = '1' then
          need_stop <= '1';
        end if;
      when "01" =>  -- 2楼
        if req_go(1) = '1' then
          need_stop <= '1';
        elsif dir_reg = '0' and req_up(1) = '1' then
          -- 上行模式停靠上行外呼
          need_stop <= '1';
        elsif dir_reg = '1' and req_dn(1) = '1' then
          -- 下行模式停靠下行外呼
          need_stop <= '1';
        end if;
      when "10" =>  -- 3楼
        -- 3楼是顶楼，只有下行外呼，任何方向到达都需停靠
        if req_go(2) = '1' or req_dn(2) = '1' then
          need_stop <= '1';
        end if;
      when others =>
        need_stop <= '0';
    end case;
  end process;

  ---------------------------------------------------------------
  -- 输出连接
  ---------------------------------------------------------------
  current_floor <= floor_reg;
  direction     <= dir_reg;
  state_out     <= current_state;

  ---------------------------------------------------------------
  -- 进程1: 时序逻辑（状态寄存器 + 楼层/方向更新）
  -- 在 clk_1hz 上升沿将 next_xxx 写入寄存器
  ---------------------------------------------------------------
  process(clk_1hz, rst_n)
  begin
    if rst_n = '0' then
      -- 异步复位：1楼、上行方向、空闲状态
      current_state <= S_IDLE;
      floor_reg     <= "00";    -- 1楼
      dir_reg       <= '0';     -- 上行
    elsif rising_edge(clk_1hz) then
      current_state <= next_state;
      floor_reg     <= next_floor;
      dir_reg       <= next_dir;
    end if;
  end process;

  ---------------------------------------------------------------
  -- 进程2: 组合逻辑（计算 next_state 和所有控制输出）
  ---------------------------------------------------------------
  process(current_state, floor_reg, dir_reg,
          req_up, req_dn, req_go, any_request,
          door_closed, door_opened, alarm_active,
          req_any, req_above, req_below, need_stop)
  begin
    -------------------------------------------------------
    -- 所有输出信号默认值（防止产生锁存器）
    -------------------------------------------------------
    next_state     <= current_state;
    next_floor     <= floor_reg;
    next_dir       <= dir_reg;
    motor_en       <= '0';
    door_open_cmd  <= '0';
    door_close_cmd <= '0';
    clear_req      <= "000";

    -------------------------------------------------------
    -- 报警最高优先级：任何状态下 alarm 有效立即进入 S_ALARM
    -------------------------------------------------------
    if alarm_active = '1' and current_state /= S_ALARM then
      next_state <= S_ALARM;
    else

    case current_state is

      --=====================================================
      -- S_IDLE: 空闲等待
      -- 无请求则保持；有请求则判断方向开始运行
      --=====================================================
      when S_IDLE =>
        if any_request = '1' then
          -- 当前楼层有请求：直接开门
          if (floor_reg = "00" and req_any(0) = '1') or
             (floor_reg = "01" and req_any(1) = '1') or
             (floor_reg = "10" and req_any(2) = '1') then
            next_state <= S_DOOR_OPENING;
          -- 仅上方有请求
          elsif req_above = '1' and req_below = '0' then
            next_dir   <= '0';  -- 上行
            next_state <= S_MOVING_UP;
          -- 仅下方有请求
          elsif req_below = '1' and req_above = '0' then
            next_dir   <= '1';  -- 下行
            next_state <= S_MOVING_DOWN;
          -- 上下均有请求，默认先上行
          elsif req_above = '1' and req_below = '1' then
            next_dir   <= '0';  -- 上行
            next_state <= S_MOVING_UP;
          end if;
        end if;

      --=====================================================
      -- S_DOOR_OPENING: 开门中
      -- 发出开门命令，等待 door_opened 信号
      --=====================================================
      when S_DOOR_OPENING =>
        door_open_cmd <= '1';
        -- 清除当前楼层的请求
        case floor_reg is
          when "00"   => clear_req <= "001";  -- 清1楼
          when "01"   => clear_req <= "010";  -- 清2楼
          when "10"   => clear_req <= "100";  -- 清3楼
          when others => clear_req <= "000";
        end case;
        if door_opened = '1' then
          next_state <= S_DOOR_OPEN;
        end if;

      --=====================================================
      -- S_DOOR_OPEN: 门开等待
      -- 维持开门，等待门控制器自主关门（10秒超时或手动关门）
      -- 当门完全关闭后，转入检查请求状态
      --=====================================================
      when S_DOOR_OPEN =>
        door_open_cmd <= '1';  -- 维持开门
        if door_closed = '1' then
          -- 门已关闭（door_controller 自主完成了关门流程）
          next_state <= S_CHECK_REQ;
        end if;

      --=====================================================
      -- S_DOOR_CLOSING: 关门中（预留状态，当前流程中不使用）
      -- 门的关闭由 door_controller 自主完成
      -- 发出关门命令，等待 door_closed 信号
      --=====================================================
      when S_DOOR_CLOSING =>
        door_close_cmd <= '1';
        if door_closed = '1' then
          next_state <= S_CHECK_REQ;
        end if;

      --=====================================================
      -- S_CHECK_REQ: 检查请求，决定下一步动作
      -- 核心调度逻辑：SCAN 算法方向决策
      --=====================================================
      when S_CHECK_REQ =>
        if any_request = '0' then
          -- 无任何请求
          if floor_reg /= "00" then
            -- 不在1楼，返回1楼
            next_state <= S_RETURN_HOME;
            next_dir   <= '1';  -- 下行返回
          else
            -- 已在1楼，进入空闲
            next_state <= S_IDLE;
          end if;

        elsif dir_reg = '0' then
          -- 当前方向为上
          if req_above = '1' then
            -- 上方有请求，继续上行
            next_state <= S_MOVING_UP;
          elsif need_stop = '1' then
            -- 上方无请求但当前楼层有反向请求，换向后先开门服务本层
            next_dir   <= '1';
            next_state <= S_DOOR_OPENING;
          elsif req_below = '1' then
            -- 上方无请求，当前层无请求，下方有请求，切换下行
            next_dir   <= '1';
            next_state <= S_MOVING_DOWN;
          else
            -- 仅当前楼层有请求（安全兜底）
            next_state <= S_DOOR_OPENING;
          end if;

        else
          -- 当前方向为下 (dir_reg = '1')
          if req_below = '1' then
            -- 下方有请求，继续下行
            next_state <= S_MOVING_DOWN;
          elsif need_stop = '1' then
            -- 下方无请求但当前楼层有反向请求，换向后先开门服务本层
            next_dir   <= '0';
            next_state <= S_DOOR_OPENING;
          elsif req_above = '1' then
            -- 下方无请求，当前层无请求，上方有请求，切换上行
            next_dir   <= '0';
            next_state <= S_MOVING_UP;
          else
            -- 仅当前楼层有请求
            next_state <= S_DOOR_OPENING;
          end if;
        end if;

      --=====================================================
      -- S_MOVING_UP: 上升运动
      -- 每拍上升一层，到达后检查是否停靠
      --=====================================================
      when S_MOVING_UP =>
        motor_en <= '1';
        -- 楼层 +1（上限保护：最大 "10" = 3楼）
        if floor_reg < "10" then
          next_floor <= floor_reg + 1;
        else
          next_floor <= "10";
        end if;
        -- 移动后的状态判断在 S_ARRIVED 或组合逻辑中完成
        -- 先跳转到 S_ARRIVED 做到达检测
        next_state <= S_ARRIVED;

      --=====================================================
      -- S_MOVING_DOWN: 下降运动
      -- 每拍下降一层，到达后检查是否停靠
      --=====================================================
      when S_MOVING_DOWN =>
        motor_en <= '1';
        -- 楼层 -1（下限保护：最小 "00" = 1楼）
        if floor_reg > "00" then
          next_floor <= floor_reg - 1;
        else
          next_floor <= "00";
        end if;
        next_state <= S_ARRIVED;

      --=====================================================
      -- S_ARRIVED: 到达检测
      -- 检查新楼层是否有匹配请求
      -- 注意: 此时 floor_reg 还是旧值，next_floor 是新值
      -- 但由于寄存器还未更新，需要用 next_floor 来判断
      --=====================================================
      when S_ARRIVED =>
        -- 此时 floor_reg 已经是移动后的新楼层（上一拍 MOVING 写入）
        if need_stop = '1' then
          -- 有匹配请求，开门
          next_state <= S_DOOR_OPENING;
        else
          -- 无匹配请求，判断是否到达边界或继续移动
          if dir_reg = '0' then
            -- 上行方向
            if floor_reg = "10" then
              -- 到达顶楼，检查请求决定下一步
              next_state <= S_CHECK_REQ;
            elsif req_above = '1' then
              -- 上方仍有请求，继续上行
              next_state <= S_MOVING_UP;
            else
              -- 上方无请求，检查方向
              next_state <= S_CHECK_REQ;
            end if;
          else
            -- 下行方向
            if floor_reg = "00" then
              -- 到达底楼
              next_state <= S_CHECK_REQ;
            elsif req_below = '1' then
              -- 下方仍有请求，继续下行
              next_state <= S_MOVING_DOWN;
            else
              next_state <= S_CHECK_REQ;
            end if;
          end if;
        end if;

      --=====================================================
      -- S_RETURN_HOME: 返回1楼
      -- 无请求时自动回归1楼
      --=====================================================
      when S_RETURN_HOME =>
        motor_en <= '1';
        next_dir <= '1';  -- 维持下行

        -- 如果中途出现新请求，中断返回
        if any_request = '1' then
          next_state <= S_CHECK_REQ;
        elsif floor_reg = "00" then
          -- 已到1楼
          next_state <= S_IDLE;
          next_dir   <= '0';  -- 恢复默认上行方向
        else
          -- 继续下降
          next_floor <= floor_reg - 1;
        end if;

      --=====================================================
      -- S_ALARM: 报警状态
      -- 等待报警解除后进入 S_CHECK_REQ，如果无请求则返回1楼
      --=====================================================
      when S_ALARM =>
        -- 报警期间电机停止，门保持当前状态
        if alarm_active = '0' then
          next_state <= S_CHECK_REQ;
        end if;

      --=====================================================
      -- 默认分支（防止非法状态）
      --=====================================================
      when others =>
        next_state <= S_IDLE;
        next_floor <= "00";
        next_dir   <= '0';

    end case;

    end if;  -- alarm_active 判断结束

  end process;

end architecture rtl;