设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › PIC单片机 › pic16f877加2块8x8led点阵滚动显示数字时钟Proteus仿真 ...
返回列表 发新帖
查看: 2937|回复: 0
打印 上一主题 下一主题
收起左侧

pic16f877加2块8x8led点阵滚动显示数字时钟Proteus仿真程序

[复制链接]
跳转到指定楼层
楼主
ID:732506 发表于 2020-5-26 04:10 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）


单片机源程序如下:
  1. //-----------------------------------------------------------------
  2. //  名称: 8×8LED点阵屏显示数字
  3. //-----------------------------------------------------------------
  4. //  说明: 8×8LED点阵屏循环显示数字0-9,刷新过程由定时器中断完成
  5. //   
  6. //-----------------------------------------------------------------
  7. #include <pic.h>
  8. #define INT8U   unsigned char
  9. #define INT16U  unsigned int
  10. #define _XTAL_FREQ 1000000UL
  11. unsigned char s,m;

  13. unsigned char column[8]={0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80};  //column number select chart                         
  14. //数字0~9的8*8点阵编码
  15. //const INT8U Table_OF_Digits[] =
  16. //{  
  17.       
  18. //};

  20. const unsigned char dot5x3[10][3] = {
  21.                                                                          {0x07,0x77,0x07},  //0 3column for 1 digit
  22.                                                                    {0xff,0x07,0xff},  //1
  23.                                                                    {0x47,0x57,0x17},  //2
  24.                                                                    {0x57,0x57,0x07},  //3
  25.                                                                    {0x1f,0xdf,0x07},  //4
  26.                                                                    {0x17,0x57,0x47},  //5
  27.                                                                    {0x07,0x57,0x47},  //6
  28.                                                                    {0x7f,0x7f,0x07},  //7
  29.                                                                    {0x07,0x57,0x07},  //8
  30.                                                                    {0x17,0x57,0x07},  //9

  32.                                                                    };

  34. void display()
  35. {
  36.         INT8U i,j;       
  37.        
  38.         for (i=0;i<32;i++)
  39.         {
  40.                 for (j=0;j<12;j++)
  41.                 {
  42.                 if(16>i&&i>=0)
  43.                 {
  44.                         if(i<8)
  45.                         {
  46.                         PORTB=0xff;          //关闭显示
  47.                         PORTB=dot5x3[m/10][0]>>2|11000000;
  48.                           PORTC=column[i%8];         //选通第1个点阵，显示第i列
  49.                           __delay_ms(1);           //显示延时
  50.                         PORTC=0x00;          //关闭显示
  51.                           PORTB=0xff;          //关闭显示
  52.                         }
  53.                         else
  54.                         {
  55.                         PORTB=0xff;          //关闭显示
  56.                         PORTB=dot5x3[m/10][0]>>2|11000000;
  57.                           PORTD=column[i%8];         //选通第2个点阵，显示第i列
  58.                           __delay_ms(1);           //显示延时
  59.                         PORTD=0x00;          //关闭显示
  60.                           PORTB=0xff;          //关闭显示
  61.                         }
  62.                 }
  63.                 if(17>i&&i>=1)
  64.                   {
  65.                         if(i<9)
  66.                         {
  67.                         PORTB=0xff;          //关闭显示
  68.                         PORTB=dot5x3[m/10][1]>>2|11000000;
  69.                           PORTC=column[(i-1)%8];         //选通第1个点阵，显示第i列
  70.                           __delay_ms(1);           //显示延时
  71.                         PORTC=0x00;          //关闭显示
  72.                         PORTB=0xff;          //关闭显示
  73.                         }
  74.                           else
  75.                         {
  76.                         PORTB=0xff;          //关闭显示
  77.                         PORTB=dot5x3[m/10][1]>>2|11000000;
  78.                           PORTD=column[(i-1)%8];         //选通第2个点阵，显示第i列
  79.                           __delay_ms(1);           //显示延时
  80.                         PORTD=0x00;          //关闭显示
  81.                         PORTB=0xff;          //关闭显示
  82.                         }
  83.                 }
  84.                 if(18>i&&i>=2)
  85.                 {
  86.                         if(i<10)
  87.                         {
  88.                         PORTB=0xff;          //关闭显示
  89.                         PORTB=dot5x3[m/10][2]>>2|11000000;
  90.                           PORTC=column[(i-2)%8];         //选通左起第2个数码管，显示i位
  91.                           __delay_ms(1);           //显示延时
  92.                         PORTC=0x00;          //关闭显示
  93.                         PORTB=0xff;          //关闭显示
  94.                         }
  95.                         else
  96.                         {
  97.                         PORTB=0xff;          //关闭显示
  98.                         PORTB=dot5x3[m/10][2]>>2|11000000;
  99.                           PORTD=column[(i-2)%8];         //选通左起第2个数码管，显示i位
  100.                           __delay_ms(1);           //显示延时
  101.                         PORTD=0x00;          //关闭显示
  102.                         PORTB=0xff;          //关闭显示
  103.                         }
  104.                 }
  105.                 if(19>i&&i>=3)
  106.                 {
  107.                         if(i<11)
  108.                         {
  109.                         PORTB=0xff;          //关闭显示               
  110.                         PORTC=column[(i-3)%8];         //选通左起第2个数码管，显示i位
  111.                         __delay_ms(1);           //显示延时
  112.                         PORTC=0x00;          //关闭显示
  113.                         PORTB=0xff;          //关闭显示
  114.                         }
  115.                         else
  116.                         {
  117.                         PORTB=0xff;          //关闭显示               
  118.                         PORTD=column[(i-3)%8];         //选通左起第2个数码管，显示i位
  119.                         __delay_ms(1);           //显示延时
  120.                         PORTD=0x00;          //关闭显示
  121.                         PORTB=0xff;          //关闭显示         
  122.                         }
  123.                 }
  124.                 if(20>i&&i>=4)
  125.                 {
  126.                         if(i<12)
  127.                         {
  128.                         PORTB=0xff;          //关闭显示
  129.                         PORTB=dot5x3[m%10][0]>>2|11000000;
  130.                           PORTC=column[(i-4)%8];         //选通左起第1个数码管，显示i位
  131.                           __delay_ms(1);           //显示延时
  132.                         PORTC=0x00;          //关闭显示
  133.                           PORTB=0xff;          //关闭显示
  134.                         }
  135.                         else
  136.                         {
  137.                         PORTB=0xff;          //关闭显示
  138.                         PORTB=dot5x3[m%10][0]>>2|11000000;
  139.                           PORTD=column[(i-4)%8];         //选通左起第1个数码管，显示i位
  140.                           __delay_ms(1);           //显示延时
  141.                         PORTD=0x00;          //关闭显示
  142.                           PORTB=0xff;          //关闭显示
  143.                         }
  144.                 }
  145.                 if(21>i&&i>=5)
  146.                 {
  147.                         if(i<13)
  148.                         {
  149.                         PORTB=0xff;          //关闭显示       
  150.                           PORTB=dot5x3[m%10][1]>>2|11000000;
  151.                           PORTC=column[(i-5)%8];         //选通左起第2个数码管，显示i位
  152.                           __delay_ms(1);           //显示延时
  153.                         PORTC=0x00;          //关闭显示
  154.                         PORTB=0xff;          //关闭显示
  155.                         }
  156.                         else
  157.                         {
  158.                         PORTB=0xff;          //关闭显示       
  159.                           PORTB=dot5x3[m%10][1]>>2|11000000;
  160.                           PORTD=column[(i-5)%8];         //选通左起第2个数码管，显示i位
  161.                           __delay_ms(1);           //显示延时
  162.                         PORTD=0x00;          //关闭显示
  163.                         PORTB=0xff;          //关闭显示
  164.                         }
  165.                 }
  166.                 if(22>i&&i>=6)
  167.                 {
  168.                         if(i<14)
  169.                         {
  170.                         PORTB=0xff;          //关闭显示
  171.                           PORTB=dot5x3[m%10][2]>>2|11000000;
  172.                           PORTC=column[(i-6)%8];         //选通左起第2个数码管，显示i位
  173.                           __delay_ms(1);           //显示延时
  174.                         PORTC=0x00;          //关闭显示
  175.                         PORTB=0xff;          //关闭显示               
  176.                         }
  177.                         else
  178.                         {
  179.                         PORTB=0xff;          //关闭显示
  180.                           PORTB=dot5x3[m%10][2]>>2|11000000;
  181.                           PORTD=column[(i-6)%8];         //选通左起第2个数码管，显示i位
  182.                           __delay_ms(1);           //显示延时
  183.                         PORTD=0x00;          //关闭显示
  184.                         PORTB=0xff;          //关闭显示               
  185.                         }
  186.                 }
  187.                 if(23>i&&i>=7)
  188.                 {
  189.                         if(i<15)
  190.                         {
  191.                         PORTB=0xff;          //关闭显示               
  192.                         //RTC=column[(i-7)%8];         //选通左起第2个数码管，显示i位
  193.                         __delay_ms(1);           //显示延时
  194.                         PORTC=0x00;          //关闭显示       
  195.                         PORTB=0xff;          //关闭显示         
  196.                         }
  197.                         else
  198.                         {
  199.                         PORTB=0xff;          //关闭显示               
  200.                         //RTD=column[(i-7)%8];         //选通左起第2个数码管，显示i位
  201.                         __delay_ms(1);           //显示延时
  202.                         PORTD=0x00;          //关闭显示
  203.                         PORTB=0xff;          //关闭显示
  204.                         }
  205.                 }
  206.                 if(24>i&&i>=8)
  207.                 {
  208.                         if(i<16)
  209.                         {
  210.                         PORTB=0xff;          //关闭显示
  211.                         PORTB=dot5x3[s/10][0]>>2|11000000;
  212.                           PORTC=column[(i-8)%8];         //选通左起第1个数码管，显示i位
  213.                           __delay_ms(1);           //显示延时
  214.                         PORTC=0x00;          //关闭显示
  215.                           PORTB=0xff;          //关闭显示
  216.                         }
  217.                         else
  218.                         {
  219.                         PORTB=0xff;          //关闭显示       
  220.                         PORTB=dot5x3[s/10][0]>>2|11000000;
  221.                           PORTD=column[(i-8)%8];         //选通左起第1个数码管，显示i位
  222.                           __delay_ms(1);           //显示延时
  223.                         PORTD=0x00;          //关闭显示
  224.                           PORTB=0xff;          //关闭显示
  225.                         }
  226.                 }       
  227.                   if(25>i&&i>=9)
  228.                 {
  229.                         if(i<17)
  230.                         {
  231.                         PORTB=0xff;          //关闭显示
  232.                         PORTB=dot5x3[s/10][1]>>2|11000000;
  233.                           PORTC=column[(i-9)%8];         //选通左起第2个数码管，显示i位
  234.                           __delay_ms(1);           //显示延时
  235.                         PORTC=0x00;          //关闭显示
  236.                         PORTB=0xff;          //关闭显示
  237.                         }
  238.                         else
  239.                         {
  240.                         PORTB=0xff;          //关闭显示
  241.                         PORTB=dot5x3[s/10][1]>>2|11000000;
  242.                           PORTD=column[(i-9)%8];         //选通左起第2个数码管，显示i位
  243.                           __delay_ms(1);           //显示延时
  244.                         PORTD=0x00;          //关闭显示
  245.                         PORTB=0xff;          //关闭显示
  246.                         }
  247.                 }
  248.                 if(26>i&&i>=10)
  249.                 {
  250.                         if(i<18)
  251.                         {
  252.                         PORTB=0xff;          //关闭显示
  253.                           PORTB=dot5x3[s/10][2]>>2|11000000;
  254.                           PORTC=column[(i-10)%8];         //选通左起第2个数码管，显示i位
  255.                           __delay_ms(1);           //显示延时
  256.                         PORTC=0x00;          //关闭显示
  257.                         PORTB=0xff;          //关闭显示
  258.                         }
  259.                         else
  260.                         {
  261.                         PORTB=0xff;          //关闭显示
  262.                         PORTB=dot5x3[s/10][2]>>2|11000000;
  263.                           PORTD=column[(i-10)%8];         //选通左起第2个数码管，显示i位
  264.                           __delay_ms(1);           //显示延时
  265.                         PORTD=0x00;          //关闭显示
  266.                         PORTB=0xff;          //关闭显示
  267.                         }
  268.                 }
  269.                 if(27>i&&i>=11)
  270.                 {
  271.                         if(i<19)
  272.                         {
  273.                         PORTB=0xff;          //关闭显示               
  274.                         //RTC=column[(i-11)%8];         //选通左起第2个数码管，显示i位
  275.                         __delay_ms(1);           //显示延时
  276.                         PORTC=0x00;          //关闭显示
  277.                         }
  278.                         else
  279.                         {
  280.                         PORTB=0xff;          //关闭显示               
  281.                         //RTD=column[(i-11)%8];         //选通左起第2个数码管，显示i位
  282.                         __delay_ms(1);           //显示延时
  283.                         PORTD=0x00;          //关闭显示
  284.                         }
  285.                 }
  286.                 if(28>i&&i>=12)
  287.                 {
  288.                         if(i<20)
  289.                         {
  290.                         PORTB=0xff;          //关闭显示
  291.                         PORTB=dot5x3[s%10][0]>>2|11000000;
  292.                           PORTC=column[(i-12)%8];         //选通左起第1个数码管，显示i位
  293.                           __delay_ms(1);           //显示延时
  294.                         PORTC=0x00;          //关闭显示
  295.                           PORTB=0xff;          //关闭显示
  296.                         }
  297.                         else
  298.                         {
  299.                         PORTB=0xff;          //关闭显示
  300.                         PORTB=dot5x3[s%10][0]>>2|11000000;
  301.                           PORTD=column[(i-12)%8];         //选通左起第1个数码管，显示i位
  302.                           __delay_ms(1);           //显示延时
  303.                         PORTD=0x00;          //关闭显示
  304.                           PORTB=0xff;          //关闭显示
  305.                         }
  306.                 }
  307.                 if(29>i&&i>=13)
  308.                 {
  309.                         if(i<21)
  310.                         {
  311.                         PORTB=0xff;          //关闭显示       
  312.                           PORTB=dot5x3[s%10][1]>>2|11000000;
  313.                           PORTC=column[(i-13)%8];         //选通左起第2个数码管，显示i位
  314.                           __delay_ms(1);           //显示延时
  315.                         PORTC=0x00;          //关闭显示
  316.                         PORTB=0xff;          //关闭显示
  317.                         }
  318.                         else
  319.                         {
  320.                         PORTB=0xff;          //关闭显示       
  321.                           PORTB=dot5x3[s%10][1]>>2|11000000;
  322.                           PORTD=column[(i-13)%8];         //选通左起第2个数码管，显示i位
  323.                           __delay_ms(1);           //显示延时
  324.                         PORTD=0x00;          //关闭显示
  325.                         PORTB=0xff;          //关闭显示
  326.                         }
  327.                 }
  328.                 if(30>i&&i>=14)
  329.                 {
  330.                         if(i<22)
  331.                         {
  332.                         PORTB=0xff;          //关闭显示
  333.                           PORTB=dot5x3[s%10][2]>>2|11000000;
  334.                           PORTC=column[(i-14)%8];         //选通左起第2个数码管，显示i位
  335.                           __delay_ms(1);           //显示延时
  336.                         PORTC=0x00;          //关闭显示
  337.                         PORTB=0xff;          //关闭显示       
  338.                         }
  339.                         else
  340.                         {
  341.                         PORTB=0xff;          //关闭显示
  342.                           PORTB=dot5x3[s%10][2]>>2|11000000;
  343.                           PORTD=column[(i-14)%8];         //选通左起第2个数码管，显示i位
  344.                           __delay_ms(1);           //显示延时
  345.                         PORTD=0x00;          //关闭显示         
  346.                         PORTB=0xff;          //关闭显示       
  347.                         }
  348.                 }
  349.                 if(31>i&&i>=15)
  350.                 {
  351.                         if(i<23)
  352.                         {
  353.                         PORTB=0xff;          //关闭显示               
  354.                         //RTC=column[(i-15)%8];         //选通左起第2个数码管，显示i位
  355.                         __delay_ms(1);           //显示延时
  356.                         PORTC=0x00;          //关闭显示
  357.                         PORTB=0xff;          //关闭显示       
  358.                         }
  359.                         else
  360.                         {
  361.                         PORTB=0xff;          //关闭显示               
  362.                         //RTD=column[(i-15)%8];         //选通左起第2个数码管，显示i位
  363.                         __delay_ms(1);           //显示延时
  364.                         PORTD=0x00;          //关闭显示
  365.                         PORTB=0xff;          //关闭显示         
  366.                         }
  367.                 }
  368.                 }
  369.         //__delay_ms(40);       
  370.         }
  371.         __delay_ms(2000);           //显示延时        
  372. }



  376. //------------------------------------------------------------------
  377. // 主程序
  378. //------------------------------------------------------------------
  379. void main()
  380. {   
  381.        
  382.     TRISB = TRISC = TRISD = 0x00;                            //配置端口

  384.         //TRISB=0x00;TRISC=0x00; //PB PC PD out put
  385.         PORTB=0xff;
  386.         PORTC=PORTD=0x00;
  387.         PSA=0;
  388.         PS2=0; PS1=PS0=1;
  389.         TMR0 = (INT8U)(256-_XTAL_FREQ/16*0.002);
  390.         T0IF=0;
  391.         T0CS=0;
  392.         T0IE=1;
  393.         GIE=1;

  395.         s=45;m=59;
  396.         while(1)
  397.         {
  398.          
  399.                  display();
  400.         //        __delay_ms(10);       
  401.         }

  403. }


  406. //-----------------------------------------------------------------
  407. // TMR0溢出中断控制点阵屏刷新显示
  408. //-----------------------------------------------------------------
  409. void interrupt TMR0_OVR_Interrupt()
  410. {
  411.    //static INT8U  i = 0, Num_Index = 0;
  412.    static INT8U t = 0;
  413.    if (T0IE & T0IF)
  414.    {        
  415.         T0IF=0;
  416.                 t++;
  417.                 if (t==61)
  418.                 {
  419.                 t=0;s++;              

  421.                   if (s==60)
  422.                             {
  423.                                   s=0;m++;
  424.                                     if (m==60)
  425.                                    {m=0;}
  426.                         }
  427.                 }

  429.    }
  430. }
复制代码

所有资料51hei提供下载:
2-8x8led.zip (23.97 KB, 下载次数: 40)


评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励！

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏1 分享淘帖 顶顶 踩踩
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表