int main()
{
m2x_context *ctx = NULL;
m2x_response response;
const char *from = "2015-01-01T01:00:00.000Z";
const char *end = "2016-01-01T01:00:00.000Z";
char buf[2048];
ctx = m2x_open(M2X_KEY);
sprintf(buf, "{\"from\": \"%s\", \"end\": \"%s\"}", from, end);
printf("Deleting location hisory from: %s end: %s for device: %s\n", from, end, device_id);
response = m2x_device_delete_location_history(ctx, device_id, buf);
printf("Status code: %d\n", response.status);
if (m2x_is_success(&response) && response.raw) {
printf("%s\n", response.raw);
}
m2x_release_response(&response);
m2x_close(ctx);
return 0;
}
/*******************************************************************************
**
** Function create_device
**
** Description Create Device,
** Hardcoded
** to add reading from configuration file.
**
** Returns void
**
*******************************************************************************/
static int create_device(void)
{
char *master_key;
char fname[50];
FILE *device_fp;
printf("Creating M2X device \n");
sprintf(fname, "/etc/m2x/dev_%s", name);
device_fp = fopen (fname, "r");
if (device_fp)
{
fscanf(device_fp, "%s", device_id);
APPL_TRACE_INFO("Device '%s' Exists. Device ID:%s\n",name, device_id );
fclose(device_fp);
return 2;
}
else
{
/* 1.3 Create a Device */
sprintf(buf, "{\"name\": \"%s\", \"description\": \"%s\", \"tags\": \"%s\", \"visibility\": \"%s\"}",
name, description, tags, visibility);
APPL_TRACE_INFO("Create device: %s\n", buf);
response = m2x_device_create(ctx, buf);
APPL_TRACE_INFO("Status code: %d\n", response.status);
if (m2x_is_success(&response) && response.raw)
{
APPL_TRACE_INFO("%s\n", response.raw);
APPL_TRACE_INFO("Feed ID : %s\n", json_object_get_string(json_value_get_object(
response.json), "id"));
memcpy(device_id, json_object_get_string(json_value_get_object(response.json), "id"),
sizeof(device_id));
APPL_TRACE_INFO("%s\n", &device_id);
/* Store the Device Id in the file */
/*sprintf(fname, "/etc/m2x/dev_%s", name);*/
device_fp = fopen (fname, "w+");
if (device_fp) {
fprintf(device_fp, "%s", device_id);
fclose(device_fp);
} else
{
printf("create_device: Failed to open file");
}
device_count++;
}
/* Release the response so that same struct is used for next response */
m2x_release_response(&response);
/* Sleep for about a min, since it takes ~40 sec to create the device */
sleep(45);
return 1;
}
}
static int create_trigger(void)
{
/* 3.0 Create a Trigger */
memset(&buf, 0, sizeof(buf));
sprintf(buf, "{\"stream\": \"%s\", \"name\": \"High Temperature\", \"condition\": \">\", \"value\": \"75\", \"callback_url\": \"http://requestb.in/1dsaa5u1\", \"status\": \"enabled\", \"send_location\": \"true\" }",
stream_name);
response = m2x_device_trigger_create(ctx, &device_id, buf);
if (m2x_is_success(&response) && response.raw) {
printf("%s\n", response.raw);
}
sleep(5);
}
int main()
{
m2x_context *ctx = NULL;
char buf[2048];
m2x_response response;
ctx = m2x_open(M2X_KEY);
sprintf(buf, "{\"name\": \"%s\", \"description\": \"%s\", \"tags\": \"%s\", \"visibility\": \"%s\"}",
name, description, tags, visibility);
printf("Update device %s: %s\n", feed_id, buf);
response = m2x_device_update(ctx, feed_id, buf);
printf("Status code: %d\n", response.status);
if (m2x_is_success(&response) && response.raw) {
printf("%s\n", response.raw);
}
m2x_release_response(&response);
m2x_close(ctx);
return 0;
}
int main()
{
m2x_context ctx;
struct json_token *arr = NULL, *tok = NULL, *tok2 = NULL;
int i, len;
m2x_response response;
char buf[40];
m2x_open(M2X_KEY, &ctx);
response = m2x_device_list(&ctx, "");
printf("Response Status Code: %d\n", response.status);
if (m2x_is_success(&response)) {
arr = (struct json_token *) response.data;
printf("Total: %d\n", parse_integer(find_json_token(arr, "body.total")));
printf("Pages: %d\n", parse_integer(find_json_token(arr, "body.pages")));
printf("Limit: %d\n\n", parse_integer(find_json_token(arr, "body.limit")));
tok = find_json_token(arr, "body.devices");
if (tok) {
i = 0;
while (1) {
sprintf(buf, "[%d].id", i);
tok2 = find_json_token(tok, buf);
if (!tok2) { break; }
print_token_as_string("Device ID: ", tok2);
sprintf(buf, "[%d].name", i);
tok2 = find_json_token(tok, buf);
print_token_as_string("Device Name: ", tok2);
printf("\n");
i++;
}
}
}
m2x_release_response(&ctx, &response);
m2x_close(&ctx);
return 0;
}
static int post_to_m2x(int length, char *input_val)
{
int data_length = length - 8;
int is_ok;
unsigned char UUID[2];
unsigned char BDA[6];
unsigned char *SENSOR_DATA;
unsigned char *tmp_val = input_val;
unsigned int uuid_is=0;
short value, x, y, z;
/* Receive a message from client */
/*
Sample Data for Sensors
Humidity org.bluetooth.characteristic.humidity 0x2A6F Adopted
Pressure org.bluetooth.characteristic.pressure 0x2A6D Adopted
Temperature org.bluetooth.characteristic.temperature 0x2A6E Adopted
Magnetic Flux Density - 3D org.bluetooth.characteristic.magnetic_flux_density_3D 0x2AA1 Adopted
AABBBBCCCCCCDD(DDDD)
AA - Length of data (2)
BBBB - UUID (2)
CCCCCC - BDA (6)
DD(DDDD) - Value (2 or 6 bytes)
interpret_data(length, buf)
*/
/*
AABBBBCCCCCCDD(DDDD)
AA - Length of data (2)
BB BB - UUID (4)
CC CC CC CC CC CC- BDA (6)
DD DD (DD DD DD DD) - Value (2 or 6 bytes)
e.g. 10 or 14
0a 00 6f 2a 45 20 01 18 10 00 e6 01
0a 00 6d 2a 45 20 01 18 10 00 95 27
0a 00 6e 2a 45 20 01 18 10 00 e9 00
0a 00 6f 2a 45 20 01 18 10 00 e6 01
0e 00 a0 bb 45 20 01 18 10 00 00 00 00 00 00 00
0e 00 a1 bb 45 20 01 18 10 00 c8 00 58 ff 00 00
*/
memcpy(UUID, tmp_val, 2);
uuid_is = UUID[0] | UUID[1]<<8;
printf("uuid_is = %d, length=%\n", uuid_is, length, data_length);
memcpy(BDA, &tmp_val[2], 6);
printf("BDA = %s", BDA);
if ((data_length == 2) || (data_length ==6)) {
/*memcpy(SENSOR_DATA, &tmp_val[8], data_length);*/
SENSOR_DATA=&tmp_val[8];
/*SENSOR_DATA[data_length]= "\n";*/
printf("Sensor_data: %x %x", SENSOR_DATA[0], SENSOR_DATA[1]);
switch(data_length)
{
case 2:
STREAM_TO_UINT16(value, SENSOR_DATA);
printf("Sensor_data: %x ",value);
break;
case 6:
STREAM_TO_UINT16(value, SENSOR_DATA);
STREAM_TO_UINT16(x, SENSOR_DATA);
STREAM_TO_UINT16(y, SENSOR_DATA);
STREAM_TO_UINT16(z, SENSOR_DATA);
printf("Sensor_data: x=%x y=%x z=%x", x,y,z);
x = x & 0x000F;
z = y & 0x00F0;
z = y & 0x0F00;
break;
}
}
else{
return;
}
/* Reading the first two bytes for the length */
switch(uuid_is) {
case UUID_CHARACTERISTIC_HUMIDITY:
stream_id= HUMIDITY;
break;
case UUID_CHARACTERISTIC_TEMPERATURE:
stream_id= TEMPERATURE;
break;
case UUID_CHARACTERISTIC_PRESSURE:
stream_id= PRESSURE;
break;
case UUID_CHARACTERISTIC_FLUX:
stream_id= MAGNETO_FLUX;
break;
case UUID_CHARACTERISTIC_ACCELEROMETER:
stream_id= ACCL;
break;
case UUID_CHARACTERISTIC_GYROSCOPE:
stream_id= GYRO;
break;
}
memset(&buf, 0, sizeof(buf));
printf("\nReceived Sensor reading from :");
switch(stream_id) {
case HUMIDITY:
printf("HUMIDITY");
sprintf(buf, "{ \"value\": \"%d.%d\" }", value/10,value%10);
break;
case TEMPERATURE:
printf("TEMPERATURE");
sprintf(buf, "{ \"value\": \"%d\" }", value/10, value%10);
break;
case PRESSURE:
printf("PRESSURE");
sprintf(buf, "{ \"value\": \"%d\" }", value);
break;
case GYRO:
printf("GYRO");
sprintf(buf, "{ \"value\": \"%x%x%x\" }", x,y,z );
break;
case ACCL:
printf("ACCL");
sprintf(buf, "{ \"value\": \"%x%x%x\" }", x,y,z );
break;
case MAGNETO_FLUX:
printf("MAGNETO");
sprintf(buf, "{ \"value\": \"%x%x%x\" }", x,y,z );
break;
default:
break;
}
printf("(%d)\n", stream_id);
/*{ "value": x }*/
printf("buf: %s \n", buf);
#ifdef RUN_M2X
response = m2x_device_stream_value_update(ctx, &device_id, stream_name_list[stream_id], buf);
if (m2x_is_success(&response) && response.raw) {
printf("%s\n", response.raw);
}
else {
/* Error in updating value */
}
/* Release the response so that same struct is used for next response */
m2x_release_response(&response);
/* sleep(5);*/
#endif
}
/*******************************************************************************
**
** Function initialize_setup
**
** Description Create streams and trigger
** Can be hardcoded
** to add reading from configuration file.
**
** Returns void
**
*******************************************************************************/
static int create_streams(void)
{
FILE *streams_fp;
char fname[10];
char key_from_file[100];
int stream_len=0;
int device_present;
int stream_present[MAX_STREAM];
int j;
printf("Creating M2X Streams \n");
memset(stream_present, 0, MAX_STREAM);
/* Get the list of streams from the M2X Server and validate that all the Streams are present */
response = m2x_device_streams(ctx, device_id);
printf("Response code: %d\n", response.status);
if (m2x_is_success(&response)) {
JSON_Array *streams = json_object_get_array(json_value_get_object(
response.json), "streams");
size_t i;
for (i = 0; i < json_array_get_count(streams); i++) {
JSON_Object *json_stream = json_array_get_object(streams, i);
const char *stream_name = json_object_get_string(json_stream, "name");
for (j=0; j< MAX_STREAM; j++)
{
if (strncmp(stream_name, stream_name_list[j],strlen(stream_name)))
{
stream_present[j] = 1; /* Stream already present*/
}
}
printf("Name : %s\n", stream_name);
printf("\n");
}
}
m2x_release_response(&response);
/* Create a Stream */
for (i=0; i < MAX_STREAM; i++)
{
if (stream_present[i])
continue;
printf("Creating %d M2X Stream :\"%s\" of size=%d \n", i, stream_name_list[i], sizeof(stream_name_list[i]));
memset(&buf, 0, sizeof(buf));
stream_len= strlen(stream_name_list[i]);
stream_len = (stream_len<MAX_STREAM_NAME)?stream_len:MAX_STREAM_NAME;
memcpy(stream_name, stream_name_list[i], stream_len+1);
/*stream_name[stream_len]='\n';*/
APPL_TRACE_INFO("\nBefore m2x_device_stream_create device_id: %s |\n", &device_id);
APPL_TRACE_INFO("\nBefore m2x_device_stream_create stream_name: %s |\n", stream_name);
switch(i) {
case HUMIDITY:
sprintf(buf, "{ \"unit\": { \"label\": \"percentage\", \"symbol\": \"%%\" }, \"type\": \"numeric\" }");
break;
case TEMPERATURE:
sprintf(buf, "{ \"unit\": { \"label\": \"celsius\", \"symbol\": \"C\" }, \"type\": \"numeric\" }");
break;
case PRESSURE:
sprintf(buf, "{ \"unit\": { \"label\": \"pascal\", \"symbol\": \"Pa\" }, \"type\": \"numeric\" }");
break;
case GYRO:
sprintf(buf, "{ \"unit\": { \"label\": \"point\", \"symbol\": \"p\" }, \"type\": \"numeric\" }");
break;
case ACCL:
sprintf(buf, "{ \"unit\": { \"label\": \"point\", \"symbol\": \"p\" }, \"type\": \"numeric\" }");
break;
case MAGNETO_FLUX:
sprintf(buf, "{ \"unit\": { \"label\": \"point\", \"symbol\": \"p\" }, \"type\": \"numeric\" }");
break;
}
response = m2x_device_stream_create(ctx, &device_id, stream_name, buf);
if (m2x_is_success(&response) && response.raw) {
APPL_TRACE_INFO("%s\n", response.raw);
}
/* Store the Device Id in the file */
sprintf(fname, "/tmp/m2x/stream_%s", stream_name);
streams_fp = fopen (fname, "w+");
fprintf(streams_fp, "%s", stream_name);
fclose(streams_fp);
/* Release the response so that same struct is used for next response */
m2x_release_response(&response);
/* Sleep for about a min, since it takes ~40 sec to create the device */
sleep(5);
}
}
int m2x_fetch_pending_commands(m2x_context *ctx, const char *dev_id)
{
m2x_response response;
m2x_command *command;
struct json_token *arr = NULL, *tok = NULL;
char command_ids[M2X_COMMAND_QUEUE_LENGTH + 1][M2X_ID_MAX_LENGTH + 1];
char token_path[30];
int idx = 0;
int inserted_any = 0;
/* Fetch the summaries of the next outstanding commands, if any. */
response = m2x_device_commands(ctx, dev_id, M2X__FETCH_COMMANDS_PARAMS);
if (!m2x_is_success(&response))
return 0;
arr = (struct json_token *) response.data;
/* Capture the command id string from each command summary in the list. */
for (idx = 0; idx < M2X_COMMAND_QUEUE_LENGTH; idx++) {
/* Get the id token at the token path. */
sprintf(token_path, "body.commands[%i].id", idx);
tok = find_json_token(arr, token_path);
if (!tok)
break;
/* Store the command id string from the token. */
command_ids[idx][0] = '\0';
strncat(command_ids[idx], tok->ptr, tok->len);
}
/* Add a terminator as the last element of the command_ids array. */
command_ids[idx][0] = '\0';
/* Clean up. */
m2x_release_response(ctx, &response);
/* Use the command ids to fetch and store each detailed representation. */
for (idx = 0; idx < M2X_COMMAND_QUEUE_LENGTH; idx++) {
/* Break early if we've reache the terminator. */
if (command_ids[idx][0] == '\0')
break;
/* Fetch the detailed representation of the command by id. */
response = m2x_device_view_command(ctx, dev_id, command_ids[idx]);
if (!m2x_is_success(&response))
break;
/* Get the representation token from the response json. */
arr = (struct json_token *) response.data;
tok = find_json_token(arr, "body");
if (!tok)
break;
/* Create and insert the command into the commands queue. */
command = m2x_create_command(ctx, tok->ptr, tok->len);
if (command) {
m2x_insert_command(ctx, command);
inserted_any = 1;
}
/* Clean up. */
m2x_release_response(ctx, &response);
break;
}
/* Clean up. */
m2x_release_response(ctx, &response);
return inserted_any;
}