kmp_request.c File Reference

#include <esp8266.h>
#include "driver/uart.h"
#include "unix_time.h"
#include "mqtt.h"
#include "tinyprintf.h"
#include "utils.h"
#include "kmp.h"
#include "kmp_request.h"
#include "config.h"
#include "crypto/crypto.h"
#include "crypto/aes.h"

Include dependency graph for kmp_request.c:

Go to the source code of this file.

Macros
#define	QUEUE_SIZE   256

Functions
static ICACHE_FLASH_ATTR void	kmp_received_task (os_event_t *events)
ICACHE_FLASH_ATTR void	kmp_request_init ()
ICACHE_FLASH_ATTR void	kmp_set_mqtt_client (MQTT_Client *client)
ICACHE_FLASH_ATTR void	kmp_register_meter_is_ready_cb (meter_is_ready_cb cb)
ICACHE_FLASH_ATTR unsigned int	kmp_get_received_serial ()
ICACHE_FLASH_ATTR unsigned int	kmp_get_received_energy_kwh ()
ICACHE_FLASH_ATTR static void	kmp_get_serial_timer_func ()
ICACHE_FLASH_ATTR static void	kmp_get_register_timer_func ()
ICACHE_FLASH_ATTR static void	kmp_receive_timeout_timer_func ()
ICACHE_FLASH_ATTR void	kmp_request_send ()
unsigned int	kmp_fifo_in_use ()
unsigned char	kmp_fifo_put (unsigned char c)
unsigned char	kmp_fifo_get (unsigned char *c)
unsigned char	kmp_fifo_snoop (unsigned char *c, unsigned int pos)

Variables
uint32_t	kmp_serial = 0
meter_is_ready_cb	kmp_meter_is_ready_cb = NULL
bool	meter_is_ready_cb_called = false
volatile unsigned int	fifo_head
volatile unsigned int	fifo_tail
volatile unsigned char	fifo_buffer [QUEUE_SIZE]
unsigned char	frame [KMP_FRAME_L]
unsigned int	frame_length
uint16_t	register_list [8]
kmp_response_t	response
static MQTT_Client *	mqtt_client = NULL
static os_timer_t	kmp_get_serial_timer
static os_timer_t	kmp_get_register_timer
static os_timer_t	kmp_receive_timeout_timer
unsigned int	kmp_requests_sent

Macro Definition Documentation

QUEUE_SIZE

#define QUEUE_SIZE   256

Definition at line 13 of file kmp_request.c.

Referenced by kmp_fifo_get(), kmp_fifo_put(), and kmp_fifo_snoop().

Function Documentation

kmp_fifo_get()

unsigned char kmp_fifo_get

(

unsigned char *

c

)

Definition at line 384 of file kmp_request.c.

References fifo_buffer, fifo_tail, kmp_fifo_in_use(), and QUEUE_SIZE.

Referenced by kmp_received_task().

                                             {
    if (kmp_fifo_in_use() != 0) {
        *c = fifo_buffer[fifo_tail++ % QUEUE_SIZE];
        // wrap
        if (fifo_tail == QUEUE_SIZE) {
            fifo_tail = 0;
        }
        return 1;
    }
    else {
        return 0;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

kmp_fifo_in_use()

unsigned int kmp_fifo_in_use

(

)

Definition at line 366 of file kmp_request.c.

References fifo_head, and fifo_tail.

Referenced by kmp_fifo_get(), kmp_fifo_put(), and kmp_fifo_snoop().

                               {
    return fifo_head - fifo_tail;
}

Here is the caller graph for this function:

kmp_fifo_put()

unsigned char kmp_fifo_put

(

unsigned char

c

)

Definition at line 370 of file kmp_request.c.

References fifo_buffer, fifo_head, kmp_fifo_in_use(), and QUEUE_SIZE.

Referenced by uart0_rx_intr_handler().

                                            {
    if (kmp_fifo_in_use() != QUEUE_SIZE) {
        fifo_buffer[fifo_head++ % QUEUE_SIZE] = c;
        // wrap
        if (fifo_head == QUEUE_SIZE) {
            fifo_head = 0;
        }
        return 1;
    }
    else {
        return 0;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

kmp_fifo_snoop()

unsigned char kmp_fifo_snoop	(	unsigned char *	c,
		unsigned int	pos
	)

Definition at line 398 of file kmp_request.c.

References fifo_buffer, fifo_tail, kmp_fifo_in_use(), and QUEUE_SIZE.

                                                                 {
    if (kmp_fifo_in_use() > (pos)) {
        *c = fifo_buffer[(fifo_tail + pos) % QUEUE_SIZE];
        return 1;
    }
    else {
        return 0;
    }
}

Here is the call graph for this function:

kmp_get_received_energy_kwh()

ICACHE_FLASH_ATTR unsigned int kmp_get_received_energy_kwh

(

)

Definition at line 209 of file kmp_request.c.

References ICACHE_FLASH_ATTR, kmp_response_t::kmp_response_register_list, kmp_unit_to_string(), kmp_value_to_string(), mw_to_w_str(), and strncmp.

                                           {
    unsigned char kmp_unit_string[16];
    unsigned char kmp_value_string[64];
    
    char e1_kwh[64];
    
    kmp_value_to_string(response.kmp_response_register_list[0].value, response.kmp_response_register_list[0].si_ex, kmp_value_string);
    kmp_unit_to_string(response.kmp_response_register_list[0].unit, kmp_unit_string);

    if (strncmp(kmp_unit_string, "MWh", 16) == 0) {
        mw_to_w_str(kmp_unit_string, e1_kwh);
    }

#ifdef DEBUG_NO_METER
    return pseudo_data_debug_no_meter;
#else
    return atoi(e1_kwh);
#endif
}

Here is the call graph for this function:

kmp_get_received_serial()

ICACHE_FLASH_ATTR unsigned int kmp_get_received_serial

(

)

Definition at line 203 of file kmp_request.c.

References ICACHE_FLASH_ATTR, and kmp_serial.

                                       {
    return kmp_serial;
}

kmp_get_register_timer_func()

ICACHE_FLASH_ATTR static void kmp_get_register_timer_func ( )

static

Definition at line 238 of file kmp_request.c.

References frame, frame_length, ICACHE_FLASH_ATTR, kmp_get_register(), register_list, and uart0_tx_buffer().

Referenced by kmp_request_send().

                                          {
    // get registers
    // prepare frame
    register_list[0] = 0x3c;    // heat energy (E1)
    register_list[1] = 0x44;    // volume register (V1)
    register_list[2] = 0x3EC;   // operational hour counter (HR)
    register_list[3] = 0x56;    // current flow temperature (T1)
    register_list[4] = 0x57;    // current return flow temperature (T2)
    register_list[5] = 0x59;    // current temperature difference (T1-T2)
    register_list[6] = 0x4A;    // current flow in flow (FLOW1)
    register_list[7] = 0x50;    // current power calculated on the basis of V1-T1-T2 (EFFEKT1)
    frame_length = kmp_get_register(frame, register_list, 8);
    
    // send frame
    uart0_tx_buffer(frame, frame_length);     // send kmp request
}

Here is the call graph for this function:

Here is the caller graph for this function:

kmp_get_serial_timer_func()

ICACHE_FLASH_ATTR static void kmp_get_serial_timer_func ( )

static

Definition at line 230 of file kmp_request.c.

References frame, frame_length, ICACHE_FLASH_ATTR, kmp_get_serial(), and uart0_tx_buffer().

Referenced by kmp_request_send().

                                        {
    // get serial
    // prepare frame
    frame_length = kmp_get_serial(frame);
    uart0_tx_buffer(frame, frame_length);     // send kmp request
}

Here is the call graph for this function:

Here is the caller graph for this function:

kmp_receive_timeout_timer_func()

ICACHE_FLASH_ATTR static void kmp_receive_timeout_timer_func ( )

static

Definition at line 256 of file kmp_request.c.

References ICACHE_FLASH_ATTR, kmp_request_send(), and kmp_requests_sent.

Referenced by kmp_request_send().

                                             {
    if (kmp_requests_sent > 0) {
        // if no reply received, retransmit
        kmp_request_send();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

kmp_received_task()

static ICACHE_FLASH_ATTR void kmp_received_task ( os_event_t *  events )

static

Definition at line 46 of file kmp_request.c.

References current_unix_time, encrypt_aes_hmac_combined(), get_unix_time(), ICACHE_FLASH_ATTR, kmp_decode_frame(), kmp_fifo_get(), KMP_FRAME_L, kmp_meter_is_ready_cb, kmp_requests_sent, kmp_response_t::kmp_response_register_list, kmp_response_t::kmp_response_serial, kmp_serial, kmp_unit_to_string(), kmp_value_to_string(), memset, meter_is_ready_cb_called, MQTT_Publish(), MQTT_TOPIC_L, os_memset, os_printf, os_strncpy, response, strcat, strlen, system_get_free_heap_size(), and tfp_snprintf().

Referenced by kmp_request_init().

                                                  {
    unsigned char c;
    unsigned int i;
    uint64_t current_unix_time;
    char current_unix_time_string[64];  // BUGFIX var
    char key_value[256];
    unsigned char topic[MQTT_TOPIC_L];
    unsigned char message[KMP_FRAME_L];
    int message_l;
        
    // vars for aes encryption
    uint8_t cleartext[KMP_FRAME_L];

    // allocate struct for response
    kmp_response_t response;
    unsigned char kmp_unit_string[16];
    unsigned char kmp_value_string[64];

    //ETS_UART_INTR_DISABLE();

    memset(message, 0x00, KMP_FRAME_L);         // clear message buffer
    i = 0;
    while (kmp_fifo_get(&c) && (i <= KMP_FRAME_L)) {
        message[i++] = c;
    }
    message_l = i;

    // decode kmp frame
    if (kmp_decode_frame(message, message_l, &response) > 0) {
        // tell user_main we got a serial
        if (kmp_meter_is_ready_cb && !meter_is_ready_cb_called) {
            meter_is_ready_cb_called = true;
            kmp_meter_is_ready_cb();
        }
#ifdef DEBUG
        else {
            os_printf("tried to call kmp_meter_is_ready_cb() before it was set - should not happen\n");
        }
#endif
        message_l = 0;      // zero it so we can reuse it for mqtt string
        current_unix_time = (uint32)(get_unix_time());      // TODO before 2038 ,-)
    
        if (response.kmp_response_serial) {
            kmp_serial = response.kmp_response_serial;  // save it for later use
        }
        else if (current_unix_time) {   // only send mqtt if we got current time via ntp
            // prepare for mqtt transmission if we got serial number from meter
            
            // format /sample/v1/serial/unix_time => val1=23&val2=val3&baz=blah
            //topic_l = os_sprintf(topic, "/sample/v1/%lu/%lu", kmp_serial, current_unix_time);
            // BUG here.                        returns 0 -^
            // this is a fix
            memset(topic, 0, sizeof(topic));            // clear it
            tfp_snprintf(current_unix_time_string, 64, "%u", (uint32_t)current_unix_time);
            tfp_snprintf(topic, MQTT_TOPIC_L, "/sample/v2/%u/%s", kmp_serial, current_unix_time_string);

            memset(message, 0, sizeof(message));            // clear it
            
            // heap size
            tfp_snprintf(key_value, MQTT_TOPIC_L, "heap=%u&", system_get_free_heap_size());
            strcat(message, key_value);
            
            // heating meter specific
            // flow temperature
            kmp_value_to_string(response.kmp_response_register_list[3].value, response.kmp_response_register_list[3].si_ex, kmp_value_string);
            kmp_unit_to_string(response.kmp_response_register_list[3].unit, kmp_unit_string);
            tfp_snprintf(key_value, MQTT_TOPIC_L, "t1=%s %s&", kmp_value_string, kmp_unit_string);
            strcat(message, key_value);
            
            // return flow temperature
            kmp_value_to_string(response.kmp_response_register_list[4].value, response.kmp_response_register_list[4].si_ex, kmp_value_string);
            kmp_unit_to_string(response.kmp_response_register_list[4].unit, kmp_unit_string);
            tfp_snprintf(key_value, MQTT_TOPIC_L, "t2=%s %s&", kmp_value_string, kmp_unit_string);
            strcat(message, key_value);
            
            // temperature difference
            kmp_value_to_string(response.kmp_response_register_list[5].value, response.kmp_response_register_list[5].si_ex, kmp_value_string);
            kmp_unit_to_string(response.kmp_response_register_list[5].unit, kmp_unit_string);
            tfp_snprintf(key_value, MQTT_TOPIC_L, "tdif=%s %s&", kmp_value_string, kmp_unit_string);
            strcat(message, key_value);
            
            // flow
            kmp_value_to_string(response.kmp_response_register_list[6].value, response.kmp_response_register_list[6].si_ex, kmp_value_string);
            kmp_unit_to_string(response.kmp_response_register_list[6].unit, kmp_unit_string);
            tfp_snprintf(key_value, MQTT_TOPIC_L, "flow1=%s %s&", kmp_value_string, kmp_unit_string);
            strcat(message, key_value);
            
            // current power
            kmp_value_to_string(response.kmp_response_register_list[7].value, response.kmp_response_register_list[7].si_ex, kmp_value_string);
            kmp_unit_to_string(response.kmp_response_register_list[7].unit, kmp_unit_string);
            tfp_snprintf(key_value, MQTT_TOPIC_L, "effect1=%s %s&", kmp_value_string, kmp_unit_string);
            strcat(message, key_value);
            
            // hours
            kmp_value_to_string(response.kmp_response_register_list[2].value, response.kmp_response_register_list[2].si_ex, kmp_value_string);
            kmp_unit_to_string(response.kmp_response_register_list[2].unit, kmp_unit_string);
            tfp_snprintf(key_value, MQTT_TOPIC_L, "hr=%s %s&", kmp_value_string, kmp_unit_string);
            strcat(message, key_value);
            
            // volume
            kmp_value_to_string(response.kmp_response_register_list[1].value, response.kmp_response_register_list[1].si_ex, kmp_value_string);
            kmp_unit_to_string(response.kmp_response_register_list[1].unit, kmp_unit_string);
            tfp_snprintf(key_value, MQTT_TOPIC_L, "v1=%s %s&", kmp_value_string, kmp_unit_string);
            strcat(message, key_value);
            
            // power
            kmp_value_to_string(response.kmp_response_register_list[0].value, response.kmp_response_register_list[0].si_ex, kmp_value_string);
            kmp_unit_to_string(response.kmp_response_register_list[0].unit, kmp_unit_string);
            tfp_snprintf(key_value, MQTT_TOPIC_L, "e1=%s %s&", kmp_value_string, kmp_unit_string);
            strcat(message, key_value);
            
            memset(cleartext, 0, sizeof(message));
            os_strncpy(cleartext, message, sizeof(message));    // make a copy of message for later use
            os_memset(message, 0, sizeof(message));         // ...and clear it
                        
            // encrypt and send
            message_l = encrypt_aes_hmac_combined(message, topic, strlen(topic), cleartext, strlen(cleartext) + 1);
                        
            if (mqtt_client) {
                // if mqtt_client is initialized
                if (kmp_serial && (message_l > 1)) {
                    // if we received both serial and registers send it
                    MQTT_Publish(mqtt_client, topic, message, message_l, 2, 0); // QoS level 2
                }
            }
            kmp_requests_sent = 0;  // reset retry counter
            // disable timer
        }
    }
    else {
        // error decoding frame - kmp_receive_timeout_timer_func() retransmits after timeout
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

kmp_register_meter_is_ready_cb()

ICACHE_FLASH_ATTR void kmp_register_meter_is_ready_cb

(

meter_is_ready_cb

cb

)

Definition at line 197 of file kmp_request.c.

References ICACHE_FLASH_ATTR, and kmp_meter_is_ready_cb.

                                                          {
    kmp_meter_is_ready_cb = cb;
}

kmp_request_init()

ICACHE_FLASH_ATTR void kmp_request_init

(

)

Definition at line 181 of file kmp_request.c.

References fifo_head, fifo_tail, ICACHE_FLASH_ATTR, kmp_received_task(), kmp_received_task_prio, kmp_received_task_queue, kmp_received_task_queue_length, kmp_requests_sent, and system_os_task().

                        {
    fifo_head = 0;
    fifo_tail = 0;

    kmp_requests_sent = 0;
    
    system_os_task(kmp_received_task, kmp_received_task_prio, kmp_received_task_queue, kmp_received_task_queue_length);
}

Here is the call graph for this function:

kmp_request_send()

ICACHE_FLASH_ATTR void kmp_request_send

(

)

Definition at line 264 of file kmp_request.c.

References DEFAULT_METER_SERIAL, encrypt_aes_hmac_combined(), get_unix_time(), KMP_FRAME_L, kmp_get_register_timer, kmp_get_register_timer_func(), kmp_get_serial_timer, kmp_get_serial_timer_func(), kmp_meter_is_ready_cb, kmp_receive_timeout_timer, kmp_receive_timeout_timer_func(), kmp_requests_sent, kmp_serial, memset, meter_is_ready_cb_called, MQTT_MESSAGE_L, MQTT_Publish(), MQTT_TOPIC_L, NULL, os_printf, os_timer_arm, os_timer_disarm, os_timer_func_t, os_timer_setfn, strlen, system_get_free_heap_size(), and tfp_snprintf().

Referenced by kmp_receive_timeout_timer_func().

                        {
#ifdef DEBUG_NO_METER
    char cleartext[MQTT_MESSAGE_L];
    char topic[MQTT_TOPIC_L];
    char message[KMP_FRAME_L];
    int message_l;

    uint8_t sine_wave[256] = {
        0x80, 0x83, 0x86, 0x89, 0x8C, 0x90, 0x93, 0x96,
        0x99, 0x9C, 0x9F, 0xA2, 0xA5, 0xA8, 0xAB, 0xAE,
        0xB1, 0xB3, 0xB6, 0xB9, 0xBC, 0xBF, 0xC1, 0xC4,
        0xC7, 0xC9, 0xCC, 0xCE, 0xD1, 0xD3, 0xD5, 0xD8,
        0xDA, 0xDC, 0xDE, 0xE0, 0xE2, 0xE4, 0xE6, 0xE8,
        0xEA, 0xEB, 0xED, 0xEF, 0xF0, 0xF1, 0xF3, 0xF4,
        0xF5, 0xF6, 0xF8, 0xF9, 0xFA, 0xFA, 0xFB, 0xFC,
        0xFD, 0xFD, 0xFE, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFE, 0xFE, 0xFD,
        0xFD, 0xFC, 0xFB, 0xFA, 0xFA, 0xF9, 0xF8, 0xF6,
        0xF5, 0xF4, 0xF3, 0xF1, 0xF0, 0xEF, 0xED, 0xEB,
        0xEA, 0xE8, 0xE6, 0xE4, 0xE2, 0xE0, 0xDE, 0xDC,
        0xDA, 0xD8, 0xD5, 0xD3, 0xD1, 0xCE, 0xCC, 0xC9,
        0xC7, 0xC4, 0xC1, 0xBF, 0xBC, 0xB9, 0xB6, 0xB3,
        0xB1, 0xAE, 0xAB, 0xA8, 0xA5, 0xA2, 0x9F, 0x9C,
        0x99, 0x96, 0x93, 0x90, 0x8C, 0x89, 0x86, 0x83,
        0x80, 0x7D, 0x7A, 0x77, 0x74, 0x70, 0x6D, 0x6A,
        0x67, 0x64, 0x61, 0x5E, 0x5B, 0x58, 0x55, 0x52,
        0x4F, 0x4D, 0x4A, 0x47, 0x44, 0x41, 0x3F, 0x3C,
        0x39, 0x37, 0x34, 0x32, 0x2F, 0x2D, 0x2B, 0x28,
        0x26, 0x24, 0x22, 0x20, 0x1E, 0x1C, 0x1A, 0x18,
        0x16, 0x15, 0x13, 0x11, 0x10, 0x0F, 0x0D, 0x0C,
        0x0B, 0x0A, 0x08, 0x07, 0x06, 0x06, 0x05, 0x04,
        0x03, 0x03, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01,
        0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x03,
        0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x0A,
        0x0B, 0x0C, 0x0D, 0x0F, 0x10, 0x11, 0x13, 0x15,
        0x16, 0x18, 0x1A, 0x1C, 0x1E, 0x20, 0x22, 0x24,
        0x26, 0x28, 0x2B, 0x2D, 0x2F, 0x32, 0x34, 0x37,
        0x39, 0x3C, 0x3F, 0x41, 0x44, 0x47, 0x4A, 0x4D,
        0x4F, 0x52, 0x55, 0x58, 0x5B, 0x5E, 0x61, 0x64,
        0x67, 0x6A, 0x6D, 0x70, 0x74, 0x77, 0x7A, 0x7D
    };
#endif
    os_timer_disarm(&kmp_get_serial_timer);
    os_timer_setfn(&kmp_get_serial_timer, (os_timer_func_t *)kmp_get_serial_timer_func, NULL);
    os_timer_arm(&kmp_get_serial_timer, 0, 0);      // now
    
    os_timer_disarm(&kmp_get_register_timer);
    os_timer_setfn(&kmp_get_register_timer, (os_timer_func_t *)kmp_get_register_timer_func, NULL);
    os_timer_arm(&kmp_get_register_timer, 400, 0);      // after 0.4 seconds
    
    // start retransmission timeout timer
    os_timer_disarm(&kmp_receive_timeout_timer);
    os_timer_setfn(&kmp_receive_timeout_timer, (os_timer_func_t *)kmp_receive_timeout_timer_func, NULL);
    os_timer_arm(&kmp_receive_timeout_timer, 2000, 0);      // after 2 seconds
    
    kmp_requests_sent++;
#ifdef DEBUG_NO_METER
    // clear data
    memset(message, 0, sizeof(message));
    memset(topic, 0, sizeof(topic));

    // fake serial for testing without meter
    kmp_serial = atoi(DEFAULT_METER_SERIAL);

    tfp_snprintf(topic, MQTT_TOPIC_L, "/sample/v2/%u/%u", kmp_serial, get_unix_time());
    memset(cleartext, 0, sizeof(cleartext));
    tfp_snprintf(cleartext, KMP_FRAME_L, "heap=%u&t1=%u.00 C&t2=%u.00 C&tdif=%u.00 K&flow1=%u l/h&effect1=%u.0 kW&hr=%u h&v1=%u.00 m3&e1=%u kWh&",
        system_get_free_heap_size(),
        65 + ((sine_wave[pseudo_data_debug_no_meter] * 10) >> 8),       // t1
        45 + ((sine_wave[(pseudo_data_debug_no_meter + 128) & 0xff] * 10) >> 8),    // t2
        10,                                                             // tdif
        100 + ((sine_wave[((pseudo_data_debug_no_meter + 64) * 7) & 0xff] * 50) >> 8),  // flow
        15 + ((sine_wave[pseudo_data_debug_no_meter] * 10) >> 8),       // effect1
        pseudo_data_debug_no_meter / 60,                                // hr
        pseudo_data_debug_no_meter,                                     // v1
        pseudo_data_debug_no_meter                                      // e1
    );
    pseudo_data_debug_no_meter++;   // let it wrap around

    // tell user_main we got a serial
    if (kmp_meter_is_ready_cb && !meter_is_ready_cb_called) {
        meter_is_ready_cb_called = true;
        kmp_meter_is_ready_cb();
    }
#ifdef DEBUG
    else {
        os_printf("tried to call kmp_meter_is_ready_cb() before it was set - should not happen\n");
    }
#endif

    // encrypt and send
    message_l = encrypt_aes_hmac_combined(message, topic, strlen(topic), cleartext, strlen(cleartext) + 1);

    if (mqtt_client) {
        // if mqtt_client is initialized
        MQTT_Publish(mqtt_client, topic, message, message_l, 2, 0); // QoS level 2
    }
#endif
    kmp_requests_sent = 0;  // reset retry counter
}

Here is the call graph for this function:

Here is the caller graph for this function:

kmp_set_mqtt_client()

ICACHE_FLASH_ATTR void kmp_set_mqtt_client

(

MQTT_Client *

client

)

Definition at line 192 of file kmp_request.c.

References ICACHE_FLASH_ATTR.

                                              {
    mqtt_client = client;
}

Variable Documentation

fifo_buffer

volatile unsigned char fifo_buffer[QUEUE_SIZE]

Definition at line 22 of file kmp_request.c.

Referenced by kmp_fifo_get(), kmp_fifo_put(), and kmp_fifo_snoop().

fifo_head

volatile unsigned int fifo_head

Definition at line 21 of file kmp_request.c.

Referenced by kmp_fifo_in_use(), kmp_fifo_put(), and kmp_request_init().

fifo_tail

volatile unsigned int fifo_tail

Definition at line 21 of file kmp_request.c.

Referenced by kmp_fifo_get(), kmp_fifo_in_use(), kmp_fifo_snoop(), and kmp_request_init().

frame

unsigned char frame[KMP_FRAME_L]

Definition at line 25 of file kmp_request.c.

Referenced by kmp_get_register_timer_func(), and kmp_get_serial_timer_func().

frame_length

unsigned int frame_length

Definition at line 26 of file kmp_request.c.

Referenced by kmp_get_register_timer_func(), and kmp_get_serial_timer_func().

kmp_get_register_timer

os_timer_t kmp_get_register_timer

static

Definition at line 35 of file kmp_request.c.

Referenced by kmp_request_send().

kmp_get_serial_timer

os_timer_t kmp_get_serial_timer

static

Definition at line 34 of file kmp_request.c.

Referenced by kmp_request_send().

kmp_meter_is_ready_cb

meter_is_ready_cb kmp_meter_is_ready_cb = NULL

Definition at line 16 of file kmp_request.c.

Referenced by kmp_received_task(), kmp_register_meter_is_ready_cb(), and kmp_request_send().

kmp_receive_timeout_timer

os_timer_t kmp_receive_timeout_timer

static

Definition at line 37 of file kmp_request.c.

Referenced by kmp_request_send().

kmp_requests_sent

unsigned int kmp_requests_sent

Definition at line 39 of file kmp_request.c.

Referenced by kmp_receive_timeout_timer_func(), kmp_received_task(), kmp_request_init(), and kmp_request_send().

kmp_serial

uint32_t kmp_serial = 0

Definition at line 15 of file kmp_request.c.

Referenced by kmp_get_received_serial(), kmp_received_task(), and kmp_request_send().

meter_is_ready_cb_called

bool meter_is_ready_cb_called = false

Definition at line 17 of file kmp_request.c.

Referenced by kmp_received_task(), and kmp_request_send().

mqtt_client

MQTT_Client* mqtt_client = NULL

static

Definition at line 32 of file kmp_request.c.

register_list

uint16_t register_list[8]

Definition at line 27 of file kmp_request.c.

Referenced by kmp_get_register_timer_func().

response

kmp_response_t response

Definition at line 30 of file kmp_request.c.

Referenced by kmp_received_task().