main.c

Go to the documentation of this file.

/* USER CODE BEGIN Header */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
 
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include <stdio.h>
#include <stdbool.h>
#include <string.h>
#include "DS3231.h"
#include "AT24C32.h"
 
/* USER CODE END Includes */
 
/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
 
/* USER CODE END PTD */
 
/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
 
#define CLOCK_ROW 11
 
#define ANSI_HIDE_CURSOR "\x1b[?25l"
 
#define FORCE_SET_TIME 0
 
#define SET_TIME_OFFSET_SECONDS 0
 
#define CLOCK_MARKER_ADDRESS 0U
 
#define CLOCK_MARKER_MAGIC   0x44533332U
 
#define CLOCK_MARKER_SIZE    8U
 
/* USER CODE END PD */
 
/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
 
/* USER CODE END PM */
 
/* Private variables ---------------------------------------------------------*/
 
I2C_HandleTypeDef hi2c1;
 
UART_HandleTypeDef huart1;
 
/* USER CODE BEGIN PV */
static DS3231_t rtc;
 
static AT24C32_t eeprom;
 
static const char *const dayNames[8] =
{
    "", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"
};
 
static const char *const monthNames[13] =
{
    "", "January", "February", "March", "April", "May", "June",
    "July", "August", "September", "October", "November", "December"
};
/* USER CODE END PV */
 
/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_I2C1_Init(void);
static void MX_USART1_UART_Init(void);
/* USER CODE BEGIN PFP */
static bool reportOscillator(void);
static bool parseBuildTime(DS3231_TIME_t *time);
static void setClockFromBuildTime(void);
static bool readClockMarker(void);
static void writeClockMarker(void);
static void startClock(void);
static void printTime(void);
/* USER CODE END PFP */
 
/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
 
#ifdef REDIRECT_PRINTF
#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
 
PUTCHAR_PROTOTYPE
{
  HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, 0xFFFF);
 
  return ch;
}
#endif
 
/* USER CODE END 0 */
 
int main(void)
{
 
  /* USER CODE BEGIN 1 */
 
  /* USER CODE END 1 */
 
  /* MCU Configuration--------------------------------------------------------*/
 
  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();
 
  /* USER CODE BEGIN Init */
 
  /* USER CODE END Init */
 
  /* Configure the system clock */
  SystemClock_Config();
 
  /* USER CODE BEGIN SysInit */
 
  /* USER CODE END SysInit */
 
  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_I2C1_Init();
  MX_USART1_UART_Init();
  /* USER CODE BEGIN 2 */
 
  printf("\x1b[2J\x1b[H");  // Clear the dumb terminal screen
  printf(ANSI_HIDE_CURSOR);
  printf("\x1b[1mDS3231 real-time clock\x1b[0m\r\n-----------------------\r\n\r\n");
  fflush(stdout);   // no newline in the sequence, so push it out now
 
  if (ds3231Init(&rtc, &hi2c1, 0) != DS3231_OK) {
    printf("DS3231 not found on I2C1 (HAL status %d, I2C error 0x%02lX)\r\n",
           (int)rtc.lastStatus, (unsigned long)HAL_I2C_GetError(&hi2c1));
    Error_Handler();
  }
 
  if (at24c32Init(&eeprom, &hi2c1, 7, 0) != AT24C32_OK) {
    printf("AT24C32 EEPROM not found on I2C1 (HAL status %d, I2C error 0x%02lX)\r\n",
           (int)eeprom.lastStatus, (unsigned long)HAL_I2C_GetError(&hi2c1));
    Error_Handler();
  }
 
  startClock();
 
  /* USER CODE END 2 */
 
  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */
 
    /* USER CODE BEGIN 3 */
    printTime();
    HAL_Delay(1000);
  }
  /* USER CODE END 3 */
}
 
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
 
  HAL_PWREx_ConfigSupply(PWR_LDO_SUPPLY);
 
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE0);
 
  while(!__HAL_PWR_GET_FLAG(PWR_FLAG_VOSRDY)) {}
 
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_DIV1;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
  RCC_OscInitStruct.PLL.PLLM = 4;
  RCC_OscInitStruct.PLL.PLLN = 60;
  RCC_OscInitStruct.PLL.PLLP = 2;
  RCC_OscInitStruct.PLL.PLLQ = 4;
  RCC_OscInitStruct.PLL.PLLR = 2;
  RCC_OscInitStruct.PLL.PLLRGE = RCC_PLL1VCIRANGE_3;
  RCC_OscInitStruct.PLL.PLLVCOSEL = RCC_PLL1VCOWIDE;
  RCC_OscInitStruct.PLL.PLLFRACN = 0;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }
 
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2
                              |RCC_CLOCKTYPE_D3PCLK1|RCC_CLOCKTYPE_D1PCLK1;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.SYSCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB3CLKDivider = RCC_APB3_DIV2;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_APB1_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_APB2_DIV2;
  RCC_ClkInitStruct.APB4CLKDivider = RCC_APB4_DIV2;
 
  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_4) != HAL_OK)
  {
    Error_Handler();
  }
}
 
