基于EP4CE6E22C8写一个VHDL洗衣机控制器设计编码，编码要求 ： （1）设计一个电子定时器，控制洗衣机作如下运转：定时启动—>正转20秒->暂停10秒->反转20秒->暂停10秒->定时未到回到“正转20秒 暂停10秒 ……”，定时到则停止； （2）若定时到，则停机发出音响信号； （3）用两个数码管显示洗涤的预置时间（分钟数），按倒计时方式对洗涤过程作计时显示，直到时间到停机；洗涤过程由“开始”信号开始； （4）三只LED灯表示“正转”、“反转”、“暂停”三个状态。

以下是基于EP4CE6E22C8的VHDL洗衣机控制器的设计编码：

-- 电子定时器模块
library ieee;
use ieee.std_logic_1164.all;

entity Timer is
    port(
        clk: in std_logic;
        start: in std_logic;
        reset: in std_logic;
        time: out std_logic_vector(15 downto 0);
        beep: out std_logic;
        led1: out std_logic;
        led2: out std_logic;
        led3: out std_logic
    );
end entity Timer;

architecture Behavioral of Timer is

    type state_type is (s_idle, s_forward, s_pause, s_backward);
    signal state: state_type := s_idle;
    
    signal count: integer range 0 to 49999999 := 0;   -- 计数器，50MHz时钟信号，计数1秒
    signal timer_val: integer range 0 to 599 := 0;    -- 定时器初始值，60秒
    
    signal forward_time: integer range 0 to 19 := 0;  -- 正转时间，20秒
    signal backward_time: integer range 0 to 19 := 0; -- 反转时间，20秒
    signal pause_time: integer range 0 to 9 := 0;     -- 暂停时间，10秒
    
    signal beep_counter: integer range 0 to 999999 := 0; -- 控制蜂鸣器响声
    signal beep_freq: integer range 0 to 999999 := 0;    -- 蜂鸣器响声频率
    signal beep_on: std_logic := '0';                    -- 蜂鸣器开关
    
begin
    
    process(clk, reset)
    begin
        if reset = '1' then
            state <= s_idle;
            count <= 0;
            timer_val <= 60;
            
            forward_time <= 19;
            backward_time <= 19;
            pause_time <= 9;
            
            beep_counter <= 0;
            beep_freq <= 0;
            beep_on <= '0';
            
            time <= "0000000000000000";
            beep <= '0';
            led1 <= '0';
            led2 <= '0';
            led3 <= '0';
            
        elsif rising_edge(clk) then
            case state is
                -- 空闲状态，等待开始信号
                when s_idle =>
                    if start = '1' then
                        state <= s_forward;
                    end if;
                -- 正转状态，持续20秒
                when s_forward =>
                    if count = 0 then
                        forward_time <= forward_time - 1;
                        if forward_time = 0 then
                            state <= s_pause;
                            pause_time <= 9;
                            led1 <= '0';
                            led2 <= '0';
                            led3 <= '1';
                        end if;
                    end if;
                -- 暂停状态，持续10秒
                when s_pause =>
                    if count = 0 then
                        pause_time <= pause_time - 1;
                        if pause_time = 0 then
                            state <= s_backward;
                            backward_time <= 19;
                            led1 <= '0';
                            led2 <= '1';
                            led3 <= '0';
                        end if;
                    end if;
                -- 反转状态，持续20秒
                when s_backward =>
                    if count = 0 then
                        backward_time <= backward_time - 1;
                        if backward_time = 0 then
                            state <= s_pause;
                            pause_time <= 9;
                            led1 <= '1';
                            led2 <= '0';
                            led3 <= '0';
                        end if;
                    end if;
            end case;
            count <= count + 1;
            if count = 49999999 then
                count <= 0;
                timer_val <= timer_val - 1;
                if timer_val = -1 then
                    time <= "0000000000000000";
                    beep_freq <= 2000;
                    beep_on <= '1';
                else
                    time <= std_logic_vector(to_unsigned(timer_val, 16));
                end if;
            end if;
            if beep_counter = beep_freq then
                beep_counter <= 0;
                beep_on <= not beep_on;
            else
                beep_counter <= beep_counter + 1;
            end if;
        end if;
    end process;
    
    beep <= beep_on;
    
end architecture Behavioral;

在上述代码中，Timer模块实现了电子定时器的功能，包括控制洗衣机正转、反转、暂停的时间，定时器计时结束时触发音响信号，用LED灯表示正转、反转、暂停三个状态，并且将定时器的值传递给数码管模块进行显示。

接下来是数码管模块的代码：

-- 数码管模块
library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
use ieee.std_logic_unsigned.all;

entity SevenSegmentDisplay is
    port(
        clk: in std_logic;
        reset: in std_logic;
        start: in std_logic;
        time: in std_logic_vector(15 downto 0);
        display: out std_logic_vector(15 downto 0)
    );
end entity SevenSegmentDisplay;

architecture Behavioral of SevenSegmentDisplay is

    signal count: integer range 0 to 49999999 := 0;   -- 计数器，50MHz时钟信号，计数1秒
    signal timer_val: integer range 0 to 599 := 0;    -- 定时器初始值，60秒
    
    signal beep_freq: integer range 0 to 999999 := 0;    -- 蜂鸣器响声频率
    
    -- 数码管码表，0~9
    constant ssg_digits: std_logic_vector(9 downto 0) := "1111110000000000", 
                                              "0110000000000000",
                                              "1101101000000000",
                                              "1111001000000000",
                                              "0110011000000000",
                                              "1011011000000000",
                                              "1011111000000000",
                                              "1110000000000000",
                                              "1111111000000000",
                                              "1111011000000000";
    
    -- 数码管显示模式，0表示正常显示，1表示倒计时
    signal mode: std_logic := '0';
    
    -- 倒计时计数器
    signal countdown_counter: integer range 0 to 99999999 := 0;
    
begin
    
    process(clk, reset)
    begin
        if reset = '1' then
            count <= 0;
            timer_val <= 60;
            beep_freq <= 0;
            mode <= '0';
            countdown_counter <= 0;
            display <= "0000000000000000";
        elsif rising_edge(clk) then
            if start = '1' then
                mode <= '1';
            end if;
            if mode = '0' then
                display <= ssg_digits(to_integer(unsigned(time(15 downto 12))));
            else
                if count = 0 then
                    countdown_counter <= countdown_counter + 1;
                    if countdown_counter = 50000000 then
                        countdown_counter <= 0;
                        timer_val <= timer_val - 1;
                        if timer_val = -1 then
                            mode <= '0';
                            beep_freq <= 2000;
                        end if;
                    end if;
                end if;
                display <= ssg_digits(to_integer(unsigned(timer_val(5 downto 2))));
            end if;
            count <= count + 1;
            if count = 49999999 then
                count <= 0;
            end if;
            if beep_freq > 0 then
                beep_freq <= beep_freq - 1;
            end if;
        end if;
    end process;
    
    -- 数码管显示模式，按键控制
    process(reset, start)
    begin
        if reset = '1' then
            mode <= '0';
        elsif rising_edge(start) then
            if mode = '0' then
                mode <= '1';
            else
                mode <= '0';
            end if;
        end if;
    end process;
    
end architecture Behavioral;

在上述代码中，SevenSegmentDisplay模块实现了数码管的显示功能，包括正常显示洗涤的预置时间和按倒计时方式对洗涤过程作计时显示。同时，通过按键控制数码管的显示模式。

需要注意的是，以上代码仅是模块的设计编码，还需要进行仿真和综合实现。同时，需要将模块中的I/O信号和外部电路进行连接。