mirror
/
SP8EBC-ParaTNC
kopia lustrzana https://github.com/SP8EBC/ParaTNC
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność
SP8EBC-ParaTNC/src/main.c

1850 wiersze
55 KiB
C
Czysty Bezpośredni odnośnik Wina Historia

#include "main.h"
#ifdef STM32F10X_MD_VL
#include <stm32f10x_rcc.h>
#include <stm32f10x_iwdg.h>
#include <stm32f10x.h>
#include <drivers/f1/gpio_conf_stm32f1x.h>
#endif
#ifdef STM32L471xx
#include <stm32l4xx_hal_cortex.h>
#include <stm32l4xx.h>
#include <stm32l4xx_ll_iwdg.h>
#include <stm32l4xx_ll_rcc.h>
#include <stm32l4xx_ll_gpio.h>
#include "cmsis/stm32l4xx/system_stm32l4xx.h"
#include "gsm/sim800c.h"
#include "gsm/sim800c_engineering.h"
#include "gsm/sim800c_poolers.h"
#include "gsm/sim800c_gprs.h"
#include "http_client/http_client.h"
#include "nvm.h"
#include "aprsis.h"
#include "api/api.h"
#include "drivers/l4/pwm_input_stm32l4x.h"
#include "drivers/l4/spi_speed_stm32l4x.h"
#include "drivers/max31865.h"
#endif
#include <delay.h>
#include <LedConfig.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "packet_tx_handler.h"
#include "station_config.h"
#include <stored_configuration_nvm/config_data_externs.h>
#include <stored_configuration_nvm/configuration_handler.h>
#include "diag/Trace.h"
#include "antilib_adc.h"
#include "afsk_pr.h"
#include "TimerConfig.h"
#include "PathConfig.h"
#include "LedConfig.h"
#include "backup_registers.h"
#include "io.h"
#include "float_to_string.h"
#include "pwr_save.h"
#include "button.h"
#include <wx_pwr_switch.h>
#include "io_default_vbat_scaling.h"
#include "it_handlers.h"
#include "aprs/digi.h"
#include "aprs/telemetry.h"
#include "aprs/dac.h"
#include "aprs/beacon.h"
#include "aprs/status.h"
#include "ve_direct_protocol/parser.h"
#include "rte_wx.h"
#include "rte_pv.h"
#include "rte_main.h"
#include "rte_rtu.h"
#include <wx_handler.h>
#include "drivers/dallas.h"
#include "drivers/i2c.h"
#include "drivers/spi.h"
#include "drivers/analog_anemometer.h"
#include "dust_sensor/sds011.h"
#include "aprs/wx.h"
#include "../system/include/modbus_rtu/rtu_serial_io.h"
#include "../system/include/davis_vantage/davis.h"
#include "../system/include/davis_vantage/davis_parsers.h"
#include "drivers/ms5611.h"
#include <drivers/bme280.h>
#include "umb_master/umb_master.h"
#include "umb_master/umb_channel_pool.h"
#include "umb_master/umb_0x26_status.h"
#include "drivers/dallas.h"
#include <kiss_communication/kiss_communication.h>
#include <etc/kiss_configuation.h>
#include <etc/dallas_temperature_limits.h>
#define SOH 0x01
//#include "variant.h"
//#define SERIAL_TX_TEST_MODE
// Niebieska dioda -> DCD
// Zielona dioda -> anemometr albo TX
// backup registers (ParaTNC)
// 0 ->
// 2 -> boot and hard fault count
// 3 -> controller configuration status
// 4 ->
// 5 ->
// 6 -> weather and telemetry timers & counters
// backup registers (ParaMETEO)
// 0 -> powersave status
// 1 -> last sleep rtc time
// 2 -> last wakeup rtc time
// 3 -> controller configuration status
// 4 -> wakeup events MSB, sleep events LSB
// 5 -> monitor
// 6 -> last sleep time
// 7 -> weather and telemetry timers & counters
#define CONFIG_FIRST_RESTORED (1)
#define CONFIG_FIRST_FAIL_RESTORING (1 << 1)
#define CONFIG_FIRST_CRC_OK (1 << 2)
#define CONFIG_SECOND_RESTORED (1 << 3)
#define CONFIG_SECOND_FAIL_RESTORING (1 << 4)
#define CONFIG_SECOND_CRC_OK (1 << 5)
/**
* A foreword about '#define' mess. This software is indented to run on at least two
* different hardware platforms. First which is ParaTNC basing on STM32F100 and second
* ParaMETEO using STM32L476. In future more platforms may appear. Like ParaTNC2 which
* will be a ParaMETEO without battery charging and in form factor similar to ParaTNC.
*
* To obtain such compatibility a lot of #defines and different makefiles has to be used.
* Some parts of the code are 'included' per target CPU basis, as are independent from
* target platform directly. Including system headers (CMSIS, std peripheral driver),
* configuring low level hardware like interrupt controler, clock etc.
*
* Some parts of code and header files are related to certain platform
*
*/
// ----- main() ---------------------------------------------------------------
// used configuration structures
const config_data_mode_t * main_config_data_mode = 0;
const config_data_basic_t * main_config_data_basic = 0;
const config_data_wx_sources_t * main_config_data_wx_sources = 0;
const config_data_umb_t * main_config_data_umb = 0;
const config_data_rtu_t * main_config_data_rtu = 0;
#ifdef PARAMETEO
const config_data_gsm_t * main_config_data_gsm = 0;
#endif
//! global variable incremented by the SysTick handler to measure time in miliseconds
volatile uint32_t master_time = 0;
//! current timestamp from RTC in NVM format
uint32_t main_nvm_timestamp = 0;
//! this global variable stores numbers of ticks of idling CPU
uint32_t main_idle_cpu_ticks = 0;
//! current cpu idle ticks
uint32_t main_current_cpu_idle_ticks = 0;
//! approx cpu load in percents
int8_t main_cpu_load = 0;
//! global variable used as a timer to trigger meteo sensors mesurements
int32_t main_wx_sensors_pool_timer = 65500;
//! global variable used as a timer to trigger packet sending
int32_t main_one_minute_pool_timer = 45000;
//! one second pool interval
int32_t main_one_second_pool_timer = 1000;
//! two second pool interval
int32_t main_two_second_pool_timer = 2000;
//! ten second pool interval
int32_t main_ten_second_pool_timer = 10000;
//! one hour interval incremented inside one minute
int8_t main_one_hour_pool_timer = 60;
//! serial context for UART used to KISS
srl_context_t main_kiss_srl_ctx;
//! serial context for UART used for comm with wx sensors
srl_context_t main_wx_srl_ctx;
#if defined(PARAMETEO)
//! serial context for communication with GSM module
srl_context_t main_gsm_srl_ctx;
#endif
//! operation mode of USART1 (RS232 on RJ45 socket)
main_usart_mode_t main_usart1_kiss_mode = USART_MODE_UNDEF;
//! operation mode of USART2 (RS485)
main_usart_mode_t main_usart2_wx_mode = USART_MODE_UNDEF;
//! function configuration for left button on ParaMETEO
configuration_button_function_t main_button_one_left;
//! function configuration for right button on ParaMETEO
configuration_button_function_t main_button_two_right;
//! a pointer to KISS context
srl_context_t* main_kiss_srl_ctx_ptr;
//! a pointer to wx comms context
srl_context_t* main_wx_srl_ctx_ptr;
//! a pointer to gsm context
srl_context_t* main_gsm_srl_ctx_ptr;
//! target USART1 (kiss) baudrate
uint32_t main_target_kiss_baudrate;
//! target USART2 (wx) baudrate
uint32_t main_target_wx_baudrate;
//! controls if the KISS modem is enabled
uint8_t main_kiss_enabled = 1;
//! controls if DAVIS serialprotocol client is enabled by the configuration
uint8_t main_davis_serial_enabled = 0;
uint8_t main_modbus_rtu_master_enabled = 0;
uint8_t main_reset_config_to_default = 0;
//! global variables represending the AX25/APRS stack
AX25Ctx main_ax25;
Afsk main_afsk;
AX25Call main_own_path[3];
uint8_t main_own_path_ln = 0;
uint8_t main_own_aprs_msg_len;
char main_own_aprs_msg[OWN_APRS_MSG_LN];
char main_string_latitude[9];
char main_string_longitude[9];
char main_callsign_with_ssid[10];
uint8_t main_small_buffer[KISS_CONFIG_DIAGNOSTIC_BUFFER_LN];
char main_symbol_f = '/';
char main_symbol_s = '#';
//! global variable used to store return value from various functions
volatile uint8_t retval = 100;
uint16_t buffer_len = 0;
//! return value from UMB related functions
umb_retval_t main_umb_retval = UMB_UNINITIALIZED;
//! result of CRC calculation
uint32_t main_crc_result = 0;
#if defined(PARAMETEO)
LL_GPIO_InitTypeDef GPIO_InitTypeDef;
gsm_sim800_state_t main_gsm_state;
uint32_t rte_main_rx_total = 0;
uint32_t rte_main_tx_total = 0;
volatile int i = 0;
#endif
#if defined(PARAMETEO)
//!< Triggers additional check if ADC has properly reinitialized and conversion is working
uint8_t main_check_adc = 0;
//!< Used to store an information which telemetry descritpion frame should be sent next
telemetry_description_t main_telemetry_description = TELEMETRY_NOTHING;
#endif
char after_tx_lock;
const float main_test_float = 123.4f;
const char main_test_string[11] = "1234556aaa\0";
unsigned short rx10m = 0, tx10m = 0, digi10m = 0, digidrop10m = 0, kiss10m = 0;
static void message_callback(struct AX25Msg *msg) {
}
const char * post_content = "{\
\"main_config_data_basic_callsign\": \"SP8EBC\",\
\"main_config_data_basic_ssid\": 8,\
\"master_time\": 12345,\
\"main_cpu_load\": 50,\
\"rx10m\": 30,\
\"tx10m\": 20,\
\"digi10m\": 50,\
\"digidrop10m\": 10,\
\"kiss10m\": 5,\
\"rte_main_rx_total\": 11,\
\"rte_main_tx_total\": 12,\
\"rte_main_average_battery_voltage\": 123,\
\"rte_main_wakeup_count\": 0,\
\"rte_main_going_sleep_count\": 2,\
\"rte_main_last_sleep_master_time\": 9}";
//#define SERIAL_TX_TEST_MODE
int main(int argc, char* argv[]){
int32_t ln = 0;
it_handlers_inhibit_radiomodem_dcd_led = 1;
memset(main_own_aprs_msg, 0x00, OWN_APRS_MSG_LN);
#if defined(STM32F10X_MD_VL)
RCC->APB1ENR |= (RCC_APB1ENR_TIM2EN | RCC_APB1ENR_TIM3EN | RCC_APB1ENR_TIM7EN | RCC_APB1ENR_TIM4EN);
RCC->APB2ENR |= (RCC_APB2ENR_IOPAEN | RCC_APB2ENR_IOPBEN | RCC_APB2ENR_IOPCEN | RCC_APB2ENR_IOPDEN | RCC_APB2ENR_AFIOEN | RCC_APB2ENR_TIM1EN);
RCC->AHBENR |= RCC_AHBENR_CRCEN;
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
// choosing the signal source for the SysTick timer.
SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK);
// Configuring the SysTick timer to generate interrupt 100x per second (one interrupt = 10ms)
SysTick_Config(SystemCoreClock / SYSTICK_TICKS_PER_SECONDS);
// setting an Systick interrupt priority
NVIC_SetPriority(SysTick_IRQn, 5);
// enable access to BKP registers
RCC->APB1ENR |= (RCC_APB1ENR_PWREN | RCC_APB1ENR_BKPEN);
PWR->CR |= PWR_CR_DBP;
// read current number of boot cycles
rte_main_boot_cycles = (uint8_t)(BKP->DR2 & 0xFF);
// read current number of hard faults
rte_main_hard_faults = (uint8_t)((BKP->DR2 & 0xFF00) >> 8);
// increase boot cycles count
rte_main_boot_cycles++;
// erasing old value from backup registers
BKP->DR2 &= (0xFFFF ^ 0xFF);
// storing increased value
BKP->DR2 |= rte_main_boot_cycles;
BKP->DR3 = 0;
BKP->DR4 = 0;
BKP->DR5 = 0;
BKP->DR6 = 0;
#endif
#if defined(STM32L471xx)
system_clock_update_l4();
if (system_clock_configure_l4() != 0) {
HAL_NVIC_SystemReset();
}
// enable access to PWR control registers
RCC->APB1ENR1 |= RCC_APB1ENR1_PWREN;
system_clock_update_l4();
system_clock_configure_rtc_l4();
RCC->APB1ENR1 |= (RCC_APB1ENR1_SPI2EN | RCC_APB1ENR1_TIM2EN | RCC_APB1ENR1_TIM3EN | RCC_APB1ENR1_TIM4EN | RCC_APB1ENR1_TIM5EN | RCC_APB1ENR1_TIM7EN | RCC_APB1ENR1_USART2EN | RCC_APB1ENR1_USART3EN | RCC_APB1ENR1_DAC1EN | RCC_APB1ENR1_I2C1EN | RCC_APB1ENR1_USART3EN);
RCC->APB2ENR |= (RCC_APB2ENR_TIM1EN | RCC_APB2ENR_USART1EN | RCC_APB2ENR_TIM8EN); // RCC_APB1ENR1_USART3EN
RCC->AHB1ENR |= (RCC_AHB1ENR_CRCEN | RCC_AHB1ENR_DMA1EN);
RCC->AHB2ENR |= (RCC_AHB2ENR_ADCEN | RCC_AHB2ENR_GPIOAEN | RCC_AHB2ENR_GPIOBEN | RCC_AHB2ENR_GPIOCEN | RCC_AHB2ENR_GPIODEN);
RCC->BDCR |= RCC_BDCR_RTCEN;
/* Set Interrupt Group Priority */
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_4);
// set systick frequency
HAL_SYSTICK_Config(SystemCoreClock / (1000U / (uint32_t)10));
// set systick interrupt priority
HAL_NVIC_SetPriority(SysTick_IRQn, 5, 0U);
#endif
rte_main_reboot_req = 0;
// initializing variables & arrays in rte_wx
rte_wx_init();
rte_rtu_init();
// calculate CRC over configuration blocks
main_crc_result = configuration_handler_check_crc();
// restore config to default if requested
if (main_reset_config_to_default == 1) {
main_crc_result = 0;
backup_reg_reset_counters();
backup_reg_set_configuration(0);
#if defined(PARAMETEO)
nvm_erase_all();
// nvm_test_prefill();
#endif
}
// if first section has wrong CRC and it hasn't been restored before
if ((main_crc_result & 0x01) == 0 && (backup_reg_get_configuration() & CONFIG_FIRST_FAIL_RESTORING) == 0) {
// restore default configuration
if (configuration_handler_restore_default_first() == 0) {
// if configuration has been restored successfully
backup_reg_set_bits_configuration(CONFIG_FIRST_RESTORED);
// set also CRC flag because if restoring is successfull the region has good CRC
backup_reg_set_bits_configuration(CONFIG_FIRST_CRC_OK);
// additionally resets packet counters stored in backup registers
backup_reg_reset_counters();
}
else {
// if not store the flag in the backup register to block
// reinitializing once again in the consecutive restart
backup_reg_set_bits_configuration(CONFIG_FIRST_FAIL_RESTORING);
backup_reg_clear_bits_configuration(CONFIG_FIRST_CRC_OK);
}
}
else {
// if the combined confition is not met check failed restoring flag
if ((backup_reg_get_configuration() & CONFIG_FIRST_FAIL_RESTORING) == 0) {
// a CRC checksum is ok, so first configuration section can be used further
backup_reg_set_bits_configuration(CONFIG_FIRST_CRC_OK);
}
else {
;
}
}
// if second section has wrong CRC and it hasn't been restored before
if ((main_crc_result & 0x02) == 0 && (backup_reg_get_configuration() & CONFIG_SECOND_FAIL_RESTORING) == 0) {
// restore default configuration
if (configuration_handler_restore_default_second() == 0) {
// if configuration has been restored successfully
backup_reg_set_bits_configuration(CONFIG_SECOND_RESTORED);
// set also CRC flag as if restoring is successfull the region has good CRC
backup_reg_set_bits_configuration(CONFIG_SECOND_CRC_OK);
// additionally resets packet counters stored in backup registers
backup_reg_reset_counters();
}
else {
// if not store the flag in the backup register
backup_reg_set_bits_configuration(CONFIG_SECOND_FAIL_RESTORING);
backup_reg_clear_bits_configuration(CONFIG_SECOND_CRC_OK);
}
}
else {
// check failed restoring flag
if ((backup_reg_get_configuration() & CONFIG_SECOND_FAIL_RESTORING) == 0) {
// second configuration section has good CRC and can be used further
backup_reg_set_bits_configuration(CONFIG_SECOND_CRC_OK);
}
else {
;
}
}
// at this point both sections have either verified CRC or restored values to default
if ((backup_reg_get_configuration() & CONFIG_FIRST_CRC_OK) != 0 && (backup_reg_get_configuration() & CONFIG_SECOND_CRC_OK) != 0) {
// if both sections are OK check programming counters
if (config_data_pgm_cntr_first > config_data_pgm_cntr_second) {
// if first section has bigger programing counter use it
configuration_handler_load_configuration(REGION_FIRST);
}
else {
configuration_handler_load_configuration(REGION_SECOND);
}
}
else if ((backup_reg_get_configuration() & CONFIG_FIRST_CRC_OK) != 0 && (backup_reg_get_configuration() & CONFIG_SECOND_CRC_OK) == 0) {
// if only first region is OK use it
configuration_handler_load_configuration(REGION_FIRST);
}
else if ((backup_reg_get_configuration() & CONFIG_FIRST_CRC_OK) == 0 && (backup_reg_get_configuration() & CONFIG_SECOND_CRC_OK) != 0) {
// if only first region is OK use it
configuration_handler_load_configuration(REGION_FIRST);
}
else {
configuration_handler_load_configuration(REGION_DEFAULT);
}
// set function for left button
main_button_one_left = configuration_get_left_button();
// set function for right button
main_button_two_right = configuration_get_right_button();
// set packets intervals
packet_tx_init(main_config_data_basic->wx_transmit_period, main_config_data_basic->beacon_transmit_period, main_config_data_mode->powersave);
// initialie telemetry frames counter
telemetry_init();
#if defined(STM32F10X_MD_VL)
// disabling access to BKP registers
RCC->APB1ENR &= (0xFFFFFFFF ^ (RCC_APB1ENR_PWREN | RCC_APB1ENR_BKPEN));
PWR->CR &= (0xFFFFFFFF ^ PWR_CR_DBP);
#endif
// converting latitude into string
memset(main_string_latitude, 0x00, sizeof(main_string_latitude));
float_to_string(main_config_data_basic->latitude, main_string_latitude, sizeof(main_string_latitude), 2, 2);
// converting longitude into string
memset(main_string_longitude, 0x00, sizeof(main_string_longitude));
float_to_string(main_config_data_basic->longitude, main_string_longitude, sizeof(main_string_longitude), 2, 5);
// make a string with callsign and ssid
if (main_config_data_basic->ssid != 0) {
sprintf(main_callsign_with_ssid, "%s-%d", main_config_data_basic->callsign, main_config_data_basic->ssid);
}
else {
sprintf(main_callsign_with_ssid, "%s", main_config_data_basic->callsign);
}
switch(main_config_data_basic->symbol) {
case 0: // _SYMBOL_DIGI
main_symbol_f = '/';
main_symbol_s = '#';
break;
case 1: // _SYMBOL_WIDE1_DIGI
main_symbol_f = '1';
main_symbol_s = '#';
break;
case 2: // _SYMBOL_HOUSE
main_symbol_f = '/';
main_symbol_s = '-';
break;
case 3: // _SYMBOL_RXIGATE
main_symbol_f = 'I';
main_symbol_s = '&';
break;
case 5: // _SYMBOL_SAILBOAT
main_symbol_f = '/';
main_symbol_s = 'Y';
break;
default: // _SYMBOL_IGATE
main_symbol_f = 'R';
main_symbol_s = '&';
break;
}
#if defined _RANDOM_DELAY
// configuring a default delay value
delay_set(_DELAY_BASE, 1);
#elif !defined _RANDOM_DELAY
delay_set(_DELAY_BASE, 0);
#endif
#if defined(PARAMETEO)
if (main_button_one_left != BUTTON_DISABLED || main_button_two_right != BUTTON_DISABLED) {
// initializing GPIO used for buttons
io_buttons_init();
}
// get initial powersave mode
rte_main_curret_powersave_mode = main_config_data_mode->powersave;
// initialize all powersaving functions
pwr_save_init(main_config_data_mode->powersave);
// initialize B+ measurement
io_vbat_meas_init(configuration_get_vbat_a_coeff(), configuration_get_vbat_b_coeff());
#endif
// initalizing separated Open Collector output
io_oc_init();
// initializing GPIO used for swithing on and off voltages on pcb
io_pwr_init();
// initialize sensor power control and switch off supply voltage
wx_pwr_switch_init();
// call periodic handle to wait for 1 second and then switch on voltage
wx_pwr_switch_periodic_handle();
#if defined(PARAMETEO)
// clear all previous powersave indication bits
backup_reg_reset_all_powersave_states();
// swtich power to M4. turn on sensors but keep GSM modem turned off
pwr_save_switch_mode_to_c1();
rte_main_reset_gsm_modem = 0;
delay_fixed(300);
#endif
// waiting for 1 second to count number of ticks when the CPU is idle
main_idle_cpu_ticks = delay_fixed_with_count(1000);
// initializing UART gpio pins
io_uart_init();
#if defined(STM32F10X_MD_VL)
// enabling the clock for both USARTs
RCC->APB2ENR |= RCC_APB2ENR_USART1EN;
RCC->APB1ENR |= RCC_APB1ENR_USART2EN;
#endif
main_kiss_srl_ctx_ptr = &main_kiss_srl_ctx;
main_wx_srl_ctx_ptr = &main_wx_srl_ctx;
#if defined(PARAMETEO)
main_gsm_srl_ctx_ptr = &main_gsm_srl_ctx;
#endif
main_target_kiss_baudrate = 9600u;
#ifndef PARAMETEO
// if Victron VE-direct protocol is enabled set the baudrate to the 19200u
if (main_config_data_mode->victron == 1) {
main_target_kiss_baudrate = 19200u;
// and disable the kiss TNC option as it shares the same port
main_kiss_enabled = 0;
}
#endif
// get target working mode of USART1
if (main_config_data_mode->wx_davis == 1) {
main_usart1_kiss_mode = USART_MODE_DAVIS;
}
else if ((main_config_data_mode->wx_dust_sensor & WX_DUST_SDS011_SERIAL) > 0) {
main_usart1_kiss_mode = USART_MODE_DUST_SDS;
}
else if (main_config_data_mode->victron == 1) {
main_usart1_kiss_mode = USART_MODE_VICTRON;
}
else {
main_usart1_kiss_mode = USART_MODE_KISS;
}
// get target working mode for USART2
if (main_config_data_mode->wx_modbus == 1) {
main_usart2_wx_mode = USART_MODE_MODBUS;
}
else if (main_config_data_mode->wx_umb == 1) {
main_usart2_wx_mode = USART_MODE_UMB_MASTER;
}
else {
main_usart2_wx_mode = USART_MODE_UNINIT;
}
switch (main_usart1_kiss_mode) {
case USART_MODE_DAVIS: {
// reinitialize the KISS serial port temporary to davis baudrate
main_target_kiss_baudrate = DAVIS_DEFAULT_BAUDRATE;
// reset RX state to allow reinitialization with changed baudrate
main_kiss_srl_ctx_ptr->srl_rx_state = SRL_RX_NOT_CONFIG;
// reinitializing serial hardware to wake up Davis wx station
srl_init(main_kiss_srl_ctx_ptr, USART1, srl_usart1_rx_buffer, RX_BUFFER_1_LN, srl_usart1_tx_buffer, TX_BUFFER_1_LN, main_target_kiss_baudrate, 1);
srl_switch_timeout(main_kiss_srl_ctx_ptr, SRL_TIMEOUT_ENABLE, 3000);
davis_init(main_kiss_srl_ctx_ptr);
// try to wake up the davis base
rte_wx_davis_station_avaliable = (davis_wake_up(DAVIS_BLOCKING_IO) == 0 ? 1 : 0);
// if davis weather stations is connected to SERIAL port
if (rte_wx_davis_station_avaliable == 1) {
// turn LCD backlight on..
davis_control_backlight(1);
// wait for a while
delay_fixed(1000);
// and then off to let the user know that communication is working
davis_control_backlight(0);
// disable the KISS modem as the UART will be used for DAVIS wx station
main_kiss_enabled = 0;
// enable the davis serial protocol client to allow pooling callbacks to be called in main loop.
// This only controls the callback it doesn't mean that the station itself is responding to
// communication. It stays set to one event if Davis station
main_davis_serial_enabled = 1;
// trigger the rxcheck to get all counter values
davis_trigger_rxcheck_packet();
}
else {
// if not revert back to KISS configuration
main_target_kiss_baudrate = 9600u;
main_kiss_srl_ctx_ptr->srl_rx_state = SRL_RX_NOT_CONFIG;
// initializing UART drvier
srl_init(main_kiss_srl_ctx_ptr, USART1, srl_usart1_rx_buffer, RX_BUFFER_1_LN, srl_usart1_tx_buffer, TX_BUFFER_1_LN, main_target_kiss_baudrate, 1);
main_usart1_kiss_mode = USART_MODE_KISS;
}
break;
}
case USART_MODE_DUST_SDS: {
srl_init(main_kiss_srl_ctx_ptr, USART1, srl_usart1_rx_buffer, RX_BUFFER_1_LN, srl_usart1_tx_buffer, TX_BUFFER_1_LN, 9600u, 1);
main_kiss_enabled = 0;
break;
}
case USART_MODE_VICTRON: {
break;
}
case USART_MODE_KISS: {
srl_init(main_kiss_srl_ctx_ptr, USART1, srl_usart1_rx_buffer, RX_BUFFER_1_LN, srl_usart1_tx_buffer, TX_BUFFER_1_LN, main_target_kiss_baudrate, 1);
main_kiss_enabled = 1;
break;
}
case USART_MODE_MODBUS:
case USART_MODE_UMB_MASTER:
case USART_MODE_UNINIT:
case USART_MODE_UNDEF:
main_kiss_enabled = 0;
break;
}
switch (main_usart2_wx_mode) {
case USART_MODE_MODBUS: {
rtu_serial_init(&rte_rtu_pool_queue, 1, main_wx_srl_ctx_ptr, main_config_data_rtu);
main_target_wx_baudrate = main_config_data_rtu->slave_speed;
srl_init(main_wx_srl_ctx_ptr, USART2, srl_usart2_rx_buffer, RX_BUFFER_2_LN, srl_usart2_tx_buffer, TX_BUFFER_2_LN, main_target_wx_baudrate, main_config_data_rtu->slave_stop_bits);
srl_switch_tx_delay(main_wx_srl_ctx_ptr, 1);
// enabling rtu master code
main_modbus_rtu_master_enabled = 1;
rtu_serial_start();
break;
}
case USART_MODE_UMB_MASTER: {
main_target_wx_baudrate = main_config_data_umb->serial_speed;
srl_init(main_wx_srl_ctx_ptr, USART2, srl_usart2_rx_buffer, RX_BUFFER_2_LN, srl_usart2_tx_buffer, TX_BUFFER_2_LN, main_target_wx_baudrate, 1);
umb_master_init(&rte_wx_umb_context, main_wx_srl_ctx_ptr, main_config_data_umb);
break;
}
case USART_MODE_DAVIS:
case USART_MODE_DUST_SDS:
case USART_MODE_VICTRON:
case USART_MODE_KISS:
case USART_MODE_UNINIT:
case USART_MODE_UNDEF:
break;
}
#if defined(PARATNC)
main_wx_srl_ctx_ptr->te_pin = GPIO_Pin_8;
main_wx_srl_ctx_ptr->te_port = GPIOA;
#endif
#if defined(PARAMETEO)
main_wx_srl_ctx_ptr->te_pin = LL_GPIO_PIN_8;
main_wx_srl_ctx_ptr->te_port = GPIOA;
main_wx_srl_ctx_ptr->early_tx_assert = configuration_get_early_tx_assert(); // TODO: was 1
// initialize UART used to communicate with GPRS modem
srl_init(main_gsm_srl_ctx_ptr, USART3, srl_usart3_rx_buffer, RX_BUFFER_3_LN, srl_usart3_tx_buffer, TX_BUFFER_3_LN, 115200, 1);
#endif
// initialize APRS path with zeros
memset (main_own_path, 0x00, sizeof(main_own_path));
// configuring an APRS path used to transmit own packets (telemetry, wx, beacons)
main_own_path_ln = ConfigPath(main_own_path, main_config_data_basic);
#ifdef INTERNAL_WATCHDOG
#if defined(STM32F10X_MD_VL)
// enable write access to watchdog registers
IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable);
// Set watchdog prescaler
IWDG_SetPrescaler(IWDG_Prescaler_128);
// Set the counter value to program watchdog for about 13 seconds
IWDG_SetReload(0xFFF);
// enable the watchdog
IWDG_Enable();
// do not disable the watchdog when the core is halted on a breakpoint
DBGMCU_Config(DBGMCU_IWDG_STOP, ENABLE);
// reload watchdog counter
IWDG_ReloadCounter();
#endif
#if defined(STM32L471xx)
// enable watchdog
LL_IWDG_Enable(IWDG);
// unlock write access to configuratio registers
LL_IWDG_EnableWriteAccess(IWDG);
// set prescaler - watchdog timeout on about 32 seconds
LL_IWDG_SetPrescaler(IWDG, LL_IWDG_PRESCALER_256);
// wait for watchdog registers to update
while (LL_IWDG_IsActiveFlag_PVU(IWDG) != 0) {
i++;
if (i > 0x9FF) {
break;
}
}
// reload watchdog which also close access to configiguration registers
LL_IWDG_ReloadCounter(IWDG);
i = 0;
// do not disable watchdog when MCU halts on breakpoints
DBGMCU->APB1FZR1 &= (0xFFFFFFFF ^ DBGMCU_APB1FZR1_DBG_IWDG_STOP);
#endif
#endif
// initialize i2c controller
i2cConfigure();
#if defined(PARAMETEO)
// initialize SPI
spi_init_full_duplex_pio(SPI_MASTER_MOTOROLA, CLOCK_REVERSED_RISING, SPI_SPEED_DIV256, SPI_ENDIAN_MSB);
// initialize measurements averager
max31865_init_average();
// initialize MAX RDT amplifier
max31865_init(main_config_data_mode->wx_pt_sensor & 0x3, (main_config_data_mode->wx_pt_sensor & 0xFC) >> 2);
#endif
// initialize GPIO pins leds are connecting to
led_init();
// initialize AX25 & APRS stuff
AFSK_Init(&main_afsk);
ax25_init(&main_ax25, &main_afsk, 0, 0x00, 0x00);
DA_Init();
// configure external watchdog
io_ext_watchdog_config();
// initializing the digipeater configuration
digi_init(main_config_data_mode);
if ((main_config_data_mode->wx & WX_ENABLED) == 1) {
#if defined(PARATNC)
dallas_init(GPIOC, GPIO_Pin_11, GPIO_PinSource11, &rte_wx_dallas_average);
#endif
#if defined(PARAMETEO)
// initialize dallas one-wire driver for termometer
dallas_init(GPIOC, LL_GPIO_PIN_11, 0x0, &rte_wx_dallas_average);
#endif
// if (main_config_data_mode->wx_umb == 1) {
// // client initialization
// umb_master_init(&rte_wx_umb_context, main_wx_srl_ctx_ptr, main_config_data_umb);
// }
if ((main_config_data_mode->wx & WX_INTERNAL_SPARKFUN_WIND) == 0) {
analog_anemometer_init(main_config_data_mode->wx_anemometer_pulses_constant, 38, 100, 1);
}
else {
analog_anemometer_init(main_config_data_mode->wx_anemometer_pulses_constant, 38, 100, 1);
}
}
// configuring interrupt priorities
it_handlers_set_priorities();
// read calibration data from I2C pressure / humidity sensor
if (main_config_data_mode->wx_ms5611_or_bme == 0) {
ms5611_reset(&rte_wx_ms5611_qf);
ms5611_read_calibration(SensorCalData, &rte_wx_ms5611_qf);
ms5611_trigger_measure(0, 0);
}
else if (main_config_data_mode->wx_ms5611_or_bme == 1) {
bme280_reset(&rte_wx_bme280_qf);
bme280_setup();
bme280_read_calibration(bme280_calibration_data);
}
if (main_kiss_enabled == 1) {
// preparing initial beacon which will be sent to host PC using KISS protocol via UART
main_own_aprs_msg_len = sprintf(main_own_aprs_msg, "=%s%c%c%s%c%c %s", main_string_latitude, main_config_data_basic->n_or_s, main_symbol_f, main_string_longitude, main_config_data_basic->e_or_w, main_symbol_s, main_config_data_basic->comment);
// terminating the aprs message
main_own_aprs_msg[main_own_aprs_msg_len] = 0;
// 'sending' the message which will only encapsulate it inside AX25 protocol (ax25_starttx is not called here)
//ax25_sendVia(&main_ax25, main_own_path, (sizeof(main_own_path) / sizeof(*(main_own_path))), main_own_aprs_msg, main_own_aprs_msg_len);
ln = ax25_sendVia_toBuffer(main_own_path, (sizeof(main_own_path) / sizeof(*(main_own_path))), main_own_aprs_msg, main_own_aprs_msg_len, main_kiss_srl_ctx.srl_tx_buf_pointer, TX_BUFFER_1_LN);
// SendKISSToHost function cleares the output buffer hence routine need to wait till the UART will be ready for next transmission.
// Here this could be omitted because UART isn't used before but general idea
while(main_kiss_srl_ctx.srl_tx_state != SRL_TX_IDLE && main_kiss_srl_ctx.srl_tx_state != SRL_TX_ERROR);
// converting AX25 with beacon to KISS format
//ln = SendKISSToHost(main_afsk.tx_buf + 1, main_afsk.tx_fifo.tail - main_afsk.tx_fifo.head - 4, srl_tx_buffer, TX_BUFFER_LN);
// checking if KISS-framing was done correctly
if (ln != KISS_TOO_LONG_FRM) {
#ifdef SERIAL_TX_TEST_MODE
// infinite loop for testing UART transmission
for (;;) {
retval = srl_receive_data(main_kiss_srl_ctx_ptr, 100, '\r', '\r', 0, 0, 0);
#endif
retval = srl_start_tx(main_kiss_srl_ctx_ptr, ln);
#ifdef SERIAL_TX_TEST_MODE
while(main_kiss_srl_ctx_ptr->srl_tx_state != SRL_TX_IDLE);
#if defined(PARAMETEO)
LL_GPIO_TogglePin(GPIOC, LL_GPIO_PIN_9);
#else
GPIOC->ODR = (GPIOC->ODR ^ GPIO_Pin_9);
#endif
if (main_kiss_srl_ctx_ptr->srl_rx_state == SRL_RX_DONE) {
#if defined(PARAMETEO)
LL_GPIO_TogglePin(GPIOC, LL_GPIO_PIN_9);
#else
GPIOC->ODR = (GPIOC->ODR ^ GPIO_Pin_9);
#endif
retval = 200;
}
}
#endif
}
}
// reinitializing AFSK and AX25 driver
AFSK_Init(&main_afsk);
ADCStartConfig();
DACStartConfig();
AFSK_Init(&main_afsk);
ax25_init(&main_ax25, &main_afsk, 0, message_callback, 0);
if ((main_config_data_mode->wx & WX_ENABLED) == 1) {
// getting all meteo measuremenets to be sure that WX frames want be sent with zeros
wx_get_all_measurements(main_config_data_wx_sources, main_config_data_mode, main_config_data_umb, main_config_data_rtu);
}
#ifndef PARAMETEO
// start serial port i/o transaction depending on station configuration
if (main_config_data_mode->victron == 1) {
// initializing protocol parser
ve_direct_parser_init(&rte_pv_struct, &rte_pv_average);
// enabling timeout handling for serial port. This is required because VE protocol frame may vary in lenght
// and serial port driver could finish reception only either on stop character or when declared number of bytes
// has been received.
srl_switch_timeout(main_kiss_srl_ctx_ptr, 1, 50);
// switching UART to receive mode to be ready for data from charging controller
srl_receive_data(main_kiss_srl_ctx_ptr, VE_DIRECT_MAX_FRAME_LN, 0, 0, 0, 0, 0);
}
else {
// switching UART to receive mode to be ready for KISS frames from host
srl_receive_data(main_kiss_srl_ctx_ptr, 100, FEND, FEND, 0, 0, 0);
}
#else
if (main_kiss_enabled == 1) {
// switching UART to receive mode to be ready for KISS frames from host
srl_receive_data(main_kiss_srl_ctx_ptr, 100, FEND, FEND, 0, 0, 0);
}
else {
srl_receive_data(main_kiss_srl_ctx_ptr, 10, 0xAA, 0, 0, 0, 0);
}
#endif
io_oc_output_low();
led_control_led1_upper(false);
led_control_led2_bottom(false);
#if defined(PARAMETEO)
rte_main_battery_voltage = io_vbat_meas_get();
rte_main_average_battery_voltage = rte_main_battery_voltage;
if (main_config_data_mode->gsm == 1) {
pwr_save_switch_mode_to_c0();
}
// sleep a little bit and wait for everything to power up completely
delay_fixed(1000);
led_control_led1_upper(true);
led_control_led2_bottom(false);
delay_fixed(1000);
led_control_led1_upper(false);
led_control_led2_bottom(true);
delay_fixed(1000);
led_control_led1_upper(true);
led_control_led2_bottom(true);
delay_fixed(1000);
led_control_led1_upper(false);
led_control_led2_bottom(false);
#endif
// configuting system timers
TimerConfig();
// initialize UMB transaction
if (main_config_data_mode->wx_umb == 1) {
umb_0x26_status_request(&rte_wx_umb, &rte_wx_umb_context, main_config_data_umb);
}
// reload watchdog counter
main_reload_internal_wdg();
// reload external watchdog in case it is installed
io_ext_watchdog_service();
#ifdef PARAMETEO
// initialize NVM logger if it is enabled
if (main_config_data_mode->nvm_logger != 0) {
nvm_measurement_init();
}
// initialize everything related to GSM module
if (main_config_data_mode->gsm == 1) {
it_handlers_inhibit_radiomodem_dcd_led = 1;
led_control_led1_upper(false);
gsm_sim800_init(&main_gsm_state, 1);
http_client_init(&main_gsm_state, main_gsm_srl_ctx_ptr, 0);
// as for now it is not possible to have APRS-IS communciation and REST api at once,
// due to some data races and another timing problems while disconnecting APRS-IS to make
// room for HTTP request - hence that if below
if (main_config_data_gsm->api_enable == 1 && main_config_data_gsm->aprsis_enable == 0) {
api_init((const char *)main_config_data_gsm->api_base_url, (const char *)(main_config_data_gsm->api_station_name));
}
if (main_config_data_gsm->api_enable == 0 && main_config_data_gsm->aprsis_enable == 1) {
aprsis_init(&main_gsm_srl_ctx,
&main_gsm_state,
(const char *)main_config_data_basic->callsign,
main_config_data_basic->ssid,
main_config_data_gsm->aprsis_passcode,
(const char *)main_config_data_gsm->aprsis_server_address,
main_config_data_gsm->aprsis_server_port,
configuration_get_power_cycle_gsmradio_on_no_communications(),
main_callsign_with_ssid);
}
}
if ((main_config_data_mode->wx_dust_sensor & WX_DUST_SDS011_PWM) > 0) {
pwm_input_io_init();
pwm_input_init(1);
}
#endif
if (main_config_data_basic-> beacon_at_bootup == 1) {
#if defined(PARAMETEO)
beacon_send_own(rte_main_battery_voltage, system_is_rtc_ok());
main_wait_for_tx_complete();
// this delay is put in case if beacon is configured to use
// any path like WIDE1-1 or WIDE2-1 or another. The delay
// will wait for some time to have this beacon digipeated
// by the APRS radio network
delay_fixed(1500);
#else
beacon_send_own(0, 0);
#endif
#if defined(PARAMETEO)
status_send_powersave_registers();
#endif
}
main_nvm_timestamp = main_get_nvm_timestamp();
it_handlers_inhibit_radiomodem_dcd_led = 0;
// Infinite loop
while (1)
{
backup_reg_set_monitor(-1);
// incrementing current cpu ticks
main_current_cpu_idle_ticks++;
// system reset may be requested from various places in the application
if (rte_main_reboot_req == 1) {
NVIC_SystemReset();
}
else {
;
}
backup_reg_set_monitor(0);
#if defined(PARAMETEO)
if (rte_main_woken_up == RTE_MAIN_WOKEN_UP_EXITED) {
// restart ADCs
io_vbat_meas_enable();
// get current battery voltage and calculate current average
rte_main_battery_voltage = io_vbat_meas_get();
rte_main_average_battery_voltage = io_vbat_meas_average(rte_main_battery_voltage);
// meas average will return 0 if internal buffer isn't filled completely
if (rte_main_average_battery_voltage == 0) {
rte_main_average_battery_voltage = rte_main_battery_voltage;
}
// reinitialize APRS radio modem to clear all possible intermittent state caused by
// switching power state in the middle of APRS packet reception
ax25_new_msg_rx_flag = 0;
main_ax25.dcd = false;
//DA_Init();
ADCStartConfig();
DACStartConfig();
AFSK_Init(&main_afsk);
ax25_init(&main_ax25, &main_afsk, 0, message_callback, 0);
//TimerConfig();
rte_main_woken_up = 0;
main_check_adc = 1;
// reinitialize UART used to communicate with GPRS modem
srl_init(main_gsm_srl_ctx_ptr, USART3, srl_usart3_rx_buffer, RX_BUFFER_3_LN, srl_usart3_tx_buffer, TX_BUFFER_3_LN, 115200, 1);
backup_reg_set_monitor(1);
}
#endif
backup_reg_set_monitor(11);
// if new packet has been received from radio channel
if(ax25_new_msg_rx_flag == 1) {
// if serial port is currently not busy on transmission
if (main_kiss_srl_ctx_ptr->srl_tx_state != SRL_TXING) {
memset(main_kiss_srl_ctx.srl_tx_buf_pointer, 0x00, main_kiss_srl_ctx.srl_tx_buf_ln);
if (main_kiss_enabled == 1) {
// convert message to kiss format and send it to host
srl_start_tx(main_kiss_srl_ctx_ptr, kiss_send_ax25_to_host(ax25_rxed_frame.raw_data, (ax25_rxed_frame.raw_msg_len - 2), main_kiss_srl_ctx.srl_tx_buf_pointer, main_kiss_srl_ctx.srl_tx_buf_ln));
}
}
main_ax25.dcd = false;
// check this frame against other frame in visvous buffer waiting to be transmitted
digi_check_with_viscous(&ax25_rxed_frame);
// check if this packet needs to be repeated (digipeated) and do it if it is necessary
digi_process(&ax25_rxed_frame, main_config_data_basic, main_config_data_mode);
ax25_new_msg_rx_flag = 0;
rx10m++;
#ifdef PARAMETEO
rte_main_rx_total++;
// if aprsis is logged
if (aprsis_connected == 1 && gsm_sim800_tcpip_tx_busy() == 0) {
aprsis_igate_to_aprsis(&ax25_rxed_frame, (const char *)&main_callsign_with_ssid);
}
#endif
}
#ifdef PARAMETEO
// if GSM communication is enabled
if (main_config_data_mode->gsm == 1 && io_get_cntrl_vbat_g() == 1) {
// if data has been received
if (main_gsm_srl_ctx_ptr->srl_rx_state == SRL_RX_DONE || main_gsm_srl_ctx_ptr->srl_rx_state == SRL_RX_ERROR) {
// receive callback for communicatio with the modem
gsm_sim800_rx_done_event_handler(main_gsm_srl_ctx_ptr, &main_gsm_state);
}
if (main_gsm_srl_ctx_ptr->srl_tx_state == SRL_TX_IDLE) {
gsm_sim800_tx_done_event_handler(main_gsm_srl_ctx_ptr, &main_gsm_state);
}
if (rte_main_trigger_message_ack == 1) {
if (rte_main_received_message_source == MESSAGE_SOURCE_APRSIS && gsm_sim800_tcpip_tx_busy() == 0) {
rte_main_trigger_message_ack = 0;
aprsis_send_ack_for_message(&rte_main_received_message);
rte_main_received_message_source == MESSAGE_SOURCE_UNINITIALIZED;
}
else if (rte_main_received_message_source == MESSAGE_SOURCE_RADIO) {
}
}
if (rte_main_trigger_gsm_status == 1 && gsm_sim800_tcpip_tx_busy() == 0) {
rte_main_trigger_gsm_status = 0;
aprsis_send_gsm_status((const char *)&main_callsign_with_ssid);
}
// if GSM status message is triggered and GSM module is not busy transmitting something else
if (rte_main_trigger_gsm_aprsis_counters_packet == 1 && gsm_sim800_tcpip_tx_busy() == 0) {
rte_main_trigger_gsm_aprsis_counters_packet = 0;
aprsis_send_server_comm_counters((const char *)&main_callsign_with_ssid);
}
// if loginstring packet (APRS status packet with loginstring received from a server)
// is triggered and GSM module is not busy
if (rte_main_trigger_gsm_loginstring_packet == 1 && gsm_sim800_tcpip_tx_busy() == 0) {
rte_main_trigger_gsm_loginstring_packet = 0;
aprsis_send_loginstring((const char *)&main_callsign_with_ssid, system_is_rtc_ok(), rte_main_battery_voltage);
}
if (rte_main_trigger_gsm_telemetry_values == 1 && gsm_sim800_tcpip_tx_busy() == 0) {
rte_main_trigger_gsm_telemetry_values = 0;
aprsis_send_telemetry(1u, (const char *)&main_callsign_with_ssid);
}
if (rte_main_trigger_gsm_telemetry_descriptions == 1 && gsm_sim800_tcpip_tx_busy() == 0) {
// check if this ought to be first telemetry description in sequence
if (main_telemetry_description == TELEMETRY_NOTHING) {
// if yes check if victron telemetry is enabled
if (main_config_data_mode->victron != 0) {
// set the first packet accordingly
main_telemetry_description = TELEMETRY_PV_PARM;
}
else if (main_config_data_mode->digi_viscous != 0) {
main_telemetry_description = TELEMETRY_VISCOUS_PARAM;
}
else {
main_telemetry_description = TELEMETRY_NORMAL_PARAM;
}
}
// assemble and sent a telemetry description packet
main_telemetry_description = aprsis_send_description_telemetry(1u, main_telemetry_description, main_config_data_basic, main_config_data_mode, (const char *)&main_callsign_with_ssid);
// if there is nothing to send
if (main_telemetry_description == TELEMETRY_NOTHING) {
rte_main_trigger_gsm_telemetry_descriptions = 0;
}
}
}
#endif
// if Victron VE.direct client is enabled
if (main_config_data_mode->victron == 1) {
#ifndef PARAMETEO
// if new KISS message has been received from the host
if (main_kiss_srl_ctx_ptr->srl_rx_state == SRL_RX_DONE || main_kiss_srl_ctx_ptr->srl_rx_state == SRL_RX_ERROR) {
// cutting received string to Checksum, everything after will be skipped
ve_direct_cut_to_checksum(srl_get_rx_buffer(main_kiss_srl_ctx_ptr), TX_BUFFER_1_LN, &buffer_len);
// checking if this frame is ok
ve_direct_validate_checksum(srl_get_rx_buffer(main_kiss_srl_ctx_ptr), buffer_len, &retval);
if (retval == 1) {
// parsing data from input serial buffer to
retval = ve_direct_parse_to_raw_struct(srl_get_rx_buffer(main_kiss_srl_ctx_ptr), buffer_len, &rte_pv_struct);
if (retval == 0) {
ve_direct_add_to_average(&rte_pv_struct, &rte_pv_average);
ve_direct_get_averages(&rte_pv_average, &rte_pv_battery_current, &rte_pv_battery_voltage, &rte_pv_cell_voltage, &rte_pv_load_current);
ve_direct_set_sys_voltage(&rte_pv_struct, &rte_pv_sys_voltage);
ve_direct_store_errors(&rte_pv_struct, &rte_pv_last_error);
rte_pv_messages_count++;
}
}
else {
rte_pv_corrupted_messages_count++;
}
//memset(srl_get_rx_buffer(main_kiss_srl_ctx_ptr), 0x00, TX_BUFFER_1_LN);
srl_receive_data(main_kiss_srl_ctx_ptr, VE_DIRECT_MAX_FRAME_LN, 0, 0, 0, 0, 0);
}
#endif
}
else if ((main_config_data_mode->wx_dust_sensor & WX_DUST_SDS011_SERIAL) > 0) {
if (main_kiss_srl_ctx_ptr->srl_rx_state == SRL_RX_DONE) {
sds011_get_pms(main_kiss_srl_ctx_ptr->srl_rx_buf_pointer, 10, &rte_wx_pm10, &rte_wx_pm2_5);
// restart reception
srl_receive_data(main_kiss_srl_ctx_ptr, 10, 0xAA, 0, 0, 0, 0);
}
}
else {
// if new KISS message has been received from the host
if (main_kiss_srl_ctx_ptr->srl_rx_state == SRL_RX_DONE && main_kiss_enabled == 1) {
// parse i ncoming data and then transmit on radio freq
ln = kiss_parse_received(srl_get_rx_buffer(main_kiss_srl_ctx_ptr), srl_get_num_bytes_rxed(main_kiss_srl_ctx_ptr), &main_ax25, &main_afsk, main_small_buffer, KISS_CONFIG_DIAGNOSTIC_BUFFER_LN);
if (ln == 0) {
kiss10m++; // increase kiss messages counter
}
else if (ln > 0) {
// if a response (ACK) to this KISS frame shall be sent
// wait for any pending transmission to complete
srl_wait_for_tx_completion(main_kiss_srl_ctx_ptr);
srl_send_data(main_kiss_srl_ctx_ptr, main_small_buffer, SRL_MODE_DEFLN, ln, SRL_INTERNAL);
}
// restart KISS receiving to be ready for next frame
srl_receive_data(main_kiss_srl_ctx_ptr, 120, FEND, FEND, 0, 0, 0);
}
// if there were an error during receiving frame from host, restart rxing once again
if (main_kiss_srl_ctx_ptr->srl_rx_state == SRL_RX_ERROR && main_kiss_enabled == 1) {
srl_receive_data(main_kiss_srl_ctx_ptr, 120, FEND, FEND, 0, 0, 0);
}
}
if (kiss_current_async_message != 0xFF && main_kiss_srl_ctx_ptr->srl_tx_state == SRL_TX_IDLE) {
srl_start_tx(main_kiss_srl_ctx_ptr, kiss_async_pooler(main_kiss_srl_ctx.srl_tx_buf_pointer, main_kiss_srl_ctx.srl_tx_buf_ln));
}
// if Davis wx station is enabled and it is alive
if (main_davis_serial_enabled == 1) {
// pool the Davis wx station driver for LOOP packet
davis_loop_packet_pooler(&rte_wx_davis_loop_packet_avaliable);
davis_rxcheck_packet_pooler();
}
if (main_config_data_mode->wx_umb == 1) {
// if some UMB data have been received
if (main_wx_srl_ctx_ptr->srl_rx_state == SRL_RX_DONE) {
umb_pooling_handler(&rte_wx_umb_context, REASON_RECEIVE_IDLE, master_time, main_config_data_umb);
}
// if there were an error during receiving frame from host, restart rxing once again
if (main_wx_srl_ctx_ptr->srl_rx_state == SRL_RX_ERROR) {
umb_pooling_handler(&rte_wx_umb_context, REASON_RECEIVE_ERROR, master_time, main_config_data_umb);
}
if (main_wx_srl_ctx_ptr->srl_tx_state == SRL_TX_IDLE) {
umb_pooling_handler(&rte_wx_umb_context, REASON_TRANSMIT_IDLE, master_time, main_config_data_umb);
}
}
// if modbus rtu master is enabled
else if (main_modbus_rtu_master_enabled == 1 && io_get_cntrl_vbat_m() == 1) {
rtu_serial_pool();
}
button_check_all(main_button_one_left, main_button_two_right);
backup_reg_set_monitor(2);
// get all meteo measuremenets each 65 seconds. some values may not be
// downloaded from sensors if _METEO and/or _DALLAS_AS_TELEM aren't defined
if (main_wx_sensors_pool_timer < 10) {
if ((main_config_data_mode->wx & WX_ENABLED) == 1) {
// notice: UMB-master and Modbus-RTU uses the same UART
// so they cannot be enabled both at once
// check if modbus rtu master is enabled and configured properly
if (main_modbus_rtu_master_enabled == 1) {
// start quering all Modbus RTU devices & registers one after another
rtu_serial_start();
}
else if (main_config_data_mode->wx_umb == 1) {
// request status from the slave if UMB master is enabled
umb_0x26_status_request(&rte_wx_umb, &rte_wx_umb_context, main_config_data_umb);
}
else {
;
}
// davis serial weather station is connected using UART / RS232 used normally
// for KISS communcation between modem and host PC
if (main_davis_serial_enabled == 1) {
davis_trigger_rxcheck_packet();
}
// get all measurements from 'internal' sensors (except wind which is handled separately)
wx_get_all_measurements(main_config_data_wx_sources, main_config_data_mode, main_config_data_umb, main_config_data_rtu);
}
backup_reg_set_monitor(3);
main_wx_sensors_pool_timer = 65500;
}
/**
* ONE MINUTE POOLING
*/
if (main_one_minute_pool_timer < 10) {
backup_reg_set_monitor(4);
main_nvm_timestamp = main_get_nvm_timestamp();
#ifndef _MUTE_OWN
packet_tx_handler(main_config_data_basic, main_config_data_mode);
#endif
backup_reg_set_monitor(5);
#ifdef STM32L471xx
if (main_config_data_mode->gsm == 1) {
if (http_client_connection_errors > HTTP_CLIENT_MAX_CONNECTION_ERRORS) {
NVIC_SystemReset();
}
}
if ((main_config_data_gsm->aprsis_enable != 0) && (main_config_data_mode->gsm == 1)) {
if (pwr_save_is_currently_cutoff() == 0) {
// this checks when APRS-IS was alive last time and when any packet
// has been sent to the server.
const int i_am_ok_with_aprsis = aprsis_check_connection_attempt_alive();
if (i_am_ok_with_aprsis != 0) {
// increase counter stored in RTC backup register
backup_reg_increment_aprsis_check_reset();
// trigger a restart
NVIC_SystemReset();
}
}
}
#endif
if (rte_wx_check_weather_measurements() == 0) {
backup_reg_increment_weather_measurements_check_reset();
NVIC_SystemReset();
}
if (rte_wx_dallas_degraded_counter > DALLAS_MAX_LIMIT_OF_DEGRADED) {
backup_reg_increment_dallas_degraded_reset();
rte_main_reboot_req = 1;
}
/**
* ONE HOUR POOLING
*/
if (--main_one_hour_pool_timer < 0) {
main_one_hour_pool_timer = 60;
// check if RTC is working correctly
if (system_is_rtc_ok() == 0) {
backup_reg_increment_is_rtc_ok_check_reset();
rte_main_reboot_req = 1;
}
if ((main_config_data_gsm->aprsis_enable != 0) && (main_config_data_mode->gsm == 1)) {
rte_main_trigger_gsm_aprsis_counters_packet = 1;
}
}
main_one_minute_pool_timer = 60000;
}
/**
* ONE SECOND POOLING
*/
if (main_one_second_pool_timer < 10) {
backup_reg_set_monitor(6);
digi_pool_viscous();
button_debounce();
#ifdef PARAMETEO
// this if cannot be guarded by checking if VBAT_G is enabled
// because VBAT_G itself is controlled by initialization
// pooler
if (main_config_data_mode->gsm == 1) {
gsm_sim800_initialization_pool(main_gsm_srl_ctx_ptr, &main_gsm_state);
}
if (main_config_data_mode->gsm == 1 && io_get_cntrl_vbat_g() == 1 && rte_main_woken_up == 0) {
// check if GSM modem must be power-cycled / restarted like after
// waking up from deep sleep or chaning power saving mode
if (rte_main_reset_gsm_modem == 1) {
// rest the flag
rte_main_reset_gsm_modem = 0;
srl_init(main_gsm_srl_ctx_ptr, USART3, srl_usart3_rx_buffer, RX_BUFFER_3_LN, srl_usart3_tx_buffer, TX_BUFFER_3_LN, 115200, 1);
// reset gsm modem
gsm_sim800_reset(&main_gsm_state);
// please remember that a reset might not be performed if
// the GSM modem is inhibited completely, due to current
// power saving mode and few another things. In that case
// the flag will be cleared but modem NOT restarted
}
if (aprsis_get_aprsis_logged() == 1) {
led_control_led1_upper(true);
}
else {
led_control_led1_upper(false);
}
if (gsm_sim800_gprs_ready == 1) {
/***
*
* TEST TEST TEST TODO
*/
//retval = http_client_async_get("http://pogoda.cc:8080/meteo_backend/status", strlen("http://pogoda.cc:8080/meteo_backend/status"), 0xFFF0, 0x1, dupa);
//retval = http_client_async_post("http://pogoda.cc:8080/meteo_backend/parameteo/skrzyczne/status", strlen("http://pogoda.cc:8080/meteo_backend/parameteo/skrzyczne/status"), post_content, strlen(post_content), 0, dupa);
}
gsm_sim800_poolers_one_second(main_gsm_srl_ctx_ptr, &main_gsm_state, main_config_data_gsm);
aprsis_check_alive();
}
#endif
if ((main_config_data_mode->wx & WX_ENABLED) == 1) {
analog_anemometer_direction_handler();
}
backup_reg_set_monitor(7);
main_one_second_pool_timer = 1000;
}
else if (main_one_second_pool_timer < -10) {
if ((main_config_data_mode->wx & WX_ENABLED) == 1) {
analog_anemometer_direction_reset();
}
main_one_second_pool_timer = 1000;
}
/**
* TWO SECOND POOLING
*/
if (main_two_second_pool_timer < 10) {
if (configuration_get_inhibit_wx_pwr_handle() == 0) {
wx_pwr_switch_periodic_handle();
}
#ifdef PARAMETEO
if (configuration_get_power_cycle_vbat_r() == 1 && !main_afsk.sending) {
io_pool_vbat_r(packet_tx_get_minutes_to_next_wx());
}
#endif
wx_check_force_i2c_reset();
#ifdef PARAMETEO
max31865_pool();
#endif
main_reload_internal_wdg();
main_two_second_pool_timer = 2000;
}
/**
* TEN SECOND POOLING
*/
if (main_ten_second_pool_timer < 10) {
backup_reg_set_monitor(8);
// check if consecutive weather frame has been triggered from 'packet_tx_handler'
if (rte_main_trigger_wx_packet == 1) {
packet_tx_send_wx_frame();
rte_main_trigger_wx_packet = 0;
}
#ifdef PARAMETEO
if (main_check_adc == 1) {
AD_Restart();
main_check_adc = 0;
}
// get current battery voltage. for non parameteo this will return 0
rte_main_battery_voltage = io_vbat_meas_get();
// get average battery voltage
rte_main_average_battery_voltage = io_vbat_meas_average(rte_main_battery_voltage);
// meas average will return 0 if internal buffer isn't filled completely
if (rte_main_average_battery_voltage == 0) {
rte_main_average_battery_voltage = rte_main_battery_voltage;
}
// inhibit any power save switching when modem transmits data
if (!main_afsk.sending && rte_main_woken_up == 0 && packet_tx_is_gsm_meteo_pending() == 0) {
pwr_save_pooling_handler(main_config_data_mode, main_config_data_basic, packet_tx_get_minutes_to_next_wx(), rte_main_average_battery_voltage, rte_main_battery_voltage);
}
if ((main_config_data_mode->wx_dust_sensor & WX_DUST_SDS011_PWM) > 0) {
pwm_input_pool();
}
if (pwm_first_channel != 0) {
rte_wx_pm2_5 = pwm_first_channel;
}
if (pwm_second_channel != 0) {
rte_wx_pm10 = pwm_second_channel;
}
#endif
backup_reg_set_monitor(9);
#ifdef PARAMETEO
if (main_config_data_mode->gsm == 1 && io_get_cntrl_vbat_g() == 1 && rte_main_woken_up == 0) {
gsm_sim800_poolers_ten_seconds(main_gsm_srl_ctx_ptr, &main_gsm_state);
packet_tx_tcp_handler();
}
#endif
if (main_config_data_mode->wx_umb == 1) {
umb_channel_pool(&rte_wx_umb, &rte_wx_umb_context, main_config_data_umb);
}
if (main_config_data_mode->wx_umb == 1) {
rte_wx_umb_qf = umb_get_current_qf(&rte_wx_umb_context, master_time);
}
#ifdef STM32L471xx
if (io_get_cntrl_vbat_s() == 1) {
#else
if (io_get_5v_isol_sw___cntrl_vbat_s() == 1) {
#endif
// pool anemometer only when power is applied
wx_pool_anemometer(main_config_data_wx_sources, main_config_data_mode, main_config_data_umb, main_config_data_rtu);
}
if (main_davis_serial_enabled == 1) {
// if previous LOOP packet is ready for processing
if (rte_wx_davis_loop_packet_avaliable == 1) {
davis_parsers_loop(main_kiss_srl_ctx_ptr->srl_rx_buf_pointer, main_kiss_srl_ctx_ptr->srl_rx_buf_ln, &rte_wx_davis_loop_content);
}
// trigger consecutive LOOP packet
davis_trigger_loop_packet();
}
main_ten_second_pool_timer = 10000;
}
backup_reg_set_monitor(10);
}
// Infinite loop, never return.
}
uint16_t main_get_adc_sample(void) {
return (uint16_t) ADC1->DR;
}
void main_service_cpu_load_ticks(void) {
uint32_t cpu_ticks_load = 0;
// the biggest this result will be the biggest load the CPU is handling
cpu_ticks_load = main_idle_cpu_ticks - main_current_cpu_idle_ticks;
// calculate the cpu load
main_cpu_load = (int8_t) ((cpu_ticks_load * 100) / main_idle_cpu_ticks);
// reset the tick counter back to zero;
main_current_cpu_idle_ticks = 0;
}
void main_reload_internal_wdg(void){
#ifdef STM32F10X_MD_VL
// reload watchdog counter
IWDG_ReloadCounter();
#endif
#ifdef STM32L471xx
LL_IWDG_ReloadCounter(IWDG);
#endif
}
uint32_t main_get_nvm_timestamp(void) {
uint32_t out = 0;
/**
* Date-time timestamp in timezone local for a place where station is installed.
* Mixture of BCD and integer format, this is just sligtly processed RTC registers
* content.
* bit 0 - bit 12 === number of minutes starting from midnight (max 1440)
* bit 16 - bit 24 === days from new year (max 356)
* bit 25 - bit 31 === years (from 00 to 99, from 2000 up to 2099)
*/
#ifdef STM32L471xx
uint16_t temp = 0;
// minutes
temp = 600 * ((RTC->TR & RTC_TR_HT) >> RTC_TR_HT_Pos) +
60 * ((RTC->TR & RTC_TR_HU) >> RTC_TR_HU_Pos) +
10 * ((RTC->TR & RTC_TR_MNT) >> RTC_TR_MNT_Pos) +
1 * ((RTC->TR & RTC_TR_MNU) >> RTC_TR_MNU_Pos);
out = out | (temp & 0x7FF);
// current month
temp = 1 * ((RTC->DR & RTC_DR_MU) >> RTC_DR_MU_Pos) +
10 * ((RTC->DR & RTC_DR_MT) >> RTC_DR_MT_Pos);
switch (temp) {
case 1: temp = 0; break;
case 2: temp = 31; break;
case 3: temp = 31 + 28; break;
case 4: temp = 31 + 28 + 31; break;
case 5: temp = 31 + 28 + 31 + 30; break;
case 6: temp = 31 + 28 + 31 + 30 + 31; break;
case 7: temp = 31 + 28 + 31 + 30 + 31 + 30; break;
case 8: temp = 31 + 28 + 31 + 30 + 31 + 30 + 31; break;
case 9: temp = 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31; break;
case 10:temp = 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30; break;
case 11:temp = 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31; break;
case 12:temp = 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30; break;
}
// then add number of days from current month
temp = temp +
1 * ((RTC->DR & RTC_DR_DU) >> RTC_DR_DU_Pos) +
10 * ((RTC->DR & RTC_DR_DT) >> RTC_DR_DT_Pos);
out = out | ((temp & 0x1FF) << 16);
// years
temp = 10 * ((RTC->DR & RTC_DR_YT) >> RTC_DR_YT_Pos) +
1 * ((RTC->DR & RTC_DR_YU) >> RTC_DR_YU_Pos);
out = out | ((temp & 0x7F) << 25);
#endif
return out;
}
#pragma GCC diagnostic pop
// ----------------------------------------------------------------------------
Reference in New Issue View Git Blame Kopiuj bezpośredni odnośnik