2016-01-17 14:54:54 +01:00
/* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation , either version 3 of the License , or
* ( at your option ) any later version .
*
* This program is distributed in the hope that it will be useful ,
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
* GNU General Public License for more details .
*
* You should have received a copy of the GNU General Public License
* along with this program . If not , see < http : //www.gnu.org/licenses/>.
*
*/
2016-08-14 21:04:08 +02:00
/** STM32F1 example
2016-08-14 21:02:38 +02:00
* @ file main . c
* @ author King Kévin < kingkevin @ cuvoodoo . info >
* @ date 2016
*/
2016-01-17 14:54:54 +01:00
/* standard libraries */
# include <stdint.h> // standard integer types
# include <stdio.h> // standard I/O facilities
# include <stdlib.h> // standard utilities
# include <unistd.h> // standard streams
2016-08-14 21:02:38 +02:00
# include <string.h> // string utilities
# include <math.h> // mathematical utilities
2016-01-17 14:54:54 +01:00
/* STM32 (including CM3) libraries */
2016-01-18 16:23:35 +01:00
# include <libopencmsis/core_cm3.h> // Cortex M3 utilities
2016-10-08 14:32:31 +02:00
# include <libopencm3/cm3/scb.h> // vector table definition
2016-01-29 11:25:30 +01:00
# include <libopencm3/cm3/nvic.h> // interrupt utilities
2016-10-08 14:32:31 +02:00
# include <libopencm3/stm32/gpio.h> // general purpose input output library
# include <libopencm3/stm32/rcc.h> // real-time control clock library
2016-01-29 11:25:30 +01:00
# include <libopencm3/stm32/exti.h> // external interrupt utilities
2016-08-14 21:02:38 +02:00
# include <libopencm3/stm32/rtc.h> // real time clock utilities
2016-10-08 14:32:31 +02:00
# include <libopencm3/stm32/iwdg.h> // independent watchdog utilities
# include <libopencm3/stm32/dbgmcu.h> // debug utilities
2016-10-09 17:04:42 +02:00
# include <libopencm3/stm32/flash.h> // flash utilities
2016-10-15 16:41:38 +02:00
# include <libopencm3/stm32/timer.h> // timer utilities
2016-01-17 14:54:54 +01:00
/* own libraries */
2016-01-28 21:21:50 +01:00
# include "global.h" // board definitions
2016-10-08 18:32:21 +02:00
//#include "usart.h" // USART utilities
2016-01-18 16:23:35 +01:00
# include "usb_cdcacm.h" // USB CDC ACM utilities
2016-10-08 18:32:21 +02:00
# include "sensor_pzem.h" // PZEM electricity meter utilities
2016-09-13 22:42:56 +02:00
# include "sensor_sdm120.h" // SDM120 electricity meter utilities
2016-10-03 17:39:59 +02:00
# include "radio_esp8266.h" // ESP8266 WiFi SoC utilities
2016-01-17 14:54:54 +01:00
2016-10-10 10:24:55 +02:00
# define WATCHDOG_PERIOD 10000 /**< watchdog period in ms */
2016-08-14 21:02:38 +02:00
/** @defgroup main_flags flag set in interrupts to be processed in main task
* @ {
*/
volatile bool rtc_internal_tick_flag = false ; /**< flag set when internal RTC ticked */
/** @} */
2017-01-19 14:02:20 +01:00
# define QUERY_PERIOD 10 /**< period in seconds to query meter measurements */
2016-10-15 16:41:38 +02:00
2016-01-17 14:54:54 +01:00
int _write ( int file , char * ptr , int len )
{
2016-08-14 21:02:38 +02:00
int i ; // how much data has been sent
static char newline = 0 ; // what newline has been sent
2016-01-17 14:54:54 +01:00
if ( file = = STDOUT_FILENO | | file = = STDERR_FILENO ) {
for ( i = 0 ; i < len ; i + + ) {
2016-08-14 21:02:38 +02:00
if ( ptr [ i ] = = ' \r ' | | ptr [ i ] = = ' \n ' ) { // send CR+LF newline for most carriage return and line feed combination
if ( newline = = 0 | | ( newline = = ptr [ i ] ) ) { // newline has already been detected
2016-10-08 18:32:21 +02:00
//usart_putchar_nonblocking('\r'); // send newline over USART
//usart_putchar_nonblocking('\n'); // send newline over USART
2016-08-14 21:02:38 +02:00
cdcacm_putchar ( ' \r ' ) ; // send newline over USB
cdcacm_putchar ( ' \n ' ) ; // send newline over USB
newline = ptr [ i ] ; // remember the newline
}
if ( ptr [ i ] = = ' \n ' ) { // line feed are always considered to end a line (the LF+CR combination is not supported to better support the others)
newline = 0 ; // clear new line
}
} else { // non-newline character
2016-10-08 18:32:21 +02:00
//usart_putchar_nonblocking(ptr[i]); // send byte over USART
2016-08-14 21:02:38 +02:00
cdcacm_putchar ( ptr [ i ] ) ; // send byte over USB
newline = 0 ; // clear new line
2016-01-17 14:54:54 +01:00
}
}
return i ;
}
return - 1 ;
}
2016-08-18 10:45:36 +02:00
/** user input command */
2016-10-08 16:26:38 +02:00
static char command [ 32 ] = { 0 } ;
2016-08-18 10:45:36 +02:00
/** user input command index */
uint8_t command_i = 0 ;
2016-01-17 14:54:54 +01:00
2016-08-14 21:02:38 +02:00
/** process user command
* @ param [ in ] str user command string ( \ 0 ended )
*/
static void process_command ( char * str )
2016-01-17 14:54:54 +01:00
{
2016-08-14 21:02:38 +02:00
// split command
const char * delimiter = " " ;
char * word = strtok ( str , delimiter ) ;
if ( ! word ) {
goto error ;
}
// parse command
if ( 0 = = strcmp ( word , " help " ) ) {
printf ( " available commands: \n " ) ;
printf ( " led [on|off|toggle] \n " ) ;
printf ( " time [HH:MM:SS] \n " ) ;
} else if ( 0 = = strcmp ( word , " led " ) ) {
word = strtok ( NULL , delimiter ) ;
if ( ! word ) {
goto error ;
} else if ( 0 = = strcmp ( word , " on " ) ) {
led_on ( ) ; // switch LED on
printf ( " LED switched on \n " ) ; // notify user
} else if ( 0 = = strcmp ( word , " off " ) ) {
led_off ( ) ; // switch LED off
printf ( " LED switched off \n " ) ; // notify user
} else if ( 0 = = strcmp ( word , " toggle " ) ) {
led_toggle ( ) ; // toggle LED
printf ( " LED toggled \n " ) ; // notify user
} else {
goto error ;
}
} else if ( 0 = = strcmp ( word , " time " ) ) {
word = strtok ( NULL , delimiter ) ;
if ( ! word ) {
2016-08-28 23:15:45 +02:00
printf ( " current time: %02lu:%02lu:%02lu \n " , rtc_get_counter_val ( ) / ( 60 * 60 ) , ( rtc_get_counter_val ( ) % ( 60 * 60 ) ) / 60 , ( rtc_get_counter_val ( ) % 60 ) ) ; // get and print time from internal RTC
2016-08-14 21:02:38 +02:00
} else if ( strlen ( word ) ! = 8 | | word [ 0 ] < ' 0 ' | | word [ 0 ] > ' 2 ' | | word [ 1 ] < ' 0 ' | | word [ 1 ] > ' 9 ' | | word [ 3 ] < ' 0 ' | | word [ 3 ] > ' 5 ' | | word [ 4 ] < ' 0 ' | | word [ 4 ] > ' 9 ' | | word [ 6 ] < ' 0 ' | | word [ 6 ] > ' 5 ' | | word [ 7 ] < ' 0 ' | | word [ 7 ] > ' 9 ' ) { // time format is incorrect
goto error ;
} else {
rtc_set_counter_val ( ( ( word [ 0 ] - ' 0 ' ) * 10 + ( word [ 1 ] - ' 0 ' ) * 1 ) * ( 60 * 60 ) + ( ( word [ 3 ] - ' 0 ' ) * 10 + ( word [ 4 ] - ' 0 ' ) * 1 ) * 60 + ( ( word [ 6 ] - ' 0 ' ) * 10 + ( word [ 7 ] - ' 0 ' ) * 1 ) ) ; // set time in internal RTC counter
printf ( " time set \n " ) ;
}
} else {
goto error ;
}
return ; // command successfully processed
error :
printf ( " command not recognized. enter help to list commands \n " ) ;
2016-09-04 14:48:40 +02:00
return ;
2016-01-17 14:54:54 +01:00
}
2016-10-08 16:26:38 +02:00
/** send HTTP data
* @ warning blocking until a response has been received
* @ param [ in ] data data to be send
* @ param [ in ] length number of bytes to be sent , set to 0 to use the string length
* @ return if data has been sent
*/
static bool http_send ( uint8_t * data , size_t length )
{
if ( length = = 0 ) {
radio_esp8266_send ( data , strlen ( ( char * ) data ) ) ; // send string data
} else {
radio_esp8266_send ( data , length ) ; // send raw data
}
while ( ! radio_esp8266_activity ) { // wait until response has been received
__WFI ( ) ; // wait until something happens
}
if ( ! radio_esp8266_success ) {
fprintf ( stderr , " could not send data \n " ) ;
return false ;
}
return true ;
}
/** end HTTP connection
* @ warning blocking until a response has been received
* @ return if connection has been closed
*/
static bool http_end ( void )
{
radio_esp8266_close ( ) ; // close connection
while ( ! radio_esp8266_activity ) { // wait until response has been received
__WFI ( ) ; // wait until something happens
}
return radio_esp8266_success ;
}
/** open HTTP connection and send POST header
* @ warning blocking until a response has been received
* @ param [ in ] host host name or IP of HTTP server to connect to
* @ param [ in ] port port number of HTTP server to connect to
* @ param [ in ] length number of bytes to POST
* @ return if HTTP POST succeeded
*/
static bool http_post_header ( char * host , uint16_t port , size_t length )
{
char http_line [ 256 ] = { 0 } ; // generated lines
radio_esp8266_tcp_open ( host , port ) ; // open connection
while ( ! radio_esp8266_activity ) { // wait until response has been received
__WFI ( ) ; // wait until something happens
}
if ( ! radio_esp8266_success ) {
fprintf ( stderr , " TCP connection failed \n " ) ;
return false ;
}
2016-10-15 14:21:31 +02:00
if ( ! http_send ( ( uint8_t * ) " POST /write?db=spark_abacus HTTP/1.1 \r \n " , 0 ) ) { // send data
2016-10-08 16:26:38 +02:00
return false ;
}
if ( snprintf ( http_line , LENGTH ( http_line ) , " Content-Length: %u \r \n " , length ) < 0 ) { // set content length (for measurements)
fprintf ( stderr , " could not create line \n " ) ;
return false ;
}
if ( ! http_send ( ( uint8_t * ) http_line , 0 ) ) { // send data
return false ;
}
if ( ! http_send ( ( uint8_t * ) " Host: influx \r \n " , 0 ) ) { // send data
return false ;
}
if ( ! http_send ( ( uint8_t * ) " \r \n " , 0 ) ) { // send data
return false ;
}
return true ;
}
2016-08-14 21:02:38 +02:00
/** program entry point
* this is the firmware function started by the micro - controller
*/
2016-08-20 23:27:01 +02:00
void main ( void ) ;
void main ( void )
2016-01-17 15:03:10 +01:00
{
2016-01-29 00:24:49 +01:00
rcc_clock_setup_in_hse_8mhz_out_72mhz ( ) ; // use 8 MHz high speed external clock to generate 72 MHz internal clock
2016-08-14 21:02:38 +02:00
2016-10-08 14:32:31 +02:00
# if 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)
# endif
2016-08-18 10:45:36 +02:00
// setup board
board_setup ( ) ;
2016-08-14 21:02:38 +02:00
// setup USART and USB for user communication
2016-10-08 18:32:21 +02:00
//usart_setup(); // setup USART (for printing)
2016-08-14 21:02:38 +02:00
cdcacm_setup ( ) ; // setup USB CDC ACM (for printing)
2016-08-20 23:27:01 +02:00
setbuf ( stdout , NULL ) ; // set standard out buffer to NULL to immediately print
setbuf ( stderr , NULL ) ; // set standard error buffer to NULL to immediately print
2016-01-29 00:24:49 +01:00
2016-08-14 21:02:38 +02:00
// minimal setup ready
printf ( " welcome to the STM32F1 CuVoodoo example code \n " ) ; // print welcome message
2016-01-29 00:24:49 +01:00
2016-08-14 21:02:38 +02:00
// setup RTC
printf ( " setup internal RTC: " ) ;
2017-01-19 13:32:09 +01:00
rtc_auto_awake ( RCC_LSE , 0x8000 - 1 ) ; // ensure internal RTC is on, uses the 32.768 kHz LSE, and the prescale is set to our tick speed, else update backup registers accordingly (power off the micro-controller for the change to take effect)
2016-08-14 21:02:38 +02:00
rtc_interrupt_enable ( RTC_SEC ) ; // enable RTC interrupt on "seconds"
nvic_enable_irq ( NVIC_RTC_IRQ ) ; // allow the RTC to interrupt
printf ( " OK \n " ) ;
2016-10-03 17:46:58 +02:00
uint32_t ticks_time = rtc_get_counter_val ( ) ; // get time from internal RTC (since first start/power up)
printf ( " uptime: %02lu:%02lu:%02lu \n " , ticks_time / ( 60 * 60 ) , ( ticks_time % ( 60 * 60 ) ) / 60 , ( ticks_time % 60 ) ) ; // display time
2016-01-18 16:23:35 +01:00
2016-09-11 17:21:33 +02:00
// setup PZEM electricity meter
printf ( " setup PZEM-004 electricity meter: " ) ;
sensor_pzem_setup ( ) ; // setup PZEM electricity meter
printf ( " OK \n " ) ;
2016-09-13 22:42:56 +02:00
// setup SDM120 electricity meter
printf ( " setup SDM120 electricity meter: " ) ;
2016-10-14 10:45:15 +02:00
sensor_sdm120_setup ( 9600 ) ; // setup SDM120 electricity meter (get baud rate by scrolling through the menu on the device)
2016-09-13 22:42:56 +02:00
printf ( " OK \n " ) ;
2016-09-11 17:21:33 +02:00
2016-10-03 17:39:59 +02:00
//setup ESP8266 WiFi SoC
printf ( " setup ESP8266 WiFi SoC: " ) ;
radio_esp8266_setup ( ) ;
printf ( " OK \n " ) ;
2016-10-04 11:16:34 +02:00
2016-10-08 14:32:31 +02:00
# if !(DEBUG)
//setup watchdog to reset in case we get stuck (i.e. when an error occurred)
printf ( " setup watchdog (%.2fs): " , WATCHDOG_PERIOD / 1000.0 ) ;
iwdg_set_period_ms ( WATCHDOG_PERIOD ) ; // set independent watchdog period
iwdg_start ( ) ; // start independent watchdog
printf ( " OK \n " ) ;
2016-10-09 17:04:42 +02:00
if ( FLASH_OBR & FLASH_OBR_OPTERR ) {
printf ( " option bytes not set in flash: software wachtdog used (not started at reset) \n " ) ;
} else if ( FLASH_OBR & FLASH_OBR_WDG_SW ) {
printf ( " software wachtdog used (not started at reset) \n " ) ;
} else {
printf ( " hardware wachtdog used (started at reset) \n " ) ;
}
2016-10-08 14:32:31 +02:00
# endif
2016-10-09 17:04:42 +02:00
2016-08-14 21:02:38 +02:00
// main loop
printf ( " command input: ready \n " ) ;
2016-02-18 10:39:08 +01:00
bool action = false ; // if an action has been performed don't go to sleep
button_flag = false ; // reset button flag
2016-10-15 16:41:38 +02:00
char c = ' \0 ' ; // to store received character
2016-08-14 21:02:38 +02:00
bool char_flag = false ; // a new character has been received
2016-10-09 17:04:42 +02:00
2016-10-15 16:41:38 +02:00
// variables for PZEM-004T meter measurements
2016-10-14 10:45:15 +02:00
struct sensor_pzem_measurement_t pzem_measurements [ 2 ] [ SENSOR_PZEM_MAX ] ; // PZEM-004T measurements (2 meters, all measurements)
2016-10-14 11:09:44 +02:00
uint8_t pzem_meter = 0 ; // PZEM-004T meter index (add to prefix)
uint8_t pzem_measurement = 0 ; // PZEM-004T measurement index (matches the type)
2016-10-14 10:45:15 +02:00
2016-10-15 16:41:38 +02:00
// variables for SDM120 meter measurements
2016-10-14 10:45:15 +02:00
float sdm120_measurements [ 2 ] [ SENSOR_SDM120_MEASUREMENT_MAX ] ; // SDM120 measurements (2 meters, all measurements)
uint8_t sdm120_meter = 0 ; // SDM120 meter index (add to 1 to get ID)
uint8_t sdm120_measurement = 0 ; // SDM120 measurement index
2016-10-09 17:04:42 +02:00
2016-01-29 00:24:49 +01:00
while ( true ) { // infinite loop
2016-10-08 14:32:31 +02:00
iwdg_reset ( ) ; // kick the dog
2016-10-08 18:32:21 +02:00
/*
2016-08-14 21:02:38 +02:00
while ( usart_received ) { // data received over UART
2016-02-18 10:39:08 +01:00
action = true ; // action has been performed
2016-01-29 00:24:49 +01:00
led_toggle ( ) ; // toggle LED
2016-08-14 21:02:38 +02:00
c = usart_getchar ( ) ; // store receive character
char_flag = true ; // notify character has been received
2016-01-17 15:03:10 +01:00
}
2016-10-08 18:32:21 +02:00
*/
2016-08-14 21:02:38 +02:00
while ( cdcacm_received ) { // data received over USB
2016-02-18 10:39:08 +01:00
action = true ; // action has been performed
2016-01-29 00:24:49 +01:00
led_toggle ( ) ; // toggle LED
2016-08-14 21:02:38 +02:00
c = cdcacm_getchar ( ) ; // store receive character
char_flag = true ; // notify character has been received
2016-01-18 16:23:35 +01:00
}
2016-08-14 21:02:38 +02:00
while ( char_flag ) { // user data received
char_flag = false ; // reset flag
2016-02-18 10:39:08 +01:00
action = true ; // action has been performed
2016-08-14 21:02:38 +02:00
printf ( " %c " , c ) ; // echo receive character
if ( c = = ' \r ' | | c = = ' \n ' ) { // end of command received
if ( command_i > 0 ) { // there is a command to process
command [ command_i ] = 0 ; // end string
command_i = 0 ; // prepare for next command
process_command ( command ) ; // process user command
}
} else { // user command input
command [ command_i ] = c ; // save command input
if ( command_i < LENGTH ( command ) - 2 ) { // verify if there is place to save next character
command_i + + ; // save next character
}
}
}
2016-09-11 17:21:33 +02:00
while ( sensor_pzem_measurement_received ) { // measurement from electricity meter received
struct sensor_pzem_measurement_t measurement = sensor_pzem_measurement_decode ( ) ; // decode measurement
2016-10-14 10:45:15 +02:00
if ( measurement . type > = SENSOR_PZEM_MAX ) {
fprintf ( stderr , " unknown measurement type: %u \n " , measurement . type ) ;
while ( true ) ; // unhandled error
}
2016-09-11 17:21:33 +02:00
if ( measurement . valid ) { // only show valid measurement
2017-01-19 13:32:09 +01:00
printf ( " PZEM-004T meter %u " , pzem_meter ) ;
2016-09-11 17:21:33 +02:00
switch ( measurement . type ) {
2016-09-12 21:42:37 +02:00
case SENSOR_PZEM_VOLTAGE :
2017-01-19 13:32:09 +01:00
printf ( " voltage: %.01f V \n " , measurement . value . voltage ) ; // display measurement
2016-09-11 17:21:33 +02:00
break ;
2016-09-12 21:42:37 +02:00
case SENSOR_PZEM_CURRENT :
2017-01-19 13:32:09 +01:00
printf ( " current: %.02f A \n " , measurement . value . current ) ;
2016-09-11 17:21:33 +02:00
break ;
2016-09-12 21:42:37 +02:00
case SENSOR_PZEM_POWER :
2017-01-19 13:32:09 +01:00
printf ( " power: %u W \n " , measurement . value . power ) ;
2016-09-11 17:21:33 +02:00
break ;
2016-09-12 21:42:37 +02:00
case SENSOR_PZEM_ENERGY :
2017-01-19 13:32:09 +01:00
printf ( " energy: %lu Wh \n " , measurement . value . energy ) ;
2016-09-11 17:21:33 +02:00
break ;
2016-10-14 10:45:15 +02:00
/* not used for this application
2016-10-03 17:39:59 +02:00
case SENSOR_PZEM_ADDRESS :
2017-01-19 13:32:09 +01:00
printf ( " address set \n " ) ;
2016-10-03 17:39:59 +02:00
break ;
case SENSOR_PZEM_ALARM :
2017-01-19 13:32:09 +01:00
printf ( " alarm threshold set \n " ) ;
2016-10-03 17:39:59 +02:00
break ;
2016-10-14 10:45:15 +02:00
*/
2016-09-11 17:21:33 +02:00
default :
break ;
}
2016-10-14 11:09:44 +02:00
if ( measurement . type ! = pzem_measurement ) {
fprintf ( stderr , " PZEM-004T measurement mismatch: expected %u, got %u \n " , pzem_measurement , measurement . type ) ;
sensor_pzem_measurement_request ( 0xc0a80100 + pzem_meter , pzem_measurement ) ; // request same measurement
} else if ( pzem_measurement < SENSOR_PZEM_MAX - 1 ) { // not all measurement types requested
pzem_measurements [ pzem_meter ] [ pzem_measurement ] = measurement ; // save measurement (the type matches the index)
pzem_measurement + + ; // go to next measurement
sensor_pzem_measurement_request ( 0xc0a80100 + pzem_meter , pzem_measurement ) ; // request next measurement
2016-10-14 10:45:15 +02:00
} else { // all measurement types requested
2016-10-14 11:09:44 +02:00
pzem_measurements [ pzem_meter ] [ pzem_measurement ] = measurement ; // save measurement (the type matches the index)
pzem_meter + + ; // got to next meter
pzem_measurement = 0 ; // restart measurements
if ( pzem_meter < LENGTH ( pzem_measurements ) ) { // ensure next meter exists
sensor_pzem_measurement_request ( 0xc0a80100 + pzem_meter , pzem_measurement ) ; // request measurement for next meter
2016-10-14 10:45:15 +02:00
}
}
} else { // measurement not valid
2016-10-14 11:09:44 +02:00
fprintf ( stderr , " PZEM-004T measurement invalid \n " ) ;
sensor_pzem_measurement_request ( 0xc0a80100 + pzem_meter , pzem_measurement ) ; // request same measurement
2016-09-11 17:21:33 +02:00
}
}
2016-09-13 22:42:56 +02:00
while ( sensor_sdm120_measurement_received ) { // measurement from electricity meter received
float measurement = sensor_sdm120_measurement_decode ( ) ; // decode measurement
2016-09-14 10:02:38 +02:00
if ( isnan ( measurement ) ) {
2016-10-14 10:45:15 +02:00
printf ( " error in SDM120 response \n " ) ;
sensor_sdm120_measurement_request ( 1 + sdm120_meter , sdm120_measurement ) ; // request same measurement
2016-10-03 17:39:59 +02:00
} else if ( isinf ( measurement ) ) {
2016-10-14 10:45:15 +02:00
printf ( " error SDM120 message received \n " ) ;
while ( true ) ; // unhandled error
2016-09-13 22:42:56 +02:00
} else {
2016-10-14 10:45:15 +02:00
sdm120_measurements [ sdm120_meter ] [ sdm120_measurement ] = measurement ; // save measurement
2017-01-19 13:32:09 +01:00
printf ( " SDM120 meter %u " , sdm120_meter ) ; // display measurement
switch ( sdm120_measurement ) {
case SENSOR_SDM120_VOLTAGE :
printf ( " voltage: %.01f V \n " , measurement ) ;
break ;
case SENSOR_SDM120_CURRENT :
printf ( " current: %.02f A \n " , measurement ) ;
break ;
case SENSOR_SDM120_POWER_ACTIVE :
printf ( " power (active): %.0f W \n " , measurement ) ;
break ;
case SENSOR_SDM120_POWER_APPARENT :
printf ( " power (apparent): %.0f VA \n " , measurement ) ;
break ;
case SENSOR_SDM120_POWER_REACTIVE :
printf ( " power (reactive): %.0f VAr \n " , measurement ) ;
break ;
case SENSOR_SDM120_POWER_FACTOR :
printf ( " power factor: %.02f \n " , measurement ) ;
break ;
case SENSOR_SDM120_FREQUENCY :
printf ( " frequency: %.02f Hz \n " , measurement ) ;
break ;
case SENSOR_SDM120_ENERGY_ACTIVE_IMPORT :
printf ( " energy (import,active): %.02f KWh \n " , measurement ) ;
break ;
case SENSOR_SDM120_ENERGY_ACTIVE_EXPORT :
printf ( " energy (export,active): %.02f kWh \n " , measurement ) ;
break ;
case SENSOR_SDM120_ENERGY_REACTIVE_IMPORT :
printf ( " energy (import,reactive): %.02f kVArh \n " , measurement ) ;
break ;
case SENSOR_SDM120_ENERGY_REACTIVE_EXPORT :
printf ( " energy (export,reactive): %.02f kVArh \n " , measurement ) ;
break ;
case SENSOR_SDM120_ENERGY_ACTIVE_TOTAL :
printf ( " energy (active,total): %.02f kWh \n " , measurement ) ;
break ;
case SENSOR_SDM120_ENERGY_REACTIVE_TOTAL :
printf ( " energy (reactive,total): %.02f kVArh \n " , measurement ) ;
break ;
default :
break ;
}
2016-10-14 10:45:15 +02:00
if ( sdm120_measurement < SENSOR_SDM120_MEASUREMENT_MAX - 1 ) { // not all measurement type required
sdm120_measurement + + ; // go to next measurement
sensor_sdm120_measurement_request ( 1 + sdm120_meter , sdm120_measurement ) ; // request next measurement
} else { // all measurement types requested
sdm120_meter + + ; // got to next meter (sending to none existing meter will just end in void)
sdm120_measurement = 0 ; // start requesting all measurement
if ( sdm120_meter < LENGTH ( sdm120_measurements ) ) { // ensure next meter exists
sensor_sdm120_measurement_request ( 1 + sdm120_meter , sdm120_measurement ) ; // request measurement for next meter
}
}
2016-09-13 22:42:56 +02:00
}
}
2016-08-14 21:02:38 +02:00
while ( button_flag ) { // user pressed button
action = true ; // action has been performed
printf ( " button pressed \n " ) ;
2016-02-18 10:39:08 +01:00
led_toggle ( ) ; // toggle LED
2016-08-14 21:02:38 +02:00
for ( uint32_t i = 0 ; i < 1000000 ; i + + ) { // wait a bit to remove noise and double trigger
__asm__ ( " nop " ) ;
}
button_flag = false ; // reset flag
2016-02-18 10:39:08 +01:00
}
2016-08-14 21:02:38 +02:00
while ( rtc_internal_tick_flag ) { // the internal RTC ticked
rtc_internal_tick_flag = false ; // reset flag
2017-01-19 13:32:09 +01:00
//led_toggle(); // toggle LED (good to indicate if main function is stuck). do not toggle onboard the LED on PC13 on the blue pill board since this heavily influences the RTC (by ~13%)
2016-08-14 21:02:38 +02:00
ticks_time = rtc_get_counter_val ( ) ; // copy time from internal RTC for processing
action = true ; // action has been performed
2016-08-18 11:54:24 +02:00
if ( ( ticks_time % ( 60 ) ) = = 0 ) { // one minute passed
2017-01-19 13:41:27 +01:00
printf ( " uptime: %lu.%02lu:%02lu:%02lu \n " , ticks_time / ( 60 * 60 * 24 ) , ( ticks_time / ( 60 * 60 ) ) % 24 , ( ticks_time % ( 60 * 60 ) ) / 60 , ( ticks_time % 60 ) ) ; // display external time
2016-08-14 21:02:38 +02:00
}
2017-01-19 14:02:20 +01:00
if ( ( ticks_time % ( QUERY_PERIOD ) ) = = 0 ) { // query period passed
printf ( " query meter measurements (%lu.%02lu:%02lu:%02lu) \n " , ticks_time / ( 60 * 60 * 24 ) , ( ticks_time / ( 60 * 60 ) ) % 24 , ( ticks_time % ( 60 * 60 ) ) / 60 , ( ticks_time % 60 ) ) ;
// start getting all PZEM-004T measurements from all meters
pzem_meter = 0 ; // reset PZEM meter number
pzem_measurement = 0 ; // reset PZEM measurement index
sensor_pzem_measurement_request ( 0xc0a80100 + pzem_meter , pzem_measurement ) ; // request first measurement
// start getting all SDM120 measurements from all meters
sdm120_meter = 0 ; // reset SDM120 meter number
sdm120_measurement = 0 ; // reset SDM120 measurement index
sensor_sdm120_measurement_request ( 1 + sdm120_meter , sdm120_measurement ) ; // request first measurement
}
2016-08-14 21:02:38 +02:00
}
2016-10-15 14:21:31 +02:00
while ( pzem_meter > = LENGTH ( pzem_measurements ) & & sdm120_meter > = LENGTH ( sdm120_measurements ) ) { // all measurements received for all meter
2016-10-15 16:41:38 +02:00
action = true ; // action has been performed
2016-10-15 14:21:31 +02:00
printf ( " saving measurements to database: " ) ;
const char * pzem_strings [ SENSOR_PZEM_MAX ] = {
" voltage,meter=PZEM-004T,phase=%u value=%.1f \n " ,
" current,meter=PZEM-004T,phase=%u value=%.2f \n " ,
" power,meter=PZEM-004T,phase=%u value=%u \n " ,
" energy,meter=PZEM-004T,phase=%u value=%lu \n "
} ;
const char * sdm120_strings [ SENSOR_SDM120_MEASUREMENT_MAX ] = {
" voltage,meter=SDM120,phase=%u value=%.3f \n " ,
" current,meter=SDM120,phase=%u value=%.3f \n " ,
" power,meter=SDM120,phase=%u,type=active value=%.3f \n " ,
" power,meter=SDM120,phase=%u,type=apparent value=%.3f \n " ,
" power,meter=SDM120,phase=%u,type=reactive value=%.3f \n " ,
" power,meter=SDM120,phase=%u,type=factor value=%.3f \n " ,
" frequency,meter=SDM120,phase=%u value=%.3f \n " ,
" energy,meter=SDM120,phase=%u,type=active,direction=import value=%.3f \n " ,
" energy,meter=SDM120,phase=%u,type=active,direction=export value=%.3f \n " ,
" energy,meter=SDM120,phase=%u,type=reactive,direction=import value=%.3f \n " ,
" energy,meter=SDM120,phase=%u,type=reactive,direction=export value=%.3f \n " ,
" energy,meter=SDM120,phase=%u,type=active,direction=total value=%.3f \n " ,
" energy,meter=SDM120,phase=%u,type=reactive,direction=total value=%.3f \n "
} ;
char line [ 256 ] = { 0 } ; // measurement line to send
size_t data_length = 0 ; /**< length of the data string to send */
for ( pzem_meter = 0 ; pzem_meter < LENGTH ( pzem_measurements ) ; pzem_meter + + ) {
for ( pzem_measurement = 0 ; pzem_measurement < SENSOR_PZEM_MAX ; pzem_measurement + + ) {
struct sensor_pzem_measurement_t measurement = pzem_measurements [ pzem_meter ] [ pzem_measurement ] ; // get measurement
if ( measurement . valid ) { // only use valid measurements
switch ( measurement . type ) { // get the size (hope no error is occurring)
case SENSOR_PZEM_VOLTAGE :
data_length + = snprintf ( line , LENGTH ( line ) , pzem_strings [ pzem_measurement ] , pzem_meter , measurement . value . voltage ) ;
break ;
case SENSOR_PZEM_CURRENT :
data_length + = snprintf ( line , LENGTH ( line ) , pzem_strings [ pzem_measurement ] , pzem_meter , measurement . value . current ) ;
break ;
case SENSOR_PZEM_POWER :
data_length + = snprintf ( line , LENGTH ( line ) , pzem_strings [ pzem_measurement ] , pzem_meter , measurement . value . power ) ;
break ;
case SENSOR_PZEM_ENERGY :
data_length + = snprintf ( line , LENGTH ( line ) , pzem_strings [ pzem_measurement ] , pzem_meter , measurement . value . energy ) ;
break ;
default :
break ;
}
}
}
}
for ( sdm120_meter = 0 ; sdm120_meter < LENGTH ( sdm120_measurements ) ; sdm120_meter + + ) {
for ( sdm120_measurement = 0 ; sdm120_measurement < SENSOR_SDM120_MEASUREMENT_MAX ; sdm120_measurement + + ) {
if ( sdm120_measurement < SENSOR_SDM120_ENERGY_ACTIVE_IMPORT ) {
data_length + = snprintf ( line , LENGTH ( line ) , sdm120_strings [ sdm120_measurement ] , sdm120_meter , sdm120_measurements [ sdm120_meter ] [ sdm120_measurement ] ) ; // get the size (hope no error is occurring)
} else {
data_length + = snprintf ( line , LENGTH ( line ) , sdm120_strings [ sdm120_measurement ] , sdm120_meter , sdm120_measurements [ sdm120_meter ] [ sdm120_measurement ] * 1000.0 ) ; // get the size (hope no error is occurring)
}
}
}
// send HTTP POST request
if ( ! http_post_header ( " 192.168.42.2 " , 8086 , data_length ) ) { // send header
fprintf ( stderr , " could not sent HTTP POST header \n " ) ;
} else {
// send PZEM-004T values
for ( pzem_meter = 0 ; pzem_meter < LENGTH ( pzem_measurements ) ; pzem_meter + + ) {
for ( pzem_measurement = 0 ; pzem_measurement < SENSOR_PZEM_MAX ; pzem_measurement + + ) {
struct sensor_pzem_measurement_t measurement = pzem_measurements [ pzem_meter ] [ pzem_measurement ] ; // get measurement
if ( measurement . valid ) { // only use valid measurements
switch ( measurement . type ) { // make line (hope no error is occurring)
case SENSOR_PZEM_VOLTAGE :
snprintf ( line , LENGTH ( line ) , pzem_strings [ pzem_measurement ] , pzem_meter , measurement . value . voltage ) ;
break ;
case SENSOR_PZEM_CURRENT :
snprintf ( line , LENGTH ( line ) , pzem_strings [ pzem_measurement ] , pzem_meter , measurement . value . current ) ;
break ;
case SENSOR_PZEM_POWER :
snprintf ( line , LENGTH ( line ) , pzem_strings [ pzem_measurement ] , pzem_meter , measurement . value . power ) ;
break ;
case SENSOR_PZEM_ENERGY :
snprintf ( line , LENGTH ( line ) , pzem_strings [ pzem_measurement ] , pzem_meter , measurement . value . energy ) ;
break ;
default :
break ;
}
http_send ( ( uint8_t * ) line , 0 ) ; // don't care about the result
}
}
}
// send SDM120 values
for ( sdm120_meter = 0 ; sdm120_meter < LENGTH ( sdm120_measurements ) ; sdm120_meter + + ) {
for ( sdm120_measurement = 0 ; sdm120_measurement < SENSOR_SDM120_MEASUREMENT_MAX ; sdm120_measurement + + ) {
if ( sdm120_measurement < SENSOR_SDM120_ENERGY_ACTIVE_IMPORT ) {
if ( snprintf ( line , LENGTH ( line ) , sdm120_strings [ sdm120_measurement ] , sdm120_meter , sdm120_measurements [ sdm120_meter ] [ sdm120_measurement ] ) > 0 ) {
http_send ( ( uint8_t * ) line , 0 ) ; // don't care about the result
}
} else {
if ( snprintf ( line , LENGTH ( line ) , sdm120_strings [ sdm120_measurement ] , sdm120_meter , sdm120_measurements [ sdm120_meter ] [ sdm120_measurement ] * 1000.0 ) > 0 ) {
http_send ( ( uint8_t * ) line , 0 ) ; // don't care about the result
}
}
}
}
http_end ( ) ; // end HTTP request (don't care about the result)
printf ( " OK \n " ) ;
}
pzem_meter = 0 ; // reset meter
sdm120_meter = 0 ; // reset meter
}
2016-08-14 21:02:38 +02:00
if ( action ) { // go to sleep if nothing had to be done, else recheck for activity
2016-02-18 10:39:08 +01:00
action = false ;
} else {
__WFI ( ) ; // go to sleep
}
2016-01-17 14:54:54 +01:00
}
}
2016-01-29 11:25:30 +01:00
2016-08-14 21:02:38 +02:00
/** @brief interrupt service routine called when tick passed on RTC */
void rtc_isr ( void )
{
rtc_clear_flag ( RTC_SEC ) ; // clear flag
rtc_internal_tick_flag = true ; // notify to show new time
}