senml.h

Go to the documentation of this file.

/*
 * Copyright (C) 2021 Silke Hofstra
 *
 * This file is subject to the terms and conditions of the GNU Lesser
 * General Public License v2.1. See the file LICENSE in the top level
 * directory for more details.
 */
 
#ifndef SENML_H
#define SENML_H
 
#include <stddef.h>
#include <stdbool.h>
#include <stdint.h>
 
#include "modules.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
#ifndef CONFIG_SENML_ATTR_SUM
#define CONFIG_SENML_ATTR_SUM 0
#endif
 
#ifndef CONFIG_SENML_ATTR_VERSION
#define CONFIG_SENML_ATTR_VERSION 0
#endif
 
#ifndef CONFIG_SENML_ATTR_UPDATE_TIME
#define CONFIG_SENML_ATTR_UPDATE_TIME 0
#endif
 
typedef enum {
    /* SenML units from RFC8428 */
    SENML_UNIT_NONE,                        
    SENML_UNIT_METER,                       
    SENML_UNIT_KILOGRAM,                    
    SENML_UNIT_GRAM,                        
    SENML_UNIT_SECOND,                      
    SENML_UNIT_AMPERE,                      
    SENML_UNIT_KELVIN,                      
    SENML_UNIT_CANDELA,                     
    SENML_UNIT_MOLE,                        
    SENML_UNIT_HERTZ,                       
    SENML_UNIT_RADIAN,                      
    SENML_UNIT_STERADIAN,                   
    SENML_UNIT_NEWTON,                      
    SENML_UNIT_PASCAL,                      
    SENML_UNIT_JOULE,                       
    SENML_UNIT_WATT,                        
    SENML_UNIT_COULOMB,                     
    SENML_UNIT_VOLT,                        
    SENML_UNIT_FARAD,                       
    SENML_UNIT_OHM,                         
    SENML_UNIT_SIEMENS,                     
    SENML_UNIT_WEBER,                       
    SENML_UNIT_TESLA,                       
    SENML_UNIT_HENRY,                       
    SENML_UNIT_CELSIUS,                     
    SENML_UNIT_LUMEN,                       
    SENML_UNIT_LUX,                         
    SENML_UNIT_BECQUEREL,                   
    SENML_UNIT_GRAY,                        
    SENML_UNIT_SIEVERT,                     
    SENML_UNIT_KATAL,                       
    SENML_UNIT_SQUARE_METER,                
    SENML_UNIT_CUBIC_METER,                 
    SENML_UNIT_LITER,                       
    SENML_UNIT_METER_PER_SECOND,            
    SENML_UNIT_METER_PER_SQUARE_SECOND,     
    SENML_UNIT_CUBIC_METER_PER_SECOND,      
    SENML_UNIT_LITER_PER_SECOND,            
    SENML_UNIT_WATT_PER_SQUARE_METER,       
    SENML_UNIT_CANDELA_PER_SQUARE_METER,    
    SENML_UNIT_BIT,                         
    SENML_UNIT_BIT_PER_SECOND,              
    SENML_UNIT_LATITUDE,                    
    SENML_UNIT_LONGITUDE,                   
    SENML_UNIT_PH,                          
    SENML_UNIT_DECIBEL,                     
    SENML_UNIT_DBW,                         
    SENML_UNIT_BEL,                         
    SENML_UNIT_COUNT,                       
    SENML_UNIT_RATIO,                       
    SENML_UNIT_RATIO_2,                     
    SENML_UNIT_RELATIVE_HUMIDITY_PERCENT,   
    SENML_UNIT_REMAINING_BATTERY_PERCENT,   
    SENML_UNIT_REMAINING_BATTERY_SECONDS,   
    SENML_UNIT_RATE,                        
    SENML_UNIT_RPM,                         
    SENML_UNIT_BEAT_PER_MINUTE,             
    SENML_UNIT_BEATS,                       
    SENML_UNIT_SIEMENS_PER_METER,           
    /* SenML units from RFC8798 */
    SENML_UNIT_BYTE,                        
    SENML_UNIT_VOLT_AMPERE,                 
    SENML_UNIT_VOLT_AMPERE_SECOND,          
    SENML_UNIT_VOLT_AMPERE_REACTIVE,        
    SENML_UNIT_VOLT_AMPERE_REACTIVE_SECOND, 
    SENML_UNIT_JOULE_PER_METER,             
    SENML_UNIT_KILOGRAM_PER_CUBIC_METER,    
    SENML_UNIT_DEGREE,                      
    /* SenML units from ISO7027-1:2016 */
    SENML_UNIT_NEPHELOMETRIC_TURBIDITY_UNIT, 
    /* SenML secondary units from RFC8798 */
    SENML_UNIT_MILLISECOND,                 
    SENML_UNIT_MINUTE,                      
    SENML_UNIT_HOUR,                        
    SENML_UNIT_MEGAHERTZ,                   
    SENML_UNIT_KILOWATT,                    
    SENML_UNIT_KILOVOLT_AMPERE,             
    SENML_UNIT_KILOVAR,                     
    SENML_UNIT_AMPERE_HOUR,                 
    SENML_UNIT_WATT_HOUR,                   
    SENML_UNIT_KILOWATT_HOUR,               
    SENML_UNIT_VAR_HOUR,                    
    SENML_UNIT_KILOVAR_HOUR,                
    SENML_UNIT_KILOVOLT_AMPERE_HOUR,        
    SENML_UNIT_WATT_HOUR_PER_KILOMETER,     
    SENML_UNIT_KIBIBYTE,                    
    SENML_UNIT_GIGABYTE,                    
    SENML_UNIT_MEGABIT_PER_SECOND,          
    SENML_UNIT_BYTE_PER_SECOND,             
    SENML_UNIT_MEGABYTE_PER_SECOND,         
    SENML_UNIT_MILLIVOLT,                   
    SENML_UNIT_MILLIAMPERE,                 
    SENML_UNIT_DECIBEL_MILLIWATT,           
    SENML_UNIT_MICROGRAM_PER_CUBIC_METER,   
    SENML_UNIT_MILLIMETER_PER_HOUR,         
    SENML_UNIT_METER_PER_HOUR,              
    SENML_UNIT_PARTS_PER_MILLION,           
    SENML_UNIT_PERCENT,                     
    SENML_UNIT_PERMILLE,                    
    SENML_UNIT_HECTOPASCAL,                 
    SENML_UNIT_MILLIMETER,                  
    SENML_UNIT_CENTIMETER,                  
    SENML_UNIT_KILOMETER,                   
    SENML_UNIT_KILOMETER_PER_HOUR,          
    /* SenML secondary units from CoRE-1 */
    SENML_UNIT_PARTS_PER_BILLION,   
    SENML_UNIT_PARTS_PER_TRILLION,  
    SENML_UNIT_VOLT_AMPERE_HOUR,    
    SENML_UNIT_MILLIGRAM_PER_LITER, 
    SENML_UNIT_MICROGRAM_PER_LITER, 
    SENML_UNIT_GRAM_PER_LITER,      
} senml_unit_t;
 