static void MX_I2C1_Init(void)
{
 
  /* USER CODE BEGIN I2C1_Init 0 */
 
  /* USER CODE END I2C1_Init 0 */
 
  /* USER CODE BEGIN I2C1_Init 1 */
 
  /* USER CODE END I2C1_Init 1 */
  hi2c1.Instance = I2C1;
  hi2c1.Init.Timing = 0x307075B1;
  hi2c1.Init.OwnAddress1 = 0;
  hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
  hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
  hi2c1.Init.OwnAddress2 = 0;
  hi2c1.Init.OwnAddress2Masks = I2C_OA2_NOMASK;
  hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
  hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
  if (HAL_I2C_Init(&hi2c1) != HAL_OK)
  {
    Error_Handler();
  }
 
  if (HAL_I2CEx_ConfigAnalogFilter(&hi2c1, I2C_ANALOGFILTER_ENABLE) != HAL_OK)
  {
    Error_Handler();
  }
 
  if (HAL_I2CEx_ConfigDigitalFilter(&hi2c1, 0) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN I2C1_Init 2 */
 
  /* USER CODE END I2C1_Init 2 */
 
}
 
static void MX_USART1_UART_Init(void)
{
 
  /* USER CODE BEGIN USART1_Init 0 */
 
  /* USER CODE END USART1_Init 0 */
 
  /* USER CODE BEGIN USART1_Init 1 */
 
  /* USER CODE END USART1_Init 1 */
  huart1.Instance = USART1;
  huart1.Init.BaudRate = 19200;
  huart1.Init.WordLength = UART_WORDLENGTH_8B;
  huart1.Init.StopBits = UART_STOPBITS_1;
  huart1.Init.Parity = UART_PARITY_NONE;
  huart1.Init.Mode = UART_MODE_TX_RX;
  huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart1.Init.OverSampling = UART_OVERSAMPLING_16;
  huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
  huart1.Init.ClockPrescaler = UART_PRESCALER_DIV1;
  huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  if (HAL_UART_Init(&huart1) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_UARTEx_SetTxFifoThreshold(&huart1, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_UARTEx_SetRxFifoThreshold(&huart1, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_UARTEx_DisableFifoMode(&huart1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART1_Init 2 */
 
  /* USER CODE END USART1_Init 2 */
 
}
 
static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};
  /* USER CODE BEGIN MX_GPIO_Init_1 */
 
  /* USER CODE END MX_GPIO_Init_1 */
 
  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOH_CLK_ENABLE();
  __HAL_RCC_GPIOD_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();
 
  /*Configure GPIO pins : STLINK_RX_Pin STLINK_TX_Pin */
  GPIO_InitStruct.Pin = STLINK_RX_Pin|STLINK_TX_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  GPIO_InitStruct.Alternate = GPIO_AF7_USART3;
  HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
 
  /* USER CODE BEGIN MX_GPIO_Init_2 */
 
  /* USER CODE END MX_GPIO_Init_2 */
}
 
/* USER CODE BEGIN 4 */
 
 
void _Error_Handler(const char *file, int line)
{
    __disable_irq();
 
#ifdef REDIRECT_PRINTF
    char buf[80];
 
    snprintf(buf, sizeof(buf),
            "Trapped in _Error_Handler(). Called from: %s, line: %d\r\n",
            file, line);
    printf("%s", buf);
#endif
 
    /* User can add an implementation to report the HAL error return state. */
    while(1)
    {
    }
}
 
 
static bool reportOscillator(void)
{
    bool stopped = false;
 
    if (ds3231IsOscillatorStopped(&rtc, &stopped) != DS3231_OK) {
        printf("Could not read the DS3231 status register\r\n");
        Error_Handler();
        return false;
    }
 
    if (stopped) {
        printf("Oscillator : stop flag SET, the time is not valid until the clock is set\r\n");
    } else {
        printf("Oscillator : stop flag clear, the time is valid\r\n");
    }
    return stopped;
}
 
static bool parseBuildTime(DS3231_TIME_t *time)
{
    static const char months[] = "JanFebMarAprMayJunJulAugSepOctNovDec";
    const char *date = __DATE__;    /* "Mmm dd yyyy", day padded with a space */
    const char *clock = __TIME__;   /* "hh:mm:ss" */
    const char *found = NULL;
    uint8_t i;
 
    for (i = 0U; i < 12U; i++) {
        if (strncmp(&months[i * 3U], date, 3U) == 0) {
            found = &months[i * 3U];
            time->month = (uint8_t)(i + 1U);
        }
    }
    if (found == NULL) {
        return false;
    }
 
    time->day = (uint8_t)(((date[4] == ' ') ? 0 : (date[4] - '0')) * 10 + (date[5] - '0'));
    time->year = (uint16_t)((date[7] - '0') * 1000 + (date[8] - '0') * 100 + (date[9] - '0') * 10 + (date[10] - '0'));
    time->hour = (uint8_t)((clock[0] - '0') * 10 + (clock[1] - '0'));
    time->minute = (uint8_t)((clock[3] - '0') * 10 + (clock[4] - '0'));
    time->second = (uint8_t)((clock[6] - '0') * 10 + (clock[7] - '0'));
    time->weekday = 0U;
 
    return ds3231IsTimeValid(time);
}
 
static void setClockFromBuildTime(void)
{
    DS3231_TIME_t time;
    uint32_t epoch;
 
    if (!parseBuildTime(&time) || ds3231TimeToEpoch(&time, &epoch) != DS3231_OK ||
            ds3231EpochToTime((uint32_t)((int32_t)epoch + SET_TIME_OFFSET_SECONDS), &time) != DS3231_OK) {
        printf("The build time cannot be used to set the clock\r\n");
        Error_Handler();
        return;
    }
 
    if (ds3231SetTime(&rtc, &time) != DS3231_OK || ds3231ClearOscillatorStopFlag(&rtc) != DS3231_OK) {
        printf("Setting the DS3231 failed\r\n");
        Error_Handler();
        return;
    }
 
    printf("Clock      : set to the build time %04d-%02d-%02d %02d:%02d:%02d (offset %d s)\r\n",
            (int)time.year, (int)time.month, (int)time.day,
            (int)time.hour, (int)time.minute, (int)time.second, (int)SET_TIME_OFFSET_SECONDS);
}
 
static bool readClockMarker(void)
{
    uint8_t raw[CLOCK_MARKER_SIZE];
    uint32_t magic;
    uint32_t inverse;
 
    if (at24c32Read(&eeprom, CLOCK_MARKER_ADDRESS, raw, sizeof(raw)) != AT24C32_OK) {
        printf("Could not read the clock marker from the EEPROM\r\n");
        Error_Handler();
        return false;
    }
 
    memcpy(&magic, &raw[0], sizeof(magic));
    memcpy(&inverse, &raw[4], sizeof(inverse));
    return (magic == CLOCK_MARKER_MAGIC) && (inverse == (uint32_t)~CLOCK_MARKER_MAGIC);
}
 
static void writeClockMarker(void)
{
    uint8_t raw[CLOCK_MARKER_SIZE];
    uint32_t magic = CLOCK_MARKER_MAGIC;
    uint32_t inverse = (uint32_t)~CLOCK_MARKER_MAGIC;
 
    memcpy(&raw[0], &magic, sizeof(magic));
    memcpy(&raw[4], &inverse, sizeof(inverse));
 
    if (at24c32Write(&eeprom, CLOCK_MARKER_ADDRESS, raw, sizeof(raw)) != AT24C32_OK || !readClockMarker()) {
        printf("Writing the clock marker to the EEPROM failed\r\n");
        Error_Handler();
    }
}
 
static void startClock(void)
{
    bool stopped = reportOscillator();
    bool markerFound = readClockMarker();
 
    if (FORCE_SET_TIME) {
        printf("EEPROM     : FORCE_SET_TIME is 1, setting the clock\r\n");
    } else if (markerFound) {
        printf("EEPROM     : marker found, the clock was set before\r\n");
        printf("Clock      : left alone\r\n");
        if (stopped) {
            printf("Warning    : the oscillator stopped since the clock was set.\r\n");
            printf("             Set FORCE_SET_TIME to 1 and rebuild to set it again.\r\n");
        }
        return;
    } else {
        printf("EEPROM     : no marker, first run on this board\r\n");
    }
 
    setClockFromBuildTime();
    writeClockMarker();
    printf("EEPROM     : marker written\r\n");
 
    if (FORCE_SET_TIME) {
        printf("Reminder   : set FORCE_SET_TIME to 0 and rebuild, or every reset\r\n");
        printf("             sets the clock back to this build time.\r\n");
    }
}
 
static void printTime(void)
{
    DS3231_TIME_t now;
    DS3231_Status_t status = ds3231GetTime(&rtc, &now);
 
    if (status == DS3231_ERR_INVALID_DATA) {
        printf("\x1b[%d;1H\x1b[K  The DS3231 does not hold a valid time yet\x1b[%d;1H\x1b[K", CLOCK_ROW, CLOCK_ROW + 1);
        fflush(stdout);
        return;
    }
    if (status != DS3231_OK) {
        printf("ds3231GetTime failed, status %d\r\n", (int)status);
        Error_Handler();
        return;
    }
 
    if (now.weekday < 1U || now.weekday > 7U || now.month < 1U || now.month > 12U) {
        printf("\x1b[%d;1H\x1b[K  The DS3231 returned a date that cannot be named\x1b[%d;1H\x1b[K", CLOCK_ROW, CLOCK_ROW + 1);
        fflush(stdout);
        return;
    }
 
    printf("\x1b[%d;1H\x1b[K  %s, %s %d, %04d\x1b[%d;1H\x1b[K  \x1b[1m%02d:%02d:%02d\x1b[0m",
            CLOCK_ROW, dayNames[now.weekday], monthNames[now.month], (int)now.day, (int)now.year,
            CLOCK_ROW + 1, (int)now.hour, (int)now.minute, (int)now.second);
    fflush(stdout);
}
 
/* USER CODE END 4 */
 
 
#ifdef  USE_FULL_ASSERT
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* assert_param() can fire from inside any HAL call -- including before
   * REDIRECT_PRINTF's UART is fully set up, or from an unusual calling
   * context -- so this only attempts to report when REDIRECT_PRINTF is
   * available, then halts either way. Continuing after a failed HAL
   * parameter check is undefined behavior, not something safe to log
   * and ignore. */
  __disable_irq();
 
#ifdef REDIRECT_PRINTF
  {
    char buf[96];
 
    snprintf(buf, sizeof(buf),
             "assert_param failed: file %s, line %lu\r\n",
             (char *)file, (unsigned long)line);
    printf("%s", buf);
  }
#endif
 
  while (1)
  {
  }
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */