STC12C5A60S2单片机和ds1302制作时钟运行一会就飞了,麻烦大佬们看下我哪里有问题

ID:447439 · 发表于 2022-5-9 20:54

main函数：
void main()
{

      Time0_Init(10);
      Init_LCD1616();
      Clear_Screen(0);
      Write_6x16Font_N(1,0,0,);
      while(1)
      {
            GetKeyValue();       //读取按键数据
            GotoDisplay();       //显示时钟芯片的数据
      }
}

显示模块函数：
void write(bit flag,uchar dat)
{
      LCD1616_CS=0;
      LCD1616_RS=flag;                                     //flag=1,write command;flag=0,write data
      LCD1616_WR=0;
      LCD1616_RD=1;
      LCDPort=dat;
      LCD1616_WR=1;
}

/**************LCD160160初始化***************************/
void Init_LCD1616()
{

      LCD1616_RST = 0;
      LCD_Delay(10);                      //power on reset
      LCD1616_RST = 1;
      LCD_Delay(800);

write(0,0x25); //设置温度补偿系数-0.05%/C
write(0,0x2b); //内部 DC-DC
write(0,0xc4); // LCD 映像 MY=1，MX=0，LC0=0
write(0,0xa1); //设置行扫描频率 FR=62.5Hz
write(0,0xd1); //彩色数据格式 R-G-B
write(0,0xd5); //设置数据位为 12 位 RRRR-GGGG-BBBB
write(0,0xc8); write(0,0x00); //设置 M 信号为帧翻转
write(0,0xe9); //设置偏压比 1/10
write(0,0xa6); //正性显示
write(0,0xa4); //正常显示
write(0,0x81); write(0,0xef); //设置对比度 bf
write(0,0xd8); //设置扫描模式
write(0,0xad); //开显示
LCD_Delay(50);


}

/****************************清屏or全显************************
Input :Dat;Dat=0,清屏；Dat =1,全显.
1 column = 3 pixel;       1 pixel = 4bit;
UC1698的column：0X00-0X7F-->0-127;line: 0X00-0X9F-->0-159
但是160*160单色液晶的column为第37列到90列-->0X25-0X5A
      行地址范围0-159行-->0X00-0X9F，实际是160*162，160行，54列
由于2 column = 6 pixel =24 bit = 3Byte,所以一行有27组（3Byte）
**************************************************************/
void Clear_Screen(uchar dat1)
{
      uchar i,j;
      write(0,0x60);                      //row address LSB 最低有效位
      write(0,0x70);                      //row address MSB 最高有效位
      write(0,0x05);                      //culomn address LSB 最低有效位
      write(0,0x12);                      //culomn address MSB 最高有效位

      for(j=0;j<160;j++)
      {
            for(i=0;i<27;i++)

            {

                              write(1,dat1);       //见手册中的第21条命令格式  将RGB的每3个字节存到16位寄存器中
                              write(1,dat1);
                              write(1,dat1);
            }

      }
}

