单片机四位共阳数码管时钟问题,求大神帮忙 -

标题: 单片机四位共阳数码管时钟问题,求大神帮忙 [打印本页]

作者: zsf333666 时间: 2019-4-29 16:24
标题: 单片机四位共阳数码管时钟问题,求大神帮忙
最近一直在寻找四位共阳数码管时钟（DS1302+DS18B20+闹钟）能自动切换时间温度的那种！！但往往事不随人意！找了好多源码！！不是无法编译就是程序问题太严重，或者有时间没温度。前段时间在网上找到一个合乎要求的源码，但是仿真不出效果？？时间、温度也不显示？设置也有问题？

在此求大神们帮忙修改下！！或者看看我哪里做错了！
全部资料51hei下载地址：

4bit_clock_v11.rar (92.79 KB, 下载次数: 12)
不想下的看这里
/******************************************************************************************
//四位数码管电子钟
//应用程序 C
//neo
//V1.1 2011-7-16
//MCS-51 12MHZ C语言
//接口说明：　　DS1302、DS18B20
*********************************************************************************************/
#include <reg52.h>
#include <intrins.h>

#define uint8 unsigned char
#define uchar unsigned char
#define uint  unsigned int
uchar Disp_Buff[4];

char SB=4;  // clock set time bit
//bit Set_Flag;  // set time flag
bit T=0;  // display Temperature and Time flag
bit TT=0; // 10S Auto change display Temperature and Time flag

//#define T0_H  0xf0          // 4ms
//#define T0_L  0x60
#define T0_H  0xf5          // 2666us
#define T0_L  0x96
#define ST 20
#define T1_H  0xb1          //20ms
#define T1_L  0xe0
#define NumLed_Bit P2
#define Disp    P1
#define Key       P3
#define Key1 1
#define Key2 2
#define Key3 3
#define Key4 4
#define Key_NULL 0
sbit Beep=P0^7;
sbit Red_Led=P3^7;
sbit RST=P0^0;
sbit IO=P0^1;
sbit SCLK=P0^2;
sbit io_DQ=P0^6;

void Play(uchar t);

// Driver DS1302
/********************************************************************************************/

#define second_write 0x80
#define minute_write 0x82
#define hour_write 0x84
#define week_write 0x8a
#define day_write 0x86
#define month_write  0x88
#define year_write 0x8c
#define second_read 0x81
#define minute_read 0x83
#define hour_read 0x85
#define week_read 0x8b
#define day_read 0x87
#define month_read  0x89
#define year_read 0x8d
#define sclk_high SCLK=1;
#define sclk_low    SCLK=0;
#define io_high    IO=1;
#define io_low    IO=0;
#define io_read    IO
#define rst_high    RST=1;
#define rst_low    RST=0;
struct {uint8 second;
      uint8 minute;
         uint8 hour;
         uint8 day;
         uint8 week;
            uint8 month;
            uint8 year; } current_time;

/********************************************************************************************/

static void ds1302write(uint8 content)
{
uint8 i;
for(i=8;i>0;i--) { if(content&0x01) io_high
                     else io_low
                  content>>=1; sclk_high  sclk_low
                                    }
}

/********************************************************************************************/

static uint8 ds1302read(void)
{
uint8 i,readvalue;
io_high
for(i=8;i>0;i--) {       readvalue>>=1; if(io_read) readvalue|=0x80;
                                    else    readvalue&=0x7f;
                                    sclk_high  sclk_low  }
return readvalue;
}

/********************************************************************************************/

void ds1302write_byte (uint8 address,uint8 content)
{
rst_low  sclk_low  rst_high  ds1302write(address);
ds1302write(content); rst_low  sclk_high
}

uint8 ds1302read_byte(uint8 address)
{
uint8 readvalue;
rst_low  sclk_low  rst_high
ds1302write(address);
readvalue=ds1302read();
rst_low  sclk_high
return readvalue;
}

