增加休眠，开始上板测试

jinlicong

2024-05-29 6c7e61a54ef9b96f79704f0b965664e89f57dd52

 HARDWARE/RTC/RTC.c

@@ -1,561 +1,119 @@
#include "RTC.h"
#include "delay.h"
#include "rtc.h"
#include "extern_rtc.h"
#include "gpio.h"
#include "uart.h"



calendar_obj   calendar; //Ê®½øÖÆ
sClockBCD      Time_BCD_g; //BCD
//__IO RTC_TimeDateTypeDef calendar_g = {0};


//IIC ½ÓÊÜÊý¾ÝÁÙʱ»º³åÇø
u8 I2C_RECV_DATA[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00};//second  minutes hour week  date month year


/*******************************************
      IIC ÐźŽáÊøÐźź¯Êý
********************************************/
// // void I2C_STOP(void)
// // {
// //    SDA_OUT();//sdaÏßÊä³ö
// //    IIC_SCL=0;
// //    IIC_SDA=0;//STOP:when CLK is high DATA change form low to high
// //     delay_us(3);
// //    IIC_SCL=1; 
// //    IIC_SDA=1;//·¢ËÍI2C×ÜÏß½áÊøÐźÅ
// //    delay_us(3);
// // }

// /*******************************************
//       IIC ÐźÅÆðʼÐźź¯Êý
// ********************************************/
// void I2C_START(void)
// {
//    SDA_OUT();     //sdaÏßÊä³ö
//    IIC_SDA=1;	  	  
//    IIC_SCL=1;
//    delay_us(3);
//     IIC_SDA=0;//START:when CLK is high,DATA change form high to low 
// //   DS1339_SDA_LOW;
//    delay_us(3);
//    IIC_SCL=0;
// }


// //////////////////////

// //µÈ´ýÓ¦´ðÐźŵ½À´
// //·µ»ØÖµ£º1£¬½ÓÊÕÓ¦´ðʧ°Ü
// //        0£¬½ÓÊÕÓ¦´ð³É¹¦
// u8 I2C_Wait_Ack(void)
// {
//    u8 ucErrTime=0;
//    SDA_IN();      //SDAÉèÖÃΪÊäÈë    
//    IIC_SCL=1;delay_us(3);	 
//    while(READ_SDA)
//    {
//       ucErrTime++;
//       if(ucErrTime>250)
//       {
//          I2C_STOP();
//          return 1;
//       }
//    }
//    IIC_SCL=0;//ʱÖÓÊä³ö0 	  	
//    return 0;  
// } 


// //²úÉúACKÓ¦´ð
// void I2C_Ack(void)
// {
//    IIC_SCL=0;
//    SDA_OUT();
//    IIC_SDA=0;
//    delay_us(3);
//    IIC_SCL=1;
//    delay_us(3);
//    IIC_SCL=0;
//    delay_us(3);
// }



// //²»²úÉúACKÓ¦´ð		    
// void I2C_NAck(void)
// {
//    IIC_SCL=0;
//    SDA_OUT();
//    IIC_SDA=1;
//    delay_us(3);
//    IIC_SCL=1;
//    delay_us(3);
//    IIC_SCL=0;
// }	

// /*******************************************
//       IIC ·¢ËÍ×Ö½Úº¯Êý
//       ²ÎÊý    1£ºÒª·¢ËÍ×Ö½ÚÖµ
//       return £ºÎÞ·µ»Ø
// ********************************************/
// void I2C_TxByte(unsigned char nValue)
// {
//     int i;
//       SDA_OUT(); 	
//      IIC_SCL=0;	
//     for(i = 0;i < 8;i++)
//     {
//        if(nValue & 0x80)
//            IIC_SDA=1;
//        else
//            IIC_SDA=0;
//       nValue <<= 1;
//        delay_us(3);
//      IIC_SCL=1;	
//     delay_us(3);
//      IIC_SCL=0;	
//       delay_us(3);
//     }
// }

// /*******************************************
//       IIC ½ÓÊÕ×Ö½Úº¯Êý
//       ²ÎÊý       ÎÞ
//       return £ºÎÞ·µ»Ø
// ********************************************/
// u8  I2C_RxByte(void)
// {
//     unsigned char nTemp = 0;
//     int i;
// 	
//      SDA_IN();//SDAÉèÖÃΪÊäÈë
// 	
//     for(i = 0;i < 8;i++)
//     {

