/* 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"));
}
gboolean jobdesc_is_live (gchar *job)
{
JSON_Value *val;
JSON_Object *obj;
val = json_parse_string_with_comments (job);
obj = json_value_get_object (val);
/* without is-live configure item, default is live */
if (json_object_dotget_boolean (obj, "is-live")) {
json_value_free (val);
return TRUE;
}
json_value_free (val);
return FALSE;
}
void APP2_Tasks ( void )
{
/* Update the application state machine based
* on the current state */
switch(app2Data.state)
{
case APP2_STATE_INIT:
/* Open the device layer */
app2Data.deviceHandle = USB_DEVICE_Open( USB_DEVICE_INDEX_0, DRV_IO_INTENT_READWRITE );
if(app2Data.deviceHandle != USB_DEVICE_HANDLE_INVALID)
{
/* Register a callback with device layer to get event notification (for end point 0) */
USB_DEVICE_EventHandlerSet(app2Data.deviceHandle, APP_USBDeviceEventHandler, 0);
app2Data.state = APP2_STATE_WAIT_FOR_CONFIGURATION;
}
else
{
/* The Device Layer is not ready to be opened. We should try
* again later. */
}
break;
case APP2_STATE_WAIT_FOR_CONFIGURATION:
/* Check if the device was configured */
if(app2Data.isConfigured)
{
app2Data.state = APP2_STATE_SCHEDULE_READ;
}
break;
case APP2_STATE_SCHEDULE_READ:
if(APP_StateReset())
{
break;
}
/* If a read is complete, then schedule a read
* else wait for the current read to complete */
app2Data.state = APP2_STATE_WAIT_FOR_READ_COMPLETE;
if(app2Data.isReadComplete == true)
{
app2Data.isReadComplete = false;
app2Data.readTransferHandle = USB_DEVICE_CDC_TRANSFER_HANDLE_INVALID;
USB_DEVICE_CDC_Read (USB_DEVICE_CDC_INDEX_0,
&app2Data.readTransferHandle, app2Data.readBuffer,
APP_READ_BUFFER_SIZE);
if(app2Data.readTransferHandle == USB_DEVICE_CDC_TRANSFER_HANDLE_INVALID)
{
app2Data.state = APP2_STATE_ERROR;
break;
}
}
break;
case APP2_STATE_WAIT_FOR_READ_COMPLETE:
if(APP_StateReset())
{
break;
}
if(app2Data.isReadComplete == true)
{
// Check for delimiter
int res = APP_CheckForMessage(app2Data.readBuffer);
if(res == MESSAGE_BAD_POINTER)
{
// Do something
break;
}
else if(res == MESSAGE_NO_DELIMITER)
{
strcat(messageBuffer, app2Data.readBuffer);
memset(app2Data.readBuffer, '\0', APP_READ_BUFFER_SIZE);
app2Data.state = APP2_STATE_SCHEDULE_READ;
break;
}
strcat(messageBuffer, app2Data.readBuffer);
// Parse for the command being sent so we can handle it
int command = APP_ParseCommand(messageBuffer);
// Lets build our response message
// First initialize the JSON value and object from parson library
JSON_Value *rootValue = json_value_init_object();
JSON_Object *rootObject = json_value_get_object(rootValue);
char *serializedString = NULL;
// Build response and handle the command
switch(command)
{
// If hello command, respond with discovery packet
case COMMAND_HELLO:
json_object_dotset_string(rootObject, "message.command", "discovery");
json_object_dotset_string(rootObject, "message.discovery_object.title", APP_TITLE);
json_object_dotset_string(rootObject, "message.discovery_object.part_number", APP_PART_NUMBER);
json_object_dotset_string(rootObject, "message.discovery_object.mac_address", appData.macAddress);
json_object_dotset_string(rootObject, "message.discovery_object.firmware_version", APP_FIRMWARE_VERSION);
json_object_dotset_string(rootObject, "message.discovery_object.harmony_version", SYS_VERSION_STR);
json_object_dotset_boolean(rootObject, "message.discovery_object.is_commissioned", appData.isCommissioned);
break;
// If configuration command, respond with ACK/NACK
case COMMAND_CONFIGURE:
{
if(appData.isCommissioned == false)
{
JSON_Value *messageRoot = json_parse_string(messageBuffer);
if(json_value_get_type(messageRoot) != JSONObject)
{
BuildAckNackMessage(rootObject, "nack", "Invalid JSON Object");
break;
}
else
{
JSON_Object *messageObject = json_value_get_object(messageRoot);
if( json_object_dotget_string(messageObject, "message.configuration_object.aws_iot_endpoint_address") != NULL &&
json_object_dotget_string(messageObject, "message.configuration_object.aws_certificate") != NULL &&
json_object_dotget_string(messageObject, "message.configuration_object.aws_certificate_private_key") != NULL )
{
json_object_dotset_string(rootObject, "message.command", "ack");
json_object_dotset_string(rootObject, "message.ack_nack_message", "Writing commission parameters to flash");
sprintf((char *)appData.host, json_object_dotget_string(messageObject, "message.configuration_object.aws_iot_endpoint_address"));
sprintf((char *)appData.clientCert, json_object_dotget_string(messageObject, "message.configuration_object.aws_certificate"));
sprintf((char *)appData.clientKey, json_object_dotget_string(messageObject, "message.configuration_object.aws_certificate_private_key"));
appData.isCommissioned = true;
appData.writeToNVM = true;
}
else
{
BuildAckNackMessage(rootObject, "nack", "Invalid commission parameters");
break;
}
}
}
else
{
BuildAckNackMessage(rootObject, "nack", "Already commissioned");
}
break;
}
case COMMAND_DEBUG_SET:
{
JSON_Value *messageRoot = json_parse_string(messageBuffer);
if(json_value_get_type(messageRoot) != JSONObject)
{
BuildAckNackMessage(rootObject, "nack", "Invalid JSON Object");
break;
}
JSON_Object *messageObject = json_value_get_object(messageRoot);
if(messageObject == NULL)
{
BuildAckNackMessage(rootObject, "nack", "NULL Pointer");
break;
}
BuildAckNackMessage(rootObject, "ack", "Received debug set");
int DebugMessage = DEBUG_UPDATE;
xQueueSendToFront(app2Data.debugQueue, &DebugMessage, 1);
if(json_object_dotget_boolean(messageObject, "message.debug_set_object.set"))
appData.debugSet = true;
else
appData.debugSet = false;
break;
}
case COMMAND_BAD_JSON:
BuildAckNackMessage(rootObject, "nack", "Bad JSON");
break;
case COMMAND_INVALID:
BuildAckNackMessage(rootObject, "nack", "Command Invalid");
break;
default:
BuildAckNackMessage(rootObject, "nack", "Something went wrong");
break;
}
memset(app2Data.writeBuffer, '\0', APP_WRITE_BUFFER_SIZE);
// With our response built, serialize the response into a string
serializedString = json_serialize_to_string(rootValue);
strcpy(app2Data.writeBuffer, serializedString);
// Find length of string and add delimiter to end
app2Data.writeBuffer[strlen(app2Data.writeBuffer)] = '\r';
json_free_serialized_string(serializedString);
// Reset string buffers
memset(app2Data.readBuffer, '\0', APP_READ_BUFFER_SIZE);
memset(messageBuffer, '\0', APP_MESSAGE_BUFFER_SIZE);
app2Data.state = APP2_STATE_SCHEDULE_WRITE;
}
else
{
app2Data.state = APP2_STATE_WAIT_FOR_READ_COMPLETE;
if( uxQueueMessagesWaiting( app2Data.debugQueue ) > 0 )
{
int debugMessageNumber;
xQueueReceive( app2Data.debugQueue, &debugMessageNumber, 1 );
sprintf(app2Data.writeBuffer,
"{"
"\"message\":{"
"\"command\":\"debug\","
"\"debug_object\":{"
"\"board_ip_address\":\"%d.%d.%d.%d\","
"\"aws_iot_endpoint\":\"%s\","
"\"mac_address\":\"%s\","
"\"socket_connected\":%s,"
"\"mqtt_connected\":%s,"
"\"raw_message\":\"%s\""
"}}}\r",
appData.board_ipAddr.v4Add.v[0],
appData.board_ipAddr.v4Add.v[1],
appData.board_ipAddr.v4Add.v[2],
appData.board_ipAddr.v4Add.v[3],
appData.host,
appData.macAddress,
(appData.socket_connected ? "true" : "false"),
(appData.mqtt_connected ? "true" : "false"),
APP_ReturnDebugCodeToString(debugMessageNumber));
app2Data.state = APP2_STATE_SCHEDULE_DEBUG_WRITE;
}
}
break;
case APP2_STATE_SCHEDULE_WRITE:
if(APP_StateReset())
{
break;
}
app2Data.writeTransferHandle = USB_DEVICE_CDC_TRANSFER_HANDLE_INVALID;
app2Data.isWriteComplete = false;
app2Data.state = APP2_STATE_WAIT_FOR_WRITE_COMPLETE;
USB_DEVICE_CDC_Write(USB_DEVICE_CDC_INDEX_0,
&app2Data.writeTransferHandle, app2Data.writeBuffer, strlen(app2Data.writeBuffer),
USB_DEVICE_CDC_TRANSFER_FLAGS_DATA_COMPLETE);
break;
case APP2_STATE_WAIT_FOR_WRITE_COMPLETE:
if(APP_StateReset())
{
break;
}
/* Check if message sent. The isWriteComplete
* flag gets updated in the CDC event handler */
if(app2Data.isWriteComplete == true)
{
app2Data.state = APP2_STATE_SCHEDULE_READ;
}
break;
case APP2_STATE_SCHEDULE_DEBUG_WRITE:
if(APP_StateReset())
{
break;
}
app2Data.writeTransferHandle = USB_DEVICE_CDC_TRANSFER_HANDLE_INVALID;
app2Data.isWriteComplete = false;
app2Data.state = APP2_STATE_WAIT_FOR_DEBUG_WRITE_COMPLETE;
USB_DEVICE_CDC_Write(USB_DEVICE_CDC_INDEX_0,
&app2Data.writeTransferHandle, app2Data.writeBuffer, strlen(app2Data.writeBuffer),
USB_DEVICE_CDC_TRANSFER_FLAGS_DATA_COMPLETE);
break;
case APP2_STATE_WAIT_FOR_DEBUG_WRITE_COMPLETE:
if(APP_StateReset())
{
break;
}
/* Check if message sent. The isWriteComplete
* flag gets updated in the CDC event handler */
if(app2Data.isWriteComplete == true)
{
app2Data.state = APP2_STATE_WAIT_FOR_READ_COMPLETE;
}
break;
case APP2_STATE_ERROR:
break;
default:
break;
}
}
/*------------------------------------------------------------------
- Config file format - simplify, don't need xml, but like the structure
{
"scalars" : {
"nq" : 3,
"lrgs" : 4,
"print" : true
"t" : 10.0,
"dt" : 0.1
},
"coefficients" : {
"alpha" : [0.112, 0.234, 0.253],
"beta" : [0.453, 0.533, -0.732, 0.125, -0.653, 0.752],
"delta" : [1.0, 1.0, 1.0]
}
}
------------------------------------------------------------------*/
int main( int argc, char **argv ){
double *hz, *hhxh; /* hamiltonian components */
double *al, *be, *de;
fftw_complex *psi; /* State vector */
fftw_complex factor;
double T = 10.0, dt = 0.1;
uint64_t i, j, k, bcount;
uint64_t nQ=3, N, L=4, dim;
int *fft_dims, prnt=0;
uint64_t testi, testj;
int dzi, dzj; //TODO: consider using smaller vars for flags and these
fftw_plan plan;
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Parse configuration file
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
//TODO: going to need logic to handle incomplete config files
if( argc < 2 ){
fprintf( stderr, "Need a json configuration file. Terminating...\n" );
return 1;
}
/* Parse file and populate applicable data structures */
{
JSON_Value *root_value = NULL;
JSON_Object *root_object;
JSON_Array *array;
root_value = json_parse_file_with_comments( argv[1] );
root_object = json_value_get_object( root_value );
nQ = (uint64_t) json_object_dotget_number( root_object, "scalars.nq" );
prnt = json_object_dotget_boolean( root_object, "scalars.print" );
L = (uint64_t) json_object_dotget_number( root_object, "scalars.lrgs" );
T = json_object_dotget_number( root_object, "scalars.t" );
dt = json_object_dotget_number( root_object, "scalars.dt" );
al = (double *)malloc( nQ*sizeof(double) );
de = (double *)malloc( nQ*sizeof(double) );
be = (double *)malloc( (nQ*(nQ-1)/2)*sizeof(double) );
array = json_object_dotget_array( root_object, "coefficients.alpha" );
if( array != NULL ){
for( i = 0; i < json_array_get_count(array); i++ ){
al[i] = -json_array_get_number( array, i );
}
}
array = json_object_dotget_array( root_object, "coefficients.beta" );
if( array != NULL ){
for( i = 0; i < json_array_get_count(array); i++ ){
be[i] = -json_array_get_number( array, i );
}
}
array = json_object_dotget_array( root_object, "coefficients.delta" );
if( array != NULL ){
for( i = 0; i < json_array_get_count(array); i++ ){
de[i] = -json_array_get_number( array, i );
}
}
json_value_free( root_value );
}
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Compute the Hamiltonian and state vector for the simulation
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
Create state vector and initialize to 1/sqrt(2^n)*(|00...0> + ... + |11...1>)
TODO: keep track of local size and local base
*/
dim = 1 << nQ;
factor = 1.0/sqrt( dim );
fft_dims = (int *)malloc( nQ*sizeof(int) );
psi = (fftw_complex *)malloc( (dim)*sizeof(fftw_complex) );
hz = (double *)calloc( (dim),sizeof(double) );
hhxh = (double *)calloc( (dim),sizeof(double) );
for( i = 0; i < nQ; i++ ){
fft_dims[i] = 2;
}
plan = fftw_plan_dft( nQ, fft_dims, psi, psi, FFTW_FORWARD, FFTW_MEASURE );
/*
Assemble Hamiltonian and state vector
*/
for( k = 0; k < dim; k++ ){
//TODO: when parallelized, k in dzi test will be ~(k + base)
bcount = 0;
for( i = 0; i < nQ; i++ ){
testi = 1 << (nQ - i - 1);
dzi = ((k/testi) % 2 == 0) ? 1 : -1;
hz[k] += al[i] * dzi;
hhxh[k] += de[i] * dzi;
for( j = i; j < nQ; j++ ){
testj = 1 << (nQ - j - 1);
dzj = ((k/testj) % 2 == 0) ? 1 : -1;
hz[k] += be[bcount] * dzi * dzj;
bcount++;
}
}
psi[k] = factor;
}
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Run the Simulation
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
fftw_complex cz, cx;
double t;
N = (uint64_t)(T / dt);
for( i = 0; i < N; i++ ){
t = i*dt;
//t0 = (i-1)*dt;
//Time-dependent coefficients
cz = (-dt * I)*t/(2.0*T);
cx = (-dt * I)*(1 - t/T);
//Evolve system
expMatTimesVec( psi, hz, cz, dim ); //apply Z part
fftw_execute( plan );
expMatTimesVec( psi, hhxh, cx, dim ); //apply X part
fftw_execute( plan );
expMatTimesVec( psi, hz, cz, dim ); //apply Z part
/*
TODO: can probably get some minor speedup by incorporating this
into expMatTimesVec if needed
*/
scaleVec( psi, 1.0/dim, dim );
}
fftw_destroy_plan( plan );
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Check solution and clean up
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
//TODO: locally, collect all local largests on one
// node, find k largest from that subset
if( prnt && nQ < 6 ){
for( i = 0; i < dim; i++ ){
printf( "psi[%d] = (%f, %f)\t%f\n",
i,
creal( psi[i] ),
cimag( psi[i] ),
cabs( psi[i]*psi[i] ) );
}
} else {
uint64_t *largest = (uint64_t *)calloc( L, sizeof(uint64_t) );
findLargest( largest, psi, dim, L );
for( i = 0; i < L; ++i ){
printf( "psi[%d] = (%f, %f)\t%f\n",
i,
creal( psi[largest[L-1-i]] ),
cimag( psi[largest[L-1-i]] ),
cabs( psi[largest[L-1-i]]*psi[largest[L-1-i]] ) );
}
free( largest );
}
/*
Free work space.
*/
fftw_free( psi );
free( fft_dims );
free( hz );
free( hhxh );
return 0;
}
int config_parse(const char *file, config_t *config)
{
JSON_Value *jvroot;
JSON_Object *joroot;
JSON_Object *jomaccmd;
JSON_Array *jarray;
JSON_Value_Type jtype;
const char *string;
int ret;
int i;
if(file == NULL){
return -1;
}
/** Clear all flags */
config_free(config);
printf("Start parsing configuration file....\n\n");
/* parsing json and validating output */
jvroot = json_parse_file_with_comments(file);
jtype = json_value_get_type(jvroot);
if (jtype != JSONObject) {
return -1;
}
joroot = json_value_get_object(jvroot);
string = json_object_get_string(joroot, "band");
if(string == NULL){
config->band = LW_BAND_EU868;
}else{
for(i=0; i<LW_BAND_MAX_NUM; i++){
if(0 == strcmp(string, config_band_tab[i])){
config->band = (lw_band_t)i;
break;
}
}
if(i==LW_BAND_MAX_NUM){
config->band = LW_BAND_EU868;
}
}
string = json_object_dotget_string(joroot, "key.nwkskey");
if(string != NULL){
if(str2hex(string, config->nwkskey, 16) == 16){
config->flag |= CFLAG_NWKSKEY;
}
}
string = json_object_dotget_string(joroot, "key.appskey");
if(string != NULL){
if(str2hex(string, config->appskey, 16) == 16){
config->flag |= CFLAG_APPSKEY;
}
}
string = json_object_dotget_string(joroot, "key.appkey");
if(string != NULL){
if(str2hex(string, config->appkey, 16) == 16){
config->flag |= CFLAG_APPKEY;
}
}
ret = json_object_dotget_boolean(joroot, "join.key");
if(ret==0){
//printf("Join key false\n");
config->joinkey = false;
}else if(ret==1){
//printf("Join key true\n");
config->joinkey = true;
}else{
//printf("Unknown join key value\n");
config->joinkey = false;
}
string = json_object_dotget_string(joroot, "join.request");
if(string != NULL){
uint8_t tmp[255];
int len;
len = str2hex(string, tmp, 255);
if(len>0){
config->flag |= CFLAG_JOINR;
config->joinr = malloc(len);
if(config->joinr == NULL){
return -2;
}
config->joinr_size = len;
memcpy(config->joinr, tmp, config->joinr_size);
}
}
string = json_object_dotget_string(joroot, "join.accept");
if(string != NULL){
uint8_t tmp[255];
int len;
len = str2hex(string, tmp, 255);
if(len>0){
config->flag |= CFLAG_JOINA;
config->joina = malloc(len);
if(config->joina == NULL){
return -3;
}
config->joina_size = len;
memcpy(config->joina, tmp, config->joina_size);
}
}
jarray = json_object_get_array(joroot, "messages");
if(jarray != NULL){
uint8_t tmp[255];
for (i = 0; i < json_array_get_count(jarray); i++) {
string = json_array_get_string(jarray, i);
if(string!=NULL){
int len = str2hex(string, tmp, 255);
if(len>0){
message_t *pl = malloc(sizeof(message_t));
memset(pl, 0, sizeof(message_t));
if(pl == NULL){
return -3;
}
pl->buf = malloc(len);
if(pl->buf == NULL){
return -3;
}
pl->len = len;
memcpy(pl->buf, tmp, pl->len);
pl_insert(&config->message, pl);
}else{
printf("Messages[%d] \"%s\" is not hex string\n", i, string);
}
}else{
printf("Messages item %d is not string\n", i);
}
}
}else{
printf("Can't get payload array\n");
}
jarray = json_object_get_array(joroot, "maccommands");
if(jarray != NULL){
uint8_t mhdr;
int len;
uint8_t tmp[255];
for (i = 0; i < json_array_get_count(jarray); i++) {
jomaccmd = json_array_get_object(jarray, i);
string = json_object_get_string(jomaccmd, "MHDR");
if(string != NULL){
len = str2hex(string, &mhdr, 1);
if(len != 1){
printf("\"maccommands\"[%d].MHDR \"%s\" must be 1 byte hex string\n", i, string);
continue;
}
}else{
string = json_object_get_string(jomaccmd, "direction");
if(string != NULL){
int j;
len = strlen(string);
if(len>200){
printf("\"maccommands\"[%d].direction \"%s\" too long\n", i, string);
continue;
}
for(j=0; j<len; j++){
tmp[j] = tolower(string[j]);
}
tmp[j] = '\0';
if(0==strcmp((char *)tmp, "up")){
mhdr = 0x80;
}else if(0==strcmp((char *)tmp, "down")){
mhdr = 0xA0;
}else{
printf("\"maccommands\"[%d].MHDR \"%s\" must be 1 byte hex string\n", i, string);
continue;
}
}else{
printf("Can't recognize maccommand direction\n");
continue;
}
}
string = json_object_get_string(jomaccmd, "command");
if(string != NULL){
len = str2hex(string, tmp, 255);
if(len <= 0){
printf("\"maccommands\"[%d].command \"%s\" is not hex string\n", i, string);
continue;
}
}else{
printf("c\"maccommands\"[%d].command is not string\n", i);
continue;
}
message_t *pl = malloc(sizeof(message_t));
memset(pl, 0, sizeof(message_t));
if(pl == NULL){
return -3;
}
pl->buf = malloc(len+1);
if(pl->buf == NULL){
return -3;
}
pl->len = len+1;
pl->buf[0] = mhdr;
pl->next = 0;
memcpy(pl->buf+1, tmp, pl->len-1);
pl_insert(&config->maccmd, pl);
}
}
print_spliter();
printf("%15s %s\n","BAND:\t", config_band_tab[LW_BAND_EU868]);
printf("%15s","NWKSKEY:\t");
putlen(16);
puthbuf(config->nwkskey, 16);
printf("\n");
printf("%15s","APPSKEY:\t");
putlen(16);
puthbuf(config->appskey, 16);
printf("\n");
printf("%15s","APPKEY:\t");
putlen(16);
puthbuf(config->appkey, 16);
printf("\n");
printf("%15s","JOINR:\t");
putlen(config->joinr_size);
puthbuf(config->joinr, config->joinr_size );
printf("\n");
printf("%15s","JOINA:\t");
putlen(config->joina_size);
puthbuf(config->joina, config->joina_size );
printf("\n");
pl_print(config->message);
maccmd_print(config->maccmd);
json_value_free(jvroot);
return 0;
}