/****************写一个宋体小四***16*16*******************
16/3=5---1,补充两，凑齐6列,6列x16行
*******************************************************/
void Write_6x16Font(u8 x,y,u8 *cn)
{
      u8 i=0;
      u8 WordNum=0;       //字符个数
      u8 ZiKuDat,YingSheDat;
      u16 x1,x2,y1,y2,L;
//--设置显示区域
      x+=0X25;             //此款LCD160的列是从第0X25列开始
      write(0,0XF4);       //列起始地址
      write(0,x);             //start: 37
      write(0,0XF6);       //列结束地址
      write(0,x+5);       //end: 90
//因为列开始到结尾共90-37=53个数所以一个数代表160/53=3个像素

      write(0,0XF5);       //行起始地址
      write(0,y);             //start:0
      write(0,0XF7);       // 行结束地址
      write(0,y+15);       //end:159
      write(0,0XF8);
//--设置起始列，行地址
      x1=0X00 |(x&0X0F);
      x2=0X10 |(x>>4);
      y1=0X60 |(y&0X0F);
      y2=0X70 |(y>>4);
      write(0,x1);write(0,x2);
      write(0,y1);write(0,y2);
      write(0,0XA6);

      for(WordNum=0;WordNum<WordNumMax;WordNum++)       //扫描汉字字库
      {
      //--匹配字库数据
            if(*cn == HanZi16X16[WordNum].Index[0] && *(cn+1)==HanZi16X16[WordNum].Index[1])
            {
                     for(i=0;i<16;i++)
                     {
                              ZiKuDat=HanZi16X16[WordNum].Msk[2*i];
                     //--完成8bit字库数据的写
                              for(L=0;L<4;L++)
                              {
                                    switch(ZiKuDat&0XC0)       //判断2bit字库数据
                                    {
                                    //--将2bit字库数据转换成8bit映射数据
                                             case 0X00:YingSheDat=0X00;break;
                                             case 0X40:YingSheDat=0X0F;break;
                                             case 0X80:YingSheDat=0XF0;break;
                                             case 0XC0:YingSheDat=0XFF;break;
                                    }
                                    write(1,YingSheDat);       //写映射数据
                                    ZiKuDat<<=2;
                              }
                              ZiKuDat=HanZi16X16[WordNum].Msk[2*i+1];
                              for(L=0;L<4;L++)
                              {
                                    switch(ZiKuDat&0XC0)       //判断2bit字库数据
                                    {
                                    //--将2bit字库数据转换成8bit映射数据
                                             case 0X00:YingSheDat=0X00;break;
                                             case 0X40:YingSheDat=0X0F;break;
                                             case 0X80:YingSheDat=0XF0;break;
                                             case 0XC0:YingSheDat=0XFF;break;
                                    }
                                    write(1,YingSheDat);       //写映射数据
                                    ZiKuDat<<=2;
                              }
                              write(1,0X00);       //补最后的一字节空白
                     }
            }
      }
}

/*****************写N个小四宋体**********
9列10行,x:0-9;y:0-10;
****************************************/
void Write_6x16Font_N(u8 x,y,z,u8 *cn)
{
      u8 Cnnum=0;
      x=x*3;
      y=y*16;
      if(z)       //竖着写
      {
            while(*cn != '\0')
            {
                     Write_6x16Font(x,y+8*Cnnum,cn);
                     Cnnum++;
                     cn++;
            }
      }
      else       //横着写       //6列16行
      {
            while(*cn != '\0')
            {
                     Write_6x16Font(x+3*Cnnum,y,cn);       //汉字占两个字符
                     Cnnum++;
                     cn++;
            }
      }
}

void Write_ASCII3X16(u8 x,y,u8 *p)
{
      u8 i=0;
      u8 WordNum=0;       //字符个数
      u8 ZiKuDat,YingSheDat;
      u16 x1,x2,y1,y2,L;
//--设置显示区域
      x+=0X25;       //此款LCD160的列是从第0X25列开始
      write(0,0XF4);       //列起始地址
      write(0,x);             //start: 37
      write(0,0XF6);       //列结束地址
      write(0,x+3);       //end: 90       //横着写       //write(0,x+3);       //竖着写
      //因为列开始到结尾共90-37=53个数所以一个数代表160/53=3个像素

      write(0,0XF5);       //行起始地址
      write(0,y);             //start:0
      write(0,0XF7);       // 行结束地址
      write(0,y+15);       //end:159       //write(0,y+15*WordNum);       //竖着写
      write(0,0XF8);
//--设置起始列，行地址
      x1=0X00 |(x&0X0F);
      x2=0X10 |(x>>4);
      y1=0X60 |(y&0X0F);
      y2=0X70 |(y>>4);
      write(0,x1);write(0,x2);
      write(0,y1);write(0,y2);
      write(0,0XA6);

      WordNum = *p-32;
      for(i=0;i<16;i++)
      {
            ZiKuDat=ASCII8X16[WordNum][ i];
      //--完成8bit字库数据的写
            for(L=0;L<4;L++)       //写3(前面2列)+1(补充1列的第一字节)
            {
                     switch(ZiKuDat&0XC0)       //判断2bit字库数据
                     {
                     //--将2bit字库数据转换成8bit映射数据
                              case 0X00:YingSheDat=0X00;break;
                              case 0X40:YingSheDat=0X0F;break;
                              case 0X80:YingSheDat=0XF0;break;
                              case 0XC0:YingSheDat=0XFF;break;
                     }
                     write(1,YingSheDat);       //写映射数据
                     ZiKuDat<<=2;
            }
      //--对补充的1列的最后一字节的写
            write(1,0X00);
            write(1,0X00);
      }
}