/********************************************************************************************/

void Clock_Init(void)
{
uchar R;
if(ds1302read_byte(0xc1)!=0xf0) {
                              ds1302write_byte(0x8e,0x00);
                                                            ds1302write_byte(year_write,0x11);
                                                            ds1302write_byte(week_write,0x06);
                                                            ds1302write_byte(month_write,0x04);
                                                            ds1302write_byte(day_write,0x09);
                                                            ds1302write_byte(hour_write,0x23);
                                                            ds1302write_byte(minute_write,0x59);
                                                            ds1302write_byte(second_write,0x30);

                              ds1302write_byte(0x90,0xa5);
                              ds1302write_byte(0xc0,0xf0);
                              for (R=0;R<10;R+=2)
                                                                           {
                                                                                 ds1302write_byte(0xc2+R,0);
                                                                        }
                                                               ds1302write_byte(0x8e,0x80);
                                                            }
}

/********************************************************************************************/

void Clock_Updata(void)
{
current_time.second=ds1302read_byte(second_read);
current_time.minute=ds1302read_byte(minute_read);
current_time.hour=  ds1302read_byte(hour_read);
current_time.day= ds1302read_byte(day_read);
current_time.month= ds1302read_byte(month_read);
current_time.week=  ds1302read_byte(week_read);
current_time.year=  ds1302read_byte(year_read);
}

/********************************************************************************************/

void Write_Time(void)
{
  ds1302write_byte(0x8e,0x00);
  ds1302write_byte(0x82,((Disp_Buff[2]<<4)|Disp_Buff[3]));
  ds1302write_byte(0x84,((Disp_Buff[0]<<4)|Disp_Buff[1]));
  ds1302write_byte(0x8e,0x80);
  }

/********************************************************************************************/

void Write_Alarm(void)
{
  ds1302write_byte(0x8e,0x00);
  ds1302write_byte(0xca,((Disp_Buff[2]<<4)|Disp_Buff[3])); // alarm minute
  ds1302write_byte(0xc8,((Disp_Buff[0]<<4)|Disp_Buff[1])); // alarm hour
  ds1302write_byte(0xc6,1);
  ds1302write_byte(0x8e,0x80);
}

/********************************************************************************************/

void Alarm(void)
{
if(ds1302read_byte(0xc7)==1&&
current_time.minute==ds1302read_byte(0xcb)&&
      current_time.hour==ds1302read_byte(0xc9)  )
                                                {
                                                ds1302write_byte(0x8e,0x00);
                                                ds1302write_byte(0xc6,0);
                                                ds1302write_byte(0x8e,0x80);
                                                Play(3);
                                                }
}

/********************************************************************************************/

// DS18B20 driver

#define DQ_HIGH io_DQ=1;
#define DQ_LOW  io_DQ=0;
#define DQ_READ io_DQ
unsigned char Temperature[4];

void Delay_10Us (unsigned int Count)
{
  while(--Count)
            {
                           _nop_();
                        }
}

/********************************************************************************************/
unsigned char Ds18b20_Init(void)
  {
unsigned char Flag;

      DQ_HIGH Delay_10Us(3);
DQ_LOW  Delay_10Us(80);
DQ_HIGH Delay_10Us(15);

      Flag=DQ_READ;
return Flag;
      }
/********************************************************************************************/
void Write_f(unsigned char cmd)
{
unsigned char i;

      for(i=8;i>0;i--) {
                        EA=0;
                                       DQ_LOW
                     DQ_READ=cmd&0x01;
                     Delay_10Us(5);
                     DQ_HIGH
                     EA=1;
                                       cmd>>=1;
                                       }

      }
