精华内容
下载资源
问答
  • 多功能数字电子钟

    千次阅读 2014-08-10 22:27:57
    多功能数字电子钟             姓 名:张士卫  班 级:计135班  学 号:201358501149 指导老师:沈春华      ●设计要求  在Quartus II环境下设计芯片完成二十四小时制计时、显示、整点报时、时间...

     

    VHDL课程设计》实验报告

     

     

     

     

     

    多功能数字电子钟

     

     

     

     

     

     

    姓    名:XXX      

    班    级:XX班   

    学    号:XXXXXXXXX

    指导老师:XXX     

     

     

    ●设计要求

      Quartus II环境下设计芯片完成二十四小时制计时、显示、整点报时、时间设置和闹钟的功能。

     

    ●实验目的

      1)充分了解Quartus II运行环境以及基本操作。

    2)学习并熟练掌握控制器、计数器、数据选择器等基本元件的基本原理以及级联方式。

    3)认识数码管的显示原理以及连接方式。

    4)充分理解数字逻辑中硬件与软件相结合的设计方式和思想。

     

    ●整体设计方案

    1整体设计:通过基本的输入输出控制状态的转换以及时间、闹钟的设置以实现的电子钟基本功能。

    2系统输入:setk键控制系统状态及校时、定时中时分秒状态转换;clk1HZ的时钟信号;reset为系统复位信号;p为计数及闹钟设置键;输入信号中只有reset为开关键,其他全由按键产生。

    3系统输出:LED显示输出;蜂鸣器(bell)声音信号输出。

      4结构逻辑框图(多功能数字电子钟) 

    扫描控制电路

     

    显示控制

    电路

     

     

    计时电路

     

                                                1Hz

                                            

    k

                                                                                                                                              

    p                                                         1024Hz

    报时控制定时

    控制电路

     

                                        

    reset                     1024Hz                                                                                 蜂鸣器

                                     512Hz

    set

                                                                                                                                                

    定时电路

     

     clk(1Hz)                                                                                         clk                        1024Hz

       512Hz

                                                                                     1Hz

                                                                                                                                                                                            

                                                                                                                                                                                            

    (5) 控制器的MDS

     

     

     

     

     

     

     

     

    ●系统功能 

      1)计时:正常工作状态下,每日按24h计时制计时并显示,蜂鸣器无声,逢整点报时。

    2)校时:在计时显示状态下,set=0,进入“小时”校准状态,之后按下“k=0”则进入“分”校准状态,继续按下“k=0”则进入“调秒”状态,第三次按下“k键”又恢复到正常计时显示状态。

    ①“小时”校准状态:在“小时”校准状态下,显示“小时”的数码管闪烁,此时按下“p键”,每按一次小时加1

    ②“分”校准状态:在“分”校准状态下,显示“分”的数码管闪烁,此时按下“p键”,每按一次分钟加1

    ③“秒”校准状态:在“调秒”状态下,显示“秒”的数码管闪烁,此时长按“p键”,秒清零。

    3)整点报时:蜂鸣器在“59”分钟的第“54”、“56”、“58”秒发频率为512HZ的低音,在“59”分钟的第“60”秒即整点时发频率为1024HZ的高音。

    4)显示:采用1024HZ的频率扫描,显示驱动6LED数码管显示小时、分、秒。在“时”“分”“秒”之间扫描数码管的“g”管。

    5)闹钟:闹钟定时时间到,蜂鸣器发出周期为1秒频率为1HZ的“滴”、“滴”声,持续时间为60秒。

    6)闹钟定时设置:在正常计数状态下,按下“k=0,进入闹钟设置状态,再按下“set=0”进入闹钟的“时”设置状态,之后按下“k=0”进入闹钟的“分”设置状态,继续按下“k=0”,又恢复到闹钟定时显示状态。

    ①闹钟“小时”设置状态:在闹钟“小时”设置状态下,显示“小时”的数码管闪烁,此时按下“p键”,每按一次小时加1

    ②闹钟“分”设置状态:在闹钟“分”设置状态下,显示“分”的数码管闪烁此时按下“p键”,每按一次分钟加1

    ●各个模块分析

       ()概述:本电子钟整体芯片包括主控芯片(control2)、分频器(fenpin)、计

    数和时钟设置芯片(set_and_count)、闹钟设置芯片、译码芯片(ym)、显示控制芯片(show_control)、模8计数芯片(m8)、8选一芯片(m8_1)、整点报时芯片(sound_control_sec)、闹钟响铃控制芯片(control_sound)、显示闪烁芯片(flash

    其中在计数和时钟控制芯片中又有模24计数芯片(m24)、模60计数芯片(m64)、、21芯片(m2_1)几个底层芯片

                          顶层框图

     

                      功能分割图(计数和时钟设置芯片

     

    (二)分述

    2)主控芯片(control2

    I模块说明

      总体:控制整个电子钟,通过对输入信号的判断,实现状态转换并决定下属芯片是否启动,保证整个电路正常工作和运行。

    输入端口:k,set键来控制8个状态,这八个状态分别是显示计时时间状态,调计时的时、分、秒状态,显示闹铃时间状态调闹铃的时、分、秒的状态,reset键是复位键,用来回复到“00”状态。

    输出端口:outreset是输出清零信号;sethoursetminsetsec分别输出调整计数状态时、分、秒信号,且setsec为输出秒的清零信号;setclkhoursetclkmin分别输出调整闹钟时、分信号;sethourensetminensetsecen

      分别为调节时、分、秒的使能端;hourflaminflasecfla分别为输出调计数时、分、秒的闪烁信号;clkhourflaclkminflaclksecfla分别为输出调闹钟时、分的闪烁信号;changemode输出数码管显示闹钟状态信号。

        II模块图

              

    III仿真图

    IV源代码

    library ieee;

    use ieee.std_logic_1164.all;

    entity control2 is

        port(

              set,reset,k,cp,p:instd_logic;   

         outreset,setmin,setminen,sethour,sethouren,setsec,setsecen,hourfla,minfla,secfla,clkhourfla,clkminfla,changemode,setclkhou,setclkmin,clksecfla:outstd_logic);

    end control2;

    architecture rtl of control2 is

    type state is(s0,s1,s2,s3,t0,t1,t2,t3);

    signal sta:state;

    begin

      process(cp,k,set,reset,p)

      begin

        if(reset='0') then

           outreset<='1';sethouren<='0';setminen<='0';setsecen<='0';    

    sethour<='1';setmin<='1';setsec<='1';setclkhou<='1';setclkmin<='1';hourfla<='0';minfla<='0';secfla<='0';clkhourfla<='0';clkminfla<='0';clksecfla<='0';sta<=s0;

       elsif(rising_edge(cp)) then

          case sta is

    when s0=>changemode<='0';outreset<='0';sethouren<='0';setminen<='0';setsecen<='0';sethour<='1';setmin<='1';setsec<='1';setclkhou<='1';setclkmin<='1';hourfla<='0';minfla<='0';secfla<='0';clkhourfla<='0';clkminfla<='0';clksecfla<='0';

    if(k='0') then

      sta<=t0;

    elsif(set='0')then

     sta<=s1;

    else

     sta<=s0;

    end if;

         when s1=>changemode<='0';outreset<='0';sethouren<='1';setminen<='0';setsecen<='0';sethour<=p;setmin<='1';setsec<='1';setclkhou<='1';setclkmin<='1';hourfla<='1';minfla<='0';secfla<='0';clkhourfla<='0';clkminfla<='0';clksecfla<='0';

          if(k='0')then

            sta<=s2;

          else

            sta<=s1;

          end if;

         when s2=>changemode<='0';outreset<='0';sethouren<='0';setminen<='1';setsecen<='0';sethour<='1';setmin<=p;setsec<='1';setclkhou<='1';setclkmin<='1';hourfla<='0';minfla<='1';secfla<='0';clkhourfla<='0';clkminfla<='0';clksecfla<='0';

          if(k='0')then

            sta<=s3;

          else

            sta<=s2;

          end if;

    whens3=>changemode<='0';outreset<='0';setminen<='0';sethouren<='0';setsecen<='1';sethour<='1';setmin<='1';setsec<=p;setclkhou<='1';setclkmin<='1';hourfla<='0';minfla<='0';secfla<='1';clkhourfla<='0';clkminfla<='0';clksecfla<='0';

           if(k='0')then

             sta<=s0;

           else

             sta<=s3;

           end if;

    when

    t0=>changemode<='1';outreset<='0';setminen<='0';sethouren<='0';setsecen<='0';sethour<='1';setmin<='1';setsec<='1';setclkhou<='1';setclkmin<='1';hourfla<='0';minfla<='0';secfla<='0';clkhourfla<='0';clkminfla<='0';clksecfla<='0';

           if(k='0')then

            sta<=s0;

          elsif(set='0')then

            sta<=t1;

          else

            sta<=t0;

          end if;

        when

    t1=>changemode<='1';outreset<='0';setminen<='0';sethouren<='0';setsecen<='0';sethour<='1';setmin<='1';setsec<='1';setclkhou<=p;setclkmin<='1';hourfla<='0';minfla<='0';secfla<='0';clkhourfla<='1';clkminfla<='0';clksecfla<='0';

    if(k='0')then

           sta<=t2;

          else

           sta<=t1;

          end if;

        when t2=>changemode<='1';outreset<='0';setminen<='0';sethouren<='0';setsecen<='0';sethour<='1';setmin<='1';setsec<='1';setclkhou<='1';setclkmin<=p;hourfla<='0';minfla<='0';secfla<='0';clkhourfla<='0';clkminfla<='1';clksecfla<='0';

          if(k='0')then

            sta<=t3;

          else

            sta<=t2;

          endif;

       when t3=>changemode<='1';outreset<='0';setminen<='0';sethouren<='0';setsecen<='0';sethour<='1';setmin<='1';setsec<='1';setclkhou<='1';setclkmin<='1';hourfla<='0';minfla<='0';secfla<='0';clkhourfla<='0';clkminfla<='0';clksecfla<='1';

          if(k='0')then

            sta<=t0;

          else

            sta<=t3;

          end if;

         whenothers=>sta<=s0;

        end case;

    end if;

    end process;

    end rtl;

    (2)分频芯片(fenpin)

    I模块说明:

    总体:将输入频率(1024Hz)进行分频,输出分频后的频率。

    输入:1024Hz的时钟信号

    输出:分别输出分频后的频率(其中仅有1Hz512Hz1024Hz的频率在该实验中用到)

    II模块图

    III仿真图

    IV源代码:

    library ieee;

    use ieee.std_logic_1164.all;

    useieee.std_logic_unsigned.all;

    entity fenpin is

    port (

          clk:in std_logic;

          put:buffer std_logic_vector(9 downto 0));

    end entity ;

    architecture rt1 of fenpin is

    begin

       process(clk)

          begin

         if(clk'event and clk='0')then

             put<=put+'1';

         end if;

    end process;

    end rt1;

    (3)模24 芯片

    I模块说明

     总体说明:实现24进制的计数芯片

     输入:使能控制信号;时钟信号(本实验中将分的仅为作为时钟信号)。

     输出:24进制中的高低位。

    II模块图

         

    III仿真图 

        IV源代码

    library ieee;

    use ieee.std_logic_1164.all;

    useieee.std_logic_unsigned.all;

    entity m24 is

         port(clk,clr:in std_logic;

               ql,qh:buffer std_logic_vector (3downto 0));

    end   m24;

    architecture aaa of m24 is

    begin

        process(clk,clr)

        begin

         if(clr='1')then

           ql<="0000";

           qh<="0000";

         elsif (clk'event and clk='1')then

             if(qh="0010" andql="0011")then--23

                   ql<="0000";

                   qh<="0000";

             elsif(ql="1001")then--l=9

                  qh<=qh+'1';

                  ql<="0000";

            else

                   ql<=ql+'1';

                   qh<=qh;

               end if;

           end if;  

        end process;

    end aaa;

    (4) 模60芯片(m60)

    I模块说明

    总体说明:实现60进制的计数芯片

      输入:使能控制信号;时钟信号(本实验中将分的仅为作为时钟信号)。

    输出:60进制中的高低位。

    II模块图

     

    III仿真图

    IV源代码

    library ieee;

    use ieee.std_logic_1164.all;

    use ieee.std_logic_unsigned.all;

    entity m60 is

        port(clk,clr,ctr,clr1:in std_logic;

               co:bufferstd_logic;

               ql,qh:bufferstd_logic_vector (3 downto 0));

    end   m60;

    architecture aaa of m60 is

    begin

        process(clk,clr,clr1,ctr)

        begin

         if(clr='1' orclr1='1')then

          ql<="0000";

          qh<="0000";

           co<='0';

         elsif (clk'event andclk='1')then

            if(qh="0101" and ql="1001")then--23

                  ql<="0000";

                   qh<="0000";

                if(ctr='0')then

                   co<='1';

                elsif(ctr='1')then

                   co<='0';

                 end if;

            elsif(ql="1001")then--l=9

                 qh<=qh+'1';

                 ql<="0000";

                   co<='0';

            else

                  ql<=ql+'1';

                   qh<=qh;

                   co<='0';

               end if;

           end if;  

        end process;

    end aaa;

    (5)2选1芯片(m2-1)

     I模块说明

    总体说明:在使能的控制下实现对输入信号(两种)的选择作用。

        输入:使能控制信号;时钟信号;设置时间的时钟信号。

    输出:选择出的时钟或者是调时信号

    II模块图

    III仿真图

    IV源代码

      library ieee;

    use ieee.std_logic_1164.all;

    entity m2_1 is

      port (

            clk,set:instd_logic;

                ctr:instd_logic;

                put:bufferstd_logic);

    end m2_1;

    architecture rt1 of m2_1 is

      begin

         process(clk,set,ctr)

          begin

           if(ctr='1')then

              put<=set;

           else

              put<=clk;

          end if;

         end process;

    end rt1;

    (6)译码芯片(ym)

    I模块说明

    总体说明:通过对输入的判断,实现对输入信号的译码,使其在数码管上显示数字。

        输入:要显示的数字信号。

    输出:点亮数码管的使能信号。

    II模块图

     

    III仿真图

    IV源代码

     library ieee;

    use ieee.std_logic_1164.all;

    entity ym is

    port (

        q:in std_logic_vector(3 downto 0);

        put:bufferstd_logic_vector (0 to 6));

    end entity;

    architecture rt1 of ym is

     begin

        process(q)

        begin

         case q is

         when"0000"=>put<="1111110";

         when "0001"=>put<="0110000";

         when"0010"=>put<="1101101";

         when"0011"=>put<="1111001";

         when"0100"=>put<="0110011";

         when"0101"=>put<="1011011";

         when"0110"=>put<="1011111";

         when"0111"=>put<="1110000";

         when"1000"=>put<="1111111";

         when"1001"=>put<="1111011";

         when "1111"=>put<="0000001";

         whenothers=>put<="0000000";

         end case;

       end process;

    end rt1;

    (7)显示控制芯片---数据选择(show_control)

      I模块说明

    总体说明:在使能的控制下实现对输入信号(两种)的选择作用。

        输入:使能控制信号;时钟信号;设置时间的时钟信号。

    输出:选择出的显示技术状态或者是闹钟状态信号。

    II模块图

     

    III仿真图

    IV源代码

    library ieee;

    use ieee.std_logic_1164.all;

    entity show_control is

    port(

         c,cl:instd_logic_vector (3 downto 0);

          ctr:in std_logic;

            p:outstd_logic_vector (3 downto 0));

    end show_control;

    architecture rt1 of show_control is

    begin

         process(ctr,c,cl)

            begin

            if(ctr='1')then

                p<=cl;

            else

                p<=c;

         end if;

    end process;

    end rt1;

    (8)模8计数芯片(m8)

    I模块说明

     总体说明:实现8进制的计数芯片

     输入:时钟信号。

     输出:当前计数状态。

    II模块图

         

    III仿真图

    IV源代码

    library ieee;

    use ieee.std_logic_1164.all;

    use ieee.std_logic_unsigned.all;

    entity m8 is

       port(cp:in std_logic;

           q:bufferstd_logic_vector(2 downto 0));

    end m8;

    architecture rtl of m8 is

        begin

          process(cp)

            begin

            if(rising_edge(cp)) then

               q<=q+'1';

          end if;

           end process;

    end rtl;

    (9)8选一芯片(m8_1)

    I模块说明

     总体说明:对输入的八种信号进行选择,输出满足输出控制信号(input)的信号。

     输入:八种信号(q0~~q7);输出控制信号(input)。

     输出:选择出来的信号。

    II模块图

     

    III仿真图

    IV源代码

    library ieee;

    use ieee.std_logic_1164.all;

    entity m8_1 is

    port (

         q0,q1,q2,q3,q4,q5,q6,q7:in std_logic_vector (3 downto 0);

          input:instd_logic_vector (2 downto 0);

          output:buffer std_logic_vector(3 downto 0));

          end entity ;

    architecture rt1 of m8_1 is

    begin

      process(q0,q1,q2,q3,q4,q5,q6,q7,input)--此处不用process行不行

      begin

       case input is

        when"000"=>output<=q0;

        when"001"=>output<=q1;

        when"010"=>output<=q2;

        when "011"=>output<=q3;

        when"100"=>output<=q4;

        when"101"=>output<=q5;

        when"110"=>output<=q6;

        when"111"=>output<=q7;

      end case;

    end process;

    end rt1;

    (10)闹钟响铃控制芯片(sound_control)

     I模块说明

       总体说明:对输入闹钟时间的时分和计数时分信号进行比对,当两个时间相同时输出1,启动蜂鸣器,否则输出0

       输入:闹钟时间的时分(hlhhmlmh),计数时分(chlchhcmlcmh)。

       输出:选择出来的信号(put)。

    II模块图

          

    III仿真图

    IV源代码

    library ieee;

    use ieee.std_logic_1164.all;

    entity sound_control2 is

    port(

        hl,hh,ml,mh,chl,chh,cml,cmh:in std_logic_vector (3 downto 0);

                               clk1:in std_logic;

                                put:out std_logic);

    end sound_control2;

    architecture rt1 of sound_control2 is

    begin

          process(hl,hh,ml,mh,chl,chh,cml,cmh,clk1)

            begin

             if(hl=chl andhh=chh and mh=chh and ml=cml)then

                 put<=clk1;

             else 

                 put<='0';

             end if;

           end process;

    end rt1;

    (11)整点报时芯片(sound_control_sec)

      I模块说明

       总体说明:对输入计数分秒信号进行判断,当时间为59分且秒为545658时,将512Hz输出,或者如果时间为整点时,将1024Hz输出,启动蜂鸣器,否则输出0

       输入:计数分秒高低位(mlmhslsh);时钟信号(512Hz1024Hz

       输出:选择出来的信号(put)。

    II模块图

     

    IV源代码

    library ieee;

    use ieee.std_logic_1164.all;

    entity sound_control_sec is

    port(

          ml,mh,sl,sh:instd_logic_vector (3 downto 0);

          clk1024,clk512:instd_logic;

          put:out std_logic);

    end sound_control_sec;

    architecture rt1 of sound_control_sec is

    begin

     process(ml,mh,sl,sh,clk1024,clk512)

        begin

        if(mh="0101" and ml="1001" and sh="0101"and sl="0110") or (mh="0101" and ml="1001" andsh="0101" and sl="1000" ) or (mh="0101" andml="1001" and sh="0101" and sl="0100" )then

            put<=clk512;

        elsif(mh="0000" and ml="0000"and sh="0000" and sl="0000")

    then

           put<=clk1024;

        else 

          put<='0';

        end if;

      end process;

    end rt1;

    (12)显示闪烁芯片(flash)

         I模块说明

       总体说明:由使能端控制是否闪烁,当使能为1时,输出频率为1Hz的高低位信号,否则按照81输出信号正常输出高低位。

       输入:计数高低位(dildih);时钟信号(1Hz);使能控制端。

       输出:处理后的计数高低位(doldoh)。

    II模块图

            

    III仿真图

      IV源代码

      library ieee;

    use ieee.std_logic_1164.all;

    entity flash is

       port(

            en,clk:instd_logic;

            dih,dil:instd_logic_vector(3 downto 0);

            doh,dol:outstd_logic_vector(3 downto 0));

    end flash;

    architecture rt1 of flash is

      begin

      process(en,clk,dih,dil)

       begin

        if(en='1')then

            if(clk='1')then

               doh<=dih;

               dol<=dil;

            else

              doh<="1110";

              dol<="1110";

           end if;

         else

           doh<=dih;

           dol<=dil;

         end if;

    end process;

    end rt1;

    反思总结:

    在本次实验中,犹豫最初对本操作程序不是很了解,导致了很多的错误,以致翻了很多的错误,但是在这个过程里无论是在考虑问题的方式上还是在专业知识层面的认识上确实让我收获了很多,一下是自己的一点认识和总结

    1)设置技巧:

         ①总体设置技巧:在设置一个较为复杂的设计时应该选择“由上到下”,而不是“由下到上”的的设计思路,另外首先要整理好设计思路以及基本的构思,这样能对整体的设计有足够的了解,不至于在实验中频繁出现思路“短路”的现象。

         ②控制器的设置:在设置控制器时应该统筹下设原件的端口设置特点,否则将会出主

    控端口剩余或者是下设端口无法控制的现象。

    ③元件名称及端口设置:在设置元件是应尽量做到功能明确,并且端口设置易于区分,这样在连接时不会出现端口功能不明确而造成难于连接的问题。

         ④底层元件连接:在设置像本设计一样元件比较多且连线复杂的实验的时候,应尽量将最底层的元件连接形成一个新的能完成比较完整的功能的芯片,这样会简化最终的芯片复杂程度更加易于观看和最后的调整、检查。

         ⑤基本元件的使用:在设计时一定注意库中最基本与非门的使用,这样能够使写代码的工作量减少且能是程序尽量的简单化。

    2)合作及成长:

         ①在做实验之前应该有足够的交流,碰撞思想的“火花”以弥补个人想法不全面或是存在错误的局限性,在交流时主要融汇每个人的整体设计思路和实现方法,并且团队中的每一个人都要参与进来,这样也将让每个人都获得巨大的收获。

         ②在做完实验后,务必将本次的实验优缺点进行总结和整理,以便在以后的实验中能进一步的完善和借鉴。

         ③足够的耐心和毅力,我想这是一个合格的设计者的基本素养,在实验中必定会遇到很多棘手的问题,这正是考验自己让自己成长的关键点,所以即使在实验中遇到难以解决的问题,也应该在交流和思考之中尽力解决,将设计做的更好更完美。

     

    展开全文
  • 51单片机——多功能电子钟

    千次阅读 2016-03-18 20:35:08
    单片机——多功能电子钟 宗旨:技术的学习是有限的,分享的精神的无限的。 实现的功能有:走 时、校时、闹钟、温度、遥控这几个功能。要想实现这几个功能,其中走时所需要的就是时 芯片,即 DS1302;时间需要...

    单片机——多功能电子钟


    宗旨:技术的学习是有限的,分享的精神是无限的。


    实现的功能有:走 时、校时、闹钟、温度、遥控这几个功能。要想实现这几个功能,其中走时所需要的就是时 钟芯片,即 DS1302;时间需要显示给人看,就需要显示器件,我们用到了点阵、数码管、 独立 LED、液晶;再来看校时,校时需要输入器件。

     

    注重模块化思想:

    // 工程配置头文件config.h:
    #ifndef _CONFIG_H
    #define _CONFIG_H
    
    /* 通用头文件 */
    #include <reg52.h>
    #include <intrins.h>
    
    /* 数据类型定义 */
    typedef signed  char         int8;   // 8位有符号整型数
    typedef signed  int            int16;  //16位有符号整型数
    typedef signed  long         int32;  //32位有符号整型数
    typedef unsigned  char     uint8;  // 8位无符号整型数
    typedef unsigned  int        uint16; //16位无符号整型数
    typedef unsigned  long     uint32; //32位无符号整型数
    
    /* 全局运行参数定义 */
    #define SYS_MCLK   (11059200/12)  //系统主时钟频率,即振荡器频率÷12
    
    /* IO引脚分配定义 */
    sbit KEY_IN_1  = P2 ^ 4; //矩阵按键的扫描输入引脚1
    sbit KEY_IN_2  = P2 ^ 5; //矩阵按键的扫描输入引脚2
    sbit KEY_IN_3  = P2 ^ 6; //矩阵按键的扫描输入引脚3
    sbit KEY_IN_4  = P2 ^ 7; //矩阵按键的扫描输入引脚4
    sbit KEY_OUT_1 = P2 ^ 3; //矩阵按键的扫描输出引脚1
    sbit KEY_OUT_2 = P2 ^ 2; //矩阵按键的扫描输出引脚2
    sbit KEY_OUT_3 = P2 ^ 1; //矩阵按键的扫描输出引脚3
    sbit KEY_OUT_4 = P2 ^ 0; //矩阵按键的扫描输出引脚4
    
    sbit ADDR0 = P1 ^ 0; //LED位选译码地址引脚0
    sbit ADDR1 = P1 ^ 1; //LED位选译码地址引脚1
    sbit ADDR2 = P1 ^ 2; //LED位选译码地址引脚2
    sbit ADDR3 = P1 ^ 3; //LED位选译码地址引脚3
    sbit ENLED = P1 ^ 4; //LED显示部件的总使能引脚
    
    #define LCD1602_DB  P0  //1602液晶数据端口
    sbit LCD1602_RS = P1 ^ 0; //1602液晶指令/数据选择引脚
    sbit LCD1602_RW = P1 ^ 1; //1602液晶读写引脚
    sbit LCD1602_E  = P1 ^ 5; //1602液晶使能引脚
    
    sbit DS1302_CE = P1 ^ 7; //DS1302片选引脚
    sbit DS1302_CK = P3 ^ 5; //DS1302通信时钟引脚
    sbit DS1302_IO = P3 ^ 4; //DS1302通信数据引脚
    
    sbit I2C_SCL = P3 ^ 7; //I2C总线时钟引脚
    sbit I2C_SDA = P3 ^ 6; //I2C总线数据引脚
    
    sbit BUZZER = P1 ^ 6; //蜂鸣器控制引脚
    
    sbit IO_18B20 = P3 ^ 2; //DS18B20通信引脚
    
    sbit IR_INPUT = P3 ^ 3; //红外接收引脚
    
    #endif /* _CONFIG_H  */<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);"> </span>
    // 头文件Lcd1602.h:
    #ifndef  _LCD1602_H
    #define _LCD1602_H
    
    #ifndef  _LCD1602_C
    
    #endif
    
    void InitLcd1602();
    void LcdClearScreen();
    void LcdOpenCursor();
    void LcdCloseCursor();
    void LcdSetCursor(uint8 x, uint8 y);
    void LcdShowStr(uint8 x, uint8 y, uint8*str);
    void LcdShowChar(uint8 x, uint8 y, uint8chr);
    
    #endif /* _LCD1602_H  */
    
    // 实时时钟芯片DS1302驱动模块的头文件DS1302.h:
    #ifndef  _DS1302_H
    #define _DS1302_H
    
    struct sTime    //日期时间结构
    {
        uint16 year; //年
        uint8 mon;   //月
        uint8 day;   //日
        uint8 hour;  //时
        uint8 min;   //分
        uint8 sec;   //秒
        uint8 week;  //星期
    };
    
    #ifndef  _DS1302_C
    
    #endif
    
    void InitDS1302();
    void GetRealTime(struct sTime *time);
    void SetRealTime(struct sTime *time);
    
    #endif /* _DS1302_H  */
    // 温度传感器DS18B20驱动模块的头文件
    #ifndef  _DS18B20_H
    #define _DS18B20_H
    
    #ifndef  _DS18B20_C
    
    #endif
    
    bit Start18B20();
    bit Get18B20Temp(int16 *temp);
    
    #endif /* _DS18B20_H */
    

    // 多功能电子钟主要功能文件的头文件Time.h:
    #ifndef  _TIME_H
    #define _TIME_H
    
    #ifndef   _TIME_C
    
    #endif
    void RefreshTime();
    void RefreshDate(uint8 ops);
    void RefreshAlarm();
    void AlarmMonitor();
    void KeyAction(uint8 keycode);
    
    #endif /* _TIME_H */

    // 4*4矩阵按键驱动模块的头文件keyboard.h:
    #ifndef  _KEY_BOARD_H
    #define _KEY_BOARD_H
    
    #ifndef  _KEY_BOARD_C
    
    #endif
    
    void KeyScan();
    void KeyDriver();
    
    #endif /* _KEY_BOARD_H */<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);"> </span>

    // 点阵LED、数码管、独立LED和无源蜂鸣器的驱动模块头文件:LedBuzzer.h:
    #ifndef  _LED_BUZZER_H
    #define _LED_BUZZER_H
    
    struct sLedBuff    //LED显示缓冲区结构
    {
        uint8 array[8];   //点阵缓冲区
        uint8 number[6];  //数码管缓冲区
        uint8 alone;      //独立LED缓冲区
    };
    
    #ifndef  _LED_BUZZER_C
    extern bit staBuzzer;
    extern struct sLedBuff ledBuff;
    #endif
    
    void InitLed();
    void FlowingLight();
    void ShowLedNumber(uint8 index, uint8num, uint8 point);
    void ShowLedArray(uint8 *ptr);
    
    #endif /* _LED_BUZZER_H */<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);"> </span>

    // 主文件的头文件main.h:
    #ifndef  _MAIN_H
    #define _MAIN_H
    
    enum eStaSystem    //系统运行状态枚举
    {
        E_NORMAL, E_SET_TIME, E_SET_ALARM
    };
    
    #ifndef  _MAIN_C
    extern enum eStaSystem staSystem;
    #endif
    
    void RefreshTemp(uint8 ops);
    void ConfigTimer0(uint16 ms);
    
    #endif /* _MAIN_H */

    //=============================================================================

    // Lcd1602.c:
    #define  _LCD1602_C
    #include "config.h"
    #include "Lcd1602.h"
    
    uint8 tmpP0;   //暂存P0口的值
    bit tmpADDR0;  //暂存LED位选译码地址0的值
    bit tmpADDR1;  //暂存LED位选译码地址1的值
    
    /* 暂停LED动态扫描,暂存相关引脚的值 */
    void LedScanPause()
    {
        ENLED = 1;
        tmpP0 = P0;
        tmpADDR0 = ADDR0;
        tmpADDR1 = ADDR1;
    }
    /* 恢复LED动态扫描,恢复相关引脚的值 */
    void  LedScanContinue()
    {
        ADDR0 = tmpADDR0;
        ADDR1 = tmpADDR1;
        P0 = tmpP0;
        ENLED = 0;
    }
    /* 等待液晶准备好 */
    void  LcdWaitReady()
    {
        uint8 sta;
    
        LCD1602_DB = 0xFF;
        LCD1602_RS = 0;
        LCD1602_RW = 1;
        do
        {
            LCD1602_E = 1;
            sta = LCD1602_DB; //读取状态字
            LCD1602_E = 0;
        }
        while (sta & 0x80);   //bit7等于1表示液晶正忙,重复检测直到其等于0为止
    }
    /* 向LCD1602液晶写入一字节命令,cmd-待写入命令值 */
    void  LcdWriteCmd(uint8 cmd)
    {
        LedScanPause();
        LcdWaitReady();
        LCD1602_RS = 0;
        LCD1602_RW = 0;
        LCD1602_DB = cmd;
        LCD1602_E  = 1;
        LCD1602_E  = 0;
        LedScanContinue();
    }
    /* 向LCD1602液晶写入一字节数据,dat-待写入数据值 */
    void  LcdWriteDat(uint8 dat)
    {
        LedScanPause();
        LcdWaitReady();
        LCD1602_RS = 1;
        LCD1602_RW = 0;
        LCD1602_DB = dat;
        LCD1602_E  = 1;
        LCD1602_E  = 0;
        LedScanContinue();
    }
    /* 清屏 */
    void LcdClearScreen()
    {
        LcdWriteCmd(0x01);
    }
    /* 打开光标的闪烁效果 */
    void  LcdOpenCursor()
    {
        LcdWriteCmd(0x0F);
    }
    /* 关闭光标显示 */
    void  LcdCloseCursor()
    {
        LcdWriteCmd(0x0C);
    }
    /* 设置显示RAM起始地址,亦即光标位置,(x,y)-对应屏幕上的字符坐标 */
    void  LcdSetCursor(uint8 x, uint8 y)
    {
        uint8 addr;
    
        if (y == 0)  //由输入的屏幕坐标计算显示RAM的地址
        {
            addr = 0x00 + x;    //第一行字符地址从0x00起始
        }
        else
        {
            addr = 0x40 + x;    //第二行字符地址从0x40起始
        }
        LcdWriteCmd(addr | 0x80);  //设置RAM地址
    }
    /* 在液晶上显示字符串,(x,y)-对应屏幕上的起始坐标,str-字符串指针 */
    void  LcdShowStr(uint8 x, uint8 y, uint8*str)
    {
        LcdSetCursor(x, y);   //设置起始地址
        while (*str != '\0')  //连续写入字符串数据,直到检测到结束符
        {
            LcdWriteDat(*str++);
        }
    }
    /* 在液晶上显示一个字符,(x,y)-对应屏幕上的起始坐标,chr-字符ASCII码 */
    void  LcdShowChar(uint8 x, uint8 y, uint8chr)
    {
        LcdSetCursor(x, y);  //设置起始地址
        LcdWriteDat(chr);    //写入ASCII字符
    }
    /* 初始化1602液晶 */
    void  InitLcd1602()
    {
        LcdWriteCmd(0x38);  //16*2显示,5*7点阵,8位数据接口
        LcdWriteCmd(0x0C);  //显示器开,光标关闭
        LcdWriteCmd(0x06);  //文字不动,地址自动+1
        LcdWriteCmd(0x01);  //清屏
    }<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);"> </span>

    // 实时时钟芯片DS1302驱动模块DS1302.c:
    #define  _DS1302_C
    #include "config.h"
    #include "DS1302.h"
    
    /* 发送一个字节到DS1302通信总线上 */
    void DS1302ByteWrite(uint8 dat)
    {
        uint8 mask;
    
        for (mask = 0x01; mask != 0; mask <<= 1) //低位在前,逐位移出
        {
            if ((mask & dat) != 0) //首先输出该位数据
            {
                DS1302_IO = 1;
            }
            else
            {
                DS1302_IO = 0;
            }
            DS1302_CK = 1;       //然后拉高时钟
            DS1302_CK = 0;       //再拉低时钟,完成一个位的操作
        }
        DS1302_IO = 1;           //最后确保释放IO引脚
    }
    /* 由DS1302通信总线上读取一个字节 */
    uint8 DS1302ByteRead()
    {
        uint8 mask;
        uint8 dat = 0;
    
        for (mask = 0x01; mask != 0; mask <<= 1) //低位在前,逐位读取
        {
            if (DS1302_IO != 0)  //首先读取此时的IO引脚,并设置dat中的对应位
            {
                dat |= mask;
            }
            DS1302_CK = 1;       //然后拉高时钟
            DS1302_CK = 0;       //再拉低时钟,完成一个位的操作
        }
        return dat;              //最后返回读到的字节数据
    }
    /* 用单次写操作向某一寄存器写入一个字节,reg-寄存器地址,dat-待写入字节 */
    void DS1302SingleWrite(uint8 reg, uint8dat)
    {
        DS1302_CE = 1;                  //使能片选信号
        DS1302ByteWrite((reg << 1) | 0x80); //发送写寄存器指令
        DS1302ByteWrite(dat);           //写入字节数据
        DS1302_CE = 0;                  //除能片选信号
    }
    /* 用单次读操作从某一寄存器读取一个字节,reg-寄存器地址,返回值-读到的字节 */
    uint8 DS1302SingleRead(uint8 reg)
    {
        uint8 dat;
    
        DS1302_CE = 1;                  //使能片选信号
        DS1302ByteWrite((reg << 1) | 0x81); //发送读寄存器指令
        dat = DS1302ByteRead();         //读取字节数据
        DS1302_CE = 0;                  //除能片选信号
    
        return dat;
    }
    /* 用突发模式连续写入8个寄存器数据,dat-待写入数据指针 */
    void DS1302BurstWrite(uint8 *dat)
    {
        uint8 i;
    
        DS1302_CE = 1;
        DS1302ByteWrite(0xBE);  //发送突发写寄存器指令
        for (i = 0; i < 8; i++) //连续写入8字节数据
        {
            DS1302ByteWrite(dat[i]);
        }
        DS1302_CE = 0;
    }
    /* 用突发模式连续读取8个寄存器的数据,dat-读取数据的接收指针 */
    void DS1302BurstRead(uint8 *dat)
    {
        uint8 i;
    
        DS1302_CE = 1;
        DS1302ByteWrite(0xBF);  //发送突发读寄存器指令
        for (i = 0; i < 8; i++) //连续读取8个字节
        {
            dat[i] = DS1302ByteRead();
        }
        DS1302_CE = 0;
    }
    /* 获取实时时间,即读取DS1302当前时间并转换为时间结构体格式 */
    void GetRealTime(struct sTime *time)
    {
        uint8 buf[8];
    
        DS1302BurstRead(buf);
        time->year = buf[6] + 0x2000;
        time->mon  = buf[4];
        time->day  = buf[3];
        time->hour = buf[2];
        time->min  = buf[1];
        time->sec  = buf[0];
        time->week = buf[5];
    }
    /* 设定实时时间,时间结构体格式的设定时间转换为数组并写入DS1302 */
    void SetRealTime(struct sTime *time)
    {
        uint8 buf[8];
    
        buf[7] = 0;
        buf[6] = time->year;
        buf[5] = time->week;
        buf[4] = time->mon;
        buf[3] = time->day;
        buf[2] = time->hour;
        buf[1] = time->min;
        buf[0] = time->sec;
        DS1302BurstWrite(buf);
    }
    /* DS1302初始化,如发生掉电则重新设置初始时间 */
    void InitDS1302()
    {
        uint8 dat;
        struct sTime code InitTime[] =   //默认初始值:2014-01-0112:30:00 星期3
        {
            0x2014, 0x01, 0x01, 0x12, 0x30, 0x00, 0x03
        };
    
        DS1302_CE = 0;  //初始化DS1302通信引脚
        DS1302_CK = 0;
        dat = DS1302SingleRead(0);  //读取秒寄存器
        if ((dat & 0x80) != 0)      //由秒寄存器最高位CH的值判断DS1302是否已停止
        {
            DS1302SingleWrite(7, 0x00);  //撤销写保护以允许写入数据
            SetRealTime(&InitTime);     //设置DS1302为默认的初始时间
        }
    }<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);"> </span>

    // 温度传感器DS18B20驱动模块DS18B20.c:DS18B20.cs
    #define  _DS18B20_C
    #include "config.h"
    #include "DS18B20.h"
    
    /* 软件延时函数,延时时间(t*10)us */
    void DelayX10us(uint8 t)
    {
        do
        {
            _nop_();
            _nop_();
            _nop_();
            _nop_();
            _nop_();
            _nop_();
            _nop_();
            _nop_();
        }
        while (--t);
    }
    /* 复位总线,获取存在脉冲,以启动一次读写操作 */
    bit Get18B20Ack()
    {
        bit ack;
    
        EA = 0;   //禁止总中断
        IO_18B20 = 0;     //产生500us复位脉冲
        DelayX10us(50);
        IO_18B20 = 1;
        DelayX10us(6);    //延时60us
        ack = IO_18B20;   //读取存在脉冲
        while(!IO_18B20); //等待存在脉冲结束
        EA = 1;   //重新使能总中断
    
        return ack;
    }
    /* 向DS18B20写入一个字节,dat-待写入字节 */
    void Write18B20(uint8 dat)
    {
        uint8 mask;
    
        EA = 0;   //禁止总中断
        for (mask = 0x01; mask != 0; mask <<= 1) //低位在先,依次移出8个bit
        {
            IO_18B20 = 0;         //产生2us低电平脉冲
            _nop_();
            _nop_();
            if ((mask & dat) == 0) //输出该bit值
            {
                IO_18B20 = 0;
            }
            else
            {
                IO_18B20 = 1;
            }
            DelayX10us(6);        //延时60us
            IO_18B20 = 1;         //拉高通信引脚
        }
        EA = 1;   //重新使能总中断
    }
    /* 从DS18B20读取一个字节,返回值-读到的字节 */
    uint8 Read18B20()
    {
        uint8 dat;
        uint8 mask;
    
        EA = 0;   //禁止总中断
        for (mask = 0x01; mask != 0; mask <<= 1) //低位在先,依次采集8个bit
        {
            IO_18B20 = 0;         //产生2us低电平脉冲
            _nop_();
            _nop_();
            IO_18B20 = 1;         //结束低电平脉冲,等待18B20输出数据
            _nop_();              //延时2us
            _nop_();
            if (!IO_18B20)        //读取通信引脚上的值
            {
                dat &= ~mask;
            }
            else
            {
                dat |= mask;
            }
            DelayX10us(6);        //再延时60us
        }
        EA = 1;   //重新使能总中断
    
        return dat;
    }
    /* 启动一次18B20温度转换,返回值-表示是否启动成功 */
    bit Start18B20()
    {
        bit ack;
    
        ack = Get18B20Ack();   //执行总线复位,并获取18B20应答
        if (ack == 0)          //如18B20正确应答,则启动一次转换
        {
            Write18B20(0xCC);  //跳过ROM操作
            Write18B20(0x44);  //启动一次温度转换
        }
        return ~ack;   //ack==0表示操作成功,所以返回值对其取反
    }
    /* 读取DS18B20转换的温度值,返回值-表示是否读取成功 */
    bit Get18B20Temp(int16 *temp)
    {
        bit ack;
        uint8 LSB, MSB; //16bit温度值的低字节和高字节
    
        ack = Get18B20Ack();    //执行总线复位,并获取18B20应答
        if (ack == 0)           //如18B20正确应答,则读取温度值
        {
            Write18B20(0xCC);   //跳过ROM操作
            Write18B20(0xBE);   //发送读命令
            LSB = Read18B20();  //读温度值的低字节
            MSB = Read18B20();  //读温度值的高字节
            *temp = ((int16)MSB << 8) + LSB; //合成为16bit整型数
        }
        return~ack;  //ack==0表示操作应答,所以返回值为其取反值
    }
    

    // 多功能电子钟主要功能文件Time.c:
    #define  _TIME_C
    #include "config.h"
    #include "DS1302.h"
    #include "LedBuzzer.h"
    #include "Lcd1602.h"
    #include "Time.h"
    #include "main.h"
    
    uint8 code WeekMod[] =    //星期X字符图片表
    {
        0xFF, 0x99, 0x00, 0x00, 0x00, 0x81, 0xC3, 0xE7,  //星期日(红心)
        0xEF, 0xE7, 0xE3, 0xE7, 0xE7, 0xE7, 0xE7, 0xC3,  //星期1
        0xC3, 0x81, 0x9D, 0x87, 0xC3, 0xF9, 0xC1, 0x81,  //星期2
        0xC3, 0x81, 0x9D, 0xC7, 0xC7, 0x9D, 0x81, 0xC3,  //星期3
        0xCF, 0xC7, 0xC3, 0xC9, 0xC9, 0x81, 0xCF, 0xCF,  //星期4
        0x81, 0xC1, 0xF9, 0xC3, 0x87, 0x9D, 0x81, 0xC3,  //星期5
        0xC3, 0x81, 0xF9, 0xC3, 0x81, 0x99, 0x81, 0xC3,  //星期6
    };
    
    bit staMute = 0;  //静音标志位
    uint8 AlarmHour = 0x07;  //闹钟时间的小时数
    uint8 AlarmMin  = 0x30; //闹钟时间的分钟数
    struct sTime CurTime;    //当前日期时间
    
    uint8 SetIndex = 0;  //设置位索引
    uint8 pdata SetAlarmHour;    //闹钟小时数设置缓冲
    uint8 pdata SetAlarmMin;     //闹钟分钟数设置缓冲
    struct sTime pdata SetTime;  //日期时间设置缓冲区
    
    /* 获取当前日期时间,并刷新时间和星期的显示 */
    void RefreshTime()
    {
        GetRealTime(&CurTime);                  //获取当前日期时间
        ShowLedNumber(5, CurTime.hour >> 4, 0); //时
        ShowLedNumber(4, CurTime.hour & 0xF, 1);
        ShowLedNumber(3, CurTime.min >> 4, 0); //分
        ShowLedNumber(2, CurTime.min & 0xF, 1);
        ShowLedNumber(1, CurTime.sec >> 4, 0); //秒
        ShowLedNumber(0, CurTime.sec & 0xF, 0);
        ShowLedArray(WeekMod + CurTime.week * 8); //星期
    }
    /* 日期刷新函数,ops-刷新选项:为0时只当日期变化才刷新,非0则立即刷新 */
    void RefreshDate(uint8 ops)
    {
        uint8 pdata str[12];
        static uint8 backup = 0;
    
        if ((backup != CurTime.day) || (ops != 0))
        {
            str[0] = ((CurTime.year >> 12) & 0xF) + '0'; //4位数年份
            str[1] = ((CurTime.year >> 8) & 0xF) + '0';
            str[2] = ((CurTime.year >> 4) & 0xF) + '0';
            str[3] = (CurTime.year & 0xF) + '0';
            str[4] = '-';                       //分隔符
            str[5] = (CurTime.mon >> 4) + '0';   //月份
            str[6] = (CurTime.mon & 0xF) + '0';
            str[7] = '-';                       //分隔符
            str[8] = (CurTime.day >> 4) + '0';   //日期
            str[9] = (CurTime.day & 0xF) + '0';
            str[10] = '\0';         //字符串结束符
            LcdShowStr(0, 0, str);  //显示到液晶上
            backup = CurTime.day;   //刷新上次日期值
        }
    }
    /* 刷新闹钟时间的显示 */
    void RefreshAlarm()
    {
        uint8 pdata str[8];
    
        LcdShowStr(0, 1, "Alarm at ");     //显示提示标题
        str[0] = (AlarmHour >> 4) + '0';  //闹钟小时数
        str[1] = (AlarmHour & 0xF) + '0';
        str[2] = ':';                      //分隔符
        str[3] = (AlarmMin >> 4) + '0';   //闹钟分钟数
        str[4] = (AlarmMin & 0xF) + '0';
        str[5] = '\0';                    //字符串结束符
        LcdShowStr(9, 1, str);            //显示到液晶上
    }
    /* 闹钟监控函数,抵达设定的闹钟时间时执行闹铃 */
    void AlarmMonitor()
    {
        if ((CurTime.hour == AlarmHour) && (CurTime.min == AlarmMin)) //检查时间匹配
        {
            if (!staMute)  //检查是否静音
            {
                staBuzzer = ~staBuzzer;    //实现蜂鸣器断续鸣叫
            }
            else
            {
                staBuzzer = 0;
            }
        }
        else
        {
            staMute = 0;
            staBuzzer = 0;
        }
    }
    /* 将设置时间及标题提示显示到液晶上 */
    void ShowSetTime()
    {
        uint8 pdata str[18];
    
        str[0]  = ((SetTime.year >> 4) & 0xF) + '0'; //2位数年份
        str[1]  = (SetTime.year & 0xF) + '0';
        str[2]  = '-';
        str[3]  = (SetTime.mon >> 4) + '0';  //月份
        str[4]  = (SetTime.mon & 0xF) + '0';
        str[5]  = '-';
        str[6]  = (SetTime.day >> 4) + '0';  //日期
        str[7]  = (SetTime.day & 0xF) + '0';
        str[8]  = '-';
        str[9]  = (SetTime.week & 0xF) + '0'; //星期
        str[10] = ' ';
        str[11] = (SetTime.hour >> 4) + '0';  //小时
        str[12] = (SetTime.hour & 0xF) + '0';
        str[13] = ':';
        str[14] = (SetTime.min >> 4) + '0';   //分钟
        str[15] = (SetTime.min & 0xF) + '0';
        str[16] = '\0';
        LcdShowStr(0, 0, "Set Date Time");  //显示提示标题
        LcdShowStr(0, 1, str);             //显示设置时间值
    }
    /* 将设置闹钟及标题提示显示到液晶上 */
    void ShowSetAlarm()
    {
        uint8 pdata str[8];
    
        str[0] = (SetAlarmHour >> 4) + '0';   //小时
        str[1] = (SetAlarmHour & 0xF) + '0';
        str[2] = ':';
        str[3] = (SetAlarmMin >> 4) + '0';    //分钟
        str[4] = (SetAlarmMin & 0xF) + '0';
        str[5] = '\0';
        LcdShowStr(0, 0, "Set Alarm"); //显示提示标题
        LcdShowStr(0, 1, str);          //显示设定闹钟值
    }
    /* 取消当前设置,返回正常运行状态 */
    void CancelCurSet()
    {
        staSystem = E_NORMAL;
        LcdCloseCursor();  //关闭光标
        LcdClearScreen();  //液晶清屏
        RefreshTime();   //刷新当前时间
        RefreshDate(1);  //立即刷新日期显示
        RefreshTemp(1);  //立即刷新温度显示
        RefreshAlarm();  //闹钟设定值显示
    }
    /* 时间或闹钟设置时,设置位右移一位,到头后折回 */
    void SetRightShift()
    {
        if (staSystem == E_SET_TIME)
        {
            switch (SetIndex)
            {
            case 0:
                SetIndex = 1;
                LcdSetCursor(1, 1);
                break;
            case 1:
                SetIndex = 2;
                LcdSetCursor(3, 1);
                break;
            case 2:
                SetIndex = 3;
                LcdSetCursor(4, 1);
                break;
            case 3:
                SetIndex = 4;
                LcdSetCursor(6, 1);
                break;
            case 4:
                SetIndex = 5;
                LcdSetCursor(7, 1);
                break;
            case 5:
                SetIndex = 6;
                LcdSetCursor(9, 1);
                break;
            case 6:
                SetIndex = 7;
                LcdSetCursor(11, 1);
                break;
            case 7:
                SetIndex = 8;
                LcdSetCursor(12, 1);
                break;
            case 8:
                SetIndex = 9;
                LcdSetCursor(14, 1);
                break;
            case 9:
                SetIndex = 10;
                LcdSetCursor(15, 1);
                break;
            default:
                SetIndex = 0;
                LcdSetCursor(0, 1);
                break;
            }
        }
        else if (staSystem == E_SET_ALARM)
        {
            switch (SetIndex)
            {
            case 0:
                SetIndex = 1;
                LcdSetCursor(1, 1);
                break;
            case 1:
                SetIndex = 2;
                LcdSetCursor(3, 1);
                break;
            case 2:
                SetIndex = 3;
                LcdSetCursor(4, 1);
                break;
            default:
                SetIndex = 0;
                LcdSetCursor(0, 1);
                break;
            }
        }
    }
    /* 时间或闹钟设置时,设置位左移一位,到头后折回 */
    void SetLeftShift()
    {
        if (staSystem == E_SET_TIME)
        {
            switch (SetIndex)
            {
            case 0:
                SetIndex = 10;
                LcdSetCursor(15, 1);
                break;
            case 1:
                SetIndex = 0;
                LcdSetCursor(0, 1);
                break;
            case 2:
                SetIndex = 1;
                LcdSetCursor(1, 1);
                break;
            case 3:
                SetIndex = 2;
                LcdSetCursor(3, 1);
                break;
            case 4:
                SetIndex = 3;
                LcdSetCursor(4, 1);
                break;
            case 5:
                SetIndex = 4;
                LcdSetCursor(6, 1);
                break;
            case 6:
                SetIndex = 5;
                LcdSetCursor(7, 1);
                break;
            case 7:
                SetIndex = 6;
                LcdSetCursor(9, 1);
                break;
            case 8:
                SetIndex = 7;
                LcdSetCursor(11, 1);
                break;
            case 9:
                SetIndex = 8;
                LcdSetCursor(12, 1);
                break;
            default:
                SetIndex = 9;
                LcdSetCursor(14, 1);
                break;
            }
        }
        else if (staSystem == E_SET_ALARM)
        {
            switch (SetIndex)
            {
            case 0:
                SetIndex = 3;
                LcdSetCursor(4, 1);
                break;
            case 1:
                SetIndex = 0;
                LcdSetCursor(0, 1);
                break;
            case 2:
                SetIndex = 1;
                LcdSetCursor(1, 1);
                break;
            default:
                SetIndex = 2;
                LcdSetCursor(3, 1);
                break;
            }
        }
    }
    /* 输入设置数字,修改对应的设置位,并显示该数字,ascii-输入数字的ASCII码 */
    void InputSetNumber(uint8 ascii)
    {
        uint8 num;
    
        num = ascii - '0';
        if (num <= 9)  //只响应0~9的数字
        {
            if (staSystem == E_SET_TIME)
            {
                switch (SetIndex)
                {
                case 0:
                    SetTime.year = (SetTime.year & 0xFF0F) | (num << 4);
                    LcdShowChar(0, 1, ascii);
                    break;     //年份高位数字
                case 1:
                    SetTime.year = (SetTime.year & 0xFFF0) | (num);
                    LcdShowChar(1, 1, ascii);
                    break;      //年份低位数字
                case 2:
                    SetTime.mon = (SetTime.mon & 0x0F) | (num << 4);
                    LcdShowChar(3, 1, ascii);
                    break;      //月份高位数字
                case 3:
                    SetTime.mon = (SetTime.mon & 0xF0) | (num);
                    LcdShowChar(4, 1, ascii);
                    break;      //月份低位数字
                case 4:
                    SetTime.day = (SetTime.day & 0x0F) | (num << 4);
                    LcdShowChar(6, 1, ascii);
                    break;      //日期高位数字
                case 5:
                    SetTime.day = (SetTime.day & 0xF0) | (num);
                    LcdShowChar(7, 1, ascii);
                    break;      //日期低位数字
                case 6:
                    SetTime.week = (SetTime.week & 0xF0) | (num);
                    LcdShowChar(9, 1, ascii);
                    break;      //星期数字
                case 7:
                    SetTime.hour = (SetTime.hour & 0x0F) | (num << 4);
                    LcdShowChar(11, 1, ascii);
                    break;      //小时高位数字
                case 8:
                    SetTime.hour = (SetTime.hour & 0xF0) | (num);
                    LcdShowChar(12, 1, ascii);
                    break;      //小时低位数字
                case 9:
                    SetTime.min = (SetTime.min & 0x0F) | (num << 4);
                    LcdShowChar(14, 1, ascii);
                    break;      //分钟高位数字
                default:
                    SetTime.min = (SetTime.min & 0xF0) | (num);
                    LcdShowChar(15, 1, ascii);
                    break;      //分钟低位数字
                }
                SetRightShift();  //完成该位设置后自动右移
            }
            else if (staSystem == E_SET_ALARM)
            {
                switch (SetIndex)
                {
                case 0:
                    SetAlarmHour = (SetAlarmHour & 0x0F) | (num << 4);
                    LcdShowChar(0, 1, ascii);
                    break;      //小时高位数字
                case 1:
                    SetAlarmHour = (SetAlarmHour & 0xF0) | (num);
                    LcdShowChar(1, 1, ascii);
                    break;      //小时低位数字
                case 2:
                    SetAlarmMin = (SetAlarmMin & 0x0F) | (num << 4);
                    LcdShowChar(3, 1, ascii);
                    break;      //分钟高位数字
                default:
                    SetAlarmMin = (SetAlarmMin & 0xF0) | (num);
                    LcdShowChar(4, 1, ascii);
                    break;      //分钟低位数字
                }
                SetRightShift();  //完成该位设置后自动右移
            }
        }
    }
    /* 切换系统运行状态 */
    void SwitchSystemSta()
    {
        if (staSystem == E_NORMAL)  //正常运行切换到时间设置
        {
            staSystem = E_SET_TIME;
            SetTime.year = CurTime.year;  //当前时间拷贝到时间设置缓冲区中
            SetTime.mon  = CurTime.mon;
            SetTime.day  = CurTime.day;
            SetTime.hour = CurTime.hour;
            SetTime.min  = CurTime.min;
            SetTime.sec  = CurTime.sec;
            SetTime.week = CurTime.week;
            LcdClearScreen();  //液晶清屏
            ShowSetTime();     //显示设置时间
            SetIndex = 255;    //与接下来的右移一起将光标设在最左边的位置上
            SetRightShift();
            LcdOpenCursor();   //开启光标
        }
        else if (staSystem == E_SET_TIME)  //时间设置切换到闹钟设置
        {
            staSystem = E_SET_ALARM;
            SetTime.sec = 0;          //秒清零,即当设置时间后从0秒开始走时
            SetRealTime(&SetTime);    //设定时间写入实时时钟
            SetAlarmHour = AlarmHour; //当前闹钟值拷贝到设置缓冲区
            SetAlarmMin  = AlarmMin;
            LcdClearScreen();  //液晶清屏
            ShowSetAlarm();    //显示设置闹钟
            SetIndex = 255;    //与接下来的右移一起将光标设在最左边的位置上
            SetRightShift();
        }
        else  //闹钟设置切换会正常运行
        {
            staSystem = E_NORMAL;
            AlarmHour = SetAlarmHour;  //设定的闹钟值写入闹钟时间
            AlarmMin  = SetAlarmMin;
            LcdCloseCursor();  //关闭光标
            LcdClearScreen();  //液晶清屏
            RefreshTime();   //刷新当前时间
            RefreshDate(1);  //立即刷新日期显示
            RefreshTemp(1);  //立即刷新温度显示
            RefreshAlarm();  //闹钟设定值显示
        }
    }
    /* 按键动作函数,根据键码执行相应的操作,keycode-按键键码 */
    void KeyAction(uint8 keycode)
    {
        if  ((keycode >= '0') && (keycode <= '9')) //数字键输入当前位设定值
        {
            InputSetNumber(keycode);
        }
        else if (keycode == 0x25)  //向左键,向左切换设置位
        {
            SetLeftShift();
        }
        else if (keycode == 0x27)  //向右键,向右切换设置位
        {
            SetRightShift();
        }
        else if (keycode == 0x0D)  //回车键,切换运行状态/保存设置
        {
            SwitchSystemSta();
        }
        else if (keycode == 0x1B)  //Esc键,静音/取消当前设置
        {
            if (staSystem == E_NORMAL) //处于正常运行状态时闹铃静音
            {
                staMute = 1;
            }
            else                       //处于设置状态时退出设置
            {
                CancelCurSet();
            }
        }
    }
    
    // 4*4矩阵按键驱动模块keyboard.c:
    #define  _KEY_BOARD_C
    #include "config.h"
    #include "keyboard.h"
    #include "Time.h"
    
    const uint8 code KeyCodeMap[4][4] =   //矩阵按键到标准键码的映射表
    {
        { '1',  '2',  '3', 0x26 }, //数字键1、数字键2、数字键3、向上键
        { '4',  '5',  '6', 0x25 }, //数字键4、数字键5、数字键6、向左键
        { '7',  '8',  '9', 0x28 }, //数字键7、数字键8、数字键9、向下键
        { '0', 0x1B, 0x0D, 0x27 }   //数字键0、ESC键、  回车键、 向右键
    };
    uint8 pdata KeySta[4][4] =    //全部矩阵按键的当前状态
    {
        {1, 1, 1, 1},  {1, 1, 1, 1},  {1, 1, 1, 1}, {1, 1, 1, 1}
    };
    
    /* 按键驱动函数,检测按键动作,调度相应动作函数,需在主循环中调用 */
    void KeyDriver()
    {
        uint8 i, j;
        static uint8 pdata backup[4][4] =   //按键值备份,保存前一次的值
        {
            {1, 1, 1, 1},  {1, 1, 1, 1},  {1, 1, 1, 1}, {1, 1, 1, 1}
        };
    
        for (i = 0; i < 4; i++) //循环检测4*4的矩阵按键
        {
            for (j = 0; j < 4; j++)
            {
                if (backup[i][j] != KeySta[i][j])   //检测按键动作
                {
                    if (backup[i][j] != 0)           //按键按下时执行动作
                    {
                        KeyAction(KeyCodeMap[i][j]); //调用按键动作函数
                    }
                    backup[i][j] = KeySta[i][j];    //刷新前一次的备份值
                }
            }
        }
    }
    /* 按键扫描函数,需在定时中断中调用,推荐调用间隔1ms */
    void KeyScan()
    {
        uint8 i;
        static uint8 keyout = 0;   //矩阵按键扫描输出索引
        static uint8 keybuf[4][4] =    //矩阵按键扫描缓冲区
        {
            {0xFF, 0xFF, 0xFF, 0xFF},  {0xFF, 0xFF, 0xFF, 0xFF},
            {0xFF, 0xFF, 0xFF, 0xFF},  {0xFF, 0xFF, 0xFF, 0xFF}
        };
    
        //将一行的4个按键值移入缓冲区
        keybuf[keyout][0] = (keybuf[keyout][0] << 1) | KEY_IN_1;
        keybuf[keyout][1] = (keybuf[keyout][1] << 1) | KEY_IN_2;
        keybuf[keyout][2] = (keybuf[keyout][2] << 1) | KEY_IN_3;
        keybuf[keyout][3] = (keybuf[keyout][3] << 1) | KEY_IN_4;
        //消抖后更新按键状态
        for (i = 0; i < 4; i++) //每行4个按键,所以循环4次
        {
            if ((keybuf[keyout][i] & 0x0F) == 0x00)
            {
                //连续4次扫描值为0,即4*4ms内都是按下状态时,可认为按键已稳定的按下
                KeySta[keyout][i] = 0;
            }
            else if ((keybuf[keyout][i] & 0x0F) == 0x0F)
            {
                //连续4次扫描值为1,即4*4ms内都是弹起状态时,可认为按键已稳定的弹起
                KeySta[keyout][i] = 1;
            }
        }
        //执行下一次的扫描输出
        keyout++;        //输出索引递增
        keyout &= 0x03;  //索引值加到4即归零
        switch (keyout)  //根据索引值,释放当前输出引脚,拉低下次的输出引脚
        {
        case 0:
            KEY_OUT_4 = 1;
            KEY_OUT_1 = 0;
            break;
        case 1:
            KEY_OUT_1 = 1;
            KEY_OUT_2 = 0;
            break;
        case 2:
            KEY_OUT_2 = 1;
            KEY_OUT_3 = 0;
            break;
        case 3:
            KEY_OUT_3 = 1;
            KEY_OUT_4 = 0;
            break;
        default:
            break;
        }
    }
    
    // 点阵LED、数码管、独立LED和无源蜂鸣器的驱动模块LedBuzzer.c:
    #define  _LED_BUZZER_C
    #include "config.h"
    #include "LedBuzzer.h"
    
    uint8 code LedChar[] =    //数码管显示字符转换表
    {
        0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8,
        0x80, 0x90, 0x88, 0x83, 0xC6, 0xA1, 0x86, 0x8E
    };
    
    bit staBuzzer = 0; //蜂鸣器状态控制位,1-鸣叫、0-关闭
    struct sLedBuff ledBuff; //LED显示缓冲区,默认初值全0,正好达到上电全亮的效果
    
    /* LED初始化函数,初始化IO、配置定时器 */
    void InitLed()
    {
        //初始化IO口
        P0 = 0xFF;
        ENLED = 0;
        //配置T2作为动态扫描定时
        T2CON = 0x00;  //配置T2工作在16位自动重载定时器模式
        RCAP2H = ((65536 - SYS_MCLK / 1500) >> 8); //配置重载值,每秒产生1500次中断,
        RCAP2L = (65536 - SYS_MCLK / 1500);  //以使刷新率达到100Hz无闪烁的效果
        TH2 = RCAP2H;  //设置初值等于重载值
        TL2 = RCAP2L;
        ET2 = 1;       //使能T2中断
        PT2 = 1;       //设置T2中断为高优先级
        TR2 = 1;       //启动T2
    }
    /* 流水灯实现函数,间隔调用实现流动效果 */
    void FlowingLight()
    {
        static uint8 i = 0;
        const uint8 code tab[] =    //流动表
        {
            0x7F, 0x3F, 0x1F, 0x0F, 0x87, 0xC3, 0xE1, 0xF0, 0xF8, 0xFC, 0xFE, 0xFF
        };
    
        ledBuff.alone = tab[i];   //表中对应值送到独立LED的显示缓冲区
        if (i < (sizeof(tab) - 1)) //索引递增循环,遍历整个流动表
        {
            i++;
        }
        else
        {
            i = 0;
        }
    }
    /* 数码管上显示一位数字,index-数码管位索引(从右到左对应0~5),
    **    num-待显示的数字,point-代表是否显示此位上的小数点 */
    void ShowLedNumber(uint8 index, uint8num, uint8 point)
    {
        ledBuff.number[index] = LedChar[num]; //输入数字转换为数码管字符0~F
        if (point != 0)
        {
            ledBuff.number[index] &= 0x7F; //point不为0时点亮当前位的小数点
        }
    }
    /* 点阵上显示一帧图片,ptr-待显示图片指针 */
    void ShowLedArray(uint8 *ptr)
    {
        uint8 i;
    
        for (i = 0; i < sizeof(ledBuff.array); i++)
        {
            ledBuff.array[i] = *ptr++;
        }
    }
    /* T2中断服务函数,LED动态扫描、蜂鸣器控制 */
    void InterruptTimer2() interrupt 5
    {
        static uint8 i = 0;  //LED位选索引
    
        TF2 = 0;  //清零T2中断标志
        //全部LED动态扫描显示
        if (ENLED == 0)  //LED使能时才进行动态扫描
        {
            P0 = 0xFF;                      //关闭所有段选位,显示消隐
            P1 = (P1 & 0xF0) | i;           //位选索引值赋值到P1口低4位
            P0 = *((uint8 data*)&ledBuff + i); //缓冲区中索引位置的数据送到P0口
            if (i < (sizeof(ledBuff) - 1))  //索引递增循环,遍历整个缓冲区
            {
                i++;
            }
            else
            {
                i = 0;
            }
        }
        //由蜂鸣器状态位控制蜂鸣器
        if (staBuzzer == 1)
        {
            BUZZER = ~BUZZER;    //蜂鸣器鸣叫
        }
        else
        { BUZZER = 1; }        //蜂鸣器静音
    }
    

    // 多功能电子钟工程主文件main.c:
    #define  _MAIN_C
    #include "config.h"
    #include "Lcd1602.h"
    #include "LedBuzzer.h"
    #include "keyboard.h"
    #include "DS1302.h"
    #include "DS18B20.h"
    #include "Infrared.h"
    #include "Time.h"
    #include "main.h"
    
    bit flag2s = 0;    //2s定时标志位
    bit flag200ms = 0; //200ms定时标志
    uint8 T0RH = 0;    //T0重载值的高字节
    uint8 T0RL = 0;    //T0重载值的低字节
    enum eStaSystem staSystem = E_NORMAL;  //系统运行状态
    
    void main()
    {
        EA = 1;           //开总中断
        ConfigTimer0(1);  //配置T0定时1ms
        InitLed();        //初始化LED模块
        InitDS1302();     //初始化实时时钟模块
        InitLcd1602();    //初始化液晶模块
        Start18B20();     //启动首次温度转换
    
        while (!flag2s);  //上电后延时2秒
        flag2s = 0;
        RefreshTime();    //刷新当前时间
        RefreshDate(1);   //立即刷新日期显示
        RefreshTemp(1);   //立即刷新温度显示
        RefreshAlarm();   //闹钟设定值显示
    
        while (1)  //进入主循环
        {
            KeyDriver();      //执行按键驱动
            if (flag200ms)    //每隔200ms执行以下分支
            {
                flag200ms = 0;
                FlowingLight();  //流水灯效果实现
                RefreshTime();   //刷新当前时间
                AlarmMonitor();  //监控闹钟
                if (staSystem == E_NORMAL)  //正常运行时刷新日期显示
                {
                    RefreshDate(0);
                }
            }
            if (flag2s)  //每隔2s执行以下分支
            {
                flag2s = 0;
                if (staSystem == E_NORMAL)  //正常运行时刷新温度显示
                {
                    RefreshTemp(0);
                }
            }
        }
    }
    /* 温度刷新函数,读取当前温度并根据需要刷新液晶显示,
    ** ops-刷新选项:为0时只当温度变化才刷新,非0则立即刷新 */
    void RefreshTemp(uint8 ops)
    {
        int16 temp;
        uint8 pdata str[8];
        static int16 backup = 0;
    
        Get18B20Temp(&temp); //获取当前温度值
        Start18B20();        //启动下一次转换
        temp >>= 4;          //舍弃4bit小数位
        if ((backup != temp) || (ops != 0)) //按需要刷新液晶显示
        {
            str[0] = (temp / 10) + '0'; //十位转为ASCII码
            str[1] = (temp % 10) + '0'; //个位转为ASCII码
            str[2] = '\'';             //用'C代替℃
            str[3] = 'C';
            str[4] = '\0';             //字符串结束符
            LcdShowStr(12, 0, str);    //显示到液晶上
            backup = temp;             //刷新上次温度值
        }
    }
    /* 配置并启动T0,ms-T0定时时间 */
    void ConfigTimer0(uint16 ms)
    {
        uint32 tmp;
    
        tmp = (SYS_MCLK * ms) / 1000; //计算所需的计数值
        tmp = 65536 - tmp;        //计算定时器重载值
        tmp = tmp + 33;           //补偿中断响应延时造成的误差
        T0RH = (uint8)(tmp >> 8); //定时器重载值拆分为高低字节
        T0RL = (uint8)tmp;
        TMOD &= 0xF0;   //清零T0的控制位
        TMOD |= 0x01;   //配置T0为模式1
        TH0 = T0RH;     //加载T0重载值
        TL0 = T0RL;
        ET0 = 1;        //使能T0中断
        TR0 = 1;        //启动T0
    }
    /* T0中断服务函数,实现系统定时和按键扫描 */
    void InterruptTimer0() interrupt 1
    {
        static uint8 tmr2s = 0;
        static uint8 tmr200ms = 0;
    
        TH0 = T0RH;  //重新加载重载值
        TL0 = T0RL;
        tmr200ms++;  //定时200ms
        if (tmr200ms >= 200)
        {
            tmr200ms = 0;
            flag200ms = 1;
            tmr2s++;  //定时2s
            if (tmr2s >= 10)
            {
                tmr2s = 0;
                flag2s = 1;
            }
        }
        KeyScan();   //执行按键扫描
    }
    


    展开全文
  • 基于VHDL实现的多功能电子钟设计

    千次阅读 2018-09-09 23:42:38
    主要功能要求: 1、电子时钟。要求用 24 时制显示。分屏显示“时、分”和“分、秒”,即 4 个数码管不能同时显示“时、分、秒”,但可以只显示“时、分”,或只显示“分、秒”,通过按键来切换这两种显示方式。用...

    主要功能要求:

    1、电子时钟。要求用 24 时制显示。分屏显示“时、分”和“分、秒”,即 4 个数码管不能同时显示“时、分、秒”,但可以只显示“时、分”,或只显示“分、秒”,通过按键来切换这两种显示方式。用数码管的小数点“.”代替时、分、秒的分隔符“:”。可设置时间。设置时间时,当前设置的“时”/“分”,相应的数码管应闪烁。
    2、秒表(计时器)。秒表精度为 0.01 秒,计时范围 0~99.99 秒,用 4 个数码管显示,两个显示秒,两个显示百分秒,有暂停/继续、重置(清零)按钮。
    3、定时器。可以实现 0~9999 秒定时。设置一定时值,当计时到达设定值时输出 LED 闪烁。有设置、暂停/继续、清零定时按钮。

    参考思路:

    1. 上电默认显示 “时.分”,依次按下 MOD 按钮,分别显示“分.秒”、“秒表”、“定时器”
    2. 显示 “时.分”时,按下“SET”按钮,最右边的数码管闪烁,表示对这个数设置,按下“”按键加 1,按该数的进制自动翻转;再按下“SET”按键,往左移一个位置的位进入设置状态(闪烁);到达最左侧的数位后,又从最右边的数位开始,如此环。按下“OK”按键退出设置。
    3. 初次显示“秒表”时,显示“0000”,按下“↑”按钮,开始计时,再按一次“↑”则暂停,按下“CLR”按钮重置(清零)。
    4. 初次显示“定时器”时,显示“0000”,按下“SET”按钮,进入设置定时的时间,首次按下“SET”,最右边的数码管闪烁,表设置此数位,再按下“SET”按键,往左移一个位置的位进入设置状态(闪烁);到达最左侧的数位后,又从最右边的数位开始,如此循环。按下“OK”按键退出设置。按下“↑”按钮,开始计时,再按一次“↑”则暂停,按下“CLR”结束计时(回到初次显示定时器的状态,即显示“0000”)。若定时到达设定值,停止计数并闪烁 LED。
      以上方案共需:5 个按键: MOD、SET、↑、OK、CLR

    硬件实物图:

    我也不会用图片.jpg

    1.顶层部分代码:

    LIBRARY IEEE;
    USE IEEE.STD_LOGIC_1164.ALL;
    USE IEEE.STD_LOGIC_ARITH.ALL;
    USE IEEE.STD_LOGIC_UNSIGNED.ALL;
    
    entity multifunction_electronic_clock is
    port(
        clk:in std_logic;
        mode:in std_logic;
        set:in std_logic;
        step_up:in std_logic;
        ok:in std_logic;
        clr:in std_logic;
        CS:OUT STD_LOGIC_VECTOR(3 DOWNTO 0);
        DIS:OUT STD_LOGIC_VECTOR(7 DOWNTO 0);
        led:out std_logic
        );
    end entity;
    
    architecture STRUCT of multifunction_electronic_clock is
    
    component key is
        port(
            clk:in std_logic;
            mode:in std_logic;
            set:in std_logic;
            step_up:in std_logic;
            ok:in std_logic;
            clr:in std_logic;
            mode_out:out std_logic;
            set_out:out std_logic;
            step_up_out:out std_logic;
            ok_out:out std_logic;
            clr_out:out std_logic       
            );
    end component;
    
    
    COMPONENT FENPIN IS
    
        PORT(
            CLK:IN STD_LOGIC;
            C0:buffer STD_LOGIC;--1hz
            C1:buffer STD_LOGIC;--100khz
            C2:buffer STD_LOGIC;--闪烁频率
            C3:BUFfer STD_LOGIC --100hz
            );
    END COMPONENT;
    
    component controller is
        port(
            clk:in std_logic;
            mode:in std_logic;
            set:in std_logic;
            ok:in std_logic;    
            mode_out:out std_LOGIC_VECTOR(1 downto 0);
            flag1,flag2:buffer std_logic_vector(2 downto 0)
            );
    end component;
    
    component clock is
    port(
        clk1:in std_logic;
        clk:in std_LOGIC;
        flag1:in std_logic_vector(2 downto 0);
        step_up:in std_LOGIC;
        D_0,D_1:out std_logic_vector(3 downto 0);
        D_2,D_3:out std_logic_vector(3 downto 0);
        D_4,D_5:out std_logic_vector(3 downto 0)
        );
    end component;
    
    component shining is
    port(
        mode:in std_logic_vector(1 downto 0);
        clk1:in std_logic;
        clk:in std_logic;
        flag1,flag2:in std_logic_vector(2 downto 0);
        D_2_IN,D_3_IN,D_4_IN,D_5_IN:IN STD_LOGIC_VECTOR(3 DOWNTO 0);
        D_10_IN,D_11_IN,D_12_IN,D_13_IN:IN STD_LOGIC_VECTOR(3 DOWNTO 0);
        D_2,D_3,D_4,D_5,D_10,D_11,D_12,D_13:OUT STD_LOGIC_VECTOR(3 DOWNTO 0)        
        );
    end component;
    
    component selection is
    port(
        clk:in std_logic;
        MODE:IN STD_logic_vector(1 DOWNTO 0);
        D_0,D_1,D_2,D_3,D_4,D_5:IN STD_LOGIC_VECTOR(3 DOWNTO 0);
        D_6,D_7,D_8,D_9:IN STD_LOGIC_VECTOR(3 DOWNTO 0);
        D_10,D_11,D_12,D_13:IN STD_LOGIC_VECTOR(3 DOWNTO 0);
        D_0_OUT,D_1_OUT,D_2_OUT,D_3_OUT:OUT STD_LOGIC_VECTOR(3 DOWNTO 0)
        );
    end component;
    
    component stopwatch is
        port(
            MODE:IN STD_logic_vector(1 DOWNTO 0);
            CLK:IN STD_LOGIC;
            START:IN STD_LOGIC;
            CLR:IN STD_LOGIC;
            D_6,D_7,D_8,D_9:OUT STD_LOGIC_VECTOR(3 DOWNTO 0)
            );
    end component;
    
    component timer is
        port(
            clk:in std_logic;
            MODE:IN STD_logic_vector(1 DOWNTO 0);
            CLK_1hz:IN STD_LOGIC;
            clk_2hz:in std_logic;
            flag2:in std_logic_vector(2 downto 0);
            STEP_UP:IN STD_LOGIC;
            START:IN STD_LOGIC;--OK键
            CLR:IN STD_LOGIC;
            D_10,D_11,D_12,D_13:OUT STD_LOGIC_VECTOR(3 DOWNTO 0);
            LED:OUT STD_LOGIC
            );
    end component;
    
    component seg7led is
        PORT(
            mode:in std_logic_vector(1 downto 0);
            CLK4:IN STD_LOGIC;--时钟,复位信号
            CLEAR:in std_logic;
            D_0,D_1,D_2,D_3: IN STD_LOGIC_VECTOR(3 DOWNTO 0);--BCD码输入信号
            CS:OUT STD_LOGIC_VECTOR(3 DOWNTO 0);--数码管位选信号 
            DIS:OUT STD_LOGIC_VECTOR(7 DOWNTO 0)--数码管编码信号
        );
    END COMPONENT;      
    
    
    SIGNAL mode_out,set_out,step_up_out,ok_out,clr_out:STD_LOGIC;
    SIGNAL C_1hz,C_100khz,C_2hz,C_100hz,C_1000HZ:STD_LOGIC;
    SIGNAL MODE_STATE:STD_LOGIC_VECTOR(1 DOWNTO 0);
    SIGNAL FLAG1,FLAG2:std_logic_vector(2 downto 0);
    SIGNAL D_CLOCK0,D_CLOCK1,D_CLOCK2,D_CLOCK3,D_CLOCK4,D_CLOCK5:STD_LOGIC_VECTOR(3 
    SIGNAL D_2,D_3,D_4,D_5,D_10,D_11,D_12,D_13:STD_LOGIC_VECTOR(3 DOWNTO 0);
    SIGNAL D_S0,D_S1,D_S2,D_S3:STD_LOGIC_VECTOR(3 DOWNTO 0);
    SIGNAL D_6,D_7,D_8,D_9:STD_LOGIC_VECTOR(3 DOWNTO 0);
    SIGNAL D_TIMER10,D_TIMER11,D_TIMER12,D_TIMER13:STD_LOGIC_VECTOR(3 DOWNTO 0);
    
    begin
    
    u1:key port map(clk,mode,set,step_up,ok,clr,mode_out,set_out,step_up_out,ok_out,clr_out);
    u2:fenpin port map(clk,c_1hz,c_100khz,c_2hz,c_100hz);
    u3:controller port map(clk,mode_out,set_out,ok_out,mode_state,flag1,flag2);
    u4:clock port map(clk,c_1hz,flag1,step_up_out,D_CLOCK0,D_CLOCK1,D_CLOCK2,D_CLOCK3,D_CLOCK4,D_CLOCK5);
    u5:shining port map(modE_STATE,clk,c_2hz,flag1,flag2,D_CLOCK2,D_CLOCK3,D_CLOCK4,D_CLOCK5,D_TIMER10,D_TIMER11,D_TIMER12,D_TIMER13,D_2,D_3,D_4,D_5,D_10,D_11,D_12,D_13);
    u6:selection port map(clk,MODE_STATE,D_CLOCK0,D_CLOCK1,D_2,D_3,D_4,D_5,D_6,D_7,D_8,D_9,D_10,D_11,D_12,D_13,D_S0,D_S1,D_S2,D_S3);
    u7:stopwatch port map(MODE_STATE,C_100hz,STEP_UP_OUT,clr_out,D_6,D_7,D_8,D_9);
    u8:timer port map(clk,MODE_STATE,C_1hz,c_2hz,FLAG2,STEP_UP_OUT,OK_OUT,clr_out,D_TIMER10,D_TIMER11,D_TIMER12,D_TIMER13,LED);
    u9:seg7led port map(MODE_STATE,C_100khz,clr_out,D_S0,D_S1,D_S2,D_S3,CS,DIS);    
    end strUCT;
    

    2.按键代码

    1 library ieee;
    2 use ieee.std_logic_1164.all;
    3 use ieee.std_logic_unsigned.all;
    4
    5 entity key is
    6 port(
    7 clk:in std_logic;-- 系 统 50MHz 率 来 频 进
    8 mode,set,step_up,ok,clr:in std_logic;
    9 mode_out,set_out,step_up_out,ok_out,clr_out:out std_logic
    10 -- 当按 按下后 键 , 出一个上升脉冲 输
    11 );
    12 end key;
    13
    14 architecture behav of key is
    15 begin
    16
    17 PROCESS(CLK,mode,set,step_up,ok,clr)
    18 VARIABLE COUNT1,COUNT2,COUNT3,COUNT4,COUNT5:INTEGER RANGE 0 TO 1000000; --20ms
    19 BEGIN
    20
    21 IF RISING_EDGE(CLK) THEN
    22 IF mode='0' THEN
    23 IF COUNT1<1000000 THEN
    24 COUNT1:=COUNT1+1;
    25 ELSE
    26 COUNT1:=COUNT1;
    27 END IF;
    28
    29 IF COUNT1<=999999 THEN
    30 mode_out<='1';
    31 ELSE
    32 mode_out<='0';
    33 END IF;
    34 ELSE COUNT1:=0;
    35 END IF;
    36
    37 IF set='0' THEN
    38 IF COUNT2<1000000 THEN
    39 COUNT2:=COUNT2+1;
    40 ELSE
    41 COUNT2:=COUNT2;
    42 END IF;
    43
    44 IF COUNT2<=999999 THEN
    45 set_out<='1';
    46 ELSE
    47 set_out<='0';
    48 END IF;
    49 ELSE COUNT2:=0;
    50 END IF;
    51
    52 IF step_up='0' THEN
    53 IF COUNT3<1000000 THEN
    54 COUNT3:=COUNT3+1;
    55 ELSE
    56 COUNT3:=COUNT3;
    57 END IF;
    58
    59 IF COUNT3<=999999 THEN
    60 step_up_out<='1';
    61 ELSE
    62 step_up_out<='0';
    63 END IF;
    64 ELSE COUNT3:=0;
    65 END IF;
    66
    67 IF ok='0' THEN
    68 IF COUNT4<1000000 THEN
    69 COUNT4:=COUNT4+1;
    70 ELSE
    71 COUNT4:=COUNT4;
    72 END IF;
    73
    74 IF COUNT4<=999999 THEN
    75 ok_out<='1';
    76 ELSE
    77 ok_out<='0';
    78 END IF;
    79 ELSE COUNT4:=0;
    80 END IF;
    81
    82 IF clr='0' THEN
    83 IF COUNT5<1000000 THEN
    84 COUNT5:=COUNT5+1;
    85 ELSE
    86 COUNT5:=COUNT5;
    87 END IF;
    88
    89 IF COUNT5<=999999 THEN
    90 clr_out<='1';
    91 ELSE
    92 clr_out<='0';
    93 END IF;
    94 ELSE COUNT5:=0;
    95 END IF;
    96 END IF;
    97
    98 END PROCESS ;
    99 end behav;
    

    3.分频代码

    1 LIBRARY IEEE;
    2 USE IEEE.STD_LOGIC_1164.ALL;
    3 USE IEEE.STD_LOGIC_UNSIGNED.ALL;
    4
    5 ENTITY FENPIN IS
    6 PORT(
    7 CLK:IN STD_LOGIC;
    8 C0:buffer STD_LOGIC;--1hz
    9 C1:buffer STD_LOGIC;--100khz
    10 C2:buffer STD_LOGIC;-- 率 闪烁频
    11 C3:BUFfer STD_LOGIC;--100hz
    12 C4:buffer std_logic --1000hz
    13 );
    14 END FENPIN;
    15
    16 ARCHITECTURE BEHAVIORAL OF FENPIN IS
    17 SIGNAL COUNTER0:INTEGER RANGE 0 TO 25000000;
    18 SIGNAL COUNTER1:INTEGER RANGE 0 TO 250;
    19 SIGNAL COUNTER2:INTEGER RANGE 0 TO 12500000;
    20 SIGNAL COUNTER3:INTEGER RANGE 0 TO 250000;
    21 SIGNAL COUNTER4:INTEGER RANGE 0 TO 25000;
    22 BEGIN
    23
    24 CTR0:-- 分 出信号 频输 0  1Hz
    25 PROCESS(CLK)
    26 BEGIN
    27
    28 IF(CLK='1' AND CLK'EVENT)THEN
    29 IF(COUNTER0=25000000)THEN
    30 COUNTER0<=0;C0<=NOT C0;
    31 ELSE
    32 COUNTER0<=COUNTER0+1;
    33 END IF;
    34 END IF;
    35 END PROCESS;
    36
    37 CTR1:-- 分 出信号 频输 1 100KHz
    38 PROCESS(CLK)
    39 BEGIN
    40
    41 IF(CLK='1' AND CLK'EVENT)THEN
    42 IF(COUNTER1=250)THEN
    43 COUNTER1<=1;C1<=NOT C1;
    44 ELSE
    45 COUNTER1<=COUNTER1+1;
    46 END IF;
    47 END IF;
    48 END PROCESS;
    49
    50 CTR2:-- 分 出信号 频输 2  2Hz ( 率 闪烁频 )
    51 PROCESS(CLK)
    52 BEGIN
    53
    54 IF(CLK='1' AND CLK'EVENT)THEN
    55 IF(COUNTER2=12500000)THEN
    56 COUNTER2<=0;C2<=NOT C2;
    57 ELSE
    58 COUNTER2<=COUNTER2+1;
    59 END IF;
    60 END IF;
    61 END PROCESS;
    62
    63 CTR3:-- 分 出信号 频输 3  100Hz (秒表 率 频 )
    64 PROCESS(CLK)
    65 BEGIN
    66
    67 IF(CLK='1' AND CLK'EVENT)THEN
    68 IF(COUNTER3=250000)THEN
    69 COUNTER3<=0;C3<=NOT C3;
    70 ELSE
    71 COUNTER3<=COUNTER3+1;
    72 END IF;
    73 END IF;
    74 END PROCESS;
    75
    76 CTR4:-- 分 出信号 频输 4
    77 PROCESS(CLK)
    78 BEGIN
    79
    80 IF(CLK='1' AND CLK'EVENT)THEN
    81 IF(COUNTER4=25000)THEN
    82 COUNTER4<=0;C4<=NOT C4;
    83 ELSE
    84 COUNTER4<=COUNTER4+1;
    85 END IF;
    86 END IF;
    87 END PROCESS;
    88
    89 END BEHAVIORAL;
    

    4.按键控制

    1 library ieee;
    2 use ieee.std_logic_1164.all;
    3 use ieee.std_logic_unsigned.all;
    4
    5 entity controller is
    6 port(
    7 clk:in std_logic;
    8 mode:in std_logic;
    9 set:in std_logic;
    10 ok:in std_logic;
    11 mode_out:buffer std_LOGIC_VECTOR(1 downto 0);
    12 flag1,flag2:buffer std_logic_vector(2 downto 0)
    13 );
    14 end controller;
    15
    16 architecture kong of controller is
    17 SIGNAL SET_OK1,SET_OK2: std_logic_vector(2 downto 0):="000";
    18 signal mode_state:std_logic_vector(1 downto 0):="00";
    19 begin
    20
    21 process(mode,set,ok,clk)
    22 begin
    23
    24 if(mode='1'and mode'event)then
    25 if(mode_state="11")then
    26 mode_state<="00";
    27 else
    28 mode_state<=mode_state+1;
    29 end if;
    30 ELSE mode_state<=mode_state;
    31 end if;
    32
    33 if(mode_state="00" or mode_state="01")then
    34
    35 if(set='1'and set'event)then
    36 if(SET_OK1="100")then
    37 SET_OK1<="000";
    38 else
    39 SET_OK1<=SET_OK1+1;
    40 end if;
    41 end if;
    42
    43 -- if(ok='1')then
    44 -- SET_OK1<="000";
    45 -- end if;
    46 -- else SET_OK1<=SET_OK1;
    47 end if;
    48
    49 if(mode_state="11")then
    50 if(set='1'and set'event)then
    51 if(SET_OK2="100")then
    52 SET_OK2<="000";
    53 else
    54 SET_OK2<=SET_OK2+1;
    55 end if;
    56 end if;
    57
    58 -- if(ok='1')then
    59 -- SET_OK2<="000";
    60 -- end if;
    61 -- ELSE SET_OK2<=SET_OK2;
    62 end if;
    63 mode_out<=mode_state;
    64 FLAG1<=SET_OK1;
    65 FLAG2<=SET_OK2;
    66
    67 end process;
    68
    69 end kong;
    

    5.定时器

    1 library ieee;
    2 use ieee.std_logic_1164.all;
    3 use ieee.std_logic_unsigned.all;
    4
    5 entity clock is
    6 port(
    7 clk1:in std_logic;
    8 clk:in std_LOGIC;
    9 flag1:in std_logic_vector(2 downto 0);
    10 step_up:in std_LOGIC;
    11 D_0,D_1:out std_logic_vector(3 downto 0);
    12 D_2,D_3:out std_logic_vector(3 downto 0);
    13 D_4,D_5:out std_logic_vector(3 downto 0)
    14 );
    15 end clock;
    16
    17 architecture js of clock is
    18
    19 component xuanze4_1 is
    20 port(
    21 clk:in std_logic;
    22 in2,in3,in4,in5:in std_logic;
    23 step_up:in std_logic;
    24 flag1:in std_logic_vector(2 downto 0);
    25 co2,co3,co4,co5:out std_logic
    26 );
    27 end component;
    28
    29 component hour_24 is
    30 port (
    31 clk_l:in std_logic;
    32 clk_h:in std_logic;
    33 D_4,D_5:out std_logic_vector(3 downto 0);
    34 cout_4,cout_5:out std_logic
    35 );
    36 end component;
    37
    38 component fen60 is
    39 port (
    40 clk_l:in std_logic;
    41 clk_h:in std_logic;
    42 D_2,D_3:out std_logic_vector(3 downto 0);
    43 cout_2,cout_3:out std_logic
    44 );
    45 end component;
    46
    47 component sn60 is
    48 port (
    49 clk:in std_logic;
    50 D_0,D_1:out std_logic_vector(3 downto 0);
    51 cout:out std_logic
    52 );
    53 end component;
    54
    55 signal in2,in3,in4,in5,co2,co3,co4,co5,cout_5:std_logic;
    56
    57 begin
    58
    59 u40:xuanze4_1 port map (clk1,in2,in3,in4,in5,step_up,flag1,co2,co3,co4,co5);
    60 u41:sn60 port map(clk,D_0,D_1,in2);
    61 u42:fen60 port map(co2,co3,D_2,D_3,in3,in4);
    62 u43:hour_24 port map(co4,co5,D_4,D_5,in5,cout_5);
    63
    64 end js;
    

    6.4选1

    1 library ieee;
    2 use ieee.std_logic_1164.all;
    3 use ieee.std_logic_unsigned.all;
    4
    5 entity xuanze4_1 is
    6 port(
    7 clk:in std_logic;
    8 in2,in3,in4,in5:in std_logic;
    9 step_up:in std_logic;
    10 flag1:in std_logic_vector(2 downto 0);
    11 co2,co3,co4,co5:out std_logic
    12 );
    13 end xuanze4_1;
    14
    15 architecture xuanze of xuanze4_1 is
    16 begin
    17 process(clk,in2,in3,in4,in5,step_up,flag1)
    18 BEGIN
    19 case flag1 is
    20 when "000" => co2<=in2;
    21 co3<=in3;
    22 co4<=in4;
    23 co5<=in5;
    24 when "001" => co2<=step_up;
    25 co3<=in3;
    26 co4<=in4;
    27 co5<=in5;
    28
    29 when "010" => co3<=step_up;
    30 co2<=in2;
    31 co4<=in4;
    32 co5<=in5;
    33 when "011" => co4<=step_up;
    34 co2<=in2;
    35 co3<=in3;
    36 co5<=in5;
    37
    38 when "100" => co2<=in2;
    39 co3<=in3;
    40 co4<=in4;
    41 co5<=step_up;
    42
    43 when others => co2<=in2;
    44 co3<=in3;
    45 co4<=in4;
    46 co5<=in5;
    47 end case;
    48 end process;
    49 end xuanze;
    

    7.60秒计数器

    1 library ieee;
    2 use ieee.std_logic_1164.all;
    3 use ieee.std_logic_unsigned.all;
    4
    5 entity sn60 is
    6 port (
    7 clk:in std_logic;
    8 D_0,D_1:out std_logic_vector(3 downto 0);
    9 cout:out std_logic
    10 );
    11 end sn60;
    12
    13 architecture fe of sn60 is
    14 signal TEMP1,TEMP2:std_logic_vector(3 downto 0):="0000";
    15 signal co:std_logic:='0';
    16 begin
    17
    18 PROCESS(CLK)
    19 BEGIN
    20
    21 IF(CLK'EVENT AND CLK='1')THEN
    22 IF(TEMP1="1001")THEN
    23 TEMP1<="0000";co<='1';
    24 ELSE
    25 TEMP1<=TEMP1+1;co<='0';
    26 END IF;
    27 END IF;
    28 D_0<=TEMP1;
    29 END PROCESS;
    30
    31 PROCESS(co)
    32 BEGIN
    33
    34 IF(co'EVENT AND co='1')THEN
    35 IF(TEMP2="0101")THEN
    36 TEMP2<="0000";cout<='1';
    37 ELSE
    38 TEMP2<=TEMP2+1;cout<='0';
    39 END IF;
    40 END IF;
    41 D_1<=TEMP2;
    42 END PROCESS;
    43 end fe;
    

    8.60分计数器

    1 library ieee;
    2 use ieee.std_logic_1164.all;
    3 use ieee.std_logic_unsigned.all;
    4
    5 entity fen60 is
    6 port (
    7 clk_l:in std_logic;
    8 clk_h:in std_logic;
    9 D_2,D_3:out std_logic_vector(3 downto 0);
    10 cout_2,cout_3:out std_logic
    11 );
    12 end fen60;
    13
    14 architecture fen of fen60 is
    15 signal TEMP1,TEMP2:std_logic_vector(3 downto 0);
    16 begin
    17
    18 PROCESS(CLK_L)
    19 BEGIN
    20
    21 IF(CLK_L'EVENT AND CLK_L='1')THEN
    22 IF(TEMP1="1001")THEN
    23 TEMP1<="0000";cout_2<='1';
    24 ELSE
    25 TEMP1<=TEMP1+1;cout_2<='0';
    26 END IF;
    27 END IF;
    28 D_2<=TEMP1;
    29 END PROCESS;
    30
    31 PROCESS(clk_h)
    32 BEGIN
    33
    34 IF(clk_h'EVENT AND clk_h='1')THEN
    35 IF(TEMP2="0101")THEN
    36 TEMP2<="0000";cout_3<='1';
    37 ELSE
    38 TEMP2<=TEMP2+1;cout_3<='0';
    39 END IF;
    40 END IF;
    41 D_3<=TEMP2;
    42 END PROCESS;
    43
    44 end fen;
    

    9.24时计数器

    1 library ieee;
    2 use ieee.std_logic_1164.all;
    3 use ieee.std_logic_unsigned.all;
    4
    5 entity hour_24 is
    6 port (
    7 clk_l:in std_logic;
    8 clk_h:in std_logic;
    9 D_4,D_5:out std_logic_vector(3 downto 0);
    10 cout_4,cout_5:out std_logic
    11 );
    12 end hour_24;
    13
    14 architecture hour of hour_24 is
    15 signal TEMP1,TEMP2:std_logic_vector(3 downto 0);
    16 begin
    17
    18 PROCESS(CLK_L)
    19 BEGIN
    20
    21 IF(CLK_L'EVENT AND CLK_L='1')THEN
    22 IF(TEMP2="0010")THEN
    23 IF(TEMP1>="0100")THEN
    24 TEMP1<="0000";COUT_4<='1';
    25 ELSE
    26 TEMP1<=TEMP1+1;COUT_4<='0';
    27 END IF;
    28 ELSIF(TEMP1="1001")THEN
    29 TEMP1<="0000";COUT_4<='1';
    30 ELSE
    31 TEMP1<=TEMP1+1;COUT_4<='0';
    32 END IF;
    33 END IF;
    34 D_4<=TEMP1;
    35 END PROCESS;
    36
    37 PROCESS(clk_h)
    38 BEGIN
    39
    40 IF(clk_h'EVENT AND clk_h='1')THEN
    41 IF(TEMP2="0010")THEN
    42 TEMP2<="0000";COUT_5<='1';
    43 ELSE
    44 TEMP2<=TEMP2+1;COUT_5<='0';
    45 END IF;
    46 END IF;
    47 D_5<=TEMP2;
    48 END PROCESS;
    49
    50 end hour;
    

    10.闪烁模块

    1 library ieee;
    2 use ieee.std_logic_1164.all;
    3 use ieee.std_logic_unsigned.all;
    4
    5 entity shining is
    6 port(
    7 mode:in std_logic_vector(1 downto 0);
    8 clk1:in std_logic;
    9 clk:in std_logic;
    10 flag1,flag2:in std_logic_vector(2 downto 0);
    11 D_2_IN,D_3_IN,D_4_IN,D_5_IN:IN STD_LOGIC_VECTOR(3 DOWNTO 0);
    12 D_10_IN,D_11_IN,D_12_IN,D_13_IN:IN STD_LOGIC_VECTOR(3 DOWNTO 0);
    13 D_2,D_3,D_4,D_5,D_10,D_11,D_12,D_13:OUT STD_LOGIC_VECTOR(3 DOWNTO 0)
    14 );
    15 end shining;
    16
    17 architecture xia of shining is
    18 begin
    19
    20 process(clk1,mode,flag1,flag2,CLK,D_2_IN,D_3_IN,D_4_IN,D_5_IN,D_10_IN,D_11_IN,D_12
    _IN,D_13_IN)
    21 begin
    22 if(clk1'event and clk1='1')then
    23 case mode is
    24 when "00" =>
    25
    26 case flag1 is
    27 when "000" => D_2<=D_2_IN;
    28 D_3<=D_3_IN;
    29 D_4<=D_4_IN;
    30 D_5<=D_5_IN;
    31
    32 when "001" => IF(CLK='1')THEN
    33 D_2<="1010";
    34 ELSE
    35 D_2<=D_2_IN;
    36 END IF;
    37 D_3<=D_3_IN;
    38 D_4<=D_4_IN;
    39 D_5<=D_5_IN;
    40
    41 when "010" => IF(CLK='1')THEN
    42 D_3<="1010";
    43 ELSE
    44 D_3<=D_3_IN;
    45 END IF;
    46 D_2<=D_2_IN;
    47 D_4<=D_4_IN;
    48 D_5<=D_5_IN;
    49
    50 when "011" => IF(CLK='1')THEN
    51 D_4<="1010";
    52 ELSE
    53 D_4<=D_4_IN;
    54 END IF;
    55 D_2<=D_2_IN;
    56 D_3<=D_3_IN;
    57 D_5<=D_5_IN;
    58
    59 when "100" => IF(CLK='1')THEN
    60 D_5<="1010";
    61 ELSE
    62 D_5<=D_5_IN;
    63 END IF;
    64 D_2<=D_2_IN;
    65 D_3<=D_3_IN;
    66 D_4<=D_4_IN;
    67
    68 when others => D_2<=D_2_IN;
    69 D_3<=D_3_IN;
    70 D_4<=D_4_IN;
    71 D_5<=D_5_IN;
    72 END CASE;
    73
    74 when "01" => D_2<=D_2_IN;
    75 D_3<=D_3_IN;
    76 D_4<=D_4_IN;
    77 D_5<=D_5_IN;
    78 D_10<=D_10_IN;
    79 D_11<=D_11_IN;
    80 D_12<=D_12_IN;
    81 D_13<=D_13_IN;
    82
    83 when "10" => D_2<=D_2_IN;
    84 D_3<=D_3_IN;
    85 D_4<=D_4_IN;
    86 D_5<=D_5_IN;
    87 D_10<=D_10_IN;
    88 D_11<=D_11_IN;
    89 D_12<=D_12_IN;
    90 D_13<=D_13_IN;
    91
    92 when "11" =>
    93
    94 case flag2 is
    95 when "000" => D_10<=D_10_IN;
    96 D_11<=D_11_IN;
    97 D_12<=D_12_IN;
    98 D_13<=D_13_IN;
    99
    100 when "001" => IF(CLK='1')THEN
    101 D_10<="1010";
    102 ELSE
    103 D_10<=D_10_IN;
    104 END IF;
    105 D_11<=D_11_IN;
    106 D_12<=D_12_IN;
    107 D_13<=D_13_IN;
    108
    109 when "010" => IF(CLK='1')THEN
    110 D_11<="1010";
    111 ELSE
    112 D_11<=D_11_IN;
    113 END IF;
    114 D_10<=D_10_IN;
    115 D_12<=D_12_IN;
    116 D_13<=D_13_IN;
    117
    118 when "011" => IF(CLK='1')THEN
    119 D_12<="1010";
    120 ELSE
    121 D_12<=D_12_IN;
    122 END IF;
    123 D_10<=D_10_IN;
    124 D_11<=D_11_IN;
    125 D_13<=D_13_IN;
    126
    127 when "100" => IF(CLK='1')THEN
    128 D_13<="1010";
    129 ELSE
    130 D_13<=D_13_IN;
    131 END IF;
    132 D_10<=D_10_IN;
    133 D_11<=D_11_IN;
    134 D_12<=D_12_IN;
    135
    136 when others => D_10<=D_10_IN;
    137 D_11<=D_11_IN;
    138 D_12<=D_12_IN;
    139 D_13<=D_13_IN;
    140 END CASE;
    141 END CASE;
    142 end if;
    143 END process;
    144 end xia;
    

    11.选择器

    1 LIBRARY IEEE;
    2 USE IEEE.STD_LOGIC_1164.ALL;
    3 USE IEEE.STD_LOGIC_ARITH.ALL;
    4 USE IEEE.STD_LOGIC_UNSIGNED.ALL;
    5
    6 entity selection is
    7 port(
    8 clk:in std_logic;
    9 MODE:IN STD_logic_vector(1 DOWNTO 0);
    10 D_0,D_1,D_2,D_3,D_4,D_5:IN STD_LOGIC_VECTOR(3 DOWNTO 0);
    11 D_6,D_7,D_8,D_9:IN STD_LOGIC_VECTOR(3 DOWNTO 0);
    12 D_10,D_11,D_12,D_13:IN STD_LOGIC_VECTOR(3 DOWNTO 0);
    13 D_0_OUT,D_1_OUT,D_2_OUT,D_3_OUT:OUT STD_LOGIC_VECTOR(3 DOWNTO 0)
    14 );
    15 end entity;
    16
    17 architecture behav of selection is
    18 begin
    19 process(clk,mode,D_0,D_1,D_2,D_3,D_4,D_5,D_6,D_7,D_8,D_9,D_10,D_11,D_12,D_13)
    20 BEGIN
    21 if(clk'event and clk='1')then
    22 case mode is
    23 when "00" => D_0_OUT<=D_2;
    24 D_1_OUT<=D_3;
    25 D_2_OUT<=D_4;
    26 D_3_OUT<=D_5;
    27
    28 when "01" => D_0_OUT<=D_0;
    29 D_1_OUT<=D_1;
    30 D_2_OUT<=D_2;
    31 D_3_OUT<=D_3;
    32
    33 when "10" => D_0_OUT<=D_6;
    34 D_1_OUT<=D_7;
    35 D_2_OUT<=D_8;
    36 D_3_OUT<=D_9;
    37
    38 when "11" => D_0_OUT<=D_10;
    39 D_1_OUT<=D_11;
    40 D_2_OUT<=D_12;
    41 D_3_OUT<=D_13;
    42 END case;
    43 end if;
    44 END PROcess;
    45 end behav;
    46
    

    12.秒表

    1 LIBRARY IEEE;
    2 USE IEEE.STD_LOGIC_1164.ALL;
    3 USE IEEE.STD_LOGIC_UNSIGNED.ALL;
    4
    5 ENTITY stopwatch IS
    6 port(
    7 MODE:IN STD_logic_vector(1 DOWNTO 0);
    8 CLK:IN STD_LOGIC;
    9 START:IN STD_LOGIC;--step_up
    10 CLR:IN STD_LOGIC;
    11 D_6,D_7,D_8,D_9:OUT STD_LOGIC_VECTOR(3 DOWNTO 0)
    12 );
    13 END stopwatch;
    14
    15 ARCHITECTURE STRUCT OF stopwatch IS
    16
    17 COMPONENT COUNT_10_D_0 IS
    18
    19 PORT(
    20 mode:in std_logic_vector(1 downto 0);
    21 CLK1,CLEAR,START:IN STD_LOGIC;
    22 BCD_OUT:OUT STD_LOGIC_VECTOR(3 DOWNTO 0);
    23 COUT:BUFFER STD_LOGIC);
    24 END COMPONENT;
    25
    26 COMPONENT COUNT_10_D_1 IS
    27 PORT( CLK2,CLEAR:IN STD_LOGIC;
    28 BCD_OUT:OUT STD_LOGIC_VECTOR(3 DOWNTO 0);
    29 COUT:BUFFER STD_LOGIC);
    30 END COMPONENT;
    31
    32 COMPONENT COUNT_10_D_2 IS
    33 PORT( CLK3,CLEAR:IN STD_LOGIC;
    34 BCD_OUT:OUT STD_LOGIC_VECTOR(3 DOWNTO 0);
    35 COUT:BUFFER STD_LOGIC);
    36 END COMPONENT;
    37
    38 COMPONENT COUNT_10_D_3 IS
    39 PORT( CLK4,CLEAR:IN STD_LOGIC;
    40 BCD_OUT:OUT STD_LOGIC_VECTOR(3 DOWNTO 0);
    41 COUT:BUFFER STD_LOGIC);
    42 END COMPONENT;
    43
    44 signal clk1,clk2,clk3,cout:std_logic;
    45
    46 BEGIN
    47
    48 u71:COUNT_10_D_0 port map(mode,clk,clr,start,D_6,clk1);
    49 u72:COUNT_10_D_1 port map(clk1,clr,D_7,clk2);
    50 u73:COUNT_10_D_2 port map(clk2,clr,D_8,clk3);
    51 u74:COUNT_10_D_3 port map(clk3,clr,D_9,cout);
    52
    53
    54 END ARCHITECTURE STRUCT;
    55
    

    13.计数器……

    1 LIBRARY IEEE;
    2 USE IEEE.STD_LOGIC_1164.ALL;
    3 USE IEEE.STD_LOGIC_UNSIGNED.ALL;
    4
    5 ENTITY COUNT_10_D_0 IS
    6 PORT(
    7 mode:in std_logic_vector(1 downto 0);
    8 CLK1,CLEAR,START:IN STD_LOGIC;
    9 BCD_OUT:OUT STD_LOGIC_VECTOR(3 DOWNTO 0);
    10 COUT:BUFFER STD_LOGIC);
    11 END ENTITY COUNT_10_D_0;
    12
    13 ARCHITECTURE BEHAVIORAL OF COUNT_10_D_0 IS
    14 SIGNAL TEMP:STD_LOGIC_VECTOR(3 DOWNTO 0);
    15 SIGNAL START_STATE:STD_LOGIC:='1';
    16 BEGIN
    17
    18 PROCESS(START)
    19 BEGIN
    20
    21 IF(START'EVENT AND START='1')THEN
    22 IF(MODE="10")THEN
    23 START_STATE<=NOT START_STATE;
    24 ELSE
    25 START_STATE<='1';
    26 END IF;
    27 ELSE START_STATE<=START_STATE;
    28 END IF;
    29 END PROCESS;
    30
    31 PROCESS(CLK1,CLEAR)IS
    32 BEGIN
    33
    34 IF(CLEAR='1')THEN
    35 TEMP<="0000";COUT<='0';
    36 ELSIF(CLK1'EVENT AND CLK1='1')THEN
    37 IF(START_STATE='0')THEN
    38 IF(TEMP="1001")THEN
    39 TEMP<="0000";COUT<='1';
    40 ELSE
    41 TEMP<=TEMP+1;COUT<='0';
    42 END IF;
    43 ELSE
    44 TEMP<=TEMP;
    45 END IF;
    46 END IF;
    47 BCD_OUT<=TEMP;
    48 END PROCESS;
    49
    50 END ARCHITECTURE BEHAVIORAL;
    

    13.

    1 LIBRARY IEEE;
    2 USE IEEE.STD_LOGIC_1164.ALL;
    3 USE IEEE.STD_LOGIC_UNSIGNED.ALL;
    4
    5 ENTITY COUNT_10_D_1 IS
    6 PORT(CLK2,CLEAR:IN STD_LOGIC;
    7 BCD_OUT:OUT STD_LOGIC_VECTOR(3 DOWNTO 0);
    8 COUT:BUFFER STD_LOGIC);
    9 END ENTITY COUNT_10_D_1;
    10
    11 ARCHITECTURE BEHAVIORAL OF COUNT_10_D_1 IS
    12 SIGNAL TEMP:STD_LOGIC_VECTOR(3 DOWNTO 0);
    13 BEGIN
    14
    15 PROCESS(CLK2,CLEAR)IS
    16 BEGIN
    17
    18 IF(CLEAR='1')THEN
    19 TEMP<="0000";COUT<='0';
    20 ELSIF(CLK2'EVENT AND CLK2='1')THEN
    21 IF(TEMP="1001")THEN
    22 TEMP<="0000";COUT<='1';
    23 ELSE
    24 TEMP<=TEMP+1;COUT<='0';
    25 END IF;
    26 ELSE TEMP<=TEMP;
    27 END IF;
    28 BCD_OUT<=TEMP;
    29 END PROCESS;
    30 END ARCHITECTURE BEHAVIORAL;
    

    13.

    1 LIBRARY IEEE;
    2 USE IEEE.STD_LOGIC_1164.ALL;
    3 USE IEEE.STD_LOGIC_UNSIGNED.ALL;
    4
    5 ENTITY COUNT_10_D_2 IS
    6 PORT(CLK3,CLEAR:IN STD_LOGIC;
    7 BCD_OUT:OUT STD_LOGIC_VECTOR(3 DOWNTO 0);
    8 COUT:BUFFER STD_LOGIC);
    9 END ENTITY COUNT_10_D_2;
    10
    11 ARCHITECTURE BEHAVIORAL OF COUNT_10_D_2 IS
    12 SIGNAL TEMP:STD_LOGIC_VECTOR(3 DOWNTO 0);
    13 BEGIN
    14
    15 PROCESS(CLK3,CLEAR)IS
    16 BEGIN
    17
    18 IF(CLEAR='1')THEN
    19 TEMP<="0000";COUT<='0';
    20 ELSIF(CLK3'EVENT AND CLK3='1')THEN
    21 IF(TEMP="1001")THEN
    22 TEMP<="0000";COUT<='1';
    23 ELSE
    24 TEMP<=TEMP+1;COUT<='0';
    25 END IF;
    26 ELSE TEMP<=TEMP;
    27 END IF;
    28 BCD_OUT<=TEMP;
    29 END PROCESS;
    30 END ARCHITECTURE BEHAVIORAL;
    

    13.

    1 LIBRARY IEEE;
    2 USE IEEE.STD_LOGIC_1164.ALL;
    3 USE IEEE.STD_LOGIC_UNSIGNED.ALL;
    4
    5 ENTITY COUNT_10_D_3 IS
    6 PORT(CLK4,CLEAR:IN STD_LOGIC;
    7 BCD_OUT:OUT STD_LOGIC_VECTOR(3 DOWNTO 0);
    8 COUT:BUFFER STD_LOGIC);
    9 END ENTITY COUNT_10_D_3;
    10
    11 ARCHITECTURE BEHAVIORAL OF COUNT_10_D_3 IS
    12 SIGNAL TEMP:STD_LOGIC_VECTOR(3 DOWNTO 0);
    13 BEGIN
    14
    15 PROCESS(CLK4,CLEAR)IS
    16 BEGIN
    17
    18 IF(CLEAR='1')THEN
    19 TEMP<="0000";COUT<='0';
    20 ELSIF(CLK4'EVENT AND CLK4='1')THEN
    21 IF(TEMP="1001")THEN
    22 TEMP<="0000";COUT<='1';
    23 ELSE
    24 TEMP<=TEMP+1;COUT<='0';
    25 END IF;
    26 ELSE TEMP<=TEMP;
    27 END IF;
    28 BCD_OUT<=TEMP;
    29 END PROCESS;
    30 END ARCHITECTURE BEHAVIORAL;
    31
    

    14.定时器

    1 LIBRARY IEEE;
    2 USE IEEE.STD_LOGIC_1164.ALL;
    3 USE IEEE.STD_LOGIC_UNSIGNED.ALL;
    4
    5 entity timer is
    6 port(
    7 clk:in std_logic;
    8 MODE:IN STD_logic_vector(1 DOWNTO 0);
    9 CLK_1hz:IN STD_LOGIC;
    10 clk_2hz:in std_logic;
    11 flag2:in std_logic_vector(2 downto 0);
    12 STEP_UP:IN STD_LOGIC;
    13 START:IN STD_LOGIC;--OK 键
    14 CLR:IN STD_LOGIC;
    15 D_10,D_11,D_12,D_13:OUT STD_LOGIC_VECTOR(3 DOWNTO 0);
    16 LED:OUT STD_LOGIC
    17 );
    18 end entity;
    19
    20 architecture struct of timer is
    21
    22
    23 component xuanze_mode_4_1 is
    24 port(
    25 clk:in std_logic;
    26 in2,in3,in4,in5:in std_logic;
    27 step_up:in std_logic;
    28 flag2:in std_logic_vector(2 downto 0);
    29 co2,co3,co4,co5:out std_logic
    30 );
    31 end component;
    32
    33 component count_10000 is
    34 port (
    35 mode:in std_logic_vector(1 downto 0);
    36 flag2:in std_logic_vector(2 downto 0);
    37 clk1,clk2,clk3,clk4:in std_logic;
    38 CLEAR:in std_logic;
    39 step_up:in std_logic;
    40 start:in std_logic;--ok 键
    41 D_10,D_11,D_12,D_13:out std_logic_vector(3 downto 0);
    42 COUT1,COUT2,COUT3,COUT4:buffer std_logic
    43 );
    44 end component;
    45
    46 component alarm is
    47 port(
    48 clk:in std_logic;
    49 c_in:in std_logic;
    50 c_out:out std_logic--led
    51 );
    52 end component;
    53
    54 signal cout1,cout2,cout3,cout4,clk1,clk2,clk3,clk4:STD_LOGIC;
    55
    56 begin
    57
    58 u80:xuanze_mode_4_1 port
    map(clk,CLK_1HZ,COUT1,COUT2,COUT3,STEP_UP,FLAG2,CLK1,CLK2,CLK3,CLK4);
    59 u81:count_10000 port
    map(MODE,FLAG2,CLK1,CLK2,CLK3,CLK4,CLR,STEP_UP,START,D_10,D_11,D_12,D_13,COUT1,COU
    T2,COUT3,COUT4);
    60 u82:alarm port map(CLK_2hz,COUT4,LED);
    61
    62 end struct;
    63
    

    15.选择器

    1 library ieee;
    2 use ieee.std_logic_1164.all;
    3 use ieee.std_logic_unsigned.all;
    4
    5 entity xuanze_mode_4_1 is
    6 port(
    7 clk:in std_logic;
    8 in2,in3,in4,in5:in std_logic;
    9 step_up:in std_logic;
    10 flag2:in std_logic_vector(2 downto 0);
    11 co2,co3,co4,co5:out std_logic
    12 );
    13 end xuanze_mode_4_1;
    14
    15 architecture xuanze of xuanze_mode_4_1 is
    16 begin
    17 process(clk,flag2,in2,in3,in4,in5,step_up)
    18 BEGIN
    19 case flag2 is
    20 when "000" => co2<=in2;
    21 co3<=in3;
    22 co4<=in4;
    23 co5<=in5;
    24
    25 when "001" => co2<=step_up;
    26 co3<=in3;
    27 co4<=in4;
    28 co5<=in5;
    29
    30 when "010" => co3<=step_up;
    31 -- co2<=in2;
    32 -- co4<=in4;
    33 -- co5<=in5;
    34
    35 when "011" => co4<=step_up;
    36 -- co2<=in2;
    37 -- co3<=in3;
    38 -- co5<=in5;
    39
    40 when "100" => co5<=step_up;
    41 -- co2<=in2;
    42 -- co3<=in3;
    43 -- co4<=in4;
    44
    45 when others => NULL;
    46 end case;
    47 end process;
    48 end xuanze;
    

    16.

    1 library ieee;
    2 use ieee.std_logic_1164.all;
    3 use ieee.std_logic_unsigned.all;
    4 entity count_10000 is
    5 port (
    6 mode:in std_logic_vector(1 downto 0);
    7 flag2:in std_logic_vector(2 downto 0);
    8 clk1,clk2,clk3,clk4:in std_logic;
    9 CLEAR:in std_logic;
    10 step_up:in std_logic;
    11 start:in std_logic;
    12 D_10,D_11,D_12,D_13:out std_logic_vector(3 downto 0);
    13 COUT1,COUT2,COUT3,COUT4:buffer std_logic
    14 );
    15 end count_10000;
    16
    17 architecture behav of count_10000 is
    18 signal TEMP1,TEMP2,TEMP3,TEMP4:std_logic_vector(3 downto 0);
    19
    20 SIGNAL START_STATE:STD_LOGIC:='1';
    21 begin
    22
    23 PROCESS(START,COUT4)
    24 BEGIN
    25
    26 IF(START'EVENT AND START='1')THEN
    27 IF(MODE="11" AND FLAG2="000")THEN
    28 START_STATE<=NOT START_STATE;
    29 ELSE
    30 START_STATE<='1';
    31 END IF;
    32 ELSE START_STATE<=START_STATE;
    33 END IF;
    34 IF(COUT4='1')THEN START_STATE<='1';END IF;
    35 END PROCESS;
    36
    37 PROCESS(CLK1,CLEAR)IS
    38 BEGIN
    39
    40 IF(CLEAR='1')THEN
    41 TEMP1<="0000";COUT1<='0';
    42 ELSIF(CLK1'EVENT AND CLK1='1')THEN
    43 -- 倒 计时
    44 IF(START_STATE='0'AND COUT4='0')THEN
    45 IF(FLAG2="000")THEN
    46 IF(TEMP1="0000")THEN
    47 TEMP1<="1001";COUT1<='1';
    48 ELSE
    49 TEMP1<=TEMP1-1;COUT1<='0';
    50 END IF;
    51 END IF;
    52 ELSE
    53 -- 置数字 设
    54 IF(FLAG2/="000")THEN
    55 IF(TEMP1="1001")THEN
    56 TEMP1<="0000";
    57 ELSE
    58 TEMP1<=TEMP1+1;
    59 END IF;
    60 END IF;
    61 END IF;
    62 END IF;
    63 D_10<=TEMP1;
    64 END PROCESS;
    65
    66 PROCESS(CLK2,CLEAR)IS
    67 BEGIN
    68
    69 IF(CLEAR='1')THEN
    70 TEMP2<="0000";COUT2<='0';
    71 ELSIF(CLK2'EVENT AND CLK2='1')THEN
    72 IF(START_STATE='0'AND COUT4='0')THEN
    73 IF(TEMP2="0000")THEN
    74 TEMP2<="1001";COUT2<='1';
    75 ELSE
    76 TEMP2<=TEMP2-1;COUT2<='0';
    77 END IF;
    78 ELSE
    79 IF(FLAG2/="000")THEN
    80 IF(TEMP2="1001")THEN
    81 TEMP2<="0000";
    82 ELSE
    83 TEMP2<=TEMP2+1;
    84 END IF;
    85 ELSE TEMP2<=TEMP2;
    86 END IF;
    87 END IF;
    88 END IF;
    89 D_11<=TEMP2;
    90 END PROCESS;
    91
    92 PROCESS(CLK3,CLEAR)IS
    93 BEGIN
    94
    95 IF(CLEAR='1')THEN
    96 TEMP3<="0000";COUT3<='0';
    97 ELSIF(CLK3'EVENT AND CLK3='1')THEN
    98 IF(START_STATE='0'AND COUT4='0')THEN
    99 IF(TEMP3="0000")THEN
    100 TEMP3<="1001";COUT3<='1';
    101 ELSE
    102 TEMP3<=TEMP3-1;COUT3<='0';
    103 END IF;
    104 ELSE
    105 IF(FLAG2/="000")THEN
    106 IF(TEMP3="1001")THEN
    107 TEMP3<="0000";
    108 ELSE
    109 TEMP3<=TEMP3+1;
    110 END IF;
    111 ELSE TEMP3<=TEMP3;
    112 END IF;
    113 END IF;
    114 END IF;
    115 D_12<=TEMP3;
    116 END PROCESS;
    117
    118 PROCESS(CLK4,CLEAR)IS
    119 BEGIN
    120 IF(FLAG2/="000")THEN
    121 COUT4<='0';
    122 ELSIF(CLEAR='1')THEN
    123 TEMP4<="0000";COUT4<='0';
    124 ELSIF(CLK4'EVENT AND CLK4='1')THEN
    125 IF(START_STATE='0')THEN
    126 IF(TEMP4="0000")THEN
    127 -- TEMP4<="1001";
    128 COUT4<='1';
    129 ELSE
    130 TEMP4<=TEMP4-1;COUT4<='0';
    131 END IF;
    132 ELSE
    133 IF(FLAG2/="000")THEN
    134 IF(TEMP4="1001")THEN
    135 TEMP4<="0000";
    136 ELSE
    137 TEMP4<=TEMP4+1;
    138 END IF;
    139 ELSE TEMP4<=TEMP4;
    140 END IF;
    141 END IF;
    142 END IF;
    143 D_13<=TEMP4;
    144 END PROCESS;
    145
    146 end behav;
    

    17.计时器

    1 library ieee;
    2 use ieee.std_logic_1164.all;
    3 use ieee.std_logic_unsigned.all;
    4
    5 entity alarm is
    6 port(
    7 clk:in std_logic;
    8 c_in:in std_logic;
    9 c_out:out std_logic--led
    10 );
    11 end entity;
    12
    13 architecture behav of alarm is
    14 signal alarm_state:std_logic:='0';
    15 begin
    16
    17 process(c_in,clk)
    18 begin
    19 if(c_in='1')then
    20 if(clk='1')then c_out<='1';
    21 else c_out<='0';
    22 end if;
    23 else
    24 c_out<='0';
    25 end if;
    26 end process;
    27
    28 end behav;
    

    18.数码管显示

    1 LIBRARY IEEE;
    2 USE IEEE.STD_LOGIC_1164.ALL;
    3 USE IEEE.STD_LOGIC_UNSIGNED.ALL;
    4
    5 ENTITY seg7led IS
    6 PORT(
    7 mode:in std_logic_vector(1 downto 0);
    8 CLK4,CLEAR:IN STD_LOGIC;-- 时钟 ,复位信号
    9 D_0,D_1,D_2,D_3: IN STD_LOGIC_VECTOR(3 DOWNTO 0);-- 制 数器 进 计 BCD 入信号 码输
    10 DIS:OUT STD_LOGIC_VECTOR(7 DOWNTO 0);-- 数 管 信号 码 编码
    11 CS:OUT STD_LOGIC_VECTOR(3 DOWNTO 0)-- 数 管片 信号 码 选
    12 );
    13 END seg7led;
    14
    15 ARCHITECTURE XIANSHI OF seg7led IS
    16 SIGNAL DAKEY:STD_LOGIC_VECTOR(3 DOWNTO 0);-- 定 程 用来 的信号量 义进 间 传值
    17 SIGNAL CA:INTEGER RANGE 0 TO 3;
    18 BEGIN
    19
    20 -- 器 译码
    21 -- 实现 4 个数 管的 描 码 动态扫
    22 N0:PROCESS(CLK4,CLEAR)
    23 VARIABLE CAL:INTEGER RANGE 0 TO 3;
    24 BEGIN
    25
    26 IF(CLEAR='1')THEN
    27 CAL:=0;
    28 ELSIF RISING_EDGE(CLK4)THEN
    29 IF(CAL=3)THEN
    30 CAL:=0;
    31 ELSE
    32 CAL:=CAL+1;
    33 END IF;
    34 END IF;
    35 CA<=CAL;
    36 END PROCESS N0;
    37
    38 -- 当前 示的数 管 选择 显 码
    39 N1:PROCESS(CA)
    40 VARIABLE SS:STD_LOGIC_VECTOR(3 DOWNTO 0);
    41 BEGIN
    42
    43 CASE CA IS
    44 WHEN 0 =>SS:=D_0(3 DOWNTO 0);CS<="1110";DIS(7)<='1';
    45 WHEN 1 =>SS:=D_1(3 DOWNTO 0);CS<="1101";DIS(7)<='1';
    46 WHEN 2 =>SS:=D_2(3 DOWNTO 0);CS<="1011";if(mode/="11")then
    DIS(7)<='0';else dis(7)<='1';end if;
    47 WHEN 3 =>SS:=D_3(3 DOWNTO 0);CS<="0111";DIS(7)<='1';
    48 WHEN OTHERS => SS:="ZZZZ";CS<="1111";
    49 END CASE;
    50 DAKEY<=SS;
    51 END PROCESS N1;
    52
    53 -- 当前 示的数字 选择 显
    54 N2:PROCESS(DAKEY)
    55 BEGIN
    56 CASE DAKEY IS
    57 WHEN "0000" => DIS(6 DOWNTO 0) <= "1000000"; -- 0
    58 WHEN "0001" => DIS(6 DOWNTO 0) <= "1111001"; -- 1
    59 WHEN "0010" => DIS(6 DOWNTO 0) <= "0100100"; -- 2
    60 WHEN "0011" => DIS(6 DOWNTO 0) <= "0110000"; -- 3
    61 WHEN "0100" => DIS(6 DOWNTO 0) <= "0011001"; -- 4
    62 WHEN "0101" => DIS(6 DOWNTO 0) <= "0010010"; -- 5
    63 WHEN "0110" => DIS(6 DOWNTO 0) <= "0000010"; -- 6
    64 WHEN "0111" => DIS(6 DOWNTO 0) <= "1111000"; -- 7
    65 WHEN "1000" => DIS(6 DOWNTO 0) <= "0000000"; -- 8
    66 WHEN "1001" => DIS(6 DOWNTO 0) <= "0010000"; -- 9
    67 WHEN OTHERS => DIS(6 DOWNTO 0) <= "1111111";
    68 END CASE;
    69 END PROCESS;
    70
    71 END XIANSHI;
    

    复制完代码发现有点烦了。。。

    如果需要稍后可以自行下载文件(完整工程及技术报告)QAQ

    https://download.csdn.net/download/u012579502/10655901

    展开全文
  • 数字逻辑 课程设计 多功能电子钟 Quartus II

    万次阅读 多人点赞 2014-09-27 15:00:31
    设计方案 1.系统功能描述 (1) 系统输入:系统状态及校时、定时转换的控制信号为k、set;...(3) 多功能数字控制器的状态图如图所示 图中:S0:显示计时器时间 T0:显示闹铃时间  S1:调计

    设计方案

    1.系统功能描述

                                     (1)      系统输入:系统状态及校时、定时转换的控制信号为k、set;时钟信号clk,采用1024Hz;系统复位信号为reset。输入信号由按键产生。

                                     (2)      系统输出:LED显示输出;蜂鸣器声音信号输出。

                                     (3)      多功能数字钟控制器的状态图如图所示

                                                    图中:S0:显示计时器时间     T0:显示闹铃时间

                                                                S1:调计时的时         T1:调闹铃的时

                                                                S2:调计时的分         T2:调闹铃的分

                                                                S3:调计时的秒         T3:调闹铃的秒

                                      (4)      计时:正常工作状态下,按下“set键”,进入“小时”校准状态,之后按下“k键”则进入“分”校准状态,继续按下“k键”则进入“秒复零”状态,第三次按下“k                                                    键”又恢复到正常计时显示状态。

                                      (5)      ”小时“校准状态:在“小时”校准状态下,显示”小时的数码管闪烁,通过按下”p键“使其递增计数。

                                      (6)      ”分“校准状态:在“分”校准状态下,显示“分”的数码管闪烁,通过按下”p键“使其递增计数。

                                      (7)      “秒”复零状态:在:“秒复零”状态下,显示“秒”的数码管闪烁并复零。

                                      (8)      整点报时:蜂鸣器在“59”分钟的第51、53、55、57秒发出频率为512Hz的低音,在“59”秒发出频率为1024Hz的高音,结束时为整点。

                                      (9)      显示:要求采用扫描显示方式驱动8个LED数码管分别显示时、分、秒并且他们之间用“—”隔开。

                                      (10)  闹钟:闹钟定时时间到,蜂鸣器发出周期为1s的滴、滴声,持续时间为10秒;闹钟定时显示。

                                      (11)  闹钟定时设置:在闹钟显示状态下,按下“set键”,进入“小时”校时状态,之后按下“k键”,进入“分”校时状态,继续按下“k键”,进入“秒”校时状态,第                                                   三次按下“k键”又恢复到闹钟显示状态。

                                      (12)  闹钟的时、分、秒设置过程和计时设置相同。



    整体效果图:


    1.控制器


    library ieee;
    use ieee.std_logic_1164.all;
    entity ctr is
         port(p:in std_logic;
              cp:in std_logic;
              k:in std_logic;
              set:in std_logic;
              reset:in std_logic;
              resec:out std_logic;
    
              rehour:out std_logic;
              setmin:out std_logic;
              setminen:out std_logic;
              sethour:out std_logic;
              sethouren:out std_logic;
              hourflash:out std_logic;
              minflash:out std_logic;
              secflash:out std_logic;
              ahourflash:out std_logic;
              aminflash:out std_logic;
              asecflash:out std_logic;
              changemode:out std_logic;
              setclksec:out std_logic;
              setclkmin:out std_logic;
              setclkhour:out std_logic);
    end ctr;
    architecture rtl of ctr is
    type state is(s0,s1,s2,s3,t0,t1,t2,t3);
    signal clock_s:state;
          begin 
            process(cp,k,set,reset,p)
               begin
                  if(reset='0') then
                       resec<='1';remin<='1';rehour<='1';setminen<='0';setmin<='0';sethouren<='0';sethour<='0';hourflash<='0';minflash<='0';
                       secflash<='0';ahourflash<='0';aminflash<='0';asecflash<='0';setclksec<='0';setclkmin<='0';setclkhour<='0';clock_s<=s0;
                  elsif(rising_edge(cp)) then
                     case clock_s is
                       when s0=>changemode<='0';
                       resec<='0';remin<='0';rehour<='0';setminen<='0';setmin<='0';sethouren<='0';sethour<='0';hourflash<='0';minflash<='0';
                       secflash<='0';ahourflash<='0';aminflash<='0';asecflash<='0';setclksec<='0';setclkmin<='0';setclkhour<='0';
                            if(k='0') then
                               clock_s<=t0;
                            elsif(set='0')then
                               clock_s<=s1;
                            else
                               clock_s<=s0;
                          end if;
                       when s1=>changemode<='0';
                       resec<='0';remin<='0';rehour<='0';setminen<='0';setmin<='0';sethouren<='1';sethour<=p;hourflash<='1';minflash<='0';
                       secflash<='0';ahourflash<='0';aminflash<='0';asecflash<='0';setclksec<='0';setclkmin<='0';setclkhour<='0';
                            if(k='0')then
                               clock_s<=s2;
                            else
                               clock_s<=s1;
                          end if;
                       when s2=>changemode<='0';
                       resec<='0';remin<='0';rehour<='0';setminen<='1';setmin<=p;sethouren<='0';sethour<='0';hourflash<='0';minflash<='1';
                       secflash<='0';ahourflash<='0';aminflash<='0';asecflash<='0';setclksec<='0';setclkmin<='0';setclkhour<='0';
                            if(k='0')then
                               clock_s<=s3;
                            else
                               clock_s<=s2;
                          end if;
                       when s3=>changemode<='0';
                       resec<=p;remin<='0';rehour<='0';setminen<='0';setmin<='0';sethouren<='0';sethour<='0';hourflash<='0';minflash<='0';
                       secflash<='1';ahourflash<='0';aminflash<='0';asecflash<='0';setclksec<='0';setclkmin<='0';setclkhour<='0';
                            if(k='0')then
                               clock_s<=s0;
                            else
                               clock_s<=s3;
                          end if;
                       when t0=>changemode<='1';
                       resec<='0';remin<='0';rehour<='0';setminen<='0';setmin<='0';sethouren<='0';sethour<='0';hourflash<='0';minflash<='0';
                       secflash<='0';ahourflash<='0';aminflash<='0';asecflash<='0';setclksec<='0';setclkmin<='0';setclkhour<='0';
                            if(k='0')then
                               clock_s<=s0;
                            elsif(set='0') then
                               clock_s<=t1;
                            else
                               clock_s<=t0;
                          end if;
                       when t1=>changemode<='1';
                       resec<='0';remin<='0';rehour<='0';setminen<='0';setmin<='0';sethouren<='0';sethour<='0';hourflash<='0';minflash<='0';
                       secflash<='0';ahourflash<='1';aminflash<='0';asecflash<='0';setclksec<='0';setclkmin<='0';setclkhour<=p;
                            if(k='0')then
                               clock_s<=t2;
                            else
                               clock_s<=t1;
                          end if;
                       when t2=>changemode<='1';
                       resec<='0';remin<='0';rehour<='0';setminen<='0';setmin<='0';sethouren<='0';sethour<='0';hourflash<='0';minflash<='0';
                       secflash<='0';ahourflash<='0';aminflash<='1';asecflash<='0';setclksec<='0';setclkmin<=p;setclkhour<='0';
                            if(k='0')then
                               clock_s<=t3;
                            else
                               clock_s<=t2;
                          end if;
                       when t3=>changemode<='1';
                       resec<='0';remin<='0';rehour<='0';setminen<='0';setmin<='0';sethouren<='0';sethour<='0';hourflash<='0';minflash<='0';
                       secflash<='0';ahourflash<='0';aminflash<='0';asecflash<='1';setclksec<=p;setclkmin<='0';setclkhour<='0';
                            if(k='0')then
                               clock_s<=t0;
                            else
                               clock_s<=t3;
                          end if;
                       when others=>clock_s<=s0;
                   end case;
              end if;
           end process;
    end rtl;
    

    2.60进制计数器


    LIBRARY IEEE;
    USE IEEE.STD_LOGIC_1164.ALL;
    USE IEEE.STD_LOGIC_UNSIGNED.ALL;
    USE IEEE.STD_LOGIC_ARITH.ALL;
    ENTITY counter_60 IS
           PORT(rs,cp:IN STD_LOGIC;
                co   :OUT STD_LOGIC;
                ql,qh   :OUT STD_LOGIC_VECTOR(3 DOWNTO 0));
        END counter_60;
    ARCHITECTURE rtl OF counter_60 IS
        SIGNAL ql_temp:STD_LOGIC_VECTOR(3 DOWNTO 0):="0000";
        SIGNAL qh_temp:STD_LOGIC_VECTOR(3 DOWNTO 0):="0000";
        BEGIN
            PROCESS (rs,cp,qh_temp,ql_temp)
              BEGIN
                  if(rs='1') then
                       qh_temp<="0000";
                       ql_temp<="0000";
                       co<='0';
                elsIF(rising_edge(cp)) then
                   
                   if(qh_temp="0101" and ql_temp="1001") then
                       ql_temp<="0000";
                       qh_temp<="0000";
                       co<='1';
                   elsif(qh_temp<="0101" and ql_temp<"1001") then
                       ql_temp<=ql_temp+'1';
                       co<='0';
                   elsif(qh_temp<="0101" and ql_temp="1001") then
                       qh_temp<=qh_temp+'1';
                       ql_temp<="0000";
                       co<='0';
                end if;
              end if;
              qh<=qh_temp;
              ql<=ql_temp;
            END PROCESS;
    END rtl;
    

    3.24进制计数器


    LIBRARY IEEE;
    USE IEEE.STD_LOGIC_1164.ALL;
    USE IEEE.STD_LOGIC_UNSIGNED.ALL;
    USE IEEE.STD_LOGIC_ARITH.ALL;
    ENTITY counter_24 IS
           PORT(rs,cp:IN STD_LOGIC;
                ql,qh   :OUT STD_LOGIC_VECTOR(3 DOWNTO 0));
        END counter_24;
    ARCHITECTURE rtl OF counter_24 IS
        SIGNAL ql_temp:STD_LOGIC_VECTOR(3 DOWNTO 0):="0000";
        SIGNAL qh_temp:STD_LOGIC_VECTOR(3 DOWNTO 0):="0000";
        SIGNAL rs_temp:STD_LOGIC;
        BEGIN
            PROCESS (rs,cp)
              BEGIN
                   if(rs='1') then
                       qh_temp<="0000";
                       ql_temp<="0000";
                elsIF(rising_edge(cp)) then
                   if(qh_temp="0010" and ql_temp="0011") then
                       qh_temp<="0000";
                       ql_temp<="0000";
                   elsif(qh_temp<="0010" and ql_temp<"1001") then
                       ql_temp<=ql_temp+'1';
                   elsif(qh_temp<="0010" and ql_temp="1001") then
                       qh_temp<=qh_temp+'1';
                       ql_temp<="0000";
                end if;
              end if;
            END PROCESS;
              qh<=qh_temp;
              ql<=ql_temp;
    END rtl;
    

    4.模1024计数器(分频器)


    library ieee;
    use ieee.std_logic_1164.all;
    use ieee.std_logic_unsigned.all;
    entity counter_10 is
          port(cp:in std_logic;
               d :out std_logic_vector(9 downto 0));
    end counter_10;
    architecture rtl of counter_10 is
    signal d_temp:std_logic_vector(9 downto 0):="0000000000";
       begin
        process(cp)
          begin
           if(rising_edge(cp)) then
               if(d_temp="1111111111") then
                  d_temp<="0000000000";
               else 
                  d_temp<=d_temp+'1';
               end if;
           end if;
        end process;
    d<=d_temp;
    end rtl;
    

    5.模8计数器(数码管扫描动态显示)


    library ieee;
    use ieee.std_logic_1164.all;
    use ieee.std_logic_unsigned.all;
    entity counter_8 is
       port(cp,en:in std_logic;
            a: out std_logic_vector(2 downto 0));
    end counter_8;
    architecture rtl of counter_8 is
         signal a_temp:std_logic_vector(2 downto 0):="000";
        begin
          process(cp,en)
            begin
             if(rising_edge(cp) and en='1') then
                 if(a_temp="111") then
                    a_temp<="000";
                 else
                    a_temp<=a_temp+'1';
                end if;
             end if;
           end process;
          a<=a_temp;
    end rtl;
    

    6.数据通断器(闪烁)


    library ieee;
    use ieee.std_logic_1164.all;
    use ieee.std_logic_unsigned.all;
    entity d_ff is
        port(en:in std_logic;
             q0 :out std_logic_vector(3 downto 0);
             q1 :out std_logic_vector(3 downto 0);
             d0 :in std_logic_vector(3 downto 0);
             d1 :in std_logic_vector(3 downto 0));
    end d_ff;
    architecture rtl of d_ff is
         begin 
           process(en,d0,d1)
              begin
                if(en='1') then
                 q0<=d0;
                 q1<=d1;
                else
                 q0<="1110";
                 q1<="1110";
              end if;
           end process;
    end rtl;
    

    7.48译码器(驱动数码管显示)


    LIBRARY IEEE;
    USE IEEE.STD_LOGIC_1164.ALL;
    ENTITY decode_48 IS
        PORT(d:IN STD_LOGIC_VECTOR(3 DOWNTO 0);
             y:OUT STD_LOGIC_VECTOR(6 DOWNTO 0));
    END decode_48;
    ARCHITECTURE rtl OF decode_48 IS
           BEGIN
             PROCESS(d)
             BEGIN
             CASE d IS
                WHEN "0000"=>y<="1111110";
                WHEN "0001"=>y<="0110000";
                WHEN "0010"=>y<="1101101";
                WHEN "0011"=>y<="1111001";
                WHEN "0100"=>y<="0110011";
                WHEN "0101"=>y<="1011011";
                WHEN "0110"=>y<="1011111";
                WHEN "0111"=>y<="1110000";
                WHEN "1000"=>y<="1111111";
                WHEN "1001"=>y<="1111011";
                WHEN "1111"=>y<="0000001";
                WHEN OTHERS=>y<="0000000";
             END CASE;
           END PROCESS;
    END rtl;
     
    

    8.响铃模块


    library ieee;
    use ieee.std_logic_1164.all;
    entity ring is
            port(cp1,cp512,cp1024,en:in std_logic;
                 hourh,hourl,ahourh,ahourl,minh,minl,aminh,aminl,sech,secl,asech,asecl:in std_logic_vector(3 downto 0);
                 r:out std_logic);
    end ring;
    architecture rtl of ring is
          begin
            process(en,hourh,hourl,ahourh,ahourl,minh,minl,aminh,aminl,sech,secl,asech,asecl,cp1,cp512,cp1024)
               begin
                  if(en='1')then
                    if(hourh=ahourh and hourl=ahourl and minh=aminh and minl=aminl)then
                        if(cp1='1')then
                           r<=cp512;
                        else
                           r<='0';
                       end if;
                    elsif(minh="0101" and minl="1001" and sech="0101")then
                       if(secl="0001" or secl="0011" or secl="0101" or secl="0111")then
                           r<=cp512;
                       elsif(secl="1001")then
                           r<=cp1024;
                       else
                           r<='0';
                       end if;
                    else
                         r<='0';
                    end if;
                 end if;
            end process;
    end rtl;
    

    9.8选1数据选择器


    LIBRARY IEEE;
    USE IEEE.STD_LOGIC_1164.ALL;
    ENTITY sel_81 IS
          PORT(a:IN STD_LOGIC_VECTOR(2 DOWNTO 0);
               y:OUT STD_LOGIC_VECTOR(3 DOWNTO 0);
               d0:IN STD_LOGIC_VECTOR(3 DOWNTO 0);
               d1:IN STD_LOGIC_VECTOR(3 DOWNTO 0);
               d2:IN STD_LOGIC_VECTOR(3 DOWNTO 0);
               d3:IN STD_LOGIC_VECTOR(3 DOWNTO 0);
               d4:IN STD_LOGIC_VECTOR(3 DOWNTO 0);
               d5:IN STD_LOGIC_VECTOR(3 DOWNTO 0);
               d6:IN STD_LOGIC_VECTOR(3 DOWNTO 0);
               d7:IN STD_LOGIC_VECTOR(3 DOWNTO 0));
               
    END sel_81;
    ARCHITECTURE rtl OF sel_81 IS
          BEGIN
            PROCESS(d0,d1,d2,d3,d4,d5,d6,d7,a)
              BEGIN
                CASE a IS
                   WHEN "000"=>y<=d7;
                   WHEN "001"=>y<=d6;
                   WHEN "010"=>y<=d5;
                   WHEN "011"=>y<=d4;
                   WHEN "100"=>y<=d3;
                   WHEN "101"=>y<=d2;
                   WHEN "110"=>y<=d1;
                   WHEN "111"=>y<=d0;
                END CASE;
            END PROCESS;
    END rtl;
    

    10.一位二选一数据选择器


    library ieee;
    use ieee.std_logic_1164.all;
    entity sel_21 is 
           port(a:in std_logic;
                y:out std_logic_vector(3 downto 0);
                d0:in  std_logic_vector(3 downto 0);
                d1:in  std_logic_vector(3 downto 0));
    end sel_21;
    architecture rtl of sel_21 is
          begin
             process(a,d0,d1)
              begin
                case a is
                 when '0'=>y<=d0;
                 when '1'=>y<=d1;
                end case;
             end process;
    end rtl;
    

    11.四位二选一数据选择器


    library ieee;
    use ieee.std_logic_1164.all;
    entity selone_21 is 
           port(a:in std_logic;
                y:out std_logic;
                d0:in  std_logic;
                d1:in  std_logic);
    end selone_21;
    architecture rtl of selone_21 is
          begin
             process(a,d0,d1)
              begin
                case a is
                 when '0'=>y<=d0;
                 when '1'=>y<=d1;
                end case;
             end process;
    end rtl;
    
    心得体会:

    在课程设计开始之前,我便对电子钟的制作产生了兴趣,通过在课堂上和老师一起学习VHDL语言的使用方法,以及课下上机进行练习,我已经初步掌握了通过该语言编写程序的方法,如编写底层程序,编译,仿真,生成模块,顶层连接等。并在几次实验课上分别上机连接硬件验证了自己编写的程序的正确性,为课程设计的实现打下了基础。在课程设计的实现过程中,我也遇到了很多问题,一开始是软件使用不够熟练,经常忘记某些步骤,甚至还发生过代码被覆盖的情况,其次是我才用了从中心向四周扩散的设计思路,即首先实现基本的时钟计数和显示的功能,然后再分别添加调节时钟的功能,显示闪烁的功能,闹钟的功能等,这种方法有利有弊,好处是一开始不用想太多,不用管整体是怎样的,只要将各个模块做好即可,所以很适合在知识储备不足的情况下进行设计,但缺点就是最后会发现控制端口很多,导致控制器非常庞大,整个电路的布线较乱,集成度低,最后就是考虑问题不够周全,比如我一开始在连线测试的时候发现数字显示是反着的,但是由于电路基本已经成型,模块多,不便于查错,在一个星期的制作当中,我利用中午,晚上以及平时上机时空闲的时间进行制作,由于只有一个人,所以不会因为思路的冲突而和搭档发生争论,但由于精力有限,所以花的时间非常多,但是对于自己感兴趣的事情,即使很累依然开心。通过课程设计,我觉得自己独立思考的能力和模块化的思维有了提高,在给同学的改错和讲解过程中,我也了解了很多常见的错误以及解决方法,积累了知识和经验,同时也体现了同学之间互帮互助的精神。我还要非常感谢指导老师对我的细心指导,在老师的帮助下,我不仅顺利完成了课程设计,还体会到了作为老师的不易之处,每天面对相同的问题,几百个学生,压力和焦虑都是在所难免的,所以在以后的学习过程中,我会更加从老师的立场思考,不给老师带来额外的压力。





    展开全文
  • 2.1 设计题目:基于PIC16F877A单片机的多功能电子时钟2.2 功能实现:实时时钟显示,时间可调;实时温度显示,并具有超限报警功能。输出显示采用LCD1602或LED七段数码显示器。2.3 设计要求:自己设计硬件和程序编程,...
  • 一、实验目的本次实验使用 MSp430G2553 以及 GZ 扩展版的 LCO 显示、蜂鸣器、机械按键,实现具有多功能电子钟的设计。功能包括,按键切换工作界面、设置时间、秒表计时、闹钟的设定、闹钟的暂停与休眠。二、实验内容...
  • 基于Arduino的多功能数字时钟

    万次阅读 多人点赞 2017-05-08 22:07:57
    实现功能: 1. 显示时间、日期和星期 2. 断电保存时间 3. 通过按钮设置时间、日期 4. 整点响铃 5. 自定义闹钟 6. 显示温度 7. 自定义报警温度 8. 按键功能:按选择键进入设置时间功能;同时按 + - 键进入...
  • 多功能数字电子钟仿真文件及文章全文请戳末尾链接一、功能1、显示时间2、显示星期3、时间校准4、整点报时5、(扩展功能)定时闹钟二、原理资料已存入文章末尾链接三、元件清单四、仿真截图五、实物展示六、故障及排查1...
  • 多功能数字的设计

    千次阅读 多人点赞 2020-11-13 21:32:33
    提示:电子综合实训包括很多实验,本实验课题选择多功能电子时钟的设计,其中包括模拟电子技术和数字电子技术的知识的运用,本文使用的实验环境是win7(当然win10阔以的哦),仿真软件是Multisim10.0.1,打开界面...
  • 多功能数字时钟

    千次阅读 2015-07-27 14:11:35
    该时钟具有时、分、秒计时的电子钟电路,24小时制计时。能够准确计时,以数字的形式显示时、分、秒;具有分、时校正功能,校正输出脉冲频率为1HZ;具有仿广播电台整点报时功能,即每逢59分51秒,53秒,57秒时,发出...
  • 基于STM32F103的液晶显示电子钟

    万次阅读 多人点赞 2019-10-18 21:18:09
    摘要: ...本设计系统就是以液晶进行显示数字时钟的一个微系统设计,本设计三大部分:分别包括信息处理部分、信息采集部分和信息显示部分。其中,信息处理部分是以单片机为核心,外加一些辅助电...
  • VHDL编写多功能数字,spartan3 FPGA开发板硬件实现-学习笔记1.数字标准-功能总体描述1.1 正常时间显示模式1.2 秒表模式1.3 闹铃设定模式1.4 时间设定模式 个人理解对于一个数字设计过程需要先进行功能总体描述...
  • FPGA-Verilog多功能数字时钟

    万次阅读 多人点赞 2018-05-13 12:02:33
    4. 按键功能设计:按键调整数字时钟分钟显示;1.数字时钟顶层模块RTL视图1) 说明:这个为数字时钟的顶层模块,按键消抖模块xd,计数模块分秒CNT59,时CNT24,数码管显示sz,时间模块div;2)...
  • 多功能数字时钟(VHDL)

    千次阅读 多人点赞 2021-01-22 10:53:19
    功能要求2.各个模块描述三、具体实现过程描述1、小时计时2、分计时3、秒计时4、闹钟小时计时5、闹钟分计时6、闹钟比较模块7、控制器模块(设置状态转换)8、控制显示模块(显示时间以及校时,校分,秒清零,设置闹钟...
  • 这是我自己做的关于LED显示电子钟的制作。 目录 摘要: 1 关键词:单片机;LED点阵;数字时钟 1 1.电路设计的目的、任务、指标指标及工艺要求 2 1.1 课程设计的目的 2 1.2 课程设计的任务 2 1.3 课程设计的指标 3 ...
  • FPGA实现多功能数字(Verilog)

    千次阅读 多人点赞 2020-06-15 11:26:12
    FPGA实现多功能数字(Verilog)介绍整体框架 介绍 本文设计的数字的功能包括:正常时钟、日期显示、调整时间(日期)、整点报时、闹钟(包括闹钟音乐)、秒表、数码管显示。使用的rtl语言为Verilog,参考了一些...
  • Android小项目蓝牙电子钟

    千次阅读 2015-02-24 13:22:48
    Android蓝牙电子钟应用程序通过蓝牙设备发送消息给多功能数字电子钟,实现更新电子钟时间、设定电子钟监控时间、设定电子钟闹钟时间和调整电子钟时间误差等功能。该应用程序的UI主要基于http://blog.c
  • 基于arduino和I2C协议的OLED12864电子时钟和菜单
  • 基于51单片机电子时钟

    万次阅读 多人点赞 2019-01-05 21:39:20
    3. 能实现整时报时的功能(蜂鸣器响) 4. 闹钟模式 5.按键切换模式(模式一:时-分显示,模式二:60秒倒计时) 一、设计思路: 主体: 通过外部中断0来控制mod值;mod=0,1.2,3分别对应时钟模式,调整模式,闹钟设置...
  • STM32+OLED显示屏制作指针式电子钟

    千次阅读 多人点赞 2020-07-15 15:33:13
    一、硬件环境介绍 单片机: STM32F103C8T6 RTC时钟来源: 使用STM32内部RTC定时器得到时间。 显示屏:中景园0.96寸 SPI接口的OLED显示屏 ...2. 电子钟界面逻辑代码部分:电子钟的界面仪表盘画面更新是在RTC秒...
  • 基于STM32单片机1602显示电子时钟

    千次阅读 热门讨论 2019-07-22 21:49:54
    1、本系统采用1602显示时分秒,4个按键可以调整时间,一个按键是选择按键,一个按键是加,一个按键是减,一个按键是退出按键。 2、当选择按键按下的时候,该选择位闪烁。 主函数代码: #include “delay.h” #...
  • java线程基础知识-电子时钟

    千次阅读 2015-02-14 10:04:09
    java线程基础知识简单应用-电子时钟 参考文档《java语言程序设计》-13章线程实现电子时钟 首先是继承Thread类实现线程:这段程序可以初步了解线程的“同时执行”,运行可以发现每次运行的结果都是不同的。...
  • 数字电子电路——数字仿真图

    千次阅读 2019-04-22 14:44:22
    题目:多功能数字 要求: 1.设计的数字具有正常走时功能。 在计时开始或计时出现误差时,由校时电路完成对分、小时与标准时间的校准。 3.设计的数字具有显示功能。 设计的数字具有整点报时功能、要求能...
  • 数电课程设计——电子钟

    千次阅读 2020-07-05 16:43:37
    数电课程设计——电子钟 用到的元器件: 可解码的数码管DCD_HEX 与非门74LS00 非门74LS04 十进制计数器74LS160 比较器74LS85 若干开关 实现功能: 周时分秒计算进位 实现思路: 时分秒用异步清零法产生进位...
  • 基于74LS161实现的多功能数字

    千次阅读 多人点赞 2020-01-03 22:39:22
    1、 利用74LS161芯片将各引脚正确连接实现计数功能,并将输出连接在DCD_HEX显像管上予以显示。 2、 利用两片74LS161芯片实现60进制和24进制并实现进位和进位后的清零功能。 图2 60进制的实现 图3 24进制的实现 3...
  • 待填
  • 优化第8章数字的程序,优化的具体内容主要是与时钟相关,采用同源时钟,经过严格的计数器分频后再连接到所有触发器,时钟不能经过路选择器直接连接到触发器的时钟端 编写测试激励,对数字进行仿真,要求仿真到...
  • Verilog设计实例(7)基于Verilog的数字电子钟设计

    千次阅读 多人点赞 2020-06-17 21:51:43
    基于模块化的设计思想, 采用 Verilog HDL 语言设计一个能进行时、分、秒计时的二十四小时制的数字电子钟, 并具有整点报时功能。 采用数码管进行时间显示,要求显示格式为:小时-分钟-秒钟。
  • 温度采集选用DS18B20芯片,万年历采用直观的数字显示,数据显示采用1602A液晶显示模块,可以在LCD上同时显示年、月、日、星期、时、分、秒,还具有时间校准等功能。此万年历具有读取方便、显示直观、功能多样、电路...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 20,996
精华内容 8,398
关键字:

多功能电子显示钟