/*******************写一串字符串***3*16************
10行x18列
Input: x起始列地址，y起始行地址，*P 字符串,
         z:=0,横着写，=1竖着写
**************************************************/
void Write_ASCII3X16_N(u8 x,y,z,u8 *p)
{
      u8 WordNum=0;
      x=x*3;
      y=y*16;
      if(z)
      {
            while(*p != '\0')
            {
                     Write_ASCII3X16(x,y+16*WordNum,p);
                     WordNum++;
                     p++;
            }
      }
      else
      {
            while(*p != '\0')
            {
                     Write_ASCII3X16(x+3*WordNum,y,p);
                     WordNum++;
                     p++;
            }
      }
}

ds1302时钟函数：

#include "DS1302.h"

u8 DS1302sec=1,DS1302min=1,DS1302hour=8;
u8 DS1302day=26,DS1302month=4,DS1302week,DS1302year=20;

/**********向1302写某一地址和数据（指令）**************/
void Write_Byte_1302(u8 add,u8 dat)
{
      u8 i;
      DS1302SCL = 0;
      DS1302RST = 1;
      add = add & 0xfe;             //将控制指令的最低位清零，数据能够输入
      for(i=0;i<8;i++)
      {
            DS1302SDA = add &0X01;
            DS1302SCL = 1;                      //上升沿输入数据
            DS1302SCL = 0;
            add >>= 1;
      }
      for(i=0;i<8;i++)
      {
            DS1302SDA = dat &0X01;
            DS1302SCL=1;                      //上升沿输入数据
            DS1302SCL=0;
            dat>>=1;
      }

      DS1302RST = 0;                      //写完数据后将rst清零，终止数传输
}

/*************读取1302的数据**********/
u8 Read_Byte_1302(u8 add)
{
      u8 i,dat;
      DS1302SCL = 0;
      DS1302RST = 1;             //开启数据传输
      add = add |0x01;             //将最低位置一，保证数据是输出
      for(i=0;i<8;i++)
      {
            DS1302SDA = add &0X01;
            DS1302SCL=1;
            DS1302SCL=0;
            add >>=1;
      }
      for(i=0;i<8;i++)
      {
            dat >>=1;
            if(DS1302SDA)       dat = dat | 0x80;
            else       dat = dat & 0x7f;
            DS1302SCL=1;
            DS1302SCL=0;
      }
      DS1302RST = 0;                      //终止数据传输
      dat=dat/16*10+dat%16;
      return       dat;
}

void Write_1302()
{
      Write_Byte_1302(0x8e,0x00);             //关闭写保护
      Write_Byte_1302(0x80,0x80);
      Write_Byte_1302(0x80,DS1302sec/10*16+DS1302sec%10);
      Write_Byte_1302(0x82,DS1302min/10*16+DS1302min%10);
      Write_Byte_1302(0x84,DS1302hour/10*16+DS1302hour%10);
      Write_Byte_1302(0x86,DS1302day/10*16+DS1302day%10);
      Write_Byte_1302(0x88,DS1302month/10*16+DS1302month%10);
      Write_Byte_1302(0x8c,DS1302year/10*16+DS1302year%10);
      Write_Byte_1302(0x8e,0x80);             //开启写保护
}

