/* Testing correctness of parsed values */
void test_suite_2(void) {
JSON_Value *root_value;
JSON_Object *object;
JSON_Array *array;
int i;
const char *filename = "tests/test_2.txt";
printf("Testing %s:\n", filename);
root_value = json_parse_file(filename);
TEST(root_value);
TEST(json_value_get_type(root_value) == JSONObject);
object = json_value_get_object(root_value);
TEST(STREQ(json_object_get_string(object, "string"), "lorem ipsum"));
TEST(STREQ(json_object_get_string(object, "utf string"), "lorem ipsum"));
TEST(json_object_get_number(object, "positive one") == 1.0);
TEST(json_object_get_number(object, "negative one") == -1.0);
TEST(json_object_get_number(object, "hard to parse number") == -0.000314);
TEST(json_object_get_boolean(object, "boolean true") == 1);
TEST(json_object_get_boolean(object, "boolean false") == 0);
TEST(json_value_get_type(json_object_get_value(object, "null")) == JSONNull);
array = json_object_get_array(object, "string array");
if (array != NULL && json_array_get_count(array) > 1) {
TEST(STREQ(json_array_get_string(array, 0), "lorem"));
TEST(STREQ(json_array_get_string(array, 1), "ipsum"));
} else {
tests_failed++;
}
array = json_object_get_array(object, "x^2 array");
if (array != NULL) {
for (i = 0; i < json_array_get_count(array); i++) {
TEST(json_array_get_number(array, i) == (i * i));
}
} else {
tests_failed++;
}
TEST(json_object_get_array(object, "non existent array") == NULL);
TEST(STREQ(json_object_dotget_string(object, "object.nested string"), "str"));
TEST(json_object_dotget_boolean(object, "object.nested true") == 1);
TEST(json_object_dotget_boolean(object, "object.nested false") == 0);
TEST(json_object_dotget_value(object, "object.nested null") != NULL);
TEST(json_object_dotget_number(object, "object.nested number") == 123);
TEST(json_object_dotget_value(object, "should.be.null") == NULL);
TEST(json_object_dotget_value(object, "should.be.null.") == NULL);
TEST(json_object_dotget_value(object, ".") == NULL);
TEST(json_object_dotget_value(object, "") == NULL);
array = json_object_dotget_array(object, "object.nested array");
if (array != NULL && json_array_get_count(array) > 1) {
TEST(STREQ(json_array_get_string(array, 0), "lorem"));
TEST(STREQ(json_array_get_string(array, 1), "ipsum"));
} else {
tests_failed++;
}
TEST(json_object_dotget_boolean(object, "nested true"));
json_value_free(root_value);
}
/* Testing correctness of parsed values */
void test_suite_2(JSON_Value *root_value) {
JSON_Object *root_object;
JSON_Array *array;
size_t i;
TEST(root_value);
TEST(json_value_get_type(root_value) == JSONObject);
root_object = json_value_get_object(root_value);
TEST(STREQ(json_object_get_string(root_object, "string"), "lorem ipsum"));
TEST(STREQ(json_object_get_string(root_object, "utf string"), "lorem ipsum"));
TEST(STREQ(json_object_get_string(root_object, "utf-8 string"), "あいうえお"));
TEST(STREQ(json_object_get_string(root_object, "surrogate string"), "lorem𝄞ipsum𝍧lorem"));
TEST(json_object_get_number(root_object, "positive one") == 1.0);
TEST(json_object_get_number(root_object, "negative one") == -1.0);
TEST(json_object_get_number(root_object, "hard to parse number") == -0.000314);
TEST(json_object_get_boolean(root_object, "boolean true") == 1);
TEST(json_object_get_boolean(root_object, "boolean false") == 0);
TEST(json_value_get_type(json_object_get_value(root_object, "null")) == JSONNull);
array = json_object_get_array(root_object, "string array");
if (array != NULL && json_array_get_count(array) > 1) {
TEST(STREQ(json_array_get_string(array, 0), "lorem"));
TEST(STREQ(json_array_get_string(array, 1), "ipsum"));
} else {
tests_failed++;
}
array = json_object_get_array(root_object, "x^2 array");
if (array != NULL) {
for (i = 0; i < json_array_get_count(array); i++) {
TEST(json_array_get_number(array, i) == (i * i));
}
} else {
tests_failed++;
}
TEST(json_object_get_array(root_object, "non existent array") == NULL);
TEST(STREQ(json_object_dotget_string(root_object, "object.nested string"), "str"));
TEST(json_object_dotget_boolean(root_object, "object.nested true") == 1);
TEST(json_object_dotget_boolean(root_object, "object.nested false") == 0);
TEST(json_object_dotget_value(root_object, "object.nested null") != NULL);
TEST(json_object_dotget_number(root_object, "object.nested number") == 123);
TEST(json_object_dotget_value(root_object, "should.be.null") == NULL);
TEST(json_object_dotget_value(root_object, "should.be.null.") == NULL);
TEST(json_object_dotget_value(root_object, ".") == NULL);
TEST(json_object_dotget_value(root_object, "") == NULL);
array = json_object_dotget_array(root_object, "object.nested array");
if (array != NULL && json_array_get_count(array) > 1) {
TEST(STREQ(json_array_get_string(array, 0), "lorem"));
TEST(STREQ(json_array_get_string(array, 1), "ipsum"));
} else {
tests_failed++;
}
TEST(json_object_dotget_boolean(root_object, "nested true"));
TEST(STREQ(json_object_get_string(root_object, "/**/"), "comment"));
TEST(STREQ(json_object_get_string(root_object, "//"), "comment"));
}
char *json(UDF_INIT *initid, UDF_ARGS *args,
char *result, unsigned long *length,
char *is_null, char *error)
{
JSON_Value *jv = json_parse_string(args->args[0]);
JSON_Value_Type json_type = json_value_get_type(jv);
if(json_type==JSONError){
*length=0;
*is_null=1;
*error=1;
json_value_free(jv);
return NULL;
}else{
if(json_type == JSONObject){
JSON_Object *o = json_value_get_object(jv);
JSON_Value *value = json_object_dotget_value(o,args->args[1]);
if(value==NULL){
*length = 0;
*is_null = 0;
return NULL;
}else{
*is_null = 0;
switch(json_value_get_type(value)){
case JSONArray:
*is_null = 1;
break;
case JSONError:
case JSONObject:
*is_null = 1;
*error = 1;
break;
case JSONString:
strcpy(initid->ptr,((char*)json_value_get_string(value)));
break;
case JSONNumber:
sprintf(initid->ptr,"%f",json_value_get_number(value));
break;
case JSONNull:
*is_null = 1;
break;
case JSONBoolean:
sprintf(initid->ptr,"%d",json_value_get_boolean(value));
break;
}
*length = initid->ptr == NULL ? 0 : strlen(initid->ptr);
}
}else{
*is_null = 1;
}
json_value_free(jv);
return initid->ptr;
}
}
void do_network(JSON_Value* json, char* msg) {
if(json_value_get_type(json) == JSONObject) {
JSON_Object* obj = json_value_get_object(json);
if(strcmp(json_object_dotget_string(obj, "type"), "act.heating.central") == 0) {
if(json_object_dotget_value(obj, "msg.level") != 0) {
int heatingLevel = 9 - (int)json_object_dotget_number(obj, "msg.level");
printf("ACTING on cmd: %d\n", heatingLevel);
if(heatingLevel > 9) heatingLevel = 9;
if(heatingLevel < 0) heatingLevel = 0;
printf("Set level %d\n", heatingLevel);
serial_write("%d", heatingLevel);
}
}
}
}
int parse_SX1301_configuration(const char * conf_file) {
int i;
const char conf_obj[] = "SX1301_conf";
char param_name[32]; /* used to generate variable parameter names */
const char *str; /* used to store string value from JSON object */
struct lgw_conf_board_s boardconf;
struct lgw_conf_rxrf_s rfconf;
struct lgw_conf_rxif_s ifconf;
JSON_Value *root_val;
JSON_Object *root = NULL;
JSON_Object *conf = NULL;
JSON_Value *val;
uint32_t sf, bw;
/* try to parse JSON */
root_val = json_parse_file_with_comments(conf_file);
root = json_value_get_object(root_val);
if (root == NULL) {
MSG("ERROR: %s id not a valid JSON file\n", conf_file);
exit(EXIT_FAILURE);
}
conf = json_object_get_object(root, conf_obj);
if (conf == NULL) {
MSG("INFO: %s does not contain a JSON object named %s\n", conf_file, conf_obj);
return -1;
} else {
MSG("INFO: %s does contain a JSON object named %s, parsing SX1301 parameters\n", conf_file, conf_obj);
}
/* set board configuration */
memset(&boardconf, 0, sizeof boardconf); /* initialize configuration structure */
val = json_object_get_value(conf, "lorawan_public"); /* fetch value (if possible) */
if (json_value_get_type(val) == JSONBoolean) {
boardconf.lorawan_public = (bool)json_value_get_boolean(val);
} else {
MSG("WARNING: Data type for lorawan_public seems wrong, please check\n");
boardconf.lorawan_public = false;
}
val = json_object_get_value(conf, "clksrc"); /* fetch value (if possible) */
if (json_value_get_type(val) == JSONNumber) {
boardconf.clksrc = (uint8_t)json_value_get_number(val);
} else {
MSG("WARNING: Data type for clksrc seems wrong, please check\n");
boardconf.clksrc = 0;
}
MSG("INFO: lorawan_public %d, clksrc %d\n", boardconf.lorawan_public, boardconf.clksrc);
/* all parameters parsed, submitting configuration to the HAL */
if (lgw_board_setconf(boardconf) != LGW_HAL_SUCCESS) {
MSG("WARNING: Failed to configure board\n");
}
/* set configuration for RF chains */
for (i = 0; i < LGW_RF_CHAIN_NB; ++i) {
memset(&rfconf, 0, sizeof(rfconf)); /* initialize configuration structure */
sprintf(param_name, "radio_%i", i); /* compose parameter path inside JSON structure */
val = json_object_get_value(conf, param_name); /* fetch value (if possible) */
if (json_value_get_type(val) != JSONObject) {
MSG("INFO: no configuration for radio %i\n", i);
continue;
}
/* there is an object to configure that radio, let's parse it */
sprintf(param_name, "radio_%i.enable", i);
val = json_object_dotget_value(conf, param_name);
if (json_value_get_type(val) == JSONBoolean) {
rfconf.enable = (bool)json_value_get_boolean(val);
} else {
rfconf.enable = false;
}
if (rfconf.enable == false) { /* radio disabled, nothing else to parse */
MSG("INFO: radio %i disabled\n", i);
} else { /* radio enabled, will parse the other parameters */
snprintf(param_name, sizeof param_name, "radio_%i.freq", i);
rfconf.freq_hz = (uint32_t)json_object_dotget_number(conf, param_name);
snprintf(param_name, sizeof param_name, "radio_%i.rssi_offset", i);
rfconf.rssi_offset = (float)json_object_dotget_number(conf, param_name);
snprintf(param_name, sizeof param_name, "radio_%i.type", i);
str = json_object_dotget_string(conf, param_name);
if (!strncmp(str, "SX1255", 6)) {
rfconf.type = LGW_RADIO_TYPE_SX1255;
} else if (!strncmp(str, "SX1257", 6)) {
rfconf.type = LGW_RADIO_TYPE_SX1257;
} else {
MSG("WARNING: invalid radio type: %s (should be SX1255 or SX1257)\n", str);
}
snprintf(param_name, sizeof param_name, "radio_%i.tx_enable", i);
val = json_object_dotget_value(conf, param_name);
if (json_value_get_type(val) == JSONBoolean) {
rfconf.tx_enable = (bool)json_value_get_boolean(val);
} else {
rfconf.tx_enable = false;
}
MSG("INFO: radio %i enabled (type %s), center frequency %u, RSSI offset %f, tx enabled %d\n", i, str, rfconf.freq_hz, rfconf.rssi_offset, rfconf.tx_enable);
}
/* all parameters parsed, submitting configuration to the HAL */
if (lgw_rxrf_setconf(i, rfconf) != LGW_HAL_SUCCESS) {
MSG("WARNING: invalid configuration for radio %i\n", i);
}
}
/* set configuration for LoRa multi-SF channels (bandwidth cannot be set) */
for (i = 0; i < LGW_MULTI_NB; ++i) {
memset(&ifconf, 0, sizeof(ifconf)); /* initialize configuration structure */
sprintf(param_name, "chan_multiSF_%i", i); /* compose parameter path inside JSON structure */
val = json_object_get_value(conf, param_name); /* fetch value (if possible) */
if (json_value_get_type(val) != JSONObject) {
MSG("INFO: no configuration for LoRa multi-SF channel %i\n", i);
continue;
}
/* there is an object to configure that LoRa multi-SF channel, let's parse it */
sprintf(param_name, "chan_multiSF_%i.enable", i);
val = json_object_dotget_value(conf, param_name);
if (json_value_get_type(val) == JSONBoolean) {
ifconf.enable = (bool)json_value_get_boolean(val);
} else {
ifconf.enable = false;
}
if (ifconf.enable == false) { /* LoRa multi-SF channel disabled, nothing else to parse */
MSG("INFO: LoRa multi-SF channel %i disabled\n", i);
} else { /* LoRa multi-SF channel enabled, will parse the other parameters */
sprintf(param_name, "chan_multiSF_%i.radio", i);
ifconf.rf_chain = (uint32_t)json_object_dotget_number(conf, param_name);
sprintf(param_name, "chan_multiSF_%i.if", i);
ifconf.freq_hz = (int32_t)json_object_dotget_number(conf, param_name);
// TODO: handle individual SF enabling and disabling (spread_factor)
MSG("INFO: LoRa multi-SF channel %i enabled, radio %i selected, IF %i Hz, 125 kHz bandwidth, SF 7 to 12\n", i, ifconf.rf_chain, ifconf.freq_hz);
}
/* all parameters parsed, submitting configuration to the HAL */
if (lgw_rxif_setconf(i, ifconf) != LGW_HAL_SUCCESS) {
MSG("WARNING: invalid configuration for LoRa multi-SF channel %i\n", i);
}
}
/* set configuration for LoRa standard channel */
memset(&ifconf, 0, sizeof(ifconf)); /* initialize configuration structure */
val = json_object_get_value(conf, "chan_Lora_std"); /* fetch value (if possible) */
if (json_value_get_type(val) != JSONObject) {
MSG("INFO: no configuration for LoRa standard channel\n");
} else {
val = json_object_dotget_value(conf, "chan_Lora_std.enable");
if (json_value_get_type(val) == JSONBoolean) {
ifconf.enable = (bool)json_value_get_boolean(val);
} else {
ifconf.enable = false;
}
if (ifconf.enable == false) {
MSG("INFO: LoRa standard channel %i disabled\n", i);
} else {
ifconf.rf_chain = (uint32_t)json_object_dotget_number(conf, "chan_Lora_std.radio");
ifconf.freq_hz = (int32_t)json_object_dotget_number(conf, "chan_Lora_std.if");
bw = (uint32_t)json_object_dotget_number(conf, "chan_Lora_std.bandwidth");
switch(bw) {
case 500000: ifconf.bandwidth = BW_500KHZ; break;
case 250000: ifconf.bandwidth = BW_250KHZ; break;
case 125000: ifconf.bandwidth = BW_125KHZ; break;
default: ifconf.bandwidth = BW_UNDEFINED;
}
sf = (uint32_t)json_object_dotget_number(conf, "chan_Lora_std.spread_factor");
switch(sf) {
case 7: ifconf.datarate = DR_LORA_SF7; break;
case 8: ifconf.datarate = DR_LORA_SF8; break;
case 9: ifconf.datarate = DR_LORA_SF9; break;
case 10: ifconf.datarate = DR_LORA_SF10; break;
case 11: ifconf.datarate = DR_LORA_SF11; break;
case 12: ifconf.datarate = DR_LORA_SF12; break;
default: ifconf.datarate = DR_UNDEFINED;
}
MSG("INFO: LoRa standard channel enabled, radio %i selected, IF %i Hz, %u Hz bandwidth, SF %u\n", ifconf.rf_chain, ifconf.freq_hz, bw, sf);
}
if (lgw_rxif_setconf(8, ifconf) != LGW_HAL_SUCCESS) {
MSG("WARNING: invalid configuration for LoRa standard channel\n");
}
}
/* set configuration for FSK channel */
memset(&ifconf, 0, sizeof(ifconf)); /* initialize configuration structure */
val = json_object_get_value(conf, "chan_FSK"); /* fetch value (if possible) */
if (json_value_get_type(val) != JSONObject) {
MSG("INFO: no configuration for FSK channel\n");
} else {
val = json_object_dotget_value(conf, "chan_FSK.enable");
if (json_value_get_type(val) == JSONBoolean) {
ifconf.enable = (bool)json_value_get_boolean(val);
} else {
ifconf.enable = false;
}
if (ifconf.enable == false) {
MSG("INFO: FSK channel %i disabled\n", i);
} else {
ifconf.rf_chain = (uint32_t)json_object_dotget_number(conf, "chan_FSK.radio");
ifconf.freq_hz = (int32_t)json_object_dotget_number(conf, "chan_FSK.if");
bw = (uint32_t)json_object_dotget_number(conf, "chan_FSK.bandwidth");
if (bw <= 7800) ifconf.bandwidth = BW_7K8HZ;
else if (bw <= 15600) ifconf.bandwidth = BW_15K6HZ;
else if (bw <= 31200) ifconf.bandwidth = BW_31K2HZ;
else if (bw <= 62500) ifconf.bandwidth = BW_62K5HZ;
else if (bw <= 125000) ifconf.bandwidth = BW_125KHZ;
else if (bw <= 250000) ifconf.bandwidth = BW_250KHZ;
else if (bw <= 500000) ifconf.bandwidth = BW_500KHZ;
else ifconf.bandwidth = BW_UNDEFINED;
ifconf.datarate = (uint32_t)json_object_dotget_number(conf, "chan_FSK.datarate");
MSG("INFO: FSK channel enabled, radio %i selected, IF %i Hz, %u Hz bandwidth, %u bps datarate\n", ifconf.rf_chain, ifconf.freq_hz, bw, ifconf.datarate);
}
if (lgw_rxif_setconf(9, ifconf) != LGW_HAL_SUCCESS) {
MSG("WARNING: invalid configuration for FSK channel\n");
}
}
json_value_free(root_val);
return 0;
}
/**
*
* @property: (in): encoders.x.elements.element.property.name or source.elements.element.property.name
*/
gchar * jobdesc_element_property_value (gchar *job, gchar *property)
{
JSON_Value *val;
JSON_Object *obj;
JSON_Array *array;
JSON_Value_Type type;
JSON_Value *value;
gchar *p;
gint64 i;
gdouble n;
gint index;
val = json_parse_string_with_comments (job);
obj = json_value_get_object (val);
if (g_str_has_prefix (property, "encoder")) {
array = json_object_dotget_array (obj, "encoders");
sscanf (property, "encoder.%d", &index);
obj = json_array_get_object (array, index);
p = g_strrstr (property, "elements");
value = json_object_dotget_value (obj, p);
} else if (g_str_has_prefix (property, "source")) {
value = json_object_dotget_value (obj, property);
}
if (value == NULL) {
json_value_free (val);
return NULL;
}
type = json_value_get_type (value);
switch (type) {
case JSONString:
p = g_strdup (json_value_get_string (value));
break;
case JSONNumber:
n = json_value_get_number (value);
i = n;
if (i == n) {
p = g_strdup_printf ("%ld", i);
} else {
p = g_strdup_printf ("%f", n);
}
break;
case JSONBoolean:
if (json_value_get_boolean (value)) {
p = g_strdup ("TRUE");
} else {
p = g_strdup ("FALSE");
}
break;
default:
GST_ERROR ("property value invalid.");
}
json_value_free (val);
return p;
}