//           IIC_SCL=1;
//         if(READ_SDA)
//        {
//           nTemp |= (0x01 << (7-i));
//        }
//       delay_us(3);
//           IIC_SCL=0;
//         delay_us(3);
//     }

//     return nTemp;
// }


// /*******************************************
//       IIC ·¢ËÍÊý×麯Êý
//    ²ÎÊý     1 num : ·¢ËÍ×Ö½ÚÊý
//        2 device_addr : iicÄ¿±êµØÖ·
//        3 *data   £º·¢ËÍÊý×éµØÖ·
//    return £ºÎÞ·µ»Ø
// ********************************************/
// void I2C_Write(u8 num, u8 Write_addr,u8 *data)
// {
//     int i = 0;
//     unsigned char *send_data = data;

//     I2C_START();
//     I2C_TxByte(DS1339_Write_Add);
//      I2C_Wait_Ack();
//     I2C_TxByte(Write_addr);
// 	
//     for(i = 0;i < num;i++)
//     {
//          I2C_Wait_Ack();
//       I2C_TxByte(send_data[i]);
//     }
//       I2C_STOP();
// }


// /*******************************************
//       IIC ¶ÁÈ¡Êý×麯Êý
//    ²ÎÊý     1 num : ·¢ËÍ×Ö½ÚÊý
//        2 device_addr : iicÄ¿±êµØÖ·
//        3 *data   £º½ÓÊÕÊý×éµØÖ·
//    return £ºÎÞ·µ»Ø
// ********************************************/
// void I2C_Read(u8 num, u8 Read_addr)
// {
//   u8 i = 0;

//      I2C_START();
//     I2C_TxByte(DS1339_Write_Add);
//       I2C_Wait_Ack();
//       I2C_TxByte(Read_addr);
//       I2C_Wait_Ack();
// 	
//      I2C_START();
//     I2C_TxByte(DS1339_Read_Add);
//  
//   for(i = 0; i < num;i++)
//   {		
//     I2C_Ack();
//     I2C_RECV_DATA[i] = I2C_RxByte();
//   }
//       I2C_NAck();
//     I2C_STOP();
// }


// u8 OSFBIT_Check(void)
// {
//   I2C_Read(1,DS1339_Status_Reg);
//  if(I2C_RECV_DATA[0]&0x80)
//     return 1;
//  else 
//     return 0;
// }


// void OSFBIT_SetLow(void)
// {
//    u8 a=0;
//  I2C_Write(1,DS1339_Status_Reg,&a);
// }

void IIC_Start(void)
void RTC_IRQHandler(void)
{
   SDA_OUT();     
   IIC_SCL=1;
   IIC_SDA=1;
   delay_us(10);
   IIC_SDA=0;
   delay_us(10);
   IIC_SCL=0;	
   delay_us(10);
	
	
	
}	  
 
void IIC_Stop(void)
{
   u8 i;
   SDA_OUT();//sda???
   IIC_SDA=0;
   delay_us(10);
   IIC_SCL=1;
   delay_us(10);
   IIC_SDA=1;
   for(i=0;i<5;i++)
   {
      delay_us(10);
   }		   	
//   if(__SYS_DELAY_SEC_FLAG_GET(sys_active_time) == SET && LargeCurrent_LimitingProcess() == 3)
//      SysWakeUp_ClockCfg();
//   if( RTC_ISR_SEC_IF_Chk() == SET)//²éѯÃëÖӶϱêÖ¾ÊÇ·ñÖÃÆð
//   {
//      RTC_ISR_SEC_IF_Clr();      //Çå³ýÃëÖжϱêÖ¾
//      sys_time_g.sys_run_period = SET;
//      Get_Sys_Rtc_Time(&calendar_g);
//   }	
}
 
u8 IIC_Wait_Ack(void)


void RTC_Init(void)
{	
   CMU_PERCLK_SetableEx(RTCCLK, ENABLE);  //RTC×ÜÏßʱÖÓʹÄÜ
   //RTCʹÓÃXTLF/RCHF£¬Éϵç×Ô¶¯ÆðÕñ£¬²»ÐèҪʹÄܹ¤×÷ʱÖÓ
	
  RTC_ISR_SEC_IF_Clr();      //Çå³ýÃëÖжϱêÖ¾											
   RTC_IER_SEC_IE_Setable(ENABLE);//´ò¿ªRTCÃëÖжÏ	
	
   NVIC_DisableIRQ(RTC_IRQn);            //NVICÖжϿØÖÆÆ÷ÅäÖÃ
   NVIC_SetPriority(RTC_IRQn,1);
   NVIC_EnableIRQ(RTC_IRQn);	
	
   RTC_CR_RTC_EN_Setable(ENABLE);  //ʹÄÜRTC_A
}


/******************************************
 * func:    Get_Sys_Rtc_Time
 * desc:    »ñȡϵͳRTCʱ¼ä
 * input:   pOutput_timedata £º»ñȡϵͳʱ¼äÖ¸Õ루BCD¸ñʽ£©
 * output:  none
 * return:  none
 *****************************************/
ErrorStatus_STM32 Get_Sys_Rtc_Time(__IO RTC_TimeDateTypeDef * pOutput_timedata)
{
   u8 ucErrTime=0;
   SDA_IN();      //SDA?????  
   delay_us(10);   
   delay_us(10);
   while(READ_SDA)
   uint08 n, i;
   ErrorStatus_STM32 Result = ERROR_1;

   RTC_TimeDateTypeDef TempTime1,TempTime2;
	
   for(n=0 ;n<3; n++)
   {
      ucErrTime++;
      if(ucErrTime>250)
      {
         IIC_Stop();
         return 1;
      }
      RTC_TimeDate_GetEx(&TempTime1);//¶ÁÒ»´Îʱ¼ä
      RTC_TimeDate_GetEx(&TempTime2);//ÔÙ¶ÁÒ»´Îʱ¼ä
      
   }
   IIC_SCL=0;//????0 	   
   return 0;  
} 
 
void IIC_Ack(void)
{
	
   SDA_OUT();
   IIC_SDA=0;;
   delay_us(10);
   IIC_SCL=1;
   delay_us(10);
   IIC_SCL=0;
   delay_us(10);
}
	    
void IIC_NAck(void)
{
   SDA_OUT();
   IIC_SDA=1;;
   delay_us(10);
   IIC_SCL=1;
   delay_us(10);
   IIC_SCL=0;
   delay_us(10);
}					 				     
		  
void IIC_Send_Byte(u8 txd)
{ 
   u8 i;
   SDA_OUT();
   for(i=0;i<8;i++)
   {
      if(txd & 0x80) IIC_SDA=1;
      else IIC_SDA=0;
      txd <<= 1;
      delay_us(10);
       IIC_SCL=1;
      delay_us(10);
      IIC_SCL=0;	
   }
   delay_us(10);
   IIC_SCL=1;
   delay_us(10);
   IIC_SCL=0;
} 	    
 
u8 IIC_Read_Byte(unsigned char ack)
{
   u8 i,receive=0;
   SDA_IN();//SDA?????
	
      for(i=0;i<8;i++)
      for(i=0; i<7; i++)//Á½ÕßÒ»ÖÂ, ±íʾ¶ÁÈ¡³É¹¦
      {
         IIC_SCL=1;
         delay_us(10);
         receive <<=1;
         if(READ_SDA) receive |= 0x01;
			
         IIC_SCL=0;
         delay_us(10);
         if(((uint08*)(&TempTime1))[i] != ((uint08*)(&TempTime2))[i]) break;
      }
      SDA_OUT();
      return receive;
      if(i == 7)
      {
         Result = SUCCESS_0;
         memcpy((uint08*)(pOutput_timedata), (uint08*)(&TempTime1), 7);//¶ÁÈ¡ÕýÈ·Ôò¸üÐÂеÄʱ¼ä		
//         memcpy(&sys_realtime_data_g.time_para_s,&TempTime1,7);
         break;
      }
   }
   return Result;
}

/******************************************
 * func:    Set_Sys_Rtc_Time
 * desc:    ÉèÖÃϵͳRTCʱ¼ä
 * input:   pInput_timedata£ºÐ´ÈëµÄϵͳʱ¼äÖ¸Õ루BCD¸ñʽ£©
 * output:  none
 * return:  none
 *****************************************/
ErrorStatus_STM32 Set_Sys_Rtc_Time(uint8_t year,uint8_t month,uint8_t day,uint8_t hour,uint8_t min,uint8_t sec,uint8_t week)
{
   uint08 n, i;
   ErrorStatus_STM32 Result;
   RTC_TimeDateTypeDef TempTime1;
   RTC_TimeDateTypeDef real_time = {year,month,day,hour,min,sec,week};
   for(n=0 ;n<3; n++)
   {
      RTC_WER_Write(RTC_WRITE_ENABLE );      //½â³ýRTCд±£»¤
      RTC_TimeDate_SetEx(&real_time);         //ÉèÖÃRTC
      RTC_WER_Write(RTC_WRITE_DISABLE );   //´ò¿ªRTCд±£»¤
      
}
 
 
void R8025AC_Read(u8 sadd, u8 *buf, u8 len)
{
   u8 i;
   IIC_Start();
   IIC_Send_Byte(0x64);
   IIC_Send_Byte(sadd);
   IIC_Start();
   IIC_Send_Byte(0x65);
   for(i=0;i<len-1;i++)
   {
      buf[i] = IIC_Read_Byte(1);
      IIC_Ack();
      Result = Get_Sys_Rtc_Time(&TempTime1);   //¶ÁÈ¡È·ÈÏÉèÖýá¹û
      if(Result == SUCCESS_0)
      {
         Result = ERROR_1;
         for(i=0; i<7; i++)//Á½ÕßÒ»ÖÂ, ±íʾÉèÖóɹ¦
         {
            if(((uint08*)(&TempTime1))[i] != ((uint08*)(&real_time))[i]) break;
         }
         if(i == 7)
         {
            Result = SUCCESS_0;
            break;
         }
      }
   }
   buf[i] = IIC_Read_Byte(0);
   IIC_NAck();
   IIC_Stop();
   return Result;
}
 
void R8025AC_Write(u8 sadd,u8 *buf,u8 len)

void rtc_setalarm(RTC_AlarmTmieTypeDef* para)
{
   u8 i;
   RTC_AlarmTime_SetEx(para);   //ÉèÖÃÄÖÖÓʱ¼ä	
   
   IIC_Start();
   IIC_Send_Byte(0X64);
   IIC_Send_Byte(sadd);
	
   for(i=0;i<len;i++)
   {
      IIC_Send_Byte(buf[i]);
   }
   IIC_Stop();
   RTC_ISR_ALARM_IF_Clr();      //Çå³ýÄÖÖÓÖжϱêÖ¾											
   RTC_IER_ALARM_IE_Setable(ENABLE);//´ò¿ªÄÖÖÓÖжÏ	
   RTC_ALARM_ALMEN_Setable(ENABLE);//ÄÖÖÓ¹¦ÄÜʹÄÜ
}



void set_alarm(void)
{


#if 0
   u8 alarm[5];
   alarm[0] = 64;
  alarm[1] = 0x00;  // Counter ?0x0500,?1280??,??64Hz???,??20S?????
  alarm[2] = 0x19;  //??Time interrupt,FOUT ?1hz(????????), ??????64Hz?
  alarm[3] = 0x00;   
  alarm[4] = 0x50;  //??????2s(??),??Time interrupt
  R8025AC_Write(0x0B,alarm,5);
#endif
	
#if 1
u8 alarm[5];
alarm[0] = 0;    //B                                                    //??????             //??????
alarm[1] = 0x00;  // Counter ?0x0500,?1280??,??64Hz???,??20S?????                                  //
alarm[2] = 0x02;  //D??Time interrupt,FOUT ?1hz(????????), ??????64Hz?     00011001  19                  //00000010  02
alarm[3] = 0x00;   //E                                                                             //00000000
alarm[4] = 0x60;  //F??????2s(??),??Time interrupt                        01010000    50               //01100000    60
R8025AC_Write(0x0B, alarm, 5);
#endif

#if 0
/*²»¿ªRTCÖжÏ*/
u8 alarm[5];
alarm[0] = 0;    //B                                                    //??????             //??????
alarm[1] = 0x00;  // Counter ?0x0500,?1280??,??64Hz???,??20S?????                                  //
alarm[2] = 0x02;  //D??Time interrupt,FOUT ?1hz(????????), ??????64Hz?     00011001  19                  //00000010  02
alarm[3] = 0x00;   //E                                                                             //00000000
alarm[4] = 0x40;  //F??????2s(??),??Time interrupt                        01010000    50               //01100000    60
R8025AC_Write(0x0B, alarm, 5);
#endif

}



// void set_peroid_alarm()
// {
//    u8 alarm[4];
//    u8 sec_alarm;
//    u8 second;
//    //alarm[0] = 0x00;
//    Get_Time();
//    second   =   calendar.sec;
//    if(second < 58)
//    {
//       second = second + 2;
//    }else
//    {
//       second = second - 58;
//    }
//    sec_alarm = (second / 10)*16 + (second % 10);

//    alarm[0] = sec_alarm;
//     alarm[1] = 0x80;
//     alarm[2] = 0x80;
//     alarm[3] = 0x91;
//    I2C_Write(4,0x07,&alarm[0]);
//    I2C_Read(4,0x07);
// 	
//    sec_alarm = 0x00;
//    I2C_Write(1,0x0f,&sec_alarm);
//    sec_alarm = 0x05;
//    I2C_Write(1,0x0e,&sec_alarm);
// /*   while(1)
//    {
//       I2C_Read(1,0x0f);
//       delay_ms(1);
//    }*/
// }


// void set_peroid_alarm_rst()
// {
//    u8 alarm[4];
//    u8 sec_alarm;
//    u8 second;
//    //alarm[0] = 0x00;
//    Get_Time();
//    second   =   calendar.sec;
//    if(second < 58)
//    {
//       second = second + 2;
//    }else
//    {
//       second = second - 58;
//    }

//    sec_alarm = (second / 10)*16 + (second % 10);

//    alarm[0] = sec_alarm;
//     alarm[1] = 0x80;
//     alarm[2] = 0x80;
//     alarm[3] = 0x80;
//    I2C_Write(4,0x07,&alarm[0]);
//    sec_alarm = 0x00;
//    I2C_Write(1,0x0f,&sec_alarm);

// }



void  Time_new_Set(u8 year,u8 month,u8 date,u8 week,u8 hour,u8 min,u8 sec)
{
   u8 time[7];

   time[0]=((sec/10)<<4)|(sec%10);
   time[1]=((min/10)<<4)|(min%10);
   time[2]=((hour/10)<<4)|(hour%10);
   time[3]=week;
   time[4]=((date/10)<<4)|(date%10);
   time[5]=((month/10)<<4)|(month%10);
   time[6]=((year/10)<<4)|(year%10);
  R8025AC_Write(0x00,time,7);
}


void  Time_Set(u16 year,u8 month,u8 date,u8 week,u8 hour,u8 min,u8 sec)
{
   u8 time[7];
   year%=100;
   time[0]=((sec/10)<<4)|(sec%10);
   time[1]=((min/10)<<4)|(min%10);
   time[2]=((hour/10)<<4)|(hour%10);
   time[3]=week;
   time[4]=((date/10)<<4)|(date%10);
   time[5]=((month/10)<<4)|(month%10);
   time[6]=((year/10)<<4)|(year%10);
  R8025AC_Write(0x00,time,7);
}

void  BCD_time_Set(u8 year,u8 month,u8 date,u8 week,u8 hour,u8 min,u8 sec)
{
   u8 time[7];

   time[0]=sec;
   time[1]=min;
   time[2]=hour;
   time[3]=week;
   time[4]=date;
   time[5]=month;
   time[6]=year;
  R8025AC_Write(0x00,time,7);
}



void  Get_Time(void)
{

   R8025AC_Read(0x00,I2C_RECV_DATA,7);
	
   Time_BCD_g.year = I2C_RECV_DATA[6];
   Time_BCD_g.month = I2C_RECV_DATA[5];
   Time_BCD_g.day = I2C_RECV_DATA[4];
   Time_BCD_g.hour = I2C_RECV_DATA[2];
   Time_BCD_g.min = I2C_RECV_DATA[1];
   Time_BCD_g.sec = I2C_RECV_DATA[0];
	
	
   calendar.sec=((I2C_RECV_DATA[0]&0xf0)>>4)*10+(I2C_RECV_DATA[0]&0x0f);
  calendar.min=((I2C_RECV_DATA[1]&0xf0)>>4)*10+(I2C_RECV_DATA[1]&0x0f);
   calendar.hour=((I2C_RECV_DATA[2]&0xf0)>>4)*10+(I2C_RECV_DATA[2]&0x0f);
   calendar.week=I2C_RECV_DATA[3];
   calendar.date=((I2C_RECV_DATA[4]&0xf0)>>4)*10+(I2C_RECV_DATA[4]&0x0f);
   calendar.month=((I2C_RECV_DATA[5]&0xf0)>>4)*10+(I2C_RECV_DATA[5]&0x0f);	
  calendar.year=2000+((I2C_RECV_DATA[6]&0xf0)>>4)*10+(I2C_RECV_DATA[6]&0x0f);

}





void test_rtc(void)
{
//   u8 time_read[7];
	
   //ÉèÖÃʱ¼ä
//   Time_Set(2019,11,11,1,12,12,12);
   while(1)
   {
      //Time_Set(2019,11,11,1,12,12,12);
      delay_ms(888);

//      Get_Time();
   }
	
}