/***********************显示周*********************/
//=====计算2000～2099年任一天星期几
//             year:00-99
//             month:01-12
//             day:01-31
u8       GetWeekFromDay(u8 y,u8 m,u8 d)
{
      u8 value;
      if(m==1||m==2)
      {
            m+=12;
            if(y>0)       y--;
            else y=4;
      }
      value=(d+2*m+3*(m+1)/5+y+y/4)%7;
      return value;
}

void Read_1302()
{
      DS1302sec =Read_Byte_1302(0x80);
      DS1302min =Read_Byte_1302(0x82);
      DS1302hour =Read_Byte_1302(0x84);
      DS1302day =Read_Byte_1302(0x86);
      DS1302month =Read_Byte_1302(0x88);
      DS1302year =Read_Byte_1302(0x8c);

      DS1302week = GetWeekFromDay(DS1302year,DS1302month,DS1302day);
}

按键函数：
#include "KEYBord.h"
#include "DisplayTime.h"

void DelayKey(u16 t)
{
      u16 i,j;
      for(i=0;i<t;i++)
            for(j=0;j<250;j++);
}

u8 Menu=0;             //菜单
u8 Flicker=0;       //闪烁位置

char xdata KeyValue[10]={0};       //按键操作数组

void DealKeyValue(u8 KeyValu)
{
      switch(KeyValu)
      {
            case 0XA5:       //设置
                                    if(Menu==0)
                                    {
                                             //--年
                                             KeyValue[0]=DS1302year/10;
                                             KeyValue[1]=DS1302year%10;
                                             //--月
                                             KeyValue[2]=DS1302month/10;
                                             KeyValue[3]=DS1302month%10;
                                             //--日
                                             KeyValue[4]=DS1302day/10;
                                             KeyValue[5]=DS1302day%10;
                                             //--时
                                             KeyValue[6]=DS1302hour/10;
                                             KeyValue[7]=DS1302hour%10;
                                             //--分
                                             KeyValue[8]=DS1302min/10;
                                             KeyValue[9]=DS1302min%10;
                                             //--秒
                                             KeyValue[10]=0;
                                             KeyValue[11]=0;
                                             Clear_Screen(0);       //清屏
                                             Write_6x16Font_N(5,0,0,"时间设置");

                                             Flicker=1;
                                             Menu=1;
                                    }
                                    else if(Menu==1)       //保存时间
                                    {
                                             DS1302year = KeyValue[0]*10 +KeyValue[1];
                                             DS1302month = KeyValue[2]*10 +KeyValue[3];
                                             DS1302day = KeyValue[4]*10 +KeyValue[5];
                                             DS1302hour =  KeyValue[6]*10 +KeyValue[7];
                                             DS1302min =  KeyValue[8]*10 +KeyValue[9];
                                             DS1302sec =  0;




                                             Clear_Screen(0);       //清屏
                                             Menu=0;
                                    }
                                    break;
            case 0XA6:       //返回
                                    Menu=0;
                                    Flicker=0;

                                    break;
            case 0XA1:       //左
                                    if(Menu==1)
                                    {
                                             Flicker--;
                                             if(Flicker<1)       Flicker=10;
                                    }
                                    break;
            case 0XA2:       //上
                                    if(Menu==1)
                                    {
                                             KeyValue[Flicker-1]++;
                                             if(KeyValue[2]>1)             KeyValue[2]=0;
                                             if((KeyValue[3]>2)&&(KeyValue[2]==1))       KeyValue[3]=0;
                                             if(KeyValue[4]>3)             KeyValue[4]=0;
                                             if((KeyValue[5]>1)&&(KeyValue[4]==3))       KeyValue[5]=0;
                                             if(KeyValue[6]>2)             KeyValue[6]=0;
                                             if(KeyValue[8]>5)             KeyValue[8]=0;
                                             if( KeyValue[Flicker-1]>9)       KeyValue[Flicker-1]=0;
                                    }
                                    break;
            case 0XA3:       //下
                                    if(Menu==1)
                                    {
                                             KeyValue[Flicker-1]--;

                                             if(KeyValue[Flicker-1] <0 )
                                             {
                                                      if(Flicker==3)       KeyValue[2]=1;
                                                      else if((Flicker==4) &&(KeyValue[2] == 1) )KeyValue[3]=2;
                                                      else if( Flicker==5) KeyValue[4] =3;
                                                      else if( Flicker==7) KeyValue[6] =2;
                                                      else if( Flicker==9) KeyValue[8] =5;
                                                      else       KeyValue[Flicker-1]       =9;
                                             }
                                    }
                                    break;
            case 0XA4:       //右
                                    if(Menu==1)
                                    {
                                             Flicker++;
                                             if(Flicker>10)       Flicker=1;
                                    }
                                    break;
            default :break;

      }
}