/********************************************************************************************/
unsigned char Read_f(void)
{
      unsigned char Read_Value,i;

      for (i=8;i>0;i--) {
                           EA=0;
                                             DQ_LOW
                     Read_Value>>=1;
                     DQ_HIGH
                     if (DQ_READ==1) Read_Value|=0x80;
                     EA=1;
                                             Delay_10Us(3);
                                             }

  return Read_Value;
}
/********************************************************************************************/
unsigned int Read_Temp(void)
   {
         unsigned char Temp_H, Temp_L;
      unsigned int  Return_Temp;
      EA=0;                               // close interrupt;
               Ds18b20_Init();
      Write_f(0xcc);
      Write_f(0x44);
      Ds18b20_Init();
      Write_f(0xcc);
      Write_f(0xbe);
      Temp_L=Read_f();
      Temp_H=Read_f();
      EA=1;
               Return_Temp=Temp_H;
      Return_Temp<<=8;
      Return_Temp|=Temp_L;
      return Return_Temp;
      }
/********************************************************************************************/
void Temperature_Update(void)
{
   unsigned char T_flag=0;
   unsigned int  Temp_Dat;
   float       Temp;
   Temp_Dat=Read_Temp();
   if(Temp_Dat&0xf000) {T_flag=1; Temp_Dat=~Temp_Dat+1; }
   Temp=Temp_Dat*0.0625;
   Temp_Dat=Temp*10;
   Temperature[0]=T_flag;
   Temperature[1]=Temp_Dat/100;
   Temperature[2]=Temp_Dat%100/10;
   Temperature[3]=Temp_Dat%10;

      }

/********************************************************************************************/
void Timer0_Init(void)
{
TMOD|=0x01;
TH0=T0_H;
TL0=T0_L;
EA=1;
ET0=1;
TR0=1;
}

/********************************************************************************************/
bit T_10S,T_1S;
bit S;                      // shining flag
bit pp=1;    // open or close :
unsigned int ms1,ms2,ms3;
uchar Bit;// Number Led select

uchar code Disp_NumCode[]={0xc0,0xf9,0xa4,0xb0,
                        0x99,0x92,0x82,0xf8,
                                                0x80,0x90,       // dp-a       P07-P00  0-9,
                                                0xa7,                //c       10
                                                0xc8,0x86,0xc0, //NEO  11-13
                                                0x92,0xc6,0x88, // S,C,A 14-16
                                                0xa1,0x8c,0x8e, // d,p,F 17-19
                                                0xff,                //  " "  20
                                                0xc7,0xf7          // L  21  _ 22
                                                };

/********************************************************************************************/
uchar code Open_Logo[]={11,12,13,20};
uchar code S_C[]={14,22,15,20};
uchar code S_A[]={14,22,16,20};
uchar code d_p[]={17,22,18,20};
uchar code BELL[]={17,12,21,21};
uchar code ON[]= {20,13,11,20};
uchar code OFF[]={20,13,19,19};

