标题: STC12C5A60S2单片机和ds1302制作时钟运行一会就飞了,麻烦大佬们看下我哪里有问题 [打印本页]
作者: 小丑only    时间: 2022-5-9 20:54
标题: STC12C5A60S2单片机和ds1302制作时钟运行一会就飞了,麻烦大佬们看下我哪里有问题
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
{}
作者: 人人学会单片机    时间: 2022-5-9 22:33
http://www.51hei.com/bbs/dpj-200968-1.html 单片机+DS1302+DS18B20+74HC595的LED16x32点阵温度万年历源代码
作者: Hephaestus    时间: 2022-5-9 23:07
那么你是怎么判断跑飞了呢？
作者: 小丑only    时间: 2022-5-9 23:12
Hephaestus 发表于 2022-5-9 23:07
那么你是怎么判断跑飞了呢？

下载到实物运行后，有年月日时分秒显示。走秒大约40秒就白屏了。
作者: xiaosan    时间: 2022-5-10 06:41
注意一下变量，看看中断程序和主程序。
作者: yzwzfyz    时间: 2022-5-10 08:58
画出逻辑框图，走通框图，再依框图写程序。
作者: 小丑only    时间: 2022-5-10 09:21
yzwzfyz 发表于 2022-5-10 08:58
画出逻辑框图，走通框图，再依框图写程序。

调试了好多遍了，中断和主程序都附上边了
作者: 小丑only    时间: 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屏
作者: zhxiufan    时间: 2022-5-10 10:16
如果中断里面调用外部程序，就很容易跑飞。
作者: glinfei    时间: 2022-5-10 14:24
是啥都不动，一开机过几十秒就白屏，还是按了键以后才白屏？白屏是全亮那种，还是跟没通电一样的？
程序都是抄的，不该出啥问题啊，
作者: man1234567    时间: 2022-5-10 14:35
断开1302试试，如果问题依旧就与1302无关。
至于是程序跑飞还是器件暗伤，试试看门狗或静态显示就知道了。
作者: 小丑only    时间: 2022-5-10 16:13
man1234567 发表于 2022-5-10 14:35
断开1302试试，如果问题依旧就与1302无关。
至于是程序跑飞还是器件暗伤，试试看门狗或静态显示就知道了。

不是ds1302的问题，断开依旧
作者: 小丑only    时间: 2022-5-10 16:14
glinfei 发表于 2022-5-10 14:24
是啥都不动，一开机过几十秒就白屏，还是按了键以后才白屏？白屏是全亮那种，还是跟没通电一样的？
程序都 ...

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

会不会是写入太频繁？
如果不按键
while(1)只运行GotoDisplay里的DisplayTime
有没有测量过多久运行一次DisplayTime？
液晶屏又接受多快的刷新？
会不会刷的太快把它刷傻了?
作者: 小丑only    时间: 2022-5-10 20:34
lkc8210 发表于 2022-5-10 17:31
会不会是写入太频繁？
如果不按键
while(1)只运行GotoDisplay里的DisplayTime

也考虑过，后来只留时间刷写程序。还是问题依旧。
作者: 小丑only    时间: 2022-5-11 08:06
man1234567 发表于 2022-5-10 14:35
断开1302试试，如果问题依旧就与1302无关。
至于是程序跑飞还是器件暗伤，试试看门狗或静态显示就知道了。

静态显示两天了都很稳定
作者: lkc8210    时间: 2022-5-11 09:31
小丑only 发表于 2022-5-10 20:34
也考虑过，后来只留时间刷写程序。还是问题依旧。

多久刷一次？
作者: 小丑only    时间: 2022-5-11 09:42
lkc8210 发表于 2022-5-11 09:31
多久刷一次？

时间不会测试，但是我把按键扫描屏蔽掉了。
作者: lkc8210    时间: 2022-5-11 11:28
简单粗暴
  1. uint DelayCnt = 0;
  2. void main()
  3. {

  5.         Time0_Init(10);
  6.         Init_LCD1616();
  7.         Clear_Screen(0);
  8.         Write_6x16Font_N(1,0,0,);
  9.         while(1)
  10.         {
  11.                 GetKeyValue();        //读取按键数据
  12.                                 if(DelayCnt++>10000)//按需要调节
  13.                                 {
  14.                                         DelayCnt=0;
  15.                                         GotoDisplay();        //显示时钟芯片的数据                                       
  16.                                 }
  17.         }
  18. }
复制代码
作者: 小丑only    时间: 2022-5-11 19:03
喜大普奔，惊天喜讯。问题解决了！困扰了5天，差点怀疑人生！今天下午借了台示波器，发现单片机工作不稳定。晶振起振不规律。然后检测电压和电流，发现USB供电不足，接了个DC口瞬间屏幕显示正常了。谢谢大家的指导，也学习了一些新思路。特别是uid:161164同学，多次不吝赐教。本次问题到此结束。[em01]
作者: 小丑only    时间: 2022-5-11 19:03
lkc8210 发表于 2022-5-11 11:28
简单粗暴

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



欢迎光临 (http://www.51hei.com/bbs/) Powered by Discuz! X3.1