void GetKeyValue()
{
      u8 KeyValue=0;
      static bit Keyclok=0;
      if(!K1)
      {
            if(Keyclok==0)
            {
                     DelayKey(10);
                     if(!K1)
                     {
                              KeyValue = 0XA1;
                              Keyclok = 1;
                     }
            }
      }
      else if(!K2)
      {
            if(Keyclok==0)
            {
                     DelayKey(10);
                     if(!K2)
                     {
                              KeyValue = 0XA2;
                              Keyclok = 1;
                     }
            }
      }
      else if(!K3)
      {
            if(Keyclok==0)
            {
                     DelayKey(10);
                     if(!K3)
                     {
                              KeyValue = 0XA3;
                              Keyclok = 1;
                     }
            }
      }
      else if(!K4)
      {
            if(Keyclok==0)
            {
                     DelayKey(10);
                     if(!K4)
                     {
                              KeyValue = 0XA4;
                              Keyclok = 1;
                     }
            }
      }
      else if(!K5)
      {
            if(Keyclok==0)
            {
                     DelayKey(10);
                     if(!K5)
                     {
                              KeyValue = 0XA5;
                              Keyclok = 1;
                     }
            }
      }
      else if(!K6)
      {
            if(Keyclok==0)
            {
                     DelayKey(10);
                     if(!K6)
                     {
                              KeyValue = 0XA6;
                              Keyclok = 1;
                     }
            }
      }
      else
      {
            Keyclok=0;
            KeyValue=0;
      }
      DealKeyValue(KeyValue);
}

void GotoDisplay()
{
      switch(Menu)
      {
            case 0:
                              DisplayTime();
                              break;
            case 1:
                              DisplayState1();
                              break;
            case 2:
                              break;
            case 3:
                              break;
            case 4:
                              break;
            case 5:
                              break;
            default:break;
      }
}

显示函数：
#include "DisplayTime.h"
#include "stdio.h"
#include "string.h"
#include "KEYBord.h"

u8 xdata DS1302YMD[]="2020-04-26";
u8 xdata DS1302HMS[]="07:50:30";
u8 xdata WeekD[]="星期一";

u8 xdata DisplayYMD[]="2020-05-01";
u8 xdata DisplayHMS[]="18:00:00";
u8 xdata DisplayWeek[]="星期五";

void GetWeekDat()
{
      u8 WEEK;
      WEEK = DS1302week;
      switch(WEEK)
      {
            case 0:
                              strcpy (WeekD,"星期一");
                              break;
            case 1:
                              strcpy (WeekD,"星期二");
                              break;
            case 2:
                              strcpy (WeekD,"星期三");
                              break;
            case 3:
                              strcpy (WeekD,"星期四");
                              break;
            case 4:
                              strcpy (WeekD,"星期五");
                              break;
            case 5:
                              strcpy (WeekD,"星期六");
                              break;
            case 6:
                              strcpy (WeekD,"星期日");
                              break;
      }

}