void Put_In(uchar *P)
{
uchar a;
for (a=0;a<4;a++)
         {
               Disp_Buff[a]=P[a];
         }
}
/********************************************************************************************/
void Timer0_Isr(void) interrupt 1
{
TH0=T0_H;                //4ms
TL0=T0_L;

Disp=0xff;

               switch(Bit) {
                     case 0 :NumLed_Bit=0xfe; break;
                                 case 1 :       NumLed_Bit=0xfd; break;
                                 case 2 :       NumLed_Bit=0xfb; break;
                                 case 3 :       NumLed_Bit=0xf7; break;
                                 case 4 :NumLed_Bit=0xf3; break; // display :
                                 default : break;
                              }


         switch(Bit) {
                  case 0 :  {
                                                if(SB==0)
                                                            {
                                                            if (S)    NumLed_Bit=0xfe;
                                                                                 if(S==0) NumLed_Bit=0xff;
                                                                                 }
                                                                  else NumLed_Bit=0xfe;
                                                      }break;

                                 case 1 :  {
                                             if(SB==1)
                                                      {
                                                            if (S)    NumLed_Bit=0xfd;
                                                                                 if(S==0) NumLed_Bit=0xff;
                                                                                 }
                                                                  else NumLed_Bit=0xfd;
                                                      }break;

                                 case 2 :  {
                                                if(SB==2)
                                                      {
                                                            if (S)    NumLed_Bit=0xfb;
                                                                                 if(S==0) NumLed_Bit=0xff;
                                                                                 }
                                                                  else NumLed_Bit=0xfb;
                                                      } break;

                              case 3 : {
                                          if(SB==3)
                                                      {
                                                            if (S)    NumLed_Bit=0xf7;
                                                                                 if(S==0) NumLed_Bit=0xff;
                                                                                 }
                                                      else NumLed_Bit=0xf7;
                                                      } break;

                                 case 4 : {
                                                   if(T==0||TT==0)  NumLed_Bit=0xf3;  // display :
                                                               if( T || TT )       NumLed_Bit=0xfb;       // display  .
                                                               } break;
                                 default : break;
                  }

if(Bit<4) {

                  Disp=Disp_NumCode[Disp_Buff[Bit]];
                  }
      else
            {
               if(pp==1)
               {
               if (T==0||TT==0)
                                 {
                                          if(current_time.second%2) Disp=0x7f;
                           else                   Disp=0xff;
                                             }
                        if( T || TT )       Disp=0x7f;
                        }
                        else Disp=0xff;          // close :
                  }

if(++Bit>4) Bit=0;

}
/********************************************************************************************/

void Timer1_Init(void)
{
TMOD|=0x10;
TH1=T1_H;  //20ms
TL1=T1_L;
EA=1;
ET1=1;
TR1=1;
}

/********************************************************************************************/

uchar Key_Time;
void Timer1_Isr(void) interrupt 3
{
TH1=T1_H;
TL1=T1_L;
if(Key!=0xff) Key_Time++;
if(++ms1>ST)  { ms1=0;  S=~S; } //when set time Shining       bit
if(++ms2>=50) { ms2=0;  T_1S=1; }
if(++ms3>500) { ms3=0;  T_10S=1;}
}

/********************************************************************************************/

void DelayM(unsigned int a){//-延时函数 1MS/次
      unsigned char i;
      while(a--)
      {
            for(i = 0; i < 125; i++)
                              {}
            }                                     //i 从0加到125，CPU大概就耗时1毫秒
}
/********************************************************************************************/
void Play(uchar t)
{
  uchar i;
  switch(t) {
         case 1:
                              {
                  Beep=0;
                                    DelayM(100);
               } break;
                        case 2:
                                 {
                                       Beep=0;
                                    DelayM(400);
                                       Beep=1;
                                 DelayM(500);
                                    Beep=0;
                                    DelayM(100);
                                 } break;
                     case 3:
                                 {
                                       for(i=0;i<20;i++)
                                    {
                                    Beep=0;
                                    DelayM(100);
                                       Beep=1;
                                    DelayM(100);
                                    Beep=0;
                                    DelayM(100);
                                    Beep=1;
                                 DelayM(500);
                                    }
                                 } break;
                     default : break;
                     }
Beep=1;
}
/********************************************************************************************/
uchar Key_Scan(void)
{
static bit Key_Down;
static uchar K;
uchar K_Value=0;
if(Key_Time>250) Key_Time=3;
if(Key_Time>=3&&Key_Down==0)
               {
               Key_Time=0;
                              Key_Down=1;
                              switch(Key)
                                 {
                                       case  0xfe       : K=1; break;
                                 case  0xfd       : K=2; break;
                                       case  0xfb       : K=3; break;
                                       case  0xf7       : K=4; break;
                                       default : K=0; break;
                                       }
                              }

if(Key==0xff&&Key_Down==1)
               {
                                    Key_Down=0;
                                    K_Value=K;
                                       Play(1);
                                    }
return K_Value;
}
/********************************************************************************************/
void Disp_Time(void)
{
Disp_Buff[3]=current_time.minute%16;
Disp_Buff[2]=current_time.minute/16;
Disp_Buff[1]=current_time.hour%16;
Disp_Buff[0]=current_time.hour/16;
}
/********************************************************************************************/
void Disp_Temperature_3bit(void)
{
Disp_Buff[3]=20;
Disp_Buff[2]=10; // display 'c'
Disp_Buff[1]=Temperature[2];
Disp_Buff[0]=Temperature[1];
}

/********************************************************************************************
void Disp_Temperature_4bit(void)
{
Disp_Buff[3]=Temperature[3];
Disp_Buff[2]=10; // display c
Disp_Buff[1]=Temperature[2];
Disp_Buff[0]=Temperature[1];
}
********************************************************************************************/

uchar Select_M=4;
void MENU (void)
{
uchar K;
char Menu=0;
pp=0; // close ':'
while(Menu!=4)
               {
                              K=Key_Scan();
                              switch (Menu)
                  {
                                       case 0 : { Put_In(S_C); }       break;
                                          case 1 : { Put_In(S_A); }       break;
                                       case 2 : { Put_In(d_p); }       break;
                                       case 3 : { Put_In(BELL);}
                                       default : break;
                                       }

                                       if(K==Key3) Menu=4;
                                       if(K==Key2) Menu=(Menu+1)%4;
                                       if(K==Key1) {
                                                   Select_M=Menu; Menu=4;
                                                   }
                                    }
  pp=1;
}
/********************************************************************************************/
void Set_Time(void)
{
bit Set_Flag=1;  // set time flag
uchar K;
SB=0;
Disp_Time();
T=0;
TT=0;
while(Set_Flag)
            {


                        K=Key_Scan();
                              if(K==Key1)
                                                                     {
                                                                     switch(SB)
                                                            {
                                                                  case 0 :       {
                                                                              if(Disp_Buff[1]>3)
                                                                                                                        Disp_Buff[0]=(Disp_Buff[0]+1)%2;
                                                                                 else
                                                                                                                        Disp_Buff[0]=(Disp_Buff[0]+1)%3;
                                                                                                                     } break;
                                                                  case 1 :       {
                                                                                             if(Disp_Buff[0]==2)
                                                                                                                        Disp_Buff[1]=(Disp_Buff[1]+1)%4;
                                                                                                                              else
                                                                                                                              Disp_Buff[1]=(Disp_Buff[1]+1)%10;
                                                                                                                     }  break;
                                                                  case 2 :       {
                                                                                             Disp_Buff[2]=(Disp_Buff[2]+1)%6;
                                                                              }  break;
                                                                  case 3 : {
                                                                                             Disp_Buff[3]=(Disp_Buff[3]+1)%10;
                                                                              }  break;
                                                                     default : break;
                                                                  }
                                                                        }
                              if(K==Key2) { SB=  (SB+1)%4; }
                        if(K==Key3)       { Set_Flag=0; SB=4; }
                              if(K==Key4) {
                                          Set_Flag=0; SB=4; Write_Time(); T_10S=0;
                                                      }
            }

}
/********************************************************************************************/
void Write_Ds1302Ram(uchar address,uchar dat)
{
  ds1302write_byte(0x8e,0x00);
  ds1302write_byte(address,dat);
  ds1302write_byte(0x8e,0x80);
}

/********************************************************************************************/
uchar dp; // display modle select bit
void Set_Dp(void)
{
bit dp_Set=1;
uchar K;
pp=0;                      // close ':'
//dp=ds1302read_byte(0xc3);
while(dp_Set)
{
  K=Key_Scan();
  switch(dp)
               {
               case 1 : Put_In(ON);  break;
               case 0 : Put_In(OFF); break;
               default : break;
               }
  if(K==Key3) dp_Set=0;
  if(K==Key2) dp=(dp+1)%2;
  if(K==Key1) { dp_Set=0;  Write_Ds1302Ram(0xc2,dp);  T=0;  TT=0; T_10S=0; }
}
pp=1;
}

/********************************************************************************************/
uchar Bell_State;
void Set_Bell(void)
{
bit Bell_Set=1;
uchar K;
pp=0;
//Bell_State=ds1302read_byte(0xc5);
while(Bell_Set)
{
  K=Key_Scan();
  switch(Bell_State)
               {
               case 1 : Put_In(ON);  break;
               case 0 : Put_In(OFF); break;
               default : break;
               }
  if(K==Key3) Bell_Set=0;
  if(K==Key2) Bell_State=(Bell_State+1)%2;
  if(K==Key1) {
            Write_Ds1302Ram(0xc4,Bell_State); Bell_Set=0; T=0; TT=0; T_10S=0;
                        }
}
pp=1;
}

/********************************************************************************************/

void Set_Alarm(void)
{
static bit First_Alarm_Set=0;
bit Set_Flag=1;  // set time flag
uchar K;
SB=0;
T=0;
TT=0;

if(First_Alarm_Set)
{
  Disp_Buff[0]=ds1302read_byte(0xc9)/16;          //alarm hour
  Disp_Buff[1]=ds1302read_byte(0xc9)%16;
  Disp_Buff[2]=ds1302read_byte(0xcb)/16;          //alarm minute
  Disp_Buff[3]=ds1302read_byte(0xcb)%16;
  }
  else       Disp_Time();
while(Set_Flag)
            {


                        K=Key_Scan();
                              if(K==Key1)
                                                                     {
                                                                     switch(SB)
                                                            {
                                                                  case 0 :       {
                                                                              if(Disp_Buff[1]>3)
                                                                                                                        Disp_Buff[0]=(Disp_Buff[0]+1)%2;
                                                                                 else
                                                                                                                        Disp_Buff[0]=(Disp_Buff[0]+1)%3;
                                                                                                                     } break;
                                                                  case 1 :       {
                                                                                             if(Disp_Buff[0]==2)
                                                                                                                        Disp_Buff[1]=(Disp_Buff[1]+1)%4;
                                                                                                                              else
                                                                                                                              Disp_Buff[1]=(Disp_Buff[1]+1)%10;
                                                                                                                     }  break;
                                                                  case 2 :       {
                                                                                             Disp_Buff[2]=(Disp_Buff[2]+1)%6;
                                                                              }  break;
                                                                  case 3 : {
                                                                                             Disp_Buff[3]=(Disp_Buff[3]+1)%10;
                                                                              }  break;
                                                                     default : break;
                                                                  }
                                                                        }
                              if(K==Key2) { SB=  (SB+1)%4; }
                        if(K==Key3)       { Set_Flag=0; SB=4; }
                              if(K==Key4) {
                                                      Set_Flag=0; SB=4;
                                                      First_Alarm_Set=1;
                                                      Write_Alarm(); T_10S=0;
                                                      }
            }

}
//********************************************************************************************/
/*
void Ds1302Ram_Init(void)
{
uchar i;
//for(i=0xc3;i<0xc7;i+=2)
i=ds1302read_byte(0xc3);
   if(i!=0||i!=1)
      {
      Write_Ds1302Ram(0xc2,0);
      }
i=ds1302read_byte(0xc5);
   if(i!=0||i!=1)
      {
      Write_Ds1302Ram(0xc4,0);
      }

} */
//********************************************************************************************/
void main()
{
uchar K;
Key=0xff;
Timer0_Init();
Timer1_Init();
Clock_Init();

//Ds1302Ram_Init();
Put_In(Open_Logo);
Play(1);
DelayM(3000);

dp=ds1302read_byte(0xc3);
Bell_State=ds1302read_byte(0xc5);
Clock_Updata();
while(1)
  {
//if(T_1S) {  T_1S=0;  Clock_Updata(); Temperature_Update(); }

Clock_Updata();
if(current_time.minute==0&&
   current_time.second==0&&
      Bell_State==1)
                  { DelayM(1000); Play(2);  }
                     K=Key_Scan();
                     if(K==4)       MENU();
                     if(K==1&&dp==0) T=~T;
                     switch (Select_M)
                     {
                                       case 0 : { Set_Time();  Select_M=4; } break;
                                       case 1 : { Set_Alarm(); Select_M=4; } break;
                                       case 2 : { Set_Dp(); Select_M=4; } break;
                                       case 3 : { Set_Bell();  Select_M=4; };break;
                                       default : break;
                                       }

if(T_10S==1&&dp) { TT=~TT;  T_10S=0; }

if(TT==0&&dp)
         {

                        Disp_Time();
            }
if(TT&&dp)
         {
                  Temperature_Update();
                     Disp_Temperature_3bit();
         }

if(T==0&&dp==0)
         {

                        Disp_Time();
            }
if(T&&dp==0)
         {
            Temperature_Update();
                        Disp_Temperature_3bit();
            }
Alarm();
}
}
/********************************************************************************************/

作者: wc86110 时间: 2019-4-29 20:59
这些明显是拼凑出来的，各自单独运行没问题但简单合并就出问题

作者: zsf333666 时间: 2019-4-29 23:52
原帖有图的看着是可以运行的

作者: HC6800-ES-V2.0 时间: 2019-4-30 08:41
能同时显示温度和时间问题："LCD1602不能同时显示温度和时间的问题"

作者: yzwzfyz 时间: 2019-4-30 17:21
你想做单片机这一行，就自己写，如果连这么简单的东西就搞不定就改行。

作者: zsf333666 时间: 2019-4-30 20:44

yzwzfyz 发表于 2019-4-30 17:21
你想做单片机这一行，就自己写，如果连这么简单的东西就搞不定就改行。

我对编程一窍不通，做这个纯粹是一时兴起，玩玩而已。靠这个还能发家？

作者: zsf333666 时间: 2019-4-30 21:07
我只是想找一个我喜欢的程序做出来自用而已，其实在本论坛已找到一个程序，并做出了实物。且已经运行了一星期!这个程序存在一些小问题:每天慢5秒，备用电池低于3.6伏不能保存时间(可能是DS1302的问题，4毛5还包邮的那种便宜货)，用电解电容串二极管接主电源，段电可以维持10钟不清零，而且程序中也没有开启充电功能。

作者: zsf333666 时间: 2019-4-30 21:14

yzwzfyz 发表于 2019-4-30 17:21
你想做单片机这一行，就自己写，如果连这么简单的东西就搞不定就改行。

如同：我知道如何做饭，但不知道锅盆灶具一样。
我说名字咋这么眼熟？原来上次你回复过!
谁说会做饭却不知锅碗瓢盆？那是因为你也根本不懂这个!

作者: wc86110 时间: 2019-5-1 06:14
时钟芯片不是有主电源和备用引脚么，如主电源断了备用电源能维持走时不用初始化调时间的麻烦

作者: zsf333666 时间: 2019-5-1 18:52

wc86110 发表于 2019-5-1 06:14
时钟芯片不是有主电源和备用引脚么，如主电源断了备用电源能维持走时不用初始化调时间的麻烦

我白菜一个，不懂编程。貌似是先写入一次程序后，需要在源码中注释掉1302的初始化，重新编译再次写入，断电后才可以维持走时。

作者: 51一哥 时间: 2019-12-23 17:04

zsf333666 发表于 2019-5-1 18:52
我白菜一个，不懂编程。貌似是先写入一次程序后，需要在源码中注释掉1302的初始化，重新编译再次写入，断 ...

我也是白菜嘻嘻，找到同类了

作者: an是007 时间: 2019-12-24 14:35
函数的借用要一部分一部分的拷贝，修改，编译检查

欢迎光临 (http://www.51hei.com/bbs/)