kingkevin
/
stm32f1
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
stm32f1/application.c

845 lines
34 KiB
C
Raw Permalink Blame History

/** firmware to raise sourdough starter (aka. levain)
* @file
* @author King Kévin <kingkevin@cuvoodoo.info>
* @copyright SPDX-License-Identifier: GPL-3.0-or-later
* @date 2016-2020
*/
/* standard libraries */
#include <stdint.h> // standard integer types
#include <stdlib.h> // standard utilities
#include <string.h> // string utilities
#include <time.h> // date/time utilities
#include <ctype.h> // utilities to check chars
#include <math.h> // NaN definition
/* STM32 (including CM3) libraries */
#include <libopencmsis/core_cm3.h> // Cortex M3 utilities
#include <libopencm3/cm3/scb.h> // vector table definition
#include <libopencm3/cm3/nvic.h> // interrupt utilities
#include <libopencm3/stm32/gpio.h> // general purpose input output library
#include <libopencm3/stm32/rcc.h> // real-time control clock library
#include <libopencm3/stm32/exti.h> // external interrupt utilities
#include <libopencm3/stm32/rtc.h> // real time clock utilities
#include <libopencm3/stm32/iwdg.h> // independent watchdog utilities
#include <libopencm3/stm32/dbgmcu.h> // debug utilities
#include <libopencm3/stm32/desig.h> // design utilities
#include <libopencm3/stm32/flash.h> // flash utilities
#include <libopencm3/stm32/adc.h> // ADC utilities
/* own libraries */
#include "global.h" // board definitions
#include "print.h" // printing utilities
#include "uart.h" // USART utilities
#include "usb_cdcacm.h" // USB CDC ACM utilities
#include "terminal.h" // handle the terminal interface
#include "menu.h" // menu utilities
#include "sensor_sr04.h" // range measurement utilities
#include "sensor_ds18b20.h" // 1-Wire temperature sensor utilities
#include "oled_text.h" // OLED display utilities
/** watchdog period in ms */
#define WATCHDOG_PERIOD 10000
/** wakeup frequency (i.e. least number of times per second to perform the main loop) */
#define WAKEUP_FREQ 16
/** @defgroup main_flags flag set in interrupts to be processed in main task
* @{
*/
static volatile bool wakeup_flag = false; /**< flag set when wakeup timer triggered */
static volatile bool second_flag = false; /**< flag set when a second passed */
/** @} */
/** number of seconds since boot */
static uint32_t boot_time = 0;
// current state
static uint32_t levain_time = 0; /**< when we start heating the yeas */
static uint32_t max_time = 0; /**< when the sourdough starter has grown */
static uint16_t current_height = 0; /**< current height */
static uint8_t container_height = 0; /**< how height the container is */
static uint8_t starter_height = 0; /**< how height the sourdough starter starter is */
static uint8_t max_height = 0; /**< the maximum height the sourdough starter reached */
static float heater_temp = NAN; /**< heater temperature */
static float levain_temp = NAN; /**< sourdough starter temperature */
/** heater control pin
* @note connected to power nMOS gate, pulled up to 5V
*/
#define HEATER_PIN PB12
#define heater_on() gpio_set(GPIO_PORT(HEATER_PIN), GPIO_PIN(HEATER_PIN)) // switch transistor on to let resistor heat
#define heater_off() gpio_clear(GPIO_PORT(HEATER_PIN), GPIO_PIN(HEATER_PIN)) // switch transistor off
/** maximum heater temperature, in °C
* @note 50 °C only allowed the starter to go up to 29 °C
*/
#define HEATER_LIMIT 60.0
/** ADC channel connected to thermistor */
#define THERMISTOR_CHANNEL 6 // PA6
/** voltages to convert (channel 17 = internal voltage reference) */
const uint8_t channels[] = {ADC_CHANNEL17, ADC_CHANNEL(THERMISTOR_CHANNEL)};
/** pin to control buzzer (active high, piezo-element with driver circuit) */
#define BUZZER_PIN PB2
/** temperature to heat the sourdough starter to, in °C */
const float levain_target = 30.0;
size_t putc(char c)
{
size_t length = 0; // number of characters printed
static char last_c = 0; // to remember on which character we last sent
if ('\n' == c) { // send carriage return (CR) + line feed (LF) newline for each LF
if ('\r' != last_c) { // CR has not already been sent
uart_putchar_nonblocking('\r'); // send CR over USART
usb_cdcacm_putchar('\r'); // send CR over USB
length++; // remember we printed 1 character
}
}
uart_putchar_nonblocking(c); // send byte over USART
usb_cdcacm_putchar(c); // send byte over USB
length++; // remember we printed 1 character
last_c = c; // remember last character
return length; // return number of characters printed
}
/** get voltage of thermistor (in V)
* @return thermistor voltage
*/
static double thermistor_voltage(void)
{
// read thermistor resistance using ADC (using resistor divider)
ADC_SR(ADC1) = 0; // reset flags
uint16_t adc_values[LENGTH(channels)];
double voltages[LENGTH(channels)];
for (uint8_t i = 0; i < LENGTH(channels); i++) {
adc_start_conversion_regular(ADC1); // start conversion (using trigger)
while (!adc_eoc(ADC1)); // wait until conversion finished
adc_values[i] = adc_read_regular(ADC1); // read voltage value (clears flag)
voltages[i] = adc_values[i] * 1.21 / adc_values[0]; // use 1.21 V internal voltage reference to get ADC voltage
}
return voltages[1];
}
/** get temperature of thermistor (in °C)
* @return thermistor temperature
*/
static double thermistor_temperature(void)
{
// convert to °C
// calibrated using a TP101
#define TEMP1 20.5
#define VOLTAGE1 1.813
#define TEMP2 37.9
#define VOLTAGE2 1.197
#define THERMISTOR_SLOPE ((TEMP2 - TEMP1) / (VOLTAGE2 - VOLTAGE1))
#define THERMISTOR_OFFSET (TEMP1 - VOLTAGE1 * THERMISTOR_SLOPE)
return thermistor_voltage() * THERMISTOR_SLOPE + THERMISTOR_OFFSET;
}
// menu commands
/** display available commands
* @param[in] argument no argument required
*/
static void command_help(void* argument);
/** show software and hardware version
* @param[in] argument no argument required
*/
static void command_version(void* argument)
{
(void)argument; // we won't use the argument
printf("firmware date: %04u-%02u-%02u\n", BUILD_YEAR, BUILD_MONTH, BUILD_DAY); // show firmware build date
printf("device serial: %08x%08x%08x\n", DESIG_UNIQUE_ID2, DESIG_UNIQUE_ID1, DESIG_UNIQUE_ID0); // show complete serial (different than the one used for USB)
}
/** convert RTC date/time to number of seconds
* @return number of seconds since 2000-01-01 00:00:00
* @warning for simplicity I consider every month to have 31 days
*/
static uint32_t rtc_to_seconds(void)
{
rtc_wait_for_synchro(); // wait until date/time is synchronised
const uint8_t year = ((RTC_DR >> RTC_DR_YT_SHIFT) & RTC_DR_YT_MASK) * 10 + ((RTC_DR >> RTC_DR_YU_SHIFT) & RTC_DR_YU_MASK); // get year
uint8_t month = ((RTC_DR >> RTC_DR_MT_SHIFT) & RTC_DR_MT_MASK) * 10 + ((RTC_DR >> RTC_DR_MU_SHIFT) & RTC_DR_MU_MASK); // get month
if ((RTC_ISR & RTC_ISR_INITS) && month > 0) { // month has been initialized, but starts with 1
month--; // fix for calculation
}
uint8_t day = ((RTC_DR >> RTC_DR_DT_SHIFT) & RTC_DR_DT_MASK) * 10 + ((RTC_DR >> RTC_DR_DU_SHIFT) & RTC_DR_DU_MASK); // get day
if ((RTC_ISR & RTC_ISR_INITS) && day > 0) { // day has been initialized, but starts with 1
day--; // fix for calculation
}
uint8_t hour = ((RTC_TR >> RTC_TR_HT_SHIFT) & RTC_TR_HT_MASK) * 10 + ((RTC_TR >> RTC_TR_HU_SHIFT) & RTC_TR_HU_MASK); // get hours
if (RTC_TR & RTC_TR_PM) { // PM notation is used
hour += 12;
}
const uint8_t minute = ((RTC_TR >> RTC_TR_MNT_SHIFT) & RTC_TR_MNT_MASK) * 10 + ((RTC_TR >> RTC_TR_MNU_SHIFT) & RTC_TR_MNU_MASK); // get minutes
const uint8_t second = ((RTC_TR >> RTC_TR_ST_SHIFT) & RTC_TR_ST_MASK) * 10 + ((RTC_TR >> RTC_TR_SU_SHIFT) & RTC_TR_SU_MASK); // get seconds
const uint32_t seconds = ((((((((year * 12) + month) * 31) + day) * 24) + hour) * 60) + minute) * 60 + second; // convert to number of seconds
return seconds;
}
/** show uptime
* @param[in] argument no argument required
*/
static void command_uptime(void* argument)
{
(void)argument; // we won't use the argument
const uint32_t uptime = rtc_to_seconds() - boot_time; // get time from internal RTC
printf("uptime: %u.%02u:%02u:%02u\n", uptime / (24 * 60 * 60), (uptime / (60 * 60)) % 24, (uptime / 60) % 60, uptime % 60);
}
/** show date and time
* @param[in] argument date and time to set
*/
static void command_datetime(void* argument)
{
char* datetime = (char*)argument; // argument is optional date time
const char* days[] = { "??", "Mo", "Tu", "We", "Th", "Fr", "Sa", "Su"}; // the days of the week
// set date
if (datetime) { // date has been provided
// parse date
const char* malformed = "date and time malformed, expecting YYYY-MM-DD WD HH:MM:SS\n";
if (strlen(datetime) != (4 + 1 + 2 + 1 + 2) + 1 + 2 + 1 + (2 + 1 + 2 + 1 + 2)) { // verify date/time is long enough
printf(malformed);
return;
}
if (!(isdigit((int8_t)datetime[0]) && isdigit((int8_t)datetime[1]) && isdigit((int8_t)datetime[2]) && isdigit((int8_t)datetime[3]) && \
'-' == datetime[4] && \
isdigit((int8_t)datetime[5]) && isdigit((int8_t)datetime[6]) && \
'-' == datetime[7] && \
isdigit((int8_t)datetime[8]) && isdigit((int8_t)datetime[9]) && \
' ' == datetime[10] && \
isalpha((int8_t)datetime[11]) && isalpha((int8_t)datetime[12]) && \
' ' == datetime[13] && \
isdigit((int8_t)datetime[14]) && isdigit((int8_t)datetime[15]) && \
':' == datetime[16] && \
isdigit((int8_t)datetime[17]) && isdigit((int8_t)datetime[18]) && \
':' == datetime[19] && \
isdigit((int8_t)datetime[20]) && isdigit((int8_t)datetime[21]))) { // verify format (good enough to not fail parsing)
printf(malformed);
return;
}
const uint16_t year = strtol(&datetime[0], NULL, 10); // parse year
if (year <= 2000 || year > 2099) {
puts("year out of range\n");
return;
}
const uint8_t month = strtol(&datetime[5], NULL, 10); // parse month
if (month < 1 || month > 12) {
puts("month out of range\n");
return;
}
const uint8_t day = strtol(&datetime[8], NULL, 10); // parse day
if (day < 1 || day > 31) {
puts("day out of range\n");
return;
}
const uint8_t hour = strtol(&datetime[14], NULL, 10); // parse hour
if (hour > 24) {
puts("hour out of range\n");
return;
}
const uint8_t minute = strtol(&datetime[17], NULL, 10); // parse minutes
if (minute > 59) {
puts("minute out of range\n");
return;
}
const uint8_t second = strtol(&datetime[30], NULL, 10); // parse seconds
if (second > 59) {
puts("second out of range\n");
return;
}
uint8_t week_day = 0;
for (uint8_t i = 1; i < LENGTH(days) && 0 == week_day; i++) {
if (days[i][0] == toupper(datetime[11]) && days[i][1] == tolower(datetime[12])) {
week_day = i;
break;
}
}
if (0 == week_day) {
puts("unknown week day\n");
return;
}
uint32_t date = 0; // to build the date
date |= (((year - 2000) / 10) & RTC_DR_YT_MASK) << RTC_DR_YT_SHIFT; // set year tenth
date |= (((year - 2000) % 10) & RTC_DR_YU_MASK) << RTC_DR_YU_SHIFT; // set year unit
date |= ((month / 10) & RTC_DR_MT_MASK) << RTC_DR_MT_SHIFT; // set month tenth
date |= ((month % 10) & RTC_DR_MU_MASK) << RTC_DR_MU_SHIFT; // set month unit
date |= ((day / 10) & RTC_DR_DT_MASK) << RTC_DR_DT_SHIFT; // set day tenth
date |= ((day % 10) & RTC_DR_DU_MASK) << RTC_DR_DU_SHIFT; // set day unit
date |= (week_day & RTC_DR_WDU_MASK) << RTC_DR_WDU_SHIFT; // time day of the week
uint32_t time = 0; // to build the time
time = 0; // reset time
time |= ((hour / 10) & RTC_TR_HT_MASK) << RTC_TR_HT_SHIFT; // set hour tenth
time |= ((hour % 10) & RTC_TR_HU_MASK) << RTC_TR_HU_SHIFT; // set hour unit
time |= ((minute / 10) & RTC_TR_MNT_MASK) << RTC_TR_MNT_SHIFT; // set minute tenth
time |= ((minute % 10) & RTC_TR_MNU_MASK) << RTC_TR_MNU_SHIFT; // set minute unit
time |= ((second / 10) & RTC_TR_ST_MASK) << RTC_TR_ST_SHIFT; // set second tenth
time |= ((second % 10) & RTC_TR_SU_MASK) << RTC_TR_SU_SHIFT; // set second unit
// write date
pwr_disable_backup_domain_write_protect(); // disable backup protection so we can set the RTC clock source
rtc_unlock(); // enable writing RTC registers
RTC_ISR |= RTC_ISR_INIT; // enter initialisation mode
while (!(RTC_ISR & RTC_ISR_INITF)); // wait to enter initialisation mode
RTC_DR = date; // set date
RTC_TR = time; // set time
RTC_ISR &= ~RTC_ISR_INIT; // exit initialisation mode
rtc_lock(); // protect RTC register against writing
pwr_enable_backup_domain_write_protect(); // re-enable protection now that we configured the RTC clock
boot_time = rtc_to_seconds() - boot_time; // adjust boot time
}
// show date
if (!(RTC_ISR & RTC_ISR_INITS)) { // date has not been set yet
puts("date/time not initialized\n");
} else {
rtc_wait_for_synchro(); // wait until date/time is synchronised
const uint8_t year = ((RTC_DR >> RTC_DR_YT_SHIFT) & RTC_DR_YT_MASK) * 10 + ((RTC_DR >> RTC_DR_YU_SHIFT) & RTC_DR_YU_MASK); // get year
const uint8_t month = ((RTC_DR >> RTC_DR_MT_SHIFT) & RTC_DR_MT_MASK) * 10 + ((RTC_DR >> RTC_DR_MU_SHIFT) & RTC_DR_MU_MASK); // get month
const uint8_t day = ((RTC_DR >> RTC_DR_DT_SHIFT) & RTC_DR_DT_MASK) * 10 + ((RTC_DR >> RTC_DR_DU_SHIFT) & RTC_DR_DU_MASK); // get day
const uint8_t week_day = ((RTC_DR >> RTC_DR_WDU_SHIFT) & RTC_DR_WDU_MASK); // get week day
const uint8_t hour = ((RTC_TR >> RTC_TR_HT_SHIFT) & RTC_TR_HT_MASK) * 10 + ((RTC_TR >> RTC_TR_HU_SHIFT) & RTC_TR_HU_MASK); // get hours
const uint8_t minute = ((RTC_TR >> RTC_TR_MNT_SHIFT) & RTC_TR_MNT_MASK) * 10 + ((RTC_TR >> RTC_TR_MNU_SHIFT) & RTC_TR_MNU_MASK); // get minutes
const uint8_t second = ((RTC_TR >> RTC_TR_ST_SHIFT) & RTC_TR_ST_MASK) * 10 + ((RTC_TR >> RTC_TR_SU_SHIFT) & RTC_TR_SU_MASK); // get seconds
printf("date: 20%02d-%02d-%02d %s %02d:%02d:%02d\n", year, month, day, days[week_day], hour, minute, second);
}
}
/** reset board
* @param[in] argument no argument required
*/
static void command_reset(void* argument)
{
(void)argument; // we won't use the argument
scb_reset_system(); // reset device
while (true); // wait for the reset to happen
}
/** switch to system memory (e.g. embedded bootloader)
* @param[in] argument no argument required
*/
static void command_system(void* argument)
{
(void)argument; // we won't use the argument
system_memory(); // jump to system memory
}
/** switch to DFU bootloader
* @param[in] argument no argument required
*/
static void command_bootloader(void* argument)
{
(void)argument; // we won't use the argument
dfu_bootloader(); // start DFU bootloader
}
/** show current state, e.g. all current measurements
* @param[in] argument no argument required
*/
static void command_state(void* argument)
{
(void)argument; // we won't use the argument
puts("sourdough starter statistics:\n");
uint32_t height = ((container_height && starter_height) ? (container_height - starter_height) : 0);
printf("initial height: %u mm\n", height);
height = ((container_height && current_height) ? (container_height - current_height) : 0);
printf("current height: %u mm\n", height);
printf("sourdough temperature: %.02f °C\n", levain_temp);
printf("heater temperature: %.02f °C\n", heater_temp);
puts("heater: ");
puts(gpio_get(GPIO_PORT(HEATER_PIN), GPIO_PIN(HEATER_PIN)) ? "on\n" : "off\n");
uint32_t time = (levain_time ? (rtc_to_seconds() - levain_time) : 0);
printf("current time: %02u:%02u:%02u\n", time / (60 * 60), (time / 60) % 60, time % 60);
height = ((container_height && max_height) ? (container_height - max_height) : 0);
printf("maximum height: %u mm\n", height);
time = (max_time ? (max_time - levain_time) : 0);
printf("maximum height time: %02u:%02u:%02u\n", time / (60 * 60), (time / 60) % 60, time % 60);
}
/** list of all supported commands */
static const struct menu_command_t menu_commands[] = {
{
.shortcut = 'h',
.name = "help",
.command_description = "display help",
.argument = MENU_ARGUMENT_NONE,
.argument_description = NULL,
.command_handler = &command_help,
},
{
.shortcut = 'v',
.name = "version",
.command_description = "show software and hardware version",
.argument = MENU_ARGUMENT_NONE,
.argument_description = NULL,
.command_handler = &command_version,
},
{
.shortcut = 'u',
.name = "uptime",
.command_description = "show uptime",
.argument = MENU_ARGUMENT_NONE,
.argument_description = NULL,
.command_handler = &command_uptime,
},
{
.shortcut = 'd',
.name = "date",
.command_description = "show/set date and time",
.argument = MENU_ARGUMENT_STRING,
.argument_description = "[YYYY-MM-DD HH:MM:SS]",
.command_handler = &command_datetime,
},
{
.shortcut = 'r',
.name = "reset",
.command_description = "reset board",
.argument = MENU_ARGUMENT_NONE,
.argument_description = NULL,
.command_handler = &command_reset,
},
{
.shortcut = 'S',
.name = "system",
.command_description = "reboot into system memory",
.argument = MENU_ARGUMENT_NONE,
.argument_description = NULL,
.command_handler = &command_system,
},
{
.shortcut = 'B',
.name = "bootloader",
.command_description = "reboot into DFU bootloader",
.argument = MENU_ARGUMENT_NONE,
.argument_description = NULL,
.command_handler = &command_bootloader,
},
{
.shortcut = 's',
.name = "state",
.command_description = "show state",
.argument = MENU_ARGUMENT_NONE,
.argument_description = NULL,
.command_handler = &command_state,
},
};
static void command_help(void* argument)
{
(void)argument; // we won't use the argument
printf("available commands:\n");
menu_print_commands(menu_commands, LENGTH(menu_commands)); // print global commands
}
/** process user command
* @param[in] str user command string (\0 ended)
*/
static void process_command(char* str)
{
// ensure actions are available
if (NULL == menu_commands || 0 == LENGTH(menu_commands)) {
return;
}
// don't handle empty lines
if (!str || 0 == strlen(str)) {
return;
}
bool command_handled = false;
if (!command_handled) {
command_handled = menu_handle_command(str, menu_commands, LENGTH(menu_commands)); // try if this is not a global command
}
if (!command_handled) {
printf("command not recognized. enter help to list commands\n");
}
}
/** use buzzer to beep
* @param[in] beeps number of times to beep
*/
static void beep(uint8_t beeps)
{
for (uint8_t i = 0; i < beeps; i++) {
gpio_set(GPIO_PORT(BUZZER_PIN), GPIO_PIN(BUZZER_PIN)); // enable buzzer
sleep_ms(100); // buzz to show it is working
gpio_clear(GPIO_PORT(BUZZER_PIN), GPIO_PIN(BUZZER_PIN)); // disable buzzer
if (i + 1U < beeps) {
sleep_ms(100); // buzz to show it is working
}
}
gpio_clear(GPIO_PORT(BUZZER_PIN), GPIO_PIN(BUZZER_PIN)); // ensure buzzer is disabled
}
/** program entry point
* this is the firmware function started by the micro-controller
*/
void main(void);
void main(void)
{
#if DEBUG
// enable functionalities for easier debug
DBGMCU_CR |= DBGMCU_CR_IWDG_STOP; // stop independent watchdog counter when code is halted
DBGMCU_CR |= DBGMCU_CR_WWDG_STOP; // stop window watchdog counter when code is halted
DBGMCU_CR |= DBGMCU_CR_STANDBY; // allow debug also in standby mode (keep digital part and clock powered)
DBGMCU_CR |= DBGMCU_CR_STOP; // allow debug also in stop mode (keep clock powered)
DBGMCU_CR |= DBGMCU_CR_SLEEP; // allow debug also in sleep mode (keep clock powered)
#else
// setup watchdog to reset in case we get stuck (i.e. when an error occurred)
iwdg_set_period_ms(WATCHDOG_PERIOD); // set independent watchdog period
iwdg_start(); // start independent watchdog
#endif
board_setup(); // setup board
uart_setup(); // setup USART (for printing)
usb_cdcacm_setup(); // setup USB CDC ACM (for printing)
puts("\nwelcome to the CuVoodoo elevainitor sourdough starter raiser\n"); // print welcome message
#if DEBUG
// show reset cause
if (RCC_CSR & (RCC_CSR_LPWRRSTF | RCC_CSR_WWDGRSTF | RCC_CSR_IWDGRSTF | RCC_CSR_SFTRSTF | RCC_CSR_PORRSTF | RCC_CSR_PINRSTF)) {
puts("reset cause(s):");
if (RCC_CSR & RCC_CSR_LPWRRSTF) {
puts(" low-power");
}
if (RCC_CSR & RCC_CSR_WWDGRSTF) {
puts(" window-watchdog");
}
if (RCC_CSR & RCC_CSR_IWDGRSTF) {
puts(" independent-watchdog");
}
if (RCC_CSR & RCC_CSR_SFTRSTF) {
puts(" software");
}
if (RCC_CSR & RCC_CSR_PORRSTF) {
puts(" POR/PDR");
}
if (RCC_CSR & RCC_CSR_PINRSTF) {
puts(" pin");
}
putc('\n');
RCC_CSR |= RCC_CSR_RMVF; // clear reset flags
}
#endif
#if !(DEBUG)
// show watchdog information
printf("setup watchdog: %.2fs", WATCHDOG_PERIOD / 1000.0);
if (FLASH_OBR & FLASH_OBR_OPTERR) {
puts(" (option bytes not set in flash: software watchdog used, not automatically started at reset)\n");
} else if (FLASH_OBR & FLASH_OBR_WDG_SW) {
puts(" (software watchdog used, not automatically started at reset)\n");
} else {
puts(" (hardware watchdog used, automatically started at reset)\n");
}
#endif
// setup RTC
puts("setup RTC: ");
rcc_periph_clock_enable(RCC_RTC); // enable clock for RTC peripheral
if (!(RCC_BDCR && RCC_BDCR_RTCEN)) { // the RTC has not been configured yet
pwr_disable_backup_domain_write_protect(); // disable backup protection so we can set the RTC clock source
rtc_unlock(); // enable writing RTC registers
#if defined(MINIF401)
rcc_osc_on(RCC_LSE); // enable LSE clock
while (!rcc_is_osc_ready(RCC_LSE)); // wait until clock is ready
rtc_set_prescaler(256, 128); // set clock prescaler to 32768
RCC_BDCR = (RCC_BDCR & ~(RCC_BDCR_RTCSEL_MASK << RCC_BDCR_RTCSEL_SHIFT)) | (RCC_BDCR_RTCSEL_LSE << RCC_BDCR_RTCSEL_SHIFT); // select LSE as RTC clock source
#else
rcc_osc_on(RCC_LSI); // enable LSI clock
while (!rcc_is_osc_ready(RCC_LSI)); // wait until clock is ready
rtc_set_prescaler(250, 128); // set clock prescaler to 32000
RCC_BDCR = (RCC_BDCR & ~(RCC_BDCR_RTCSEL_MASK << RCC_BDCR_RTCSEL_SHIFT)) | (RCC_BDCR_RTCSEL_LSI << RCC_BDCR_RTCSEL_SHIFT); // select LSI as RTC clock source
#endif
RCC_BDCR |= RCC_BDCR_RTCEN; // enable RTC
rtc_lock(); // protect RTC register against writing
pwr_enable_backup_domain_write_protect(); // re-enable protection now that we configured the RTC clock
}
boot_time = rtc_to_seconds(); // remember the start time
puts("OK\n");
// setup wakeup timer for periodic checks
puts("setup wakeup: ");
// RTC needs to be configured beforehand
pwr_disable_backup_domain_write_protect(); // disable backup protection so we can write to the RTC registers
rtc_unlock(); // enable writing RTC registers
rtc_clear_wakeup_flag(); // clear flag for fresh start
#if defined(MINIF401)
rtc_set_wakeup_time((32768 / 2) / WAKEUP_FREQ - 1, RTC_CR_WUCLKSEL_RTC_DIV2); // set wakeup time based on LSE (keep highest precision, also enables the wakeup timer)
#else
rtc_set_wakeup_time((32000 / 2) / WAKEUP_FREQ - 1, RTC_CR_WUCLKSEL_RTC_DIV2); // set wakeup time based on LSI (keep highest precision, also enables the wakeup timer)
#endif
rtc_enable_wakeup_timer_interrupt(); // enable interrupt
rtc_lock(); // disable writing RTC registers
// important: do not re-enable backup_domain_write_protect, since this will prevent clearing flags (but RTC registers do not need to be unlocked)
puts("OK\n");
puts("setup heater: ");
rcc_periph_clock_enable(GPIO_RCC(HEATER_PIN)); // enable clock for GPIO port domain
gpio_mode_setup(GPIO_PORT(HEATER_PIN), GPIO_MODE_INPUT, GPIO_PUPD_NONE, GPIO_PIN(HEATER_PIN)); // set GPIO to input floating
const bool heater_ok = gpio_get(GPIO_PORT(HEATER_PIN), GPIO_PIN(HEATER_PIN)); // pin should be put high
gpio_mode_setup(GPIO_PORT(HEATER_PIN), GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO_PIN(HEATER_PIN)); // set pin as output
gpio_set_output_options(GPIO_PORT(HEATER_PIN), GPIO_OTYPE_OD, GPIO_OSPEED_2MHZ, GPIO_PIN(HEATER_PIN)); // set pin output as open-drain
heater_off(); // set heater off
if (heater_ok) {
puts("OK\n");
} else {
puts("KO\n");
}
puts("setup HC-SR04 range sensor: ");
sensor_sr04_setup(); // setup peripheral
sensor_sr04_distance = 0; // clear flag
sensor_sr04_trigger(); // start measurement
while(!sensor_sr04_distance); // wait for measurement to complete
const bool sensor_sr04_ok = (1 != sensor_sr04_distance); // if no echo received, the module is not present
sensor_sr04_distance = 0; // clear flag
if (sensor_sr04_ok) {
puts("OK\n");
} else {
puts("KO\n");
}
puts("setup DS18B20 temperature sensor: ");
sensor_ds18b20_setup(); // setup peripheral
const bool sensor_ds18b20_present = (1 == sensor_ds18b20_number() && sensor_ds18b20_only()); // ensure there is only one ds18b20 sensor on the bus (so we don't have to use its ROM code)
if (sensor_ds18b20_present) {
sensor_ds18b20_precision(0, 12); // use highest resolution. it requires 750 ms to do the conversion, but we only check once a second
sensor_ds18b20_convert(0); // start the conversion
puts("OK\n");
} else {
puts("KO\n");
}
puts("setup ADC for thermistor: ");
rcc_periph_clock_enable(RCC_ADC1); // enable clock for ADC domain
adc_power_off(ADC1); // switch off ADC while configuring it
adc_set_right_aligned(ADC1); // ensure it is right aligned to get the actual value in the 16-bit register
adc_enable_scan_mode(ADC1); // use scan mode do be able to go to next discontinuous subgroup of the regular sequence
adc_enable_discontinuous_mode_regular(ADC1, 1); // use discontinuous mode (to go through all channels of the group, one after another)
adc_set_single_conversion_mode(ADC1); // ensure continuous mode is not used (that's not the same as discontinuous)
adc_eoc_after_each(ADC1); // set EOC after each conversion instead of each group
adc_set_sample_time_on_all_channels(ADC1, ADC_SMPR_SMP_28CYC); // use at least 15 cycles to be able to sample at 12-bit resolution
adc_set_regular_sequence(ADC1, LENGTH(channels), (uint8_t*)channels); // set channel to convert
adc_enable_temperature_sensor(); // enable internal voltage reference
adc_power_on(ADC1); // switch on ADC
sleep_us(3); // wait t_stab for the ADC to stabilize
rcc_periph_clock_enable(RCC_ADC1_IN(THERMISTOR_CHANNEL)); // enable clock for GPIO domain for thermistor channel
gpio_mode_setup(ADC1_IN_PORT(THERMISTOR_CHANNEL), GPIO_MODE_ANALOG, GPIO_PUPD_NONE, ADC1_IN_PIN(THERMISTOR_CHANNEL)); // set thermistor channel as analog input for the ADC
const bool thermsitor_ok = (thermistor_voltage() > 1.0 && thermistor_voltage() < 2.0); // ensure thermistor is connected
if (thermsitor_ok) {
puts("OK\n");
} else {
puts("KO\n");
}
puts("setup SSD1306 OLED display: ");
const bool oled_text_ok = oled_text_setup(); // setup display
if (oled_text_ok) {
oled_text_clear();
oled_text_line("ELEVAINITOR", 0);
oled_text_update();
puts("OK\n");
} else {
puts("KO\n");
}
// show status
const bool all_ok = heater_ok && sensor_sr04_ok && sensor_ds18b20_present && thermsitor_ok && oled_text_ok;
if (oled_text_ok) {
if (all_ok) {
oled_text_line("press button", 1);
oled_text_line("no sourdough", 2);
oled_text_update();
} else {
oled_text_line("error", 1);
if (!heater_ok) {
oled_text_line("heater", 2);
} else if (!sensor_sr04_ok) {
oled_text_line("heater MOSFET", 2);
} else if (!sensor_ds18b20_present) {
oled_text_line("heater thermo.", 2);
} else if (!thermsitor_ok) {
oled_text_line("thermistor", 2);
} else {
oled_text_line("unknown", 2);
}
oled_text_update();
}
}
puts("setup buzzer: ");
rcc_periph_clock_enable(GPIO_RCC(BUZZER_PIN)); // enable clock for GPIO port domain
gpio_clear(GPIO_PORT(BUZZER_PIN), GPIO_PIN(BUZZER_PIN)); // disable buzzer
gpio_mode_setup(GPIO_PORT(BUZZER_PIN), GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO_PIN(BUZZER_PIN)); // set pin as output
gpio_set_output_options(GPIO_PORT(BUZZER_PIN), GPIO_OTYPE_PP, GPIO_OSPEED_2MHZ, GPIO_PIN(BUZZER_PIN)); // set pin output as push-pull
beep(1); // buzz to show it is working
puts("OK\n");
// setup terminal
terminal_prefix = ""; // set default prefix
terminal_process = &process_command; // set central function to process commands
terminal_setup(); // start terminal
// start main loop
bool action = false; // if an action has been performed don't go to sleep
button_flag = false; // reset button flag
led_on(); // switch LED to indicate booting completed
uint32_t peak_time = 0; // when the sourdough starter has reached its peak
while (true) { // infinite loop
iwdg_reset(); // kick the dog
if (user_input_available) { // user input is available
action = true; // action has been performed
led_toggle(); // toggle LED
char c = user_input_get(); // store receive character
terminal_send(c); // send received character to terminal
}
if (button_flag) { // user pressed button
action = true; // action has been performed
puts("button pressed\n");
led_toggle(); // toggle LED
if (!all_ok) {
puts("can only start when all peripherals are ok\n");
puts("restart to check again\n");
} else if (0 == container_height) { // time to get container height
puts("container height: ");
sleep_ms(2000); // wait for used to remove his finger from the lid
sensor_sr04_distance = 0; // clear measurement
sensor_sr04_trigger(); // start measurement
while (!sensor_sr04_distance); // wait for distance measurement
if (1 == sensor_sr04_distance) {
puts("range sensor not available\n");
break;
} else if (sensor_sr04_distance > 255) {
puts("probably not on container\n");
break;
} else { // valid height
container_height = sensor_sr04_distance; // remember height
printf("%u mm\n", container_height); // display measurement
oled_text_line("with starter", 2); // display next instruction
oled_text_update(); // show instruction
beep(1); // beep to indicate action completed
}
sensor_sr04_distance = 0; // clear measurement
} else if (0 == levain_time || 0 == starter_height) { // time to start monitoring
puts("starter height: ");
sleep_ms(2000); // wait for used to remove his finger from the lid
sensor_sr04_distance = 0; // clear measurement
sensor_sr04_trigger(); // start measurement
while (!sensor_sr04_distance); // wait for distance measurement
if (1 == sensor_sr04_distance) {
puts("range sensor not available\n");
break;
} else if (sensor_sr04_distance >= container_height) {
puts("probably no starter\n");
break;
} else { // valid height
starter_height = sensor_sr04_distance; // remember height
max_height = starter_height; // initialize the maximum height
levain_time = rtc_to_seconds(); // remember when we start monitoring
max_time = levain_time; // initialize the maximum height time
printf("%u mm\n", starter_height); // display measurement
beep(1); // beep to indicate action completed
}
sensor_sr04_distance = 0; // clear measurement
}
sleep_ms(100); // wait a bit to remove noise and double trigger
button_flag = false; // reset flag
}
if (wakeup_flag) { // time to do periodic checks
wakeup_flag = false; // clear flag
}
if (second_flag) { // one second passed
second_flag = false; // clear flag
action = true; // action will be performed
led_toggle(); // toggle LED to indicate if main function is stuck
// get heater temperature
if (sensor_ds18b20_present) {
heater_temp = sensor_ds18b20_temperature(0); // get temperature
if (85.0 != heater_temp) { // the conversion has not been completed
sensor_ds18b20_convert(0); // start next conversion
}
}
// get sourdough starter temperature
if (thermsitor_ok) {
levain_temp = thermistor_temperature(); // get temperature
}
// update uptime
if (levain_time) {
const uint32_t uptime = rtc_to_seconds() - levain_time; // get time from internal RTC
char strtime[12]; // to store time representation
snprintf(strtime, sizeof(strtime), "%u.%02u:%02u:%02u", uptime / (24 * 60 * 60), (uptime / (60 * 60)) % 24, (uptime / 60) % 60, uptime % 60); // get uptime representation
oled_text_line(strtime, 1); // add text to display buffer
}
// get height
if (sensor_sr04_ok) { // sensor working
sensor_sr04_trigger(); // start measurement
}
// heat up sourdough starter
if (levain_time && !isnan(levain_temp) && heater_ok && !isnan(heater_temp)) {
if (levain_temp < levain_target - 0.5 && 0 == peak_time) { // temperature not reached
heater_on(); // keep heating
} else if (levain_temp > levain_target + 0.5) { // temperature reached
heater_off(); // stop heating
}
}
// turn off heater for safety
if (!isnan(heater_temp) && heater_temp > HEATER_LIMIT) {
heater_off(); // stop heating
}
// update how much the starter raised
if (current_height && container_height && starter_height && max_height && current_height <= starter_height) {
const float rising = (container_height - current_height) * 1.0 / (container_height - starter_height); // calculate ratio
char text[13]; // to store text representation
snprintf(text, sizeof(text), "%.02fx %.01fC", rising, levain_temp); // display ratio and temperature
oled_text_line(text, 2); // add text to display buffer
if (current_height < max_height && (current_height + 5U) > max_height) { // a new maximum height has been reached (and is credible)
max_height = current_height; // save new maximum height
max_time = rtc_to_seconds(); // remember the time
}
if (current_height > max_height + 5) { // the sourdough starter has been falling again
if (max_time > peak_time) {
heater_off(); // stop heating
peak_time = max_time; // remember the peak sourdough starter time
const float peak_ratio = (container_height - max_height) * 1.0 / (container_height - starter_height); // calculate ratio
const uint16_t peak_period = peak_time - levain_time; // calculate peak time
snprintf(text, sizeof(text), "%.02fx %um", peak_ratio, peak_period / 60); // display peak ratio and time
oled_text_line(text, 3); // add text to display buffer
beep(2); // beep to indicate the peak has been reached
}
}
}
// display new data (even if nothing new)
if (oled_text_ok) {
oled_text_update(); // display buffered data
}
}
if (sensor_sr04_distance) { // distance measurement is available
//printf("height: %u mm\n", sensor_sr04_distance);
current_height = sensor_sr04_distance; // save height
sensor_sr04_distance = 0; // clear flag
}
if (action) { // go to sleep if nothing had to be done, else recheck for activity
action = false;
} else {
__WFI(); // go to sleep
}
} // main loop
}
/** interrupt service routine when the wakeup timer triggered */
void rtc_wkup_isr(void)
{
static uint16_t tick = WAKEUP_FREQ; // how many wakeup have occurred
exti_reset_request(EXTI22); // clear EXTI flag used by wakeup
rtc_clear_wakeup_flag(); // clear flag
wakeup_flag = true; // notify main loop
tick--; // count the number of ticks down (do it in the ISR to no miss any tick)
if (0 == tick) { // count down completed
second_flag = true; // notify main loop a second has passed
tick = WAKEUP_FREQ; // restart count down
}
}
Reference in New Issue View Git Blame Copy Permalink