void DisplayTime()
{
      Write_6x16Font_N(1,0,0,"实时时钟精度测试");
//---显示DS1302的时间
      Read_1302();
      DS1302YMD[2] = DS1302year/10 +0X30;
      DS1302YMD[3] = DS1302year%10 +0X30;

      DS1302YMD[5] = DS1302month/10 +0X30;
      DS1302YMD[6] = DS1302month%10 +0X30;

      DS1302YMD[8] = DS1302day/10 +0X30;
      DS1302YMD[9] = DS1302day%10 +0X30;

      DS1302HMS[0] = DS1302hour/10 +0X30;
      DS1302HMS[1] = DS1302hour%10 +0X30;

      DS1302HMS[3] = DS1302min/10 +0X30;
      DS1302HMS[4] = DS1302min%10 +0X30;

      DS1302HMS[6] = DS1302sec/10 +0X30;
      DS1302HMS[7] = DS1302sec%10 +0X30;

      GetWeekDat();
      Write_ASCII3X16_N(0,1,0,"T1:DS1302");
      Write_ASCII3X16_N(0,2,0,DS1302YMD);
      Write_ASCII3X16_N(2,3,0,DS1302HMS);
      Write_6x16Font_N(12,3,0,WeekD);

}

//----设置时间------
void DisplayState1()
{
      DisplayYMD[2] = KeyValue[0] +0X30;
      DisplayYMD[3] = KeyValue[1] +0X30;

      DisplayYMD[5] = KeyValue[2] +0X30;
      DisplayYMD[6] = KeyValue[3] +0X30;

      DisplayYMD[8] = KeyValue[4] +0X30;
      DisplayYMD[9] = KeyValue[5] +0X30;

      DisplayHMS[0] = KeyValue[6] +0X30;
      DisplayHMS[1] = KeyValue[7] +0X30;

      DisplayHMS[3] = KeyValue[8] +0X30;
      DisplayHMS[4] = KeyValue[9] +0X30;

      if(Flicker<3)
      {
            if(TimeRun<2)       DisplayYMD[Flicker+1] = 32;       //空格
            else                      DisplayYMD[Flicker+1] = KeyValue[Flicker-1] +0X30;
      }
      else if(Flicker<5)
      {
            if(TimeRun<2)       DisplayYMD[Flicker+2] = 32;       //空格
            else                      DisplayYMD[Flicker+2] = KeyValue[Flicker-1] +0X30;
      }
      else if(Flicker<7)
      {
            if(TimeRun<2)       DisplayYMD[Flicker+3] = 32;       //空格
            else                      DisplayYMD[Flicker+3] = KeyValue[Flicker-1] +0X30;
      }
      else if(Flicker<9)
      {
            if(TimeRun<2)       DisplayHMS[Flicker-7] = 32;       //空格
            else                      DisplayHMS[Flicker-7] = KeyValue[Flicker-1] +0X30;
      }
      else if(Flicker<11)
      {
            if(TimeRun<2)       DisplayHMS[Flicker-6] = 32;       //空格
            else                      DisplayHMS[Flicker-6] = KeyValue[Flicker-1] +0X30;
      }
      Write_ASCII3X16_N(0,2,0,DisplayYMD);
      Write_ASCII3X16_N(2,3,0,DisplayHMS);

}

中断函数：
#include "STC12_INT.H"
u16 T0_xMS;       //定时器T0的初值变量，现定义10ms 的初值,注意要与FOSC统一单位标准

//u8 RS485LEDTimeMax=10;

