/**
* @brief Configures the RTC.
* @param None
* @retval None
*/
static void RTC_Config(void)
{
/* Enable Power Clock*/
__PWR_CLK_ENABLE();
/* Allow Access to RTC Backup domaine */
HAL_PWR_EnableBkUpAccess();
RTCHandle.Instance = RTC;
/* Check if the system was resumed from StandBy mode */
if (__HAL_PWR_GET_FLAG(PWR_FLAG_SB) != RESET)
{
/* Clear StandBy flag */
__HAL_PWR_CLEAR_FLAG(PWR_FLAG_SB);
/* Disable the write protection for RTC registers */
__HAL_RTC_WRITEPROTECTION_DISABLE(&RTCHandle);
/* Wait for RTC APB registers synchronisation (needed after start-up from Reset)*/
if (HAL_RTC_WaitForSynchro(&RTCHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/* Enable the write protection for RTC registers */
__HAL_RTC_WRITEPROTECTION_ENABLE(&RTCHandle);
/* No need to configure the RTC as the RTC config(clock source, enable,
prescaler,...) are kept after wake-up from STANDBY */
}
else
{
/* Reset Backup Domaine */
__HAL_RCC_BACKUPRESET_FORCE();
__HAL_RCC_BACKUPRESET_RELEASE();
/* Set the RTC time base to 1s */
/* Configure RTC prescaler and RTC data registers as follows:
- Hour Format = Format 24
- Asynch Prediv = Value according to source clock
- Synch Prediv = Value according to source clock
- OutPut = Output Disable
- OutPutPolarity = High Polarity
- OutPutType = Open Drain */
RTCHandle.Init.HourFormat = RTC_HOURFORMAT_24;
RTCHandle.Init.AsynchPrediv = RTC_ASYNCH_PREDIV;
RTCHandle.Init.SynchPrediv = RTC_SYNCH_PREDIV;
RTCHandle.Init.OutPut = RTC_OUTPUT_DISABLE;
RTCHandle.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;
RTCHandle.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
if (HAL_RTC_Init(&RTCHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/* Set the time to 01h 00mn 00s AM */
RTC_TimeStructure.TimeFormat = RTC_HOURFORMAT12_AM;
RTC_TimeStructure.Hours = 0x01;
RTC_TimeStructure.Minutes = 0x00;
RTC_TimeStructure.Seconds = 0x00;
if (HAL_RTC_SetTime(&RTCHandle, &RTC_TimeStructure, FORMAT_BCD) == HAL_ERROR)
{
/* Initialization Error */
Error_Handler();
}
}
}
TM_RTC_Result_t TM_RTC_SetDateTime(TM_RTC_t* data, TM_RTC_Format_t format) {
TM_RTC_t tmp;
/* Check date and time validation */
if (format == TM_RTC_Format_BCD) {
tmp.Day = RTC_BCD2BIN(data->Day);
tmp.Month = RTC_BCD2BIN(data->Month);
tmp.Year = RTC_BCD2BIN(data->Year);
tmp.Hours = RTC_BCD2BIN(data->Hours);
tmp.Minutes = RTC_BCD2BIN(data->Minutes);
tmp.Seconds = RTC_BCD2BIN(data->Seconds);
tmp.WeekDay = RTC_BCD2BIN(data->WeekDay);
} else {
tmp.Day = data->Day;
tmp.Month = data->Month;
tmp.Year = data->Year;
tmp.Hours = data->Hours;
tmp.Minutes = data->Minutes;
tmp.Seconds = data->Seconds;
tmp.WeekDay = data->WeekDay;
}
/* Check year and month */
if (
tmp.Year > 99 ||
tmp.Month == 0 ||
tmp.Month > 12 ||
tmp.Day == 0 ||
tmp.Day > RTC_Months[RTC_LEAP_YEAR(2000 + tmp.Year) ? 1 : 0][tmp.Month - 1] ||
tmp.Hours > 23 ||
tmp.Minutes > 59 ||
tmp.Seconds > 59 ||
tmp.WeekDay == 0 ||
tmp.WeekDay > 7
) {
/* Invalid date */
return TM_RTC_Result_Error;
}
/* Fill time */
RTC_TimeStruct.Hours = data->Hours;
RTC_TimeStruct.Minutes = data->Minutes;
RTC_TimeStruct.Seconds = data->Seconds;
/* Fill date */
RTC_DateStruct.Date = data->Day;
RTC_DateStruct.Month = data->Month;
RTC_DateStruct.Year = data->Year;
RTC_DateStruct.WeekDay = data->WeekDay;
/* Set time */
if (format == TM_RTC_Format_BCD) {
HAL_RTC_SetTime(&hRTC, &RTC_TimeStruct, RTC_FORMAT_BCD);
} else {
HAL_RTC_SetTime(&hRTC, &RTC_TimeStruct, RTC_FORMAT_BIN);
}
/* Set date */
if (format == TM_RTC_Format_BCD) {
HAL_RTC_SetDate(&hRTC, &RTC_DateStruct, RTC_FORMAT_BCD);
} else {
HAL_RTC_SetDate(&hRTC, &RTC_DateStruct, RTC_FORMAT_BIN);
}
/* Init RTC */
HAL_RTC_Init(&hRTC);
/* Return OK */
return TM_RTC_Result_Ok;
}
void USB_Handler(uint8_t* Buf, uint32_t *Len)
{
int sz;
RTC_DateTypeDef sDate;
RTC_TimeTypeDef sTime;
if (UserRxBufferFS[0] == 0xAB)
{
settingsPacket.startByte = UserRxBufferFS[0];
settingsPacket.command = UserRxBufferFS[1];
for (int i = 0; i < 16; i++)
settingsPacket.data[i] = UserRxBufferFS[i + 2];
switch (settingsPacket.command)
{
case READ_ID:
settingsPacket.data[0] = 1;
strcpy((char *) &settingsPacket.data[1],
(char *) &device.settings->firmware.VERSION);
break;
case SET_TIME:
sDate.Year = settingsPacket.data[0];
sDate.Month = settingsPacket.data[1];
sDate.Date = settingsPacket.data[2];
sTime.Hours = settingsPacket.data[3];
sTime.Minutes = settingsPacket.data[4];
sTime.Seconds = settingsPacket.data[5];
settingsPacket.data[0] = 1;
#ifdef __RTC__
HAL_RTC_SetDate(&hrtc, &sDate, RTC_FORMAT_BIN);
HAL_RTC_SetTime(&hrtc, &sTime, RTC_FORMAT_BIN);
#endif
break;
case GET_DOOR_EVENT:
settingsPacket.data[0] = 1;
HAL_I2C_Mem_Read(&hi2c1, EEPROM_CODE, INIT_EEPROM + 4, I2C_MEMADD_SIZE_8BIT,
(uint8_t*) device.door, sizeof(DOOR_T), 1000);
device.door->STATUS = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_3);
settingsPacket.data[1] = device.door->STATUS;
#ifdef __DEDUG__
printf("door->STATUS %u\n", device.door->STATUS);
#endif
settingsPacket.data[2] = device.door->COUNT;
settingsPacket.data[3] = device.door->TIME.Hours;
settingsPacket.data[4] = device.door->TIME.Minutes;
settingsPacket.data[5] = device.door->TIME.Seconds;
settingsPacket.data[6] = device.door->DATE.Date;
settingsPacket.data[7] = device.door->DATE.Month;
settingsPacket.data[8] = device.door->DATE.Year;
break;
case READ_VERSION:
settingsPacket.data[0] = 1;
strcpy(&settingsPacket.data[1], &device.settings->firmware.VERSION[0]);
break;
case RESET_DOOR_EVENT:
memset(device.door, 0, sizeof(DOOR_T));
HAL_I2C_Mem_Write(&hi2c1, EEPROM_CODE, INIT_EEPROM + 4, I2C_MEMADD_SIZE_8BIT,
(uint8_t*) device.door, sizeof(DOOR_T), 1000);
// HAL_I2C_Mem_Read(&hi2c1, EEPROM_CODE, INIT_EEPROM + 4, I2C_MEMADD_SIZE_8BIT,
// (uint8_t*) device.door, sizeof(DOOR_T), 1000);
break;
}
// for (int i = 0; i < *Len; i++)
// UserTxBufferFS[i] = UserRxBufferFS[i];
//
// USBD_CDC_SetTxBuffer(&hUsbDeviceFS, &UserTxBufferFS[0], *Len);
USBD_CDC_SetTxBuffer(&hUsbDeviceFS, (uint8_t*) &settingsPacket, sizeof(settingsPacket));
USBD_CDC_TransmitPacket(&hUsbDeviceFS);
USBD_CDC_SetRxBuffer(&hUsbDeviceFS, &UserRxBufferFS[0]);
USBD_CDC_ReceivePacket(&hUsbDeviceFS);
}
else
{
settingsPacket.startByte = UserRxBufferFS[0];
USBD_CDC_SetTxBuffer(&hUsbDeviceFS, (uint8_t*) &settingsPacket, 1);
USBD_CDC_TransmitPacket(&hUsbDeviceFS);
USBD_CDC_SetRxBuffer(&hUsbDeviceFS, &UserRxBufferFS[0]);
USBD_CDC_ReceivePacket(&hUsbDeviceFS);
}
}