typedef enum {
    SENML_TYPE_NUMERIC_UINT,    
    SENML_TYPE_NUMERIC_INT,     
    SENML_TYPE_NUMERIC_FLOAT,   
    SENML_TYPE_NUMERIC_DOUBLE,  
    SENML_TYPE_NUMERIC_DECFRAC, 
} senml_value_type_t;
 
typedef struct {
    int32_t e;  
    int32_t m;  
} senml_decfrac_t;
 
typedef struct {
    senml_value_type_t type; 
    union {
        uint64_t u;
        int64_t i;
        float f;
        double d;
        struct { int32_t e; int32_t m; } df ;
    } value; 
} senml_numeric_t;
 
typedef struct {
    const char *base_name;          
    senml_numeric_t base_time;      
    senml_unit_t base_unit;         
    senml_numeric_t base_value;     
#if IS_ACTIVE(CONFIG_SENML_ATTR_SUM) || defined(DOXYGEN)
    senml_numeric_t base_sum;       
#endif
#if IS_ACTIVE(CONFIG_SENML_ATTR_VERSION) || defined(DOXYGEN)
    uint64_t base_version;          
#endif
    const char *name;               
    senml_unit_t unit;              
#if IS_ACTIVE(CONFIG_SENML_ATTR_SUM) || defined(DOXYGEN)
    senml_numeric_t sum;            
#endif
    senml_numeric_t time;           
#if IS_ACTIVE(CONFIG_SENML_ATTR_UPDATE_TIME) || defined(DOXYGEN)
    senml_numeric_t update_time;    
#endif
} senml_attr_t;
 
typedef struct {
    senml_attr_t attr;      
    senml_numeric_t value;  
} senml_value_t;
 
typedef struct {
    senml_attr_t attr;  
    const char *value;  
    size_t len;         
} senml_string_value_t;
 
typedef struct {
    senml_attr_t attr;  
    bool value;         
} senml_bool_value_t;
 
typedef struct {
    senml_attr_t attr;      
    const uint8_t *value;   
    size_t len;             
} senml_data_value_t;
 
static inline senml_numeric_t senml_float(float v)
{
    return (senml_numeric_t){ .type = SENML_TYPE_NUMERIC_FLOAT,
                              .value = { .f = v } };
}
 
static inline void senml_set_float(senml_numeric_t *n, float v)
{
    n->type = SENML_TYPE_NUMERIC_FLOAT;
    n->value.f = v;
}
 
static inline senml_numeric_t senml_double(double v)
{
    return (senml_numeric_t){ .type = SENML_TYPE_NUMERIC_DOUBLE,
                              .value = { .d = v } };
}
 
static inline void senml_set_double(senml_numeric_t *n, double v)
{
    n->type = SENML_TYPE_NUMERIC_DOUBLE;
    n->value.d = v;
}
 
static inline senml_numeric_t senml_int(int64_t v)
{
    return (senml_numeric_t){ .type = SENML_TYPE_NUMERIC_INT,
                              .value = { .i = v } };
}
 
static inline void senml_set_int(senml_numeric_t *n, int64_t v)
{
    n->type = SENML_TYPE_NUMERIC_INT;
    n->value.i = v;
}
 
static inline senml_numeric_t senml_uint(uint64_t v)
{
    return (senml_numeric_t){ .type = SENML_TYPE_NUMERIC_UINT,
                              .value = { .u = v } };
}
 
static inline void set_senml_uint(senml_numeric_t *n, uint64_t v)
{
    n->type = SENML_TYPE_NUMERIC_UINT;
    n->value.u = v;
}
 
static inline senml_numeric_t senml_decfrac(int32_t m, int32_t e)
{
    return (senml_numeric_t){ .type = SENML_TYPE_NUMERIC_DECFRAC,
                              .value = { .df = { .e = e, .m = m } } };
}
 
static inline void senml_set_decfrac(senml_numeric_t *n, int32_t m, int32_t e)
{
    n->type = SENML_TYPE_NUMERIC_DECFRAC;
    n->value.df.e = e;
    n->value.df.m = m;
}
 
static inline senml_numeric_t senml_duration_s(int64_t s)
{
    return senml_int(s);
}
 
static inline void senml_set_duration_s(senml_numeric_t *n, int64_t s)
{
    senml_set_int(n, s);
}
 
static inline senml_numeric_t senml_duration_ms(int32_t ms)
{
    return senml_decfrac(ms, -3);
}
 
static inline void senml_set_duration_ms(senml_numeric_t *n, int32_t ms)
{
    senml_set_decfrac(n, ms, -3);
}
 
static inline senml_numeric_t senml_duration_us(int32_t us)
{
    return senml_decfrac(us, -6);
}
 
static inline void senml_set_duration_us(senml_numeric_t *n, int32_t us)
{
    senml_set_decfrac(n, us, -6);
}
 
static inline senml_numeric_t senml_duration_ns(int32_t ns)
{
    return senml_decfrac(ns, -9);
}
 
static inline void senml_set_duration_ns(senml_numeric_t *n, int32_t ns)
{
    senml_set_decfrac(n, ns, -9);
}
 
const char *senml_unit_to_str(senml_unit_t unit);
 
#ifdef __cplusplus
}
#endif
 
#endif /* SENML_H */