/***********定时器0初始化******************
T0XMS : 一个溢出周期的时间,单位 ms
                     1T 时 <=5ms;12T 时 <=71ms
      方式1 16位
*******************************************/
void Time0_Init(u8 T0XMS)
{
      TMOD |= 0x01;             //设置定时器模式1       16位非自动重装
//=====装载初值
#ifdef T0_1T       //1T模式
      T0_xMS =(65536-T0XMS*FOSC/1000);       //FOSC的定义在 STC8.H中
#else                      //12T模式
      T0_xMS =(65536-T0XMS*FOSC/12/1000);
#endif
      TL0 = T0_xMS;
      TH0 = T0_xMS >> 8;
      TR0 = 1;
      ET0 = 1;       //开启T0中断
      EA  = 1;
}

/***********定时器1初始化******************
T0XMS : 一个溢出周期的时间,单位 ms
                     1T 时 <=5ms;12T 时 <=71ms
      方式1 16位
//*******************************************/
/*void Time0_Init(u8 T1XMS)
{
      u16 T1_xMS;       //定时器T0的初值变量，现定义10ms 的初值,注意要与FOSC统一单位标准
      TMOD |= 0x10;             //设置定时器模式1       16位非自动重装
////=====装载初值
#ifdef T1_1T       //1T模式
      T1_xMS =(65536-T1XMS*FOSC/1000);       //FOSC的定义在 STC8.H中
#else                      //12T模式
      T1_xMS =(65536-T1XMS*FOSC/12/1000);
#endif

      TL1 = T1_xMS;
      TH1 = T1_xMS >> 8;
      TR1 = 1;
      //ET1 = 1;       //开启T1中断
      EA  = 1;
}
*/
/*********************外部中断0程序***************************/
void Int0_Isr() interrupt 0
{}

u8 Timeaa=0;
u8 TimeRun=0;
/*********************定时器0中断程序*************************/
void Time0() interrupt 1
{
      TL0 = T0_xMS;
      TH0 = T0_xMS >> 8;
      Timeaa++;
      if(Timeaa>10)
      {
            Timeaa=0;
            TimeRun++;
            if(TimeRun>5)TimeRun=0;
      }
}

/*********************外部中断1程序***************************/
void Int1_Isr() interrupt 2
{}
/*********************定时器1中断程序*************************/
void Time1() interrupt 3
{
}
/***************UART1中断程序*********************
      与定时器1配合，组成一个能接收一串数据的串口，
并能计算出接收到的数据的个数。
*************************************************/
void UART1() interrupt 4
{
}

/********************ADC中断程序*****************************/
void ADC_Isr() interrupt 5
{
}

/********************LVD中断程序****************************/
void LVD_Isr() interrupt 6
{}

/********************PCA中断程序****************************/
void PCA_Isr() interrupt 7
{}

/*********************** UART2 中断程序*********************/
void Uart2() interrupt 8
{}

/**********************SPI中断程序*************************/
void SPI_Isr() interrupt 9
{}

ID:390416 · 发表于 2022-5-9 22:33

http://www.51hei.com/bbs/dpj-200968-1.html 单片机+DS1302+DS18B20+74HC595的LED16x32点阵温度万年历源代码

ID:883242 · 发表于 2022-5-9 23:07

那么你是怎么判断跑飞了呢？

ID:447439 · 发表于 2022-5-9 23:12

Hephaestus 发表于 2022-5-9 23:07
那么你是怎么判断跑飞了呢？

下载到实物运行后，有年月日时分秒显示。走秒大约40秒就白屏了。

ID:1025260 · 发表于 2022-5-10 06:41

注意一下变量，看看中断程序和主程序。

ID:123289 · 发表于 2022-5-10 08:58

画出逻辑框图，走通框图，再依框图写程序。

ID:447439 · 发表于 2022-5-10 09:21

yzwzfyz 发表于 2022-5-10 08:58
画出逻辑框图，走通框图，再依框图写程序。

调试了好多遍了，中断和主程序都附上边了

ID:447439 · 发表于 2022-5-10 09:24

人人学会单片机发表于 2022-5-9 22:33
http://www.51hei.com/bbs/dpj-200968-1.html 单片机+DS1302+DS18B20+74HC595的LED16x32点阵温度万年历源代 ...

