1326 lines
56 KiB
C
1326 lines
56 KiB
C
/** firmware for ThermoHybaid MBS 0.2G MBLK002 thermo-cycler replacement controller board
|
||
* @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
|
||
#include <libopencm3/stm32/timer.h> // timer utilities
|
||
|
||
/* own libraries */
|
||
#include "global.h" // board definitions
|
||
#include "print.h" // printing utilities
|
||
#include "usb_cdcacm.h" // USB CDC ACM utilities
|
||
#include "terminal.h" // handle the terminal interface
|
||
#include "menu.h" // menu utilities
|
||
#include "oled_text.h" // utilities to display text on OLED
|
||
#include "sensor_max1247.h" // to read the thermistor ADC values
|
||
#include "sensor_ds18b20.h" // to read temperature from a DS18B20
|
||
|
||
/** watchdog period in ms */
|
||
#define WATCHDOG_PERIOD 10000
|
||
|
||
/** set to 0 if the RTC is reset when the board is powered on, only indicates the uptime
|
||
* set to 1 if VBAT can keep the RTC running when the board is unpowered, indicating the date and time
|
||
*/
|
||
#define RTC_DATE_TIME 0
|
||
|
||
/** number of RTC ticks per second
|
||
* @note use integer divider of oscillator to keep second precision
|
||
*/
|
||
#define RTC_TICKS_SECOND 8
|
||
|
||
/** RTC time when device is started */
|
||
static time_t time_start = 0;
|
||
|
||
/** @defgroup main_flags flag set in interrupts to be processed in main task
|
||
* @{
|
||
*/
|
||
static volatile uint32_t rtc_internal_tick_flag = 0; /**< set with time when internal RTC ticked */
|
||
static volatile bool rtc_internal_second_flag = false; /**< set when a second passed */
|
||
/** @} */
|
||
|
||
#define BED_PIN_393A PB3 /**< pin connected to LN393 output A */
|
||
#define BED_PIN_3393 PB4 /**< pin connected to ST339 output 3 */
|
||
#define BED_PIN_LK1 PB5 /**< pin connected to link 1 */
|
||
#define BED_PIN_LK2 PC14 /**< pin connected to link 2 */
|
||
#define BED_PIN_LK3 PC15 /**< pin connected to link 3 */
|
||
#define BED_PIN_LK4 PB1 /**< pin connected to link 4 */
|
||
|
||
#define LID_TEC_CHANNEL 0 /**< PA0/ADC12_CH0 is connected to the 12 kOhm thermistor in the lid heater */
|
||
#define LID_HEATER_PIN PA10 /**< pin to optocoupler cathode controlling triac to lid heater */
|
||
#define LID_HEATER_TIMER 1 /**< timer connected to lid heater pin */
|
||
#define LID_HEATER_CHANNEL 3 /**< timer channel connected to lid heater pin */
|
||
#define LID_HEATER_OC TIM_OC3 /**< output compare for timer channel connected to lid heater pin */
|
||
|
||
#define MBLK019_CH26_PIN PA1 /**< to control TR2/6 for the peltier elements */
|
||
#define MBLK019_CH14_PIN PA2 /**< to control TR1/4 for the peltier elements */
|
||
#define MBLK019_CH35_PIN PA4 /**< to control TR3/5 for the peltier elements */
|
||
#define MBLK019_PRESENCE_PIN PA3 /**< connected to ground when MBLK019 board is present */
|
||
|
||
#define CONTROL_PLAY_GREEN_LED_PIN PA5 /**< to control green LED of play/pause indicator (active high) */
|
||
#define led_cool_on() gpio_set(GPIO_PORT(CONTROL_PLAY_GREEN_LED_PIN), GPIO_PIN(CONTROL_PLAY_GREEN_LED_PIN)) /**< switch green play/pause LED on */
|
||
#define led_cool_off() gpio_clear(GPIO_PORT(CONTROL_PLAY_GREEN_LED_PIN), GPIO_PIN(CONTROL_PLAY_GREEN_LED_PIN)) /**< switch green play/pause LED off */
|
||
#define CONTROL_PLAY_ORANGE_LED_PIN PA6 /**< to control orange LED of play/pause indicator (active high) */
|
||
#define led_heat_on() gpio_set(GPIO_PORT(CONTROL_PLAY_ORANGE_LED_PIN), GPIO_PIN(CONTROL_PLAY_ORANGE_LED_PIN)) /**< switch orange play/pause LED on */
|
||
#define led_heat_off() gpio_clear(GPIO_PORT(CONTROL_PLAY_ORANGE_LED_PIN), GPIO_PIN(CONTROL_PLAY_ORANGE_LED_PIN)) /**< switch orange play/pause LED off */
|
||
#define CONTROL_POWER_RED_LED_PIN PA7 /**< to control red LED of power indicator (active high) */
|
||
#define led_power_on() gpio_set(GPIO_PORT(CONTROL_POWER_RED_LED_PIN), GPIO_PIN(CONTROL_POWER_RED_LED_PIN)) /**< switch power LED on */
|
||
#define led_power_off() gpio_clear(GPIO_PORT(CONTROL_POWER_RED_LED_PIN), GPIO_PIN(CONTROL_POWER_RED_LED_PIN)) /**< switch power LED off */
|
||
#define CONTROL_PLAY_BUTTON_LED_PIN PB0 /**< to read play/pause button (connected to ground when pressed) */
|
||
|
||
#define TEC_POWER_YELLOW PB11 /**< pin to choose which power rail to connect to yellow TEC power input (high = VCC, low = GND) */
|
||
#define tec_power_yellow_on() gpio_set(GPIO_PORT(TEC_POWER_YELLOW), GPIO_PIN(TEC_POWER_YELLOW)) // allow connecting yellow to VCC
|
||
#define tec_power_yellow_off() gpio_clear(GPIO_PORT(TEC_POWER_YELLOW), GPIO_PIN(TEC_POWER_YELLOW)) // allow connect yellow to GND
|
||
#define TEC_POWER_ORANGE PB10 /**< pin to choose which power rail to connect to orange TEC power input (high = VCC, low = GND) */
|
||
#define tec_power_orange_on() gpio_set(GPIO_PORT(TEC_POWER_ORANGE), GPIO_PIN(TEC_POWER_ORANGE)) // allow connect orange to VCC
|
||
#define tec_power_orange_off() gpio_clear(GPIO_PORT(TEC_POWER_ORANGE), GPIO_PIN(TEC_POWER_ORANGE)) // allow connect orange to GND
|
||
#define TEC_POWER_PWM PB9 /**< pin to actually let power go through TECs, where PWM can be used (active high) */
|
||
#define tec_power_pwm_on() gpio_set(GPIO_PORT(TEC_POWER_PWM), GPIO_PIN(TEC_POWER_PWM)) /**< connect yellow/orange wire as set */
|
||
#define tec_power_pwm_off() gpio_clear(GPIO_PORT(TEC_POWER_PWM), GPIO_PIN(TEC_POWER_PWM)) /**< disconnect yellow/orange wire */
|
||
#define TEC_POWER_TIMER 4 /**< timer connected to pin */
|
||
#define TEC_POWER_CHANNEL 4 /**< timer channel connected to pin */
|
||
#define TEC_POWER_OC TIM_OC4 /**< timer output compare connected to pin */
|
||
|
||
#define HEATSINK_FAN_PIN PA15 /**< pin to switch the nMOS to control the fan cooling the bad heatsink, low to disable, pulled up externally, must be 5V tolerant */
|
||
#define heatsink_fan_on() gpio_set(GPIO_PORT(HEATSINK_FAN_PIN), GPIO_PIN(HEATSINK_FAN_PIN)) /**< switch fan on, cooling the bed heat sink */
|
||
#define heatsink_fan_off() gpio_clear(GPIO_PORT(HEATSINK_FAN_PIN), GPIO_PIN(HEATSINK_FAN_PIN)) /**< switch fan off, when the bed is not used */
|
||
|
||
static bool led_power_blink = false; /**< remember we are blinking the power LED */
|
||
static bool led_heat_blink = false; /**< remember we are blinking the orange play/pause LED */
|
||
static bool led_cool_blink = false; /**< remember we are blinking the green play/pause LED */
|
||
|
||
const uint8_t channels[] = {ADC_CHANNEL17, ADC_CHANNEL(LID_TEC_CHANNEL)}; /**< voltages to convert (channel 17 = internal voltage reference) */
|
||
static bool ds18b20_present = false; /**< if DS18B20 temperature sensor is present */
|
||
|
||
/** target temperature to be reached by the lid */
|
||
static float lid_target = NAN;
|
||
/** target temperature to be reached by the bed */
|
||
static uint16_t bed_target = 0;
|
||
|
||
/** the current state of the thermo-cycler */
|
||
enum state_e {
|
||
STATE_IDLE, /**< doing nothing, waiting for a command */
|
||
STATE_SAFE, /**< safe state entered, probably because of an error */
|
||
STATE_HEAT, /**< simply heat up bed */
|
||
STATE_COOL, /**< simply cool down bed */
|
||
STATE_FAN, /**< simply use fan to set to ambient temperature */
|
||
STATE_PREPARE, /**< heat up for initialisation/first denaturation */
|
||
STATE_INITIALISATION, /**< first (longer) denaturation phase */
|
||
STATE_TO_DENATURATION, /**< transition to denaturation phase */
|
||
STATE_DENATURATION, /**< denaturation phase */
|
||
STATE_TO_ANNEALING, /**< transition to annealing phase */
|
||
STATE_ANNEALING, /**< annealing phase */
|
||
STATE_TO_EXTENSTION, /**< transition to extension phase */
|
||
STATE_EXTENSION, /**< extension phase */
|
||
STATE_TO_HOLD, /**< transition to final hold */
|
||
STATE_HOLD, /**< final hold */
|
||
} state = STATE_IDLE;
|
||
|
||
/** name of the states */
|
||
const char* state_names[] = {
|
||
[STATE_IDLE] = "ready",
|
||
[STATE_SAFE] = "safe",
|
||
[STATE_HEAT] = "heating",
|
||
[STATE_COOL] = "cooling",
|
||
[STATE_FAN] = "fanning",
|
||
[STATE_PREPARE] = ">initialisation",
|
||
[STATE_INITIALISATION] = "initialisation",
|
||
[STATE_TO_DENATURATION] = ">denaturation",
|
||
[STATE_DENATURATION] = "denaturation",
|
||
[STATE_TO_ANNEALING] = ">annealing",
|
||
[STATE_ANNEALING] = "annealing",
|
||
[STATE_TO_EXTENSTION] = ">extension",
|
||
[STATE_EXTENSION] = "extension",
|
||
// there is an optional final extension
|
||
[STATE_TO_HOLD] = ">final hold",
|
||
[STATE_HOLD] = "final hold",
|
||
};
|
||
|
||
/** set if an error or anomaly has been encountered */
|
||
static char* error = NULL;
|
||
|
||
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
|
||
usb_cdcacm_putchar('\r'); // send CR over USB
|
||
length++; // remember we printed 1 character
|
||
}
|
||
}
|
||
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
|
||
}
|
||
|
||
/** enter in safe state mode
|
||
* @note useful when an error occurred or an anomaly has been detected
|
||
*/
|
||
static void safe_state(void)
|
||
{
|
||
// this is the safest configuration of TEC switching (in cooling mode it switches all off, in heating mode it only heats mildly the top part
|
||
gpio_set(GPIO_PORT(MBLK019_CH26_PIN), GPIO_PIN(MBLK019_CH26_PIN)); // don't sink current (e.g. not powering the opto-coupler/transistor)
|
||
gpio_set(GPIO_PORT(MBLK019_CH14_PIN), GPIO_PIN(MBLK019_CH14_PIN)); // don't sink current (e.g. not powering the opto-coupler/transistor)
|
||
gpio_set(GPIO_PORT(MBLK019_CH35_PIN), GPIO_PIN(MBLK019_CH35_PIN)); // don't sink current (e.g. not powering the opto-coupler/transistor)
|
||
|
||
// take control over the H-bridge and switch it off
|
||
rcc_periph_clock_enable(GPIO_RCC(TEC_POWER_PWM)); // enable clock for GPIO port peripheral
|
||
gpio_set_mode(GPIO_PORT(TEC_POWER_PWM), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO_PIN(TEC_POWER_PWM)); // set pin as output
|
||
tec_power_pwm_off(); // switch off power
|
||
tec_power_yellow_off(); // connect wire to ground
|
||
tec_power_orange_off(); // connect wire to ground
|
||
|
||
// disable heater lid
|
||
rcc_periph_clock_enable(GPIO_RCC(LID_HEATER_PIN)); // enable clock for GPIO port peripheral
|
||
gpio_set_mode(GPIO_PORT(LID_HEATER_PIN), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_OPENDRAIN, GPIO_PIN(LID_HEATER_PIN)); // set pin back as output open-drain
|
||
gpio_set(GPIO_PORT(LID_HEATER_PIN), GPIO_PIN(LID_HEATER_PIN)); // don't sink current, not powering the opto-coupler and triac
|
||
|
||
heatsink_fan_off(); // bed is not active, so we can stop the fan, since we want to stop drawing power and having spinning things
|
||
|
||
led_heat_blink = false; // stop blinking LED
|
||
led_heat_off(); // switch off LED
|
||
led_cool_blink = false; // stop blinking LED
|
||
led_cool_off(); // switch off LED
|
||
|
||
if (error) {
|
||
led_power_blink = false; // start blinking red LED to indicate error
|
||
oled_text_line("error", 2);
|
||
oled_text_update();
|
||
}
|
||
}
|
||
|
||
/** get temperature of lid (in °C)
|
||
* @return lid temperature
|
||
*/
|
||
static float lid_temperature(void)
|
||
{
|
||
// read lid temperature using ADC
|
||
ADC_SR(ADC1) = 0; // reset flags
|
||
uint16_t adc_values[LENGTH(channels)];
|
||
float 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.2 / adc_values[0]; // use 1.2V internal voltage reference to get ADC voltage
|
||
}
|
||
//return voltages[1];
|
||
|
||
// convert to °C
|
||
// calibrated using a DS18B20 (accuracy = +- 0.5°C), with 12-bit precision
|
||
// 2.3491 V = 21.500 C, 0.1337 V = 104.9 °C
|
||
return -37.6456 * voltages[1] + 109.933;
|
||
}
|
||
|
||
/** set the power delivered to the lid heater
|
||
* @param[in] percent power (e.g. duty cycle) in %
|
||
* @note we use % since we control the duty cycle of a 1s period over a triac (e.g. 100 Hz control)
|
||
*/
|
||
static void lid_power(uint8_t percent)
|
||
{
|
||
if (STATE_SAFE == state && 0 != percent) {
|
||
puts("can't set lid power in safe state\n");
|
||
return;
|
||
}
|
||
|
||
if (0 == percent) {
|
||
timer_set_oc_value(TIM(LID_HEATER_TIMER), LID_HEATER_OC, 0); // duty cycle to 0%, to switch off heater
|
||
} else if (percent >= 100) {
|
||
timer_set_oc_value(TIM(LID_HEATER_TIMER), LID_HEATER_OC, UINT16_MAX); // duty cycle to 100%, to switch completely on heater
|
||
} else {
|
||
timer_set_oc_value(TIM(LID_HEATER_TIMER), LID_HEATER_OC, UINT16_MAX / 100 * percent - 1); // set duty cycle
|
||
}
|
||
}
|
||
|
||
/** run PID control for lid temperature */
|
||
static void lid_pid(void)
|
||
{
|
||
// I tried Ziegler–Nichols method, but it overshoots and oscillates far too much (even with the no overshoot rule)
|
||
//#define LID_KU 64
|
||
//#define LID_TU 14.96
|
||
//#define LID_KP (0.2 * LID_KU)
|
||
//#define LID_KI (0.4 * LID_KU / LID_TU)
|
||
//#define LID_KD (0.066 * LID_KU * LID_TU)
|
||
#define LID_KP 24.0
|
||
#define LID_KI 0.0
|
||
#define LID_KD 0.0
|
||
|
||
if (isnan(lid_target)) { // no target has been defined
|
||
lid_power(0);
|
||
// reinitialise errors
|
||
return;
|
||
}
|
||
|
||
static float error_sum = 0.0; // value used for the integral part
|
||
static float error_prev = 0.0; // value used for the derivate part
|
||
const float error_cur = lid_target - lid_temperature(); // get current error
|
||
error_sum += error_cur;
|
||
const float error_diff = error_cur - error_prev;
|
||
error_prev = error_cur;
|
||
float power = LID_KP * error_cur + LID_KI * error_sum + LID_KD * error_diff; // calculate needed power
|
||
// enforce limits
|
||
if (power < 0.0) {
|
||
power = 0.0;
|
||
} else if (power > 50.0) { // limit power to 50%, else it gets too warm too quick and could damage the hardware
|
||
power = 50.0;
|
||
}
|
||
lid_power((uint8_t)power); // set power
|
||
}
|
||
|
||
static void tec_power(uint16_t duty_cycle)
|
||
{
|
||
if (STATE_SAFE == state && 0 != duty_cycle) { // don't allow setting in save state (except switching off)
|
||
puts("can't set TEC power in safe state\n");
|
||
return;
|
||
}
|
||
|
||
timer_set_oc_value(TIM(TEC_POWER_TIMER), TEC_POWER_OC, duty_cycle); // duty cycle to 0%, to switch off heater
|
||
// ensure the fan is on when there is power
|
||
if (duty_cycle) {
|
||
heatsink_fan_on();
|
||
}
|
||
}
|
||
|
||
/** set TEC to heat */
|
||
static void tec_heat(void)
|
||
{
|
||
tec_power(0); // ensure power is off while switching
|
||
sleep_ms(2); // wait for the PWM to take effect
|
||
tec_power_orange_off(); // connect GND from orange TEC line
|
||
tec_power_yellow_on(); // connect VCC to yellow TEC line
|
||
|
||
// set TEC configuration to heat the top half at max
|
||
// the following heating configurations exist (when orange is connected to minus and yellow to plus)
|
||
// 26 14 35 top bott A@3V
|
||
// -- -- -- heat off 0.6
|
||
// ++ -- -- heat heat 0.6
|
||
// -- ++ -- heat heat 0.8
|
||
// -- -- ++ off heat 0.8
|
||
// -- ++ ++ off heat 1.1
|
||
// ++ -- ++ off heat 1.1
|
||
// ++ ++ -- heat heat 0.8
|
||
// ++ ++ ++ off heat 1.5
|
||
gpio_clear(GPIO_PORT(MBLK019_CH26_PIN), GPIO_PIN(MBLK019_CH26_PIN)); // sink current, powering the opto-coupler, switching the transistor on
|
||
gpio_clear(GPIO_PORT(MBLK019_CH14_PIN), GPIO_PIN(MBLK019_CH14_PIN)); // sink current, powering the opto-coupler, switching the transistor on
|
||
gpio_clear(GPIO_PORT(MBLK019_CH35_PIN), GPIO_PIN(MBLK019_CH35_PIN)); // sink current, powering the opto-coupler, switching the transistor on
|
||
}
|
||
|
||
/** set TEC to cool */
|
||
static void tec_cool(void)
|
||
{
|
||
tec_power(0); // ensure power is off while switching
|
||
sleep_ms(2); // wait for the PWM to take effect
|
||
tec_power_yellow_off(); // connect GND from yellow TEC line
|
||
tec_power_orange_on(); // connect VCC to orange TEC line
|
||
|
||
// set TEC configuration to cool the top half at max
|
||
// the following heating configurations exist (when orange is connected to minus and yellow to plus)
|
||
// 26 14 35 top bot A@3V
|
||
// -- -- -- off off 0.0
|
||
// ++ -- -- off heat 0.6
|
||
// -- ++ -- off cool 0.8
|
||
// -- -- ++ off off 0.0
|
||
// -- ++ ++ cool cool 1.5
|
||
// ++ -- ++ off heat 1.5
|
||
// ++ ++ -- cool off 1.4
|
||
// ++ ++ ++ cool heat 2.1
|
||
// cool only top at max power
|
||
gpio_clear(GPIO_PORT(MBLK019_CH26_PIN), GPIO_PIN(MBLK019_CH26_PIN)); // sink current, powering the opto-coupler, switching the transistor on
|
||
gpio_clear(GPIO_PORT(MBLK019_CH14_PIN), GPIO_PIN(MBLK019_CH14_PIN)); // sink current, powering the opto-coupler, switching the transistor on
|
||
gpio_set(GPIO_PORT(MBLK019_CH35_PIN), GPIO_PIN(MBLK019_CH35_PIN)); // don't sink current, not powering the opto-coupler, switching the transistor off
|
||
// cool top and bottom, sharing the load
|
||
//gpio_set(GPIO_PORT(MBLK019_CH26_PIN), GPIO_PIN(MBLK019_CH26_PIN));
|
||
//gpio_clear(GPIO_PORT(MBLK019_CH14_PIN), GPIO_PIN(MBLK019_CH14_PIN));
|
||
//gpio_clear(GPIO_PORT(MBLK019_CH35_PIN), GPIO_PIN(MBLK019_CH35_PIN));
|
||
}
|
||
|
||
/** read bed top half temperature
|
||
* @return temperature in °C
|
||
*/
|
||
static float bed_tophalf_temperature(void)
|
||
{
|
||
const uint16_t measurement = sensor_max1247_read(0); // read measured value from corresponding thermistor
|
||
|
||
// convert to °C
|
||
// calibrated using a DS18B20 (accuracy = +- 0.5°C), with 12-bit precision
|
||
// 558 = 19.500 °C, 616 = 21.8 °C, 1624 = 50.625 °C, 2850 = 82.250 °C, 2926 = 83.625 °C
|
||
|
||
return measurement * 0.0270798 + 4.38946;
|
||
}
|
||
|
||
/** read bed bottom half temperature
|
||
* @return temperature in °C
|
||
*/
|
||
static float bed_bothalf_temperature(void)
|
||
{
|
||
const uint16_t measurement = sensor_max1247_read(1); // read measured value from corresponding thermistor
|
||
|
||
// convert to °C
|
||
// calibrated using a DS18B20 (accuracy = +- 0.5°C), with 12-bit precision
|
||
// 549 = 19.312 °C, 12 = 63.3 °C
|
||
|
||
return measurement * 0.0270798 + 4.38946;
|
||
}
|
||
|
||
/** read bed tube temperature
|
||
* @return temperature in °C
|
||
*/
|
||
static float bed_tube_temperature(void)
|
||
{
|
||
const uint16_t measurement = sensor_max1247_read(3); // read measured value from corresponding thermistor
|
||
|
||
// convert to °C
|
||
// calibrated using a TP101 with 0.1 °C precision (unknown accuracy but is on par with DS18B20)
|
||
// 557 = 19.5 °C, 3221 = 100.9 °C
|
||
|
||
return measurement * 0.0305556 + 2.48056;
|
||
}
|
||
|
||
/** read heat sink temperature
|
||
* @return temperature in °C
|
||
*/
|
||
static float bed_heatsink_temperature(void)
|
||
{
|
||
const uint16_t measurement = sensor_max1247_read(2); // read measured value from corresponding thermistor
|
||
|
||
// convert to °C
|
||
// calibrated using a DS18B20 (accuracy = +- 0.5°C), with 12-bit precision
|
||
// 557 = 19.312 °C, 1624 = 50.625 °C
|
||
|
||
return measurement * 0.0273778 + 4.22317;
|
||
}
|
||
|
||
/** run PID control for bed temperature (using the top half) */
|
||
static void bed_pid(void)
|
||
{
|
||
// I tried Ziegler–Nichols method, but it overshoots and oscillates far too much (even with the no overshoot rule)
|
||
//#define LID_KU 64
|
||
//#define LID_TU 14.96
|
||
//#define LID_KP (0.2 * LID_KU)
|
||
//#define LID_KI (0.4 * LID_KU / LID_TU)
|
||
//#define LID_KD (0.066 * LID_KU * LID_TU)
|
||
#define BED_KP 256
|
||
#define BED_KI 0
|
||
#define BED_KD 0
|
||
|
||
if (0 == bed_target) { // no target has been defined
|
||
tec_power(0);
|
||
// reinitialise errors
|
||
return;
|
||
}
|
||
|
||
static int32_t error_sum = 0; // value used for the integral part
|
||
static int32_t error_prev = 0; // value used for the derivate part
|
||
const uint16_t temperature = sensor_max1247_read(0); // read top half sensor
|
||
const int32_t error_cur = adds32_safe(bed_target, -temperature);
|
||
error_sum = adds32_safe(error_sum, error_cur);
|
||
const int32_t error_diff = adds32_safe(error_cur, -error_prev);
|
||
error_prev = error_cur;
|
||
const int32_t p = BED_KP * error_cur; // calculate proportional part
|
||
const int32_t i = BED_KI * error_sum; // calculate integral part
|
||
const int32_t d = BED_KD * error_diff; // calculate derivate part
|
||
int32_t power = adds32_safe(adds32_safe(p, i), d); // calculate needed power
|
||
if (STATE_COOL == state) {
|
||
power = -power;
|
||
}
|
||
// enforce limits
|
||
if (power < 0) {
|
||
power = 0;
|
||
} else if (power > UINT16_MAX ) {
|
||
power = UINT16_MAX;
|
||
}
|
||
printf("set: %u is: %u %.02f p: %d i: %d d: %d power: %d\n", bed_target, temperature, bed_tophalf_temperature(), p, i, d, power);
|
||
tec_power((uint16_t)power); // set power
|
||
}
|
||
|
||
/** set new state
|
||
* @param[in] new new state to set
|
||
*/
|
||
static void set_state(enum state_e new)
|
||
{
|
||
if (STATE_SAFE == state && STATE_SAFE != new) {
|
||
puts("restart controller to exit safe state\n");
|
||
return;
|
||
}
|
||
|
||
switch (new) {
|
||
case STATE_IDLE: // you can go to idle from any state (except safe)
|
||
tec_power(0); // ensure bed is not powered anymore
|
||
tec_power_yellow_off(); // disconnect all wires
|
||
tec_power_orange_off(); // disconnect all wires
|
||
lid_power(0); // ensure lid is not powered
|
||
break;
|
||
case STATE_SAFE: // go to safe state
|
||
safe_state(); // put all peripherals in safe mode
|
||
break;
|
||
case STATE_HEAT:
|
||
heatsink_fan_on(); // switch fan on
|
||
tec_power(0); // switch power off before changing mode
|
||
tec_heat(); // switch to heating mode
|
||
break;
|
||
case STATE_COOL:
|
||
heatsink_fan_on(); // switch fan on
|
||
tec_power(0); // switch power off before changing mode
|
||
tec_cool(); // switch to heating mode
|
||
break;
|
||
case STATE_FAN:
|
||
tec_power(0); // ensure bed is not powered anymore
|
||
tec_power_yellow_off(); // disconnect all wires
|
||
tec_power_orange_off(); // disconnect all wires
|
||
lid_power(0); // ensure lid is not powered
|
||
heatsink_fan_on(); // switch fan on
|
||
break;
|
||
case STATE_PREPARE:
|
||
if (STATE_IDLE == state) { // only allowed from idle state
|
||
bed_target = 95.0; // set target temperature
|
||
lid_target = bed_target; // set temperature
|
||
heatsink_fan_on(); // switch fan on
|
||
tec_power(0); // switch power off
|
||
tec_heat(); // switch to heating mode
|
||
// TODO set unlimited time
|
||
} else { // transition not allowed
|
||
set_state(STATE_SAFE);
|
||
}
|
||
break;
|
||
case STATE_INITIALISATION:
|
||
if (STATE_PREPARE == state) { // only allowed from state
|
||
// temperature and heating is already set
|
||
// TODO set time to 5 min
|
||
} else { // transition not allowed
|
||
set_state(STATE_SAFE);
|
||
}
|
||
break;
|
||
case STATE_TO_DENATURATION:
|
||
if (STATE_EXTENSION == state) { // only allowed from state
|
||
lid_target = 95.0; // set target temperature
|
||
bed_target = 95.0; // set target temperature
|
||
// heating is already set
|
||
// TODO set unlimited time
|
||
} else { // transition not allowed
|
||
set_state(STATE_SAFE);
|
||
}
|
||
break;
|
||
case STATE_DENATURATION:
|
||
if (STATE_TO_DENATURATION == state) { // only allowed from state
|
||
// temperature and heating is already set
|
||
// TODO set time to 5 min
|
||
} else { // transition not allowed
|
||
set_state(STATE_SAFE);
|
||
}
|
||
break;
|
||
case STATE_TO_ANNEALING:
|
||
if (STATE_DENATURATION == state) { // only allowed from state
|
||
bed_target = 45.0; // set target temperature (5 °C below primer)
|
||
lid_target = bed_target; // same temperature
|
||
tec_power(0); // switch power off
|
||
tec_cool(); // switch to cooling mode
|
||
// TODO set unlimited time
|
||
} else { // transition not allowed
|
||
set_state(STATE_SAFE);
|
||
}
|
||
break;
|
||
case STATE_ANNEALING:
|
||
if (STATE_TO_ANNEALING == state) { // only allowed from state
|
||
tec_power(0); // switch power off before switching mode
|
||
tec_heat(); // switch to heating mode
|
||
// temperature is already set
|
||
// TODO set time to 30-40 s
|
||
} else { // transition not allowed
|
||
set_state(STATE_SAFE);
|
||
}
|
||
break;
|
||
case STATE_TO_EXTENSTION:
|
||
if (STATE_ANNEALING == state) { // only allowed from state
|
||
bed_target = 72.0; // set target temperature
|
||
lid_target = bed_target; // set target temperature
|
||
// heating is already set
|
||
// TODO set unlimited time
|
||
} else { // transition not allowed
|
||
set_state(STATE_SAFE);
|
||
}
|
||
break;
|
||
case STATE_EXTENSION:
|
||
if (STATE_TO_EXTENSTION == state) { // only allowed from state
|
||
// temperature and heating is already set
|
||
// TODO set time to ~1 min/kb of expected product; 5-10 min on last cycle.
|
||
} else { // transition not allowed
|
||
set_state(STATE_SAFE);
|
||
}
|
||
break;
|
||
case STATE_TO_HOLD:
|
||
if (STATE_EXTENSION == state) { // only allowed from state
|
||
bed_target = 10.0; // set target temperature (5 °C below primer)
|
||
lid_target = NAN; // we don't need to heat anymore
|
||
lid_power(0); // switch power off
|
||
tec_power(0); // switch power off
|
||
tec_cool(); // switch to cooling mode
|
||
// TODO set unlimited time
|
||
} else { // transition not allowed
|
||
set_state(STATE_SAFE);
|
||
}
|
||
break;
|
||
case STATE_HOLD:
|
||
if (STATE_TO_HOLD == state) { // only allowed from state
|
||
// nothing to do, we just reached the final hold up
|
||
// TODO set time to 30-40 s
|
||
} else { // transition not allowed
|
||
set_state(STATE_SAFE);
|
||
}
|
||
break;
|
||
default: // unknown new state
|
||
error = "unknown state to set";
|
||
set_state(STATE_SAFE);
|
||
break;
|
||
}
|
||
|
||
// display state
|
||
if (new != state && STATE_SAFE != state) {
|
||
state = new; // save new state
|
||
printf("new state: %s\n", state_names[state]); // show new state
|
||
oled_text_line(state_names[state], 1); // set new state
|
||
oled_text_update(); // show on display
|
||
}
|
||
}
|
||
|
||
/** 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);
|
||
|
||
/** show uptime
|
||
* @param[in] argument no argument required
|
||
*/
|
||
static void command_uptime(void* argument);
|
||
|
||
/** reset board
|
||
* @param[in] argument no argument required
|
||
*/
|
||
static void command_reset(void* argument);
|
||
|
||
/** switch to DFU bootloader
|
||
* @param[in] argument no argument required
|
||
*/
|
||
static void command_bootloader(void* argument);
|
||
|
||
/** switch power to TECs
|
||
* @param[in] argument pointer to unsigned integer: 0 to power all of, 1 to connect yellow to 12V, 2 to connect orange to 12V
|
||
*/
|
||
static void command_bed_power(void* argument)
|
||
{
|
||
|
||
if (argument) { // segment has been provided
|
||
const int32_t target = *(int32_t*)argument; // get while segment to turn on/off
|
||
if (target > UINT16_MAX || target < -INT16_MAX) {
|
||
printf("can't set temperature over %u\n", UINT16_MAX);
|
||
return;
|
||
}
|
||
if (0 == target) { // switch off
|
||
bed_target = 0; // remember we have no target
|
||
set_state(STATE_IDLE); // set new state
|
||
} else if (1 == target) { // just use fan
|
||
bed_target = 0; // remember we have no target
|
||
set_state(STATE_FAN); // set new state
|
||
} else if (target > 0) { // heat
|
||
bed_target = target; // remember target
|
||
set_state(STATE_HEAT); // set new state
|
||
} else { // cool
|
||
bed_target = -target; // remember target
|
||
set_state(STATE_COOL); // set new state
|
||
}
|
||
}
|
||
|
||
// print segment status
|
||
const bool yellow = gpio_get(GPIO_PORT(TEC_POWER_YELLOW), GPIO_PIN(TEC_POWER_YELLOW));
|
||
const bool orange = gpio_get(GPIO_PORT(TEC_POWER_ORANGE), GPIO_PIN(TEC_POWER_ORANGE));
|
||
if (!yellow && !orange) {
|
||
puts("TEC power off\n");
|
||
} else if (orange && !yellow) {
|
||
puts("TEC set to cooling\n");
|
||
|
||
} else if (yellow && !orange) {
|
||
puts("TEC set to heating\n");
|
||
} else {
|
||
puts("unknown TEC power setting\n");
|
||
}
|
||
}
|
||
|
||
/** switch transistors to power to TEC segments
|
||
* @param[in] argument pointer to unsigned integer: 0 to power all off
|
||
*/
|
||
static void command_bed_segment(void* argument)
|
||
{
|
||
|
||
if (argument) { // segment has been provided
|
||
const int32_t segment = *(int32_t*)argument; // get while segment to turn on/off
|
||
switch (segment) {
|
||
case 0: // switch all off
|
||
gpio_set(GPIO_PORT(MBLK019_CH26_PIN), GPIO_PIN(MBLK019_CH26_PIN));
|
||
gpio_set(GPIO_PORT(MBLK019_CH14_PIN), GPIO_PIN(MBLK019_CH14_PIN));
|
||
gpio_set(GPIO_PORT(MBLK019_CH35_PIN), GPIO_PIN(MBLK019_CH35_PIN));
|
||
break;
|
||
case 1:
|
||
gpio_clear(GPIO_PORT(MBLK019_CH26_PIN), GPIO_PIN(MBLK019_CH26_PIN));
|
||
break;
|
||
case -1:
|
||
gpio_set(GPIO_PORT(MBLK019_CH26_PIN), GPIO_PIN(MBLK019_CH26_PIN));
|
||
break;
|
||
case 2:
|
||
gpio_clear(GPIO_PORT(MBLK019_CH14_PIN), GPIO_PIN(MBLK019_CH14_PIN));
|
||
break;
|
||
case -2:
|
||
gpio_set(GPIO_PORT(MBLK019_CH14_PIN), GPIO_PIN(MBLK019_CH14_PIN));
|
||
break;
|
||
case 3:
|
||
gpio_clear(GPIO_PORT(MBLK019_CH35_PIN), GPIO_PIN(MBLK019_CH35_PIN));
|
||
break;
|
||
case -3:
|
||
gpio_set(GPIO_PORT(MBLK019_CH35_PIN), GPIO_PIN(MBLK019_CH35_PIN));
|
||
break;
|
||
default:
|
||
printf("unknown segment: %d\n", segment);
|
||
break;
|
||
}
|
||
sleep_ms(1); // wait to take effect
|
||
}
|
||
|
||
// print segment status
|
||
printf("CH26: %s CH14: %s CH35: %s\n", \
|
||
gpio_get(GPIO_PORT(MBLK019_CH26_PIN), GPIO_PIN(MBLK019_CH26_PIN)) ? "off" : "on", \
|
||
gpio_get(GPIO_PORT(MBLK019_CH14_PIN), GPIO_PIN(MBLK019_CH14_PIN)) ? "off" : "on", \
|
||
gpio_get(GPIO_PORT(MBLK019_CH35_PIN), GPIO_PIN(MBLK019_CH35_PIN)) ? "off" : "on");
|
||
}
|
||
|
||
/** switch power to lid heater
|
||
* @param[in] argument pointer to unsigned integer: 0 to power off, 1 to power on
|
||
*/
|
||
static void command_lid_power(void* argument)
|
||
{
|
||
if (NULL == argument) {
|
||
puts("provide lid power in %\n");
|
||
} else { // segment has been provided
|
||
const uint8_t power = *(uint32_t*)argument; // get while segment to turn on/off
|
||
lid_power(power);
|
||
printf("lip power set to %u %%\n", power);
|
||
}
|
||
}
|
||
|
||
/** set lid target temperature
|
||
* @param[in] argument pointer to unsigned integer: 0 to power off, else temperature in °C
|
||
*/
|
||
static void command_lid_temperature(void* argument)
|
||
{
|
||
if (argument) {
|
||
const uint32_t target = *(uint32_t*)argument;
|
||
if (0 == target) {
|
||
lid_target = NAN;
|
||
lid_power(0);
|
||
} else {
|
||
lid_target = target * 1.0;
|
||
}
|
||
}
|
||
|
||
if (isnan(lid_target)) {
|
||
puts("no lid target temperature\n");
|
||
} else {
|
||
printf("lid target temperature: %u °C\n", (uint8_t)lid_target);
|
||
}
|
||
}
|
||
|
||
static void command_safe(void* argument)
|
||
{
|
||
(void)argument; // we won't use the argument
|
||
set_state(STATE_SAFE);
|
||
printf("in safe state\n");
|
||
}
|
||
|
||
static void command_state(void* argument)
|
||
{
|
||
(void)argument; // we won't use the argument
|
||
puts(state_names[state]);
|
||
putc('\n');
|
||
|
||
if (error) {
|
||
printf("last error: %s\n", error);
|
||
puts("to clear error, restart controller\n");
|
||
} else {
|
||
printf("no error\n");
|
||
}
|
||
}
|
||
|
||
/** 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 = 'r',
|
||
.name = "reset",
|
||
.command_description = "reset board",
|
||
.argument = MENU_ARGUMENT_NONE,
|
||
.argument_description = NULL,
|
||
.command_handler = &command_reset,
|
||
},
|
||
{
|
||
.shortcut = 'B',
|
||
.name = "bootloader",
|
||
.command_description = "reboot into DFU bootloader",
|
||
.argument = MENU_ARGUMENT_NONE,
|
||
.argument_description = NULL,
|
||
.command_handler = &command_bootloader,
|
||
},
|
||
{
|
||
.shortcut = 'b',
|
||
.name = "bed",
|
||
.command_description = "provide power to bed",
|
||
.argument = MENU_ARGUMENT_SIGNED,
|
||
.argument_description = "[+-temp]",
|
||
.command_handler = &command_bed_power,
|
||
},
|
||
{
|
||
.shortcut = 's',
|
||
.name = "segment",
|
||
.command_description = "TEC segment configuration",
|
||
.argument = MENU_ARGUMENT_SIGNED,
|
||
.argument_description = "[+-0,1,2,3]",
|
||
.command_handler = &command_bed_segment,
|
||
},
|
||
{
|
||
.shortcut = 'L',
|
||
.name = "lid_power",
|
||
.command_description = "set lid power",
|
||
.argument = MENU_ARGUMENT_UNSIGNED,
|
||
.argument_description = "%",
|
||
.command_handler = &command_lid_power,
|
||
},
|
||
{
|
||
.shortcut = 'l',
|
||
.name = "lid",
|
||
.command_description = "set lid target temperature",
|
||
.argument = MENU_ARGUMENT_UNSIGNED,
|
||
.argument_description = "°C",
|
||
.command_handler = &command_lid_temperature,
|
||
},
|
||
{
|
||
.shortcut = 's',
|
||
.name = "safe",
|
||
.command_description = "enter safe state",
|
||
.argument = MENU_ARGUMENT_NONE,
|
||
.argument_description = NULL,
|
||
.command_handler = &command_safe,
|
||
},
|
||
{
|
||
.shortcut = 'e',
|
||
.name = "error",
|
||
.command_description = "show current state and error",
|
||
.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
|
||
}
|
||
|
||
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%04x%04x\n", DESIG_UNIQUE_ID2, DESIG_UNIQUE_ID1, DESIG_UNIQUE_ID0 & 0xffff, DESIG_UNIQUE_ID0 >> 16); // not that the half-works are reversed in the first word
|
||
}
|
||
|
||
static void command_uptime(void* argument)
|
||
{
|
||
(void)argument; // we won't use the argument
|
||
const uint32_t uptime = (rtc_get_counter_val() - time_start) / RTC_TICKS_SECOND; // 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);
|
||
}
|
||
|
||
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
|
||
}
|
||
|
||
static void command_bootloader(void* argument)
|
||
{
|
||
(void)argument; // we won't use the argument
|
||
// set DFU magic to specific RAM location
|
||
__dfu_magic[0] = 'D';
|
||
__dfu_magic[1] = 'F';
|
||
__dfu_magic[2] = 'U';
|
||
__dfu_magic[3] = '!';
|
||
scb_reset_system(); // reset system (core and peripherals)
|
||
while (true); // wait for the reset to happen
|
||
}
|
||
|
||
/** 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");
|
||
}
|
||
}
|
||
|
||
/** program entry point
|
||
* this is the firmware function started by the micro-controller
|
||
*/
|
||
void main(void);
|
||
void main(void)
|
||
{
|
||
rcc_clock_setup_in_hse_8mhz_out_72mhz(); // use 8 MHz high speed external clock to generate 72 MHz internal clock
|
||
|
||
#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
|
||
usb_cdcacm_setup(); // setup USB CDC ACM (for printing)
|
||
puts("\nwelcome to the CuVoodoo MBLK001 thermo-cycler driver\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 wachtdog 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
|
||
|
||
// re-use JTAG pins as GPIO (all pins are used)
|
||
rcc_periph_clock_enable(RCC_AFIO); // enable clock for alternate function domain
|
||
gpio_primary_remap(AFIO_MAPR_SWJ_CFG_JTAG_OFF_SW_ON, 0); // disable JTAG but keep SWD
|
||
|
||
// setup RTC
|
||
puts("setup internal RTC: ");
|
||
// note: the blue pill LSE oscillator is affected when toggling the onboard LED, thus prefer the HSE
|
||
rtc_auto_awake(RCC_HSE, 8000000 / 128 / RTC_TICKS_SECOND - 1); // use High Speed External oscillator (8 MHz / 128) as RTC clock (VBAT can't be used to keep the RTC running)
|
||
rtc_interrupt_enable(RTC_SEC); // enable RTC interrupt on "seconds"
|
||
nvic_enable_irq(NVIC_RTC_IRQ); // allow the RTC to interrupt
|
||
time_start = rtc_get_counter_val(); // get start time from internal RTC
|
||
puts("OK\n");
|
||
|
||
puts("setup front panel: ");
|
||
rcc_periph_clock_enable(GPIO_RCC(CONTROL_PLAY_GREEN_LED_PIN)); // enable clock for GPIO port peripheral
|
||
gpio_clear(GPIO_PORT(CONTROL_PLAY_GREEN_LED_PIN), GPIO_PIN(CONTROL_PLAY_GREEN_LED_PIN)); // switch LED off
|
||
gpio_set_mode(GPIO_PORT(CONTROL_PLAY_GREEN_LED_PIN), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO_PIN(CONTROL_PLAY_GREEN_LED_PIN)); // set pin as output push-pull to be able to power LED
|
||
rcc_periph_clock_enable(GPIO_RCC(CONTROL_PLAY_ORANGE_LED_PIN)); // enable clock for GPIO port peripheral
|
||
gpio_clear(GPIO_PORT(CONTROL_PLAY_ORANGE_LED_PIN), GPIO_PIN(CONTROL_PLAY_ORANGE_LED_PIN)); // switch LED off
|
||
gpio_set_mode(GPIO_PORT(CONTROL_PLAY_ORANGE_LED_PIN), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO_PIN(CONTROL_PLAY_ORANGE_LED_PIN)); // set pin as output push-pull to be able to power LED
|
||
rcc_periph_clock_enable(GPIO_RCC(CONTROL_POWER_RED_LED_PIN)); // enable clock for GPIO port peripheral
|
||
gpio_clear(GPIO_PORT(CONTROL_POWER_RED_LED_PIN), GPIO_PIN(CONTROL_POWER_RED_LED_PIN)); // switch LED off
|
||
gpio_set_mode(GPIO_PORT(CONTROL_POWER_RED_LED_PIN), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO_PIN(CONTROL_POWER_RED_LED_PIN)); // set pin as output push-pull to be able to power LED
|
||
// play/pause button
|
||
rcc_periph_clock_enable(GPIO_RCC(CONTROL_PLAY_BUTTON_LED_PIN)); // enable clock for button
|
||
gpio_set_mode(GPIO_PORT(CONTROL_PLAY_BUTTON_LED_PIN), GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, GPIO_PIN(CONTROL_PLAY_BUTTON_LED_PIN)); // set button pin to input
|
||
rcc_periph_clock_enable(RCC_AFIO); // enable alternate function clock for external interrupt
|
||
exti_select_source(GPIO_EXTI(CONTROL_PLAY_BUTTON_LED_PIN), GPIO_PORT(CONTROL_PLAY_BUTTON_LED_PIN)); // mask external interrupt of this pin only for this port
|
||
gpio_set(GPIO_PORT(CONTROL_PLAY_BUTTON_LED_PIN), GPIO_PIN(CONTROL_PLAY_BUTTON_LED_PIN)); // pull up to be able to detect button push (go low)
|
||
exti_set_trigger(GPIO_EXTI(CONTROL_PLAY_BUTTON_LED_PIN), EXTI_TRIGGER_FALLING); // trigger when button is pressed
|
||
exti_enable_request(GPIO_EXTI(CONTROL_PLAY_BUTTON_LED_PIN)); // enable external interrupt
|
||
nvic_enable_irq(GPIO_NVIC_EXTI_IRQ(CONTROL_PLAY_BUTTON_LED_PIN)); // enable interrupt
|
||
puts("OK\n");
|
||
|
||
puts("setup heating bed pins: ");
|
||
rcc_periph_clock_enable(GPIO_RCC(BED_PIN_393A)); // enable clock for GPIO port peripheral
|
||
gpio_set_mode(GPIO_PORT(BED_PIN_393A), GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO_PIN(BED_PIN_393A)); // set pin to input to read state
|
||
rcc_periph_clock_enable(GPIO_RCC(BED_PIN_3393)); // enable clock for GPIO port peripheral
|
||
gpio_set_mode(GPIO_PORT(BED_PIN_3393), GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO_PIN(BED_PIN_3393)); // set pin to input to read state
|
||
rcc_periph_clock_enable(GPIO_RCC(BED_PIN_LK1)); // enable clock for GPIO port peripheral
|
||
gpio_set(GPIO_PORT(BED_PIN_LK1), GPIO_PIN(BED_PIN_LK1)); // pull up
|
||
gpio_set_mode(GPIO_PORT(BED_PIN_LK1), GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, GPIO_PIN(BED_PIN_LK1)); // set pin to input to read state
|
||
rcc_periph_clock_enable(GPIO_RCC(BED_PIN_LK2)); // enable clock for GPIO port peripheral
|
||
gpio_set(GPIO_PORT(BED_PIN_LK2), GPIO_PIN(BED_PIN_LK2)); // pull up
|
||
gpio_set_mode(GPIO_PORT(BED_PIN_LK2), GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, GPIO_PIN(BED_PIN_LK2)); // set pin to input to read state
|
||
rcc_periph_clock_enable(GPIO_RCC(BED_PIN_LK3)); // enable clock for GPIO port peripheral
|
||
gpio_set(GPIO_PORT(BED_PIN_LK3), GPIO_PIN(BED_PIN_LK3)); // pull up
|
||
gpio_set_mode(GPIO_PORT(BED_PIN_LK3), GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, GPIO_PIN(BED_PIN_LK3)); // set pin to input to read state
|
||
rcc_periph_clock_enable(GPIO_RCC(BED_PIN_LK4)); // enable clock for GPIO port peripheral
|
||
gpio_set(GPIO_PORT(BED_PIN_LK4), GPIO_PIN(BED_PIN_LK4)); // pull up
|
||
gpio_set_mode(GPIO_PORT(BED_PIN_LK4), GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, GPIO_PIN(BED_PIN_LK4)); // set pin to input to read state
|
||
if (gpio_get(GPIO_PORT(BED_PIN_LK1), GPIO_PIN(BED_PIN_LK1)) && gpio_get(GPIO_PORT(BED_PIN_LK2), GPIO_PIN(BED_PIN_LK2)) && gpio_get(GPIO_PORT(BED_PIN_LK3), GPIO_PIN(BED_PIN_LK3)) && gpio_get(GPIO_PORT(BED_PIN_LK4), GPIO_PIN(BED_PIN_LK4))) { // nothing is connected
|
||
error = "heating bed board not connected"; // set error
|
||
puts("KO\n");
|
||
} else if (gpio_get(GPIO_PORT(BED_PIN_LK1), GPIO_PIN(BED_PIN_LK1)) && gpio_get(GPIO_PORT(BED_PIN_LK2), GPIO_PIN(BED_PIN_LK2)) && !gpio_get(GPIO_PORT(BED_PIN_LK3), GPIO_PIN(BED_PIN_LK3)) && !gpio_get(GPIO_PORT(BED_PIN_LK4), GPIO_PIN(BED_PIN_LK4))) { // the LK jumper setting is correct
|
||
puts("OK\n");
|
||
} else { // the jumper setting is unknown
|
||
error = "not heating bed board detected"; // set error
|
||
puts("KO\n");
|
||
}
|
||
|
||
puts("setup MAX1247 to read bed thermistors: ");
|
||
sensor_max1247_setup(); // setup communication with MAX1247 ADC
|
||
puts("OK\n");
|
||
|
||
puts("setup ADC to read lid 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_disable_scan_mode(ADC1); // ensure scan mode is disabled
|
||
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_set_sample_time_on_all_channels(ADC1, ADC_SMPR_SMP_239DOT5CYC); // use 239.5 cycles to sample (17.1 us are required for the internal voltage reference, (239.5 + 12.5) cycles @ 14 MHz max = 18 us)
|
||
adc_set_regular_sequence(ADC1, LENGTH(channels), (uint8_t*)channels); // set channel to convert
|
||
adc_enable_external_trigger_regular(ADC1, ADC_CR2_EXTSEL_SWSTART); // use software trigger to start the conversion (of the regular group)
|
||
adc_enable_temperature_sensor(); // enable internal voltage reference
|
||
adc_power_on(ADC1); // switch on ADC
|
||
sleep_us(1); // wait t_stab for the ADC to stabilize
|
||
adc_reset_calibration(ADC1); // remove previous non-calibration
|
||
adc_calibrate(ADC1); // calibrate ADC for less accuracy errors
|
||
rcc_periph_clock_enable(RCC_ADC12_IN(LID_TEC_CHANNEL)); // enable clock for GPIO domain for lid thermistor channel
|
||
gpio_set_mode(ADC12_IN_PORT(LID_TEC_CHANNEL), GPIO_MODE_INPUT, GPIO_CNF_INPUT_ANALOG, ADC12_IN_PIN(LID_TEC_CHANNEL)); // set lid thermistor channel as analogue input for the ADC
|
||
puts("OK\n");
|
||
|
||
puts("setup lid heater: ");
|
||
// verify if it is connected (the pin should be pulled up to 5V)
|
||
rcc_periph_clock_enable(GPIO_RCC(LID_HEATER_PIN)); // enable clock for GPIO port peripheral
|
||
gpio_clear(GPIO_PORT(LID_HEATER_PIN), GPIO_PIN(LID_HEATER_PIN)); // pull down
|
||
gpio_set_mode(GPIO_PORT(LID_HEATER_PIN), GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, GPIO_PIN(LID_HEATER_PIN)); // set pin as input
|
||
sleep_us(100); // let signal settle
|
||
if (!gpio_get(GPIO_PORT(LID_HEATER_PIN), GPIO_PIN(LID_HEATER_PIN))) { // signal is not pulled up
|
||
error = "power board not connected";
|
||
puts("KO\n");
|
||
} else { // power board is connected
|
||
// set up PWM output
|
||
rcc_periph_clock_enable(RCC_TIM_CH(LID_HEATER_TIMER, LID_HEATER_CHANNEL)); // enable clock for GPIO peripheral
|
||
gpio_set(TIM_CH_PORT(LID_HEATER_TIMER, LID_HEATER_CHANNEL), TIM_CH_PIN(LID_HEATER_TIMER, LID_HEATER_CHANNEL)); // don't sink current (e.g. not powering the opto-coupler/triac))
|
||
gpio_set_mode(TIM_CH_PORT(LID_HEATER_TIMER, LID_HEATER_CHANNEL), GPIO_MODE_OUTPUT_10_MHZ, GPIO_CNF_OUTPUT_ALTFN_OPENDRAIN, TIM_CH_PIN(LID_HEATER_TIMER, LID_HEATER_CHANNEL)); // set pin as output
|
||
rcc_periph_clock_enable(RCC_AFIO); // enable clock for alternate function (PWM)
|
||
rcc_periph_clock_enable(RCC_TIM(LID_HEATER_TIMER)); // enable clock for timer peripheral
|
||
rcc_periph_reset_pulse(RST_TIM(LID_HEATER_TIMER)); // reset timer state
|
||
timer_set_mode(TIM(LID_HEATER_TIMER), TIM_CR1_CKD_CK_INT, TIM_CR1_CMS_EDGE, TIM_CR1_DIR_UP); // set timer mode, use undivided timer clock, edge alignment (simple count), and count up
|
||
// since we are controlling a triac, but we don't know the zero-crossing point, we can only switch on/off on half AC waves, e.g. 100 Hz
|
||
timer_set_prescaler(TIM(LID_HEATER_TIMER), 1099 - 1); // set period to 1 Hz ((72E6/(1099)) / 2**16 = 0.9997)
|
||
timer_set_period(TIM(LID_HEATER_TIMER), UINT16_MAX); // use the whole range as period, even if we can only control up to 100 Hz
|
||
timer_set_oc_value(TIM(LID_HEATER_TIMER), LID_HEATER_OC, 0); // duty cycle to 0%, to switch off heater
|
||
timer_set_oc_mode(TIM(LID_HEATER_TIMER), LID_HEATER_OC, TIM_OCM_PWM2); // set timer to generate PWM (heater switched of as long as CNT < CCR)
|
||
timer_enable_oc_output(TIM(LID_HEATER_TIMER), LID_HEATER_OC); // enable output to generate the PWM signal
|
||
timer_enable_break_main_output(TIM(LID_HEATER_TIMER)); // required to enable timer, even when no dead time is used
|
||
timer_set_counter(TIM(LID_HEATER_TIMER), 0); // reset counter
|
||
timer_enable_counter(TIM(LID_HEATER_TIMER)); // enable timer
|
||
puts("OK\n");
|
||
}
|
||
|
||
puts("setup TEC controller: ");
|
||
rcc_periph_clock_enable(GPIO_RCC(MBLK019_CH26_PIN)); // enable clock for GPIO port peripheral
|
||
gpio_set(GPIO_PORT(MBLK019_CH26_PIN), GPIO_PIN(MBLK019_CH26_PIN)); // don't sink current (e.g. not powering the opto-coupler/transistor)
|
||
gpio_set_mode(GPIO_PORT(MBLK019_CH26_PIN), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_OPENDRAIN, GPIO_PIN(MBLK019_CH26_PIN)); // set pin as output open-drain
|
||
rcc_periph_clock_enable(GPIO_RCC(MBLK019_CH14_PIN)); // enable clock for GPIO port peripheral
|
||
gpio_set(GPIO_PORT(MBLK019_CH14_PIN), GPIO_PIN(MBLK019_CH14_PIN)); // don't sink current (e.g. not powering the opto-coupler/transistor)
|
||
gpio_set_mode(GPIO_PORT(MBLK019_CH14_PIN), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_OPENDRAIN, GPIO_PIN(MBLK019_CH14_PIN)); // set pin as output open-drain
|
||
rcc_periph_clock_enable(GPIO_RCC(MBLK019_CH35_PIN)); // enable clock for GPIO port peripheral
|
||
gpio_set(GPIO_PORT(MBLK019_CH35_PIN), GPIO_PIN(MBLK019_CH35_PIN)); // don't sink current (e.g. not powering the opto-coupler/transistor)
|
||
gpio_set_mode(GPIO_PORT(MBLK019_CH35_PIN), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_OPENDRAIN, GPIO_PIN(MBLK019_CH35_PIN)); // set pin as output open-drain
|
||
rcc_periph_clock_enable(GPIO_RCC(MBLK019_PRESENCE_PIN)); // enable clock for GPIO port peripheral
|
||
gpio_set(GPIO_PORT(MBLK019_PRESENCE_PIN), GPIO_PIN(MBLK019_PRESENCE_PIN)); // pull up
|
||
gpio_set_mode(GPIO_PORT(MBLK019_PRESENCE_PIN), GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, GPIO_PIN(MBLK019_PRESENCE_PIN)); // set pin to input to read state
|
||
if (gpio_get(GPIO_PORT(MBLK019_PRESENCE_PIN), GPIO_PIN(MBLK019_PRESENCE_PIN))) {
|
||
error = "MBLK019 not connected";
|
||
puts("KO\n");
|
||
} else {
|
||
puts("OK\n");
|
||
}
|
||
|
||
puts("setup TEC power supply: ");
|
||
rcc_periph_clock_enable(GPIO_RCC(TEC_POWER_YELLOW)); // enable clock for GPIO port peripheral
|
||
gpio_clear(GPIO_PORT(TEC_POWER_YELLOW), GPIO_PIN(TEC_POWER_YELLOW)); // don't connect wire to VCC
|
||
gpio_set_mode(GPIO_PORT(TEC_POWER_YELLOW), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO_PIN(TEC_POWER_YELLOW)); // set pin as output
|
||
rcc_periph_clock_enable(GPIO_RCC(TEC_POWER_ORANGE)); // enable clock for GPIO port peripheral
|
||
gpio_clear(GPIO_PORT(TEC_POWER_ORANGE), GPIO_PIN(TEC_POWER_ORANGE)); // don't connect wire to VCC
|
||
gpio_set_mode(GPIO_PORT(TEC_POWER_ORANGE), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO_PIN(TEC_POWER_ORANGE)); // set pin as output
|
||
// set up PWM output
|
||
rcc_periph_clock_enable(RCC_TIM_CH(TEC_POWER_TIMER, TEC_POWER_CHANNEL)); // enable clock for GPIO peripheral
|
||
gpio_clear(TIM_CH_PORT(TEC_POWER_TIMER, TEC_POWER_CHANNEL), TIM_CH_PIN(TEC_POWER_TIMER, TEC_POWER_CHANNEL)); // don't let power trough
|
||
gpio_set_mode(TIM_CH_PORT(TEC_POWER_TIMER, TEC_POWER_CHANNEL), GPIO_MODE_OUTPUT_10_MHZ, GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, TIM_CH_PIN(TEC_POWER_TIMER, TEC_POWER_CHANNEL)); // set pin as output
|
||
rcc_periph_clock_enable(RCC_AFIO); // enable clock for alternate function (PWM)
|
||
rcc_periph_clock_enable(RCC_TIM(TEC_POWER_TIMER)); // enable clock for timer peripheral
|
||
rcc_periph_reset_pulse(RST_TIM(TEC_POWER_TIMER)); // reset timer state
|
||
timer_set_mode(TIM(TEC_POWER_TIMER), TIM_CR1_CKD_CK_INT, TIM_CR1_CMS_EDGE, TIM_CR1_DIR_UP); // set timer mode, use undivided timer clock, edge alignment (simple count), and count up
|
||
// peltier elements can safely be PWMed at 300 Hz to 3000 Hz, we will keep it under 2 kHz to avoid the audible range
|
||
timer_set_prescaler(TIM(TEC_POWER_TIMER), rcc_ahb_frequency / 1500000 - 1); // set the clock frequency to 1.5 kHz
|
||
timer_set_period(TIM(TEC_POWER_TIMER), UINT16_MAX); // use the whole range as period, even if we can only control up to 100 Hz
|
||
timer_set_oc_value(TIM(TEC_POWER_TIMER), TEC_POWER_OC, 0); // duty cycle to 0%, to switch off heater
|
||
timer_set_oc_mode(TIM(TEC_POWER_TIMER), TEC_POWER_OC, TIM_OCM_PWM1); // set timer to generate PWM (heater switched of as long as CNT < CCR)
|
||
timer_enable_oc_output(TIM(TEC_POWER_TIMER), TEC_POWER_OC); // enable output to generate the PWM signal
|
||
timer_enable_break_main_output(TIM(TEC_POWER_TIMER)); // required to enable timer, even when no dead time is used
|
||
timer_set_counter(TIM(TEC_POWER_TIMER), 0); // reset counter
|
||
timer_enable_counter(TIM(TEC_POWER_TIMER)); // enable timer
|
||
puts("OK\n");
|
||
|
||
puts("setup heat sink fan: ");
|
||
// we can't test if it is connected (we only control the MOSFET directly powering the fan)
|
||
rcc_periph_clock_enable(GPIO_RCC(HEATSINK_FAN_PIN)); // enable clock for GPIO port peripheral
|
||
gpio_clear(GPIO_PORT(HEATSINK_FAN_PIN), GPIO_PIN(HEATSINK_FAN_PIN)); // switch off fan
|
||
gpio_set_mode(GPIO_PORT(HEATSINK_FAN_PIN), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_OPENDRAIN, GPIO_PIN(HEATSINK_FAN_PIN)); // set pin as output open-drain, gate of nMOS it pulled up externally
|
||
puts("OK\n");
|
||
|
||
puts("setup display: ");
|
||
if (oled_text_setup()) { // setup OLED display with default slave address
|
||
oled_text_clear(); // clear buffer (else last state is displayed)
|
||
oled_text_line("PCR 3000", 0);
|
||
oled_text_line(state_names[state], 1); // show state
|
||
oled_text_update();
|
||
puts("OK\n");
|
||
} else {
|
||
puts("KO\n");
|
||
}
|
||
|
||
puts("setup DS18B20 temperature sensor: ");
|
||
sensor_ds18b20_setup(); // configure 1-Wire bus to read from sensor
|
||
if (1 == sensor_ds18b20_number()) { // check number of devices available
|
||
sensor_ds18b20_precision(0, 12); // set precision to 12 bits
|
||
ds18b20_present = true; // remember the sensor is present (and there is only one)
|
||
sensor_ds18b20_convert(0); // start conversion (it takes almost 1 s)
|
||
puts("OK\n");
|
||
} else {
|
||
puts("KO\n");
|
||
}
|
||
|
||
// setup terminal
|
||
terminal_prefix = ""; // set default prefix
|
||
terminal_process = &process_command; // set central function to process commands
|
||
terminal_setup(); // start terminal
|
||
|
||
if (error && STATE_SAFE != state) { // an error has occurred during initialisation
|
||
set_state(STATE_SAFE); // go to safe state
|
||
} else {
|
||
led_power_on(); // indicate user we are ready
|
||
}
|
||
|
||
// 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(); // indicate user boot completed
|
||
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
|
||
sleep_ms(100); // wait a bit to remove noise
|
||
if (!gpio_get(GPIO_PORT(CONTROL_PLAY_BUTTON_LED_PIN), GPIO_PIN(CONTROL_PLAY_BUTTON_LED_PIN))) {
|
||
puts("button pressed\n");
|
||
gpio_toggle(GPIO_PORT(CONTROL_PLAY_ORANGE_LED_PIN), GPIO_PIN(CONTROL_PLAY_ORANGE_LED_PIN));
|
||
gpio_toggle(GPIO_PORT(CONTROL_PLAY_GREEN_LED_PIN), GPIO_PIN(CONTROL_PLAY_GREEN_LED_PIN));
|
||
}
|
||
sleep_ms(100); // wait a bit to remove double trigger
|
||
button_flag = false; // reset flag
|
||
}
|
||
if (rtc_internal_tick_flag) { // the internal RTC ticked
|
||
const uint32_t ticks = rtc_internal_tick_flag; // save tick time
|
||
rtc_internal_tick_flag = 0; // reset flag
|
||
action = true; // action has been performed
|
||
if (0 == (ticks % (RTC_TICKS_SECOND / 2))) { // time to blink the LEDs
|
||
if (0 == (ticks % RTC_TICKS_SECOND)) { // switch on the LEDs
|
||
if (led_power_blink) {
|
||
led_power_on();
|
||
}
|
||
if (led_heat_blink) {
|
||
led_heat_on();
|
||
}
|
||
if (led_cool_blink) {
|
||
led_cool_on();
|
||
}
|
||
} else { // switch off LEDs
|
||
if (led_power_blink) {
|
||
led_power_off();
|
||
}
|
||
if (led_heat_blink) {
|
||
led_heat_off();
|
||
}
|
||
if (led_cool_blink) {
|
||
led_cool_off();
|
||
}
|
||
}
|
||
}
|
||
if (STATE_SAFE != state) {
|
||
if (!isnan(lid_target)) {
|
||
lid_pid(); // run PID loop for lid heater
|
||
}
|
||
if (bed_target) {
|
||
bed_pid(); // run PID loop for bed heater
|
||
}
|
||
}
|
||
}
|
||
if (rtc_internal_second_flag) { // one second has passed
|
||
rtc_internal_second_flag = false; // clear flag
|
||
action = true; // remember we did something
|
||
led_toggle(); // toggle LED (good to indicate if main function is stuck)
|
||
// read temperatures
|
||
const float lid_temp = lid_temperature();
|
||
const float heatsink_temp = bed_heatsink_temperature();
|
||
const float top_temp = bed_tophalf_temperature();
|
||
const float bot_temp = bed_bothalf_temperature();
|
||
const float tube_temp = bed_tube_temperature();
|
||
// read bed temperatures
|
||
printf("bed: top=%u %.2f, bottom=%u %.02f, sink=%u %.02f, tube=%u %.02f; 393-A=%u; 339-3=%u\n",sensor_max1247_read(0), top_temp, sensor_max1247_read(1), bot_temp, sensor_max1247_read(2), heatsink_temp, sensor_max1247_read(3), tube_temp, gpio_get(GPIO_PORT(BED_PIN_393A), GPIO_PIN(BED_PIN_393A)) ? 1 : 0, gpio_get(GPIO_PORT(BED_PIN_3393), GPIO_PIN(BED_PIN_3393)) ? 1 : 0);
|
||
printf("lid: %.04f °C\n", lid_temp);
|
||
if (ds18b20_present) {
|
||
const float temp = sensor_ds18b20_temperature(0); // get temperature
|
||
sensor_ds18b20_convert(0); // start next conversion (since it takes almost 1 s)
|
||
printf("DS18B20: %.03f °C\n", temp);
|
||
}
|
||
// time to check if everything is OK
|
||
if (!error && STATE_SAFE != state) { // only check if we are not in the safe state
|
||
// check lid temperature
|
||
if (lid_temp < 5.0) { // voltage is at the upper limit (3.3V), meaning it is directly connected to the 3.3V pull-up resistor, and the lid thermistor does not pull it to ground
|
||
error = "lid thermistor is probably not connected";
|
||
} else if (lid_temp > 100.0) {
|
||
error = "lid is getting too warm";
|
||
}
|
||
// check fan
|
||
if (STATE_IDLE != state && STATE_SAFE != state) {
|
||
heatsink_fan_on(); // ensure the fan is on when heating/cooling bed
|
||
} else if (STATE_IDLE == state) {
|
||
if (heatsink_temp > 45.0) { // ensure heat sink is not above 50 °C when resting
|
||
heatsink_fan_on();
|
||
} else { // heat sink is now cold enough to touch
|
||
heatsink_fan_off();
|
||
}
|
||
}
|
||
if (heatsink_temp > 80.0) {
|
||
error = "heat sink is getting too warm";
|
||
}
|
||
if (error) { // an error has occurred
|
||
set_state(STATE_SAFE); // go to safe state
|
||
}
|
||
}
|
||
}
|
||
if (action) { // go to sleep if nothing had to be done, else recheck for activity
|
||
action = false;
|
||
} else {
|
||
__WFI(); // go to sleep
|
||
}
|
||
} // main loop
|
||
}
|
||
|
||
/** @brief interrupt service routine called when tick passed on RTC */
|
||
void rtc_isr(void)
|
||
{
|
||
static uint32_t tick = RTC_TICKS_SECOND; // this will let us known then a second passed
|
||
rtc_clear_flag(RTC_SEC); // clear flag
|
||
rtc_internal_tick_flag = rtc_get_counter_val(); // notify to show new time
|
||
tick--; // count down ticks
|
||
if (0 == tick) { // do the check here to not miss a tick
|
||
rtc_internal_second_flag = true; // let main loop know a second passed
|
||
tick = RTC_TICKS_SECOND; // reset count down
|
||
}
|
||
}
|
||
|
||
/** interrupt service routine called when button is pressed */
|
||
void GPIO_EXTI_ISR(CONTROL_PLAY_BUTTON_LED_PIN)(void)
|
||
{
|
||
exti_reset_request(GPIO_EXTI(CONTROL_PLAY_BUTTON_LED_PIN)); // reset interrupt
|
||
button_flag = true; // perform button action
|
||
}
|