cloud_codec.h

Go to the documentation of this file.

/*
 * Copyright (c) 2021 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
 */
 
#ifndef CLOUD_CODEC_H__
#define CLOUD_CODEC_H__
 
#include <zephyr/kernel.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <cJSON_os.h>
#include <zephyr/net/net_ip.h>
#include <modem/lte_lc.h>
#if defined(CONFIG_LOCATION)
#include <modem/location.h>
#endif
#include <net/wifi_location_common.h>
#include <nrf_modem_gnss.h>
 
#if defined(CONFIG_LWM2M)
#include <zephyr/net/lwm2m.h>
#else
#include "lwm2m/lwm2m_dummy.h"
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define CLOUD_GNSS_HEADING_ACC_LIMIT (float)60.0
 
struct cloud_data_battery {
        uint16_t bat;
        int64_t bat_ts;
        bool queued : 1;
};
 
struct cloud_data_gnss_pvt {
        double lat;
        double lon;
        float acc;
        float alt;
        float alt_acc;
        float spd;
        float spd_acc;
        float hdg;
        float hdg_acc;
};
 
struct cloud_data_gnss {
        int64_t gnss_ts;
 
        struct cloud_data_gnss_pvt pvt;
 
        bool queued : 1;
};
 
struct cloud_data_no_data {
        bool gnss;
 
        bool neighbor_cell;
 
        bool wifi;
};
 
struct cloud_data_cfg {
        bool active_mode;
        int location_timeout;
        int active_wait_timeout;
        int movement_resolution;
        int movement_timeout;
        double accelerometer_activity_threshold;
        double accelerometer_inactivity_threshold;
        double accelerometer_inactivity_timeout;
        struct cloud_data_no_data no_data;
};
 
struct cloud_data_impact {
        int64_t ts;
        double magnitude;
        bool queued : 1;
};
 
struct cloud_data_sensors {
        int64_t env_ts;
        double temperature;
        double humidity;
        double pressure;
        int bsec_air_quality;
        bool queued : 1;
};
 
struct cloud_data_modem_static {
        int64_t ts;
        char iccid[23];
        char appv[CONFIG_ASSET_TRACKER_V2_APP_VERSION_MAX_LEN];
        char brdv[30];
        char fw[40];
        char imei[16];
        bool queued : 1;
};
 
struct cloud_data_modem_dynamic {
        int64_t ts;
        uint8_t band;
        enum lte_lc_lte_mode nw_mode;
        uint16_t mcc;
        uint16_t mnc;
        uint16_t area;
        uint32_t cell;
        int16_t rsrp;
        char ip[INET6_ADDRSTRLEN];
        char apn[CONFIG_CLOUD_CODEC_APN_LEN_MAX];
        char mccmnc[7];
        bool queued : 1;
};
 
struct cloud_data_ui {
        int btn;
        int64_t btn_ts;
        bool queued : 1;
};
 
struct cloud_codec_data {
        char *buf;
        size_t len;
        struct lwm2m_obj_path paths[CONFIG_CLOUD_CODEC_LWM2M_PATH_LIST_ENTRIES_MAX];
        uint8_t valid_object_paths;
};
 
struct cloud_data_neighbor_cells {
        struct lte_lc_cells_info cell_data;
        struct lte_lc_ncell neighbor_cells[CONFIG_LTE_NEIGHBOR_CELLS_MAX];
        int64_t ts;
        bool queued : 1;
};
 
#if defined(CONFIG_LOCATION_METHOD_WIFI)
struct cloud_data_wifi_access_points {
        struct wifi_scan_result ap_info[CONFIG_LOCATION_METHOD_WIFI_SCANNING_RESULTS_MAX_CNT];
        uint16_t cnt;
        int64_t ts;
        bool queued : 1;
};
#endif
 
struct cloud_data_cloud_location {
        bool neighbor_cells_valid;
        struct cloud_data_neighbor_cells neighbor_cells;
#if defined(CONFIG_LOCATION_METHOD_WIFI)
        bool wifi_access_points_valid;
        struct cloud_data_wifi_access_points wifi_access_points;
#endif
        int64_t ts;
        bool queued : 1;
};
 
struct cloud_data_agnss_request {
        int mcc;
        int mnc;
        uint32_t cell;
        uint32_t area;
        struct nrf_modem_gnss_agnss_data_frame request;
        bool queued : 1;
};
struct cloud_data_pgps_request {
        uint16_t count;
        uint16_t interval;
        uint16_t day;
        uint32_t time;
        bool queued : 1;
};
 
enum cloud_codec_event_type {
        CLOUD_CODEC_EVT_CONFIG_UPDATE = 1,
};
 
struct cloud_codec_evt {
        enum cloud_codec_event_type type;
        struct cloud_data_cfg config_update;
};
 
typedef void (*cloud_codec_evt_handler_t)(const struct cloud_codec_evt *evt);
 
int cloud_codec_init(struct cloud_data_cfg *cfg, cloud_codec_evt_handler_t event_handler);
 
int cloud_codec_encode_cloud_location(
        struct cloud_codec_data *output,
        struct cloud_data_cloud_location *cloud_location);
 
/* Foward declaration */
struct location_data;
 
int cloud_codec_decode_cloud_location(const char *input, size_t input_len,
                                      struct location_data *location);
 
int cloud_codec_encode_agnss_request(struct cloud_codec_data *output,
                                     struct cloud_data_agnss_request *agnss_request);
 
int cloud_codec_encode_pgps_request(struct cloud_codec_data *output,
                                    struct cloud_data_pgps_request *pgps_request);
 
int cloud_codec_decode_config(const char *input, size_t input_len,
                              struct cloud_data_cfg *cfg);
 
int cloud_codec_encode_config(struct cloud_codec_data *output,
                              struct cloud_data_cfg *cfg);
 
int cloud_codec_encode_data(struct cloud_codec_data *output,
                            struct cloud_data_gnss *gnss_buf,
                            struct cloud_data_sensors *sensor_buf,
                            struct cloud_data_modem_static *modem_stat_buf,
                            struct cloud_data_modem_dynamic *modem_dyn_buf,
                            struct cloud_data_ui *ui_buf,
                            struct cloud_data_impact *impact_buf,
                            struct cloud_data_battery *bat_buf);
 
int cloud_codec_encode_ui_data(struct cloud_codec_data *output,
                               struct cloud_data_ui *ui_buf);
 
int cloud_codec_encode_impact_data(struct cloud_codec_data *output,
                                   struct cloud_data_impact *impact_buf);
 
int cloud_codec_encode_batch_data(struct cloud_codec_data *output,
                                  struct cloud_data_gnss *gnss_buf,
                                  struct cloud_data_sensors *sensor_buf,
                                  struct cloud_data_modem_static *modem_stat_buf,
                                  struct cloud_data_modem_dynamic *modem_dyn_buf,
                                  struct cloud_data_ui *ui_buf,
                                  struct cloud_data_impact *impact_buf,
                                  struct cloud_data_battery *bat_buf,
                                  size_t gnss_buf_count,
                                  size_t sensor_buf_count,
                                  size_t modem_stat_buf_count,
                                  size_t modem_dyn_buf_count,
                                  size_t ui_buf_count,
                                  size_t impact_buf_count,
                                  size_t bat_buf_count);
 
void cloud_codec_populate_sensor_buffer(
                                struct cloud_data_sensors *sensor_buffer,
                                struct cloud_data_sensors *new_sensor_data,
                                int *head_sensor_buf,
                                size_t buffer_count);
 
void cloud_codec_populate_ui_buffer(struct cloud_data_ui *ui_buffer,
                                    struct cloud_data_ui *new_ui_data,
                                    int *head_ui_buf,
                                    size_t buffer_count);
 
void cloud_codec_populate_impact_buffer(
                                struct cloud_data_impact *impact_buf,
                                struct cloud_data_impact *new_impact_data,
                                int *head_impact_buf,
                                size_t buffer_count);
 
void cloud_codec_populate_bat_buffer(struct cloud_data_battery *bat_buffer,
                                     struct cloud_data_battery *new_bat_data,
                                     int *head_bat_buf,
                                     size_t buffer_count);
 
void cloud_codec_populate_gnss_buffer(struct cloud_data_gnss *gnss_buffer,
                                     struct cloud_data_gnss *new_gnss_data,
                                     int *head_gnss_buf,
                                     size_t buffer_count);
 
void cloud_codec_populate_modem_dynamic_buffer(
                                struct cloud_data_modem_dynamic *modem_buffer,
                                struct cloud_data_modem_dynamic *new_modem_data,
                                int *head_modem_buf,
                                size_t buffer_count);
 
#ifdef __cplusplus
}
#endif
#endif