我这是UC1698的160屏

ID:121859 · 发表于 2022-5-10 10:16

如果中断里面调用外部程序，就很容易跑飞。

ID:844772 · 发表于 2022-5-10 14:24

是啥都不动，一开机过几十秒就白屏，还是按了键以后才白屏？白屏是全亮那种，还是跟没通电一样的？
程序都是抄的，不该出啥问题啊，

ID:584814 · 发表于 2022-5-10 14:35

断开1302试试，如果问题依旧就与1302无关。
至于是程序跑飞还是器件暗伤，试试看门狗或静态显示就知道了。

ID:447439 · 发表于 2022-5-10 16:13

man1234567 发表于 2022-5-10 14:35
断开1302试试，如果问题依旧就与1302无关。
至于是程序跑飞还是器件暗伤，试试看门狗或静态显示就知道了。

不是ds1302的问题，断开依旧

ID:447439 · 发表于 2022-5-10 16:14

glinfei 发表于 2022-5-10 14:24
是啥都不动，一开机过几十秒就白屏，还是按了键以后才白屏？白屏是全亮那种，还是跟没通电一样的？
程序都 ...

啥都不动也白屏，液晶屏厂家程序就正常

ID:161164 · 发表于 2022-5-10 17:31

小丑only 发表于 2022-5-10 16:14
啥都不动也白屏，液晶屏厂家程序就正常

会不会是写入太频繁？
如果不按键
while(1)只运行GotoDisplay里的DisplayTime
有没有测量过多久运行一次DisplayTime？
液晶屏又接受多快的刷新？
会不会刷的太快把它刷傻了?

ID:447439 · 发表于 2022-5-10 20:34

lkc8210 发表于 2022-5-10 17:31
会不会是写入太频繁？
如果不按键
while(1)只运行GotoDisplay里的DisplayTime

也考虑过，后来只留时间刷写程序。还是问题依旧。

ID:447439 · 发表于 2022-5-11 08:06

man1234567 发表于 2022-5-10 14:35
断开1302试试，如果问题依旧就与1302无关。
至于是程序跑飞还是器件暗伤，试试看门狗或静态显示就知道了。

静态显示两天了都很稳定

ID:161164 · 发表于 2022-5-11 09:31

小丑only 发表于 2022-5-10 20:34
也考虑过，后来只留时间刷写程序。还是问题依旧。

多久刷一次？

ID:447439 · 发表于 2022-5-11 09:42

lkc8210 发表于 2022-5-11 09:31
多久刷一次？

时间不会测试，但是我把按键扫描屏蔽掉了。

ID:161164 · 发表于 2022-5-11 11:28

简单粗暴

uint DelayCnt = 0;
void main()
{
Time0_Init(10);
Init_LCD1616();
Clear_Screen(0);
Write_6x16Font_N(1,0,0,);
while(1)
{
GetKeyValue(); //读取按键数据
if(DelayCnt++>10000)//按需要调节
{
DelayCnt=0;
GotoDisplay(); //显示时钟芯片的数据
}
}
}

复制代码

ID:447439 · 发表于 2022-5-11 19:03

喜大普奔，惊天喜讯。问题解决了！困扰了5天，差点怀疑人生！今天下午借了台示波器，发现单片机工作不稳定。晶振起振不规律。然后检测电压和电流，发现USB供电不足，接了个DC口瞬间屏幕显示正常了。谢谢大家的指导，也学习了一些新思路。特别是uid:161164同学，多次不吝赐教。本次问题到此结束。

[em01]

ID:447439 · 发表于 2022-5-11 19:03

lkc8210 发表于 2022-5-11 11:28
简单粗暴

谢谢亲了，多次不吝赐教。隆重感谢。问题解决了。

帐号		自动登录	找回密码
密码			立即注册


5 黑币	回复本帖可获得 5 黑币奖励! 每人限 1 次