File content as of revision 7:9ae73f85dc04:

#include "mbed.h"
#include "picojson.h"
#include "select-demo.h"
#include "iot_platform.h"
#include <string>
#include <iostream>
#include <vector>
#include "BM1383GLV.h"
#include "KX022.h"
#include "BH1745NUC.h"
#include "bh1745_driver.h"
#include "I2CCommon.h"
#include "BM1422AGMV.h"

#if DEMO == DEMO_HTTP
#include "easy-connect.h"
#include "http_request.h"
#include "NTPClient.h"
#include <time.h>

/* Detect result */
result_hvcp2_fd_t result_hvcp2_fd[DETECT_MAX];
result_hvcp2_bd_t result_hvcp2_bd[DETECT_MAX];
uint32_t result_hvcp2_bd_cnt;
uint32_t result_hvcp2_fd_cnt;

Timer http_resp_time;   // response time
uint16_t data[4];       // for color data
float magne[3];         // for geomagnetism data

BM1383GLV sensor_BM(I2C_SDA, I2C_SCL); // Atmosphere
KX022 *sensor_acc; // Accelerometer
BM1422AGMV sensor_magne(I2C_SDA, I2C_SCL); // Geomagnetism

#define JST_OFFSET 9

#define ACCESS_CODE <Access CODE>
#error "You need to replace <Access CODE for your resource> with yours"

std::string put_uri_base("<Base URI>/v1/<Tenant ID>/<Path-to-Resource>.json");
#error "You need to replace <Base URI>, <Tenant ID> and <Path-to-Resource> with yours"

std::string put_uri;

// json-object for camera
picojson::object o_bd[DETECT_MAX], o_fd[DETECT_MAX], o_fr[DETECT_MAX], o_scr[DETECT_MAX];
// json-object for sensor
picojson::object o_acc, o_atmo, o_col, o_temp, o_magne;

picojson::array data_array_acc(6);
picojson::array data_array_atmo(6);
picojson::array data_array_col(6);
picojson::array data_array_temp(6);
picojson::array data_array_magne(6);

// URI for GET request
std::string get_uri("<Base URI>/v1/<Tenant ID>/<Path-to-Resource>/_past.json");
#error "You need to replace <Base URI>, <Tenant ID> and <Path-to-Resource> with yours"

void dump_response(HttpResponse* res)
{
    DEBUG_PRINT("Status: %d - %s\n", res->get_status_code(),
                res->get_status_message().c_str());

    DEBUG_PRINT("Headers:\n");
    for (size_t ix = 0; ix < res->get_headers_length(); ix++) {
        DEBUG_PRINT("\t%s: %s\n", res->get_headers_fields()[ix]->c_str(),
                    res->get_headers_values()[ix]->c_str());
    }
    DEBUG_PRINT("\nBody (%d bytes):\n\n%s\n", res->get_body_length(),
                res->get_body_as_string().c_str());
}

std::string create_put_uri(std::string uri_base)
{
    time_t ctTime;
    struct tm *pnow;
    char date_and_hour[50];
    std::string uri;
    
    ctTime = time(NULL);
    pnow = localtime(&ctTime);
    sprintf(date_and_hour, "?$date=%04d%02d%02dT%02d%02d%02d.000%%2B%02d00",
        (pnow->tm_year + 1900), (pnow->tm_mon + 1), pnow->tm_mday,
        (pnow->tm_hour + JST_OFFSET - pnow->tm_isdst), pnow->tm_min,
        pnow->tm_sec, (JST_OFFSET - pnow->tm_isdst));

    uri = uri_base + date_and_hour;
    
    return(uri);
}

int iot_put(NetworkInterface *network, picojson::object o4)
{

#ifdef ENABLED_NTP
    put_uri = create_put_uri(put_uri_base);
#else
    put_uri = put_uri_base;
#endif  // ENABLED_NTP

    // PUT request to IoT Platform
    HttpRequest* put_req = new HttpRequest(network, HTTP_PUT, put_uri.c_str());
    put_req->set_header("Authorization", ACCESS_CODE);

    picojson::value v_all(o4);

    std::string body = v_all.serialize();

    HttpResponse* put_res = put_req->send(body.c_str(), body.length());
    
    if (!put_res) {
        DEBUG_PRINT("HttpRequest failed (error code %d)\n", put_req->get_error());
        return 1;
    }

    delete put_req;
    return 0;
}

int iot_get(NetworkInterface *network)
{
    // Do GET request to IoT Platform
    // By default the body is automatically parsed and stored in a buffer, this is memory heavy.
    // To receive chunked response, pass in a callback as last parameter to the constructor.
    HttpRequest* get_req = new HttpRequest(network, HTTP_GET, get_uri.c_str());
    get_req->set_header("Authorization", ACCESS_CODE);

    HttpResponse* get_res = get_req->send();

    if (!get_res) {
        DEBUG_PRINT("HttpRequest failed (error code %d)\n", get_req->get_error());
        return 1;
    }

    DEBUG_PRINT("\n----- HTTP GET response -----\n");

    delete get_req;

    return 0;
}
#endif  // DEMO == DEMO_HTTP

void read_color(void)
{
    bool error;
    I2CCommonBegin();
    bh1745_wait_until_found();
    bh1745_initial_setup();
    error = bh1745_read_data(&data[0]);
    MBED_ASSERT(error==0);
}

void get_geomagnetism_value(void)
{
    sensor_magne.get_val(magne);
}

int send_sensor_info(NetworkInterface *network)
{

    /* Type */
    o_acc["RecordType"] = picojson::value((string)"Accelerometer");
    o_atmo["RecordType"] = picojson::value((string)"Atmosphere");
    o_col["RecordType"] = picojson::value((string)"Color");
    o_temp["RecordType"] = picojson::value((string)"Temperature");
    o_magne["RecordType"] = picojson::value((string)"Geomagnetism");

    /* ID */
    o_acc["id"] = picojson::value((string)"0001-0001");
    o_atmo["id"] = picojson::value((string)"0001-0002");
    o_col["id"] = picojson::value((string)"0001-0003");
    o_temp["id"] = picojson::value((string)"0001-0004");
    o_magne["id"] = picojson::value((string)"0001-0005");

    /* Accelerometer data array */
    data_array_acc[0] = picojson::value((double)sensor_acc->getAccX());
    data_array_acc[1] = picojson::value((double)sensor_acc->getAccY());
    data_array_acc[2] = picojson::value((double)sensor_acc->getAccZ());

    /* Atmosphere data array */
    data_array_atmo[0] = picojson::value((double)sensor_BM.getPressure());

    /* Color data array */
    read_color();
    for(int i = 0; i < 4; i++) {
        data_array_col[i] = picojson::value(picojson::value((double)data[i]));
    }

    /* Temperature data array */
    data_array_temp[0] = picojson::value((double)sensor_BM.getTemperature());

    /* Geomagnetism data array */
    get_geomagnetism_value();
    for(int i = 0; i < 3; i++) {
        data_array_magne[i] = picojson::value(picojson::value((double)magne[i]));
    }

    /* Combine data array with object. */
    o_acc["data"] = picojson::value(data_array_acc);
    o_atmo["data"] = picojson::value(data_array_atmo);
    o_col["data"] = picojson::value(data_array_col);
    o_temp["data"] = picojson::value(data_array_temp);
    o_magne["data"] = picojson::value(data_array_magne);

    http_resp_time.reset();
    http_resp_time.start();

    /* send data */
    iot_put(network, o_acc);
    iot_put(network, o_atmo);
    iot_put(network, o_col);
    iot_put(network, o_temp);
    iot_put(network, o_magne);

    
    DEBUG_PRINT("iot_put() Response time:%dms\n", http_resp_time.read_ms());

    return 0;
}

int send_hvc_info(NetworkInterface *network)
{
    /* No face detect */
    if (result_hvcp2_fd_cnt == 0) {
        /* Do nothing */
    } else {
        for (uint32_t i = 0; i < result_hvcp2_fd_cnt; i++) {
            /* picojson-object clear */
            o_fd[i].clear();
            o_fr[i].clear();
            o_scr[i].clear();
            /* Type */
            o_fd[i]["RecordType"] = picojson::value((string)"HVC-P2(face)");
            o_fd[i]["id"] = picojson::value((string) "0001-0006");
            /* Age */
            o_fd[i]["Age"] = picojson::value((double)result_hvcp2_fd[i].age.age);
            /* Gender */
            o_fd[i]["Gender"] = picojson::value((double)result_hvcp2_fd[i].gender.gender);
            /* FaceRectangle */
            o_fr[i]["Top"]  = picojson::value((double)result_hvcp2_fd[i].face_rectangle.MinY);
            o_fr[i]["Left"] = picojson::value((double)result_hvcp2_fd[i].face_rectangle.MinX);
            o_fr[i]["Width"] = picojson::value((double)result_hvcp2_fd[i].face_rectangle.Width);
            o_fr[i]["Height"] = picojson::value((double)result_hvcp2_fd[i].face_rectangle.Height);
            /* Scores */
            o_scr[i]["Neutral"] = picojson::value((double)result_hvcp2_fd[i].scores.score_neutral);
            o_scr[i]["Anger"] = picojson::value((double)result_hvcp2_fd[i].scores.score_anger);
            o_scr[i]["Happiness"] = picojson::value((double)result_hvcp2_fd[i].scores.score_happiness);
            o_scr[i]["Surprise"] = picojson::value((double)result_hvcp2_fd[i].scores.score_surprise);
            o_scr[i]["Sadness"] = picojson::value((double)result_hvcp2_fd[i].scores.score_sadness);
            /* insert 2 structures */
            o_fd[i]["FaceRectangle"] = picojson::value(o_fr[i]);
            o_fd[i]["Scores"] = picojson::value(o_scr[i]);
        }
    }

    /* No body detect */
    if (result_hvcp2_bd_cnt == 0) {
        /* Do nothing */
    } else {
        for (uint32_t i = 0; i < result_hvcp2_bd_cnt; i++) {
            /* picojson-object clear */
            o_bd[i].clear();
            /* Type */
            o_bd[i]["RecordType"] = picojson::value((string)"HVC-P2(body)");
            o_bd[i]["id"] = picojson::value((string)"0001-0007");
            /* BodyRectangle */
            o_bd[i]["Top"] = picojson::value((double)result_hvcp2_bd[i].body_rectangle.MinY);
            o_bd[i]["Left"] = picojson::value((double)result_hvcp2_bd[i].body_rectangle.MinX);
            o_bd[i]["Width"] = picojson::value((double)result_hvcp2_bd[i].body_rectangle.Width);
            o_bd[i]["Height"] = picojson::value((double)result_hvcp2_bd[i].body_rectangle.Height);
        }
    }

    DEBUG_PRINT("Face detect count : %d\n", result_hvcp2_fd_cnt);
    DEBUG_PRINT("Body detect count : %d\n", result_hvcp2_bd_cnt);

    http_resp_time.reset();
    http_resp_time.start();

    /* send data */
    if (result_hvcp2_fd_cnt == 0) {
        /* No need to send data */
    } else {
        for (uint32_t i = 0; i < result_hvcp2_fd_cnt; i++) {
            iot_put(network, o_fd[i]);
        }
    }
    if (result_hvcp2_bd_cnt == 0) {
        /* No need to send data */
    } else {
        for (uint32_t i = 0; i < result_hvcp2_bd_cnt; i++) {
            iot_put(network, o_bd[i]);
        }
    }
    DEBUG_PRINT("iot_put() Response time:%dms\n", http_resp_time.read_ms());
    return 0;
}

void iot_ready_task(void)
{
    KX022 acc(I2C_SDA, I2C_SCL);
    sensor_acc = &acc;

    /* Initialize http */
    NetworkInterface *network = easy_connect(true);
    MBED_ASSERT(network);

#ifdef ENABLED_NTP
    // Generate the string indicating the date and hour specified for PUT request
    NTPClient ntp;
    time_t ctTime;
    struct tm *pnow;
    NTPResult ret;

    ret = ntp.setTime("ntp.nict.jp");
    MBED_ASSERT( ret==0 );

    ctTime = time(NULL);
#endif  // Enabled_NTP

    while (1) {

        semaphore_wait_ret = iot_ready_semaphore.wait();
        MBED_ASSERT(semaphore_wait_ret != -1);

#ifdef USE_HVC_P2
        /* send hvc-p2 data */
        http_resp_time.reset();
        http_resp_time.start();
        send_hvc_info(network);
        DEBUG_PRINT("send_hvc_info() Response time:%dms\n",
               http_resp_time.read_ms());
#endif  // USE_HVC_P2

#ifdef USE_SENSOR_SHIELD
        /* send sensor data */
        http_resp_time.reset();
        http_resp_time.start();
        send_sensor_info(network);
        DEBUG_PRINT("send_sensor_info() Response time:%dms\n",
               http_resp_time.read_ms());
#endif  // USE_SENSOR_SHIELD
        iot_ready_semaphore.release();

        Thread::wait(WAIT_TIME);
    };
}