/* FogCloud message receive callback: handle cloud messages here
*/
OSStatus user_fogcloud_msg_handler(mico_Context_t* mico_context,
const char* topic, const unsigned int topicLen,
unsigned char *inBuf, unsigned int inBufLen)
{
user_log_trace();
OSStatus err = kUnknownErr;
mico_fogcloud_msg_t fogcloud_msg;
int retCode = MSG_PROP_UNPROCESSED;
if((NULL == mico_context) || (NULL == topic) || (0 == topicLen) ) {
user_log("ERROR: mico_cloudmsg_dispatch params error, err=%d", err);
return kParamErr;
}
fogcloud_msg.topic = topic;
fogcloud_msg.topic_len = topicLen;
fogcloud_msg.data = inBuf;
fogcloud_msg.data_len = inBufLen;
err = mico_fogcloud_msg_dispatch(mico_context, service_table, &fogcloud_msg, &retCode);
if(kNoErr != err){
user_log("ERROR: mico_cloudmsg_dispatch error, err=%d", err);
}
else
{
if(MSG_PROP_WROTE == retCode){
g_user_context.status.user_config_need_update = true; // user params need update in flash
}
}
return err;
}
OSStatus HealthInit(app_context_t *app_context)
{
u8 idx;
OSStatus err;
for(idx = 0; idx < MAX_DEPTH_PUTDOWN; idx++) {
putdown_timer[idx].index = idx;
}
// check if schedule remind timneout every 1 minute
for(idx = 0; idx < MAX_DEPTH_SCHEDULE; idx++) {
schedule_timer[idx].index = idx;
err = mico_init_timer(&schedule_timer[idx].timer, 60*UpTicksPerSecond(), ScheduleTimeout, &schedule_timer[idx]);
if(kNoErr != err) {
user_log("[ERR]HealthInit: create schedule_timer[%d] failed", idx);
}
else {
user_log("[DBG]HealthInit: create schedule_timer[%d] success", idx);
}
err = mico_start_timer(&schedule_timer[idx].timer);
if(kNoErr != err) {
user_log("[ERR]HealthInit: start schedule_timer[%d] failed", idx);
}
else {
user_log("[DBG]HealthInit: start schedule_timer[%d] success", idx);
}
}
#if 0
// initialize if outTrigger is implement by semaphore
err = mico_rtos_init_semaphore(&semaphore_getup, 1);
require_noerr_action(err, exit, user_log("[ERR]HealthInit: create semaphore_getup failed"));
user_log("[DBG]HealthInit: create semaphore_getup success");
err = mico_rtos_init_semaphore(&semaphore_putdown, 1);
require_noerr_action(err, exit, user_log("[ERR]HealthInit: create semaphore_putdown failed"));
user_log("[DBG]HealthInit: create semaphore_putdown success");
#endif
/*
err = mico_init_timer(&timer_health_notify, 2*UpTicksPerSecond(), MOChangedNotification, app_context);
require_noerr_action(err, exit, user_log("[ERR]HealthInit: create timer_health_notify failed"));
user_log("[DBG]HealthInit: create timer_health_notify success");
err = mico_start_timer(&timer_health_notify);
require_noerr_action(err, exit, user_log("[ERR]HealthInit: start timer_health_notify failed"));
user_log("[DBG]HealthInit: start timer_health_notify success");
*/
// start the health monitor thread
err = mico_rtos_create_thread(&health_monitor_thread_handle, MICO_APPLICATION_PRIORITY, "health_monitor",
health_thread, STACK_SIZE_HEALTH_THREAD,
app_context);
require_noerr_action( err, exit, user_log("[ERR]HealthInit: create health thread failed!"));
user_log("[DBG]HealthInit: create health thread success!");
exit:
return err;
}
/* user main function, called by AppFramework.
*/
OSStatus user_main( app_context_t * const app_context )
{
user_log_trace();
OSStatus err = kUnknownErr;
user_log("User main thread start...");
// start prop get/set thread
err = mico_rtos_create_thread(NULL, MICO_APPLICATION_PRIORITY, "prop_recv", property_recv,
STACK_SIZE_PROP_RECV_THREAD, (void*)app_context);
require_noerr_action( err, exit, user_log("ERROR: Unable to start the prop_recv thread.") );
err = mico_rtos_create_thread(NULL, MICO_APPLICATION_PRIORITY, "prop_update", property_update,
STACK_SIZE_PROP_UPDATE_THREAD, (void*)app_context);
require_noerr_action( err, exit, user_log("ERROR: Unable to start the prop_update thread.") );
/* main loop for user display */
while(1){
// system work state show on OLED
system_state_display(app_context);
mico_thread_sleep(1);
}
exit:
user_log("ERROR: user_main exit with err=%d", err);
return err;
}
static void ScheduleTimeout(void* arg)
{
u8 times;
OSStatus err;
struct tm time;
SMngTimer* mng = (SMngTimer*)arg;
err = mico_reload_timer(&mng->timer);
if(err != kNoErr) {
user_log("[ERR]ScheduleTimeout: reload schedule[%d] failed", mng->index);
}
u16 remind_time = GetScheduleRemindHour(mng->index)*60 + GetScheduleRemindMinute(mng->index);
sntp_current_time_get(&time);
u16 current_time = time.tm_hour*60 + time.tm_min;
if(current_time < remind_time) {
return ;
}
times = GetScheduleRemindTimes(mng->index);
while(times--) {
u8 type = GetScheduleTrackType(mng->index);
u16 track_id = GetScheduleSelTrack(mng->index);
AaSysLogPrint(LOGLEVEL_DBG, "track type %d index %d will be played %d times", type, track_id, times);
SendQuitReq();
SendPlayReq(type, track_id);
}
}
OSStatus ControllerBusSend(ECBusCmd cmd, unsigned char *inData, unsigned int inDataLen)
{
unsigned char* inBuf;
unsigned int bufLen = sizeof(SCBusHeader) + inDataLen;
inBuf = malloc(bufLen);
if(inBuf == NULL) {
user_log("[ERR]ControllerBusSend: memory failed");
return kGeneralErr;
}
SCBusHeader* header = (SCBusHeader*)inBuf;
header->magic = 0x5a;
header->cmd = cmd;
header->datalen = inDataLen;
header->tail = 0xaa;
uint8_t data_checksum = 0;
data_checksum += header->magic;
data_checksum += header->cmd;
data_checksum += header->datalen >> 8;
data_checksum += header->datalen & 0x00ff;
data_checksum += header->tail;
for(uint16_t idx = 0; idx < inDataLen; idx++) {
data_checksum += *(inData + idx);
}
header->checksum = data_checksum;
if(inData != NULL) {
unsigned char* payload = inBuf + sizeof(SCBusHeader);
memcpy(payload, inData, inDataLen);
}
if(kNoErr != user_uartSend(inBuf, bufLen)) {
user_log("[ERR]ControllerBusSend: send failed");
return kGeneralErr;
}
user_log("[DBG]ControllerBusSend: send with following data");
print_serial_data(inBuf, bufLen);
if(inBuf != NULL) free(inBuf);
return kNoErr;
}
/* A dummy kernel idle proc
*/
void DoDoIdle(void) {
while (1) {
user_log("Idling... (%d)", cnt++);
cnt %= 1024;
Pause();
}
return;
}
void sys_ipc(uint32_t *param1)
{
/* TODO: Checking of recv-mask */
tcb_t *to_thr = NULL;
l4_thread_t to_tid = param1[REG_R0], from_tid = param1[REG_R1];
if (to_tid != L4_NILTHREAD) {
to_thr = thread_by_globalid(to_tid);
if (to_tid == TID_TO_GLOBALID(THREAD_LOG)) {
user_log(caller);
caller->state = T_RUNNABLE;
} else if ((to_thr && to_thr->state == T_RECV_BLOCKED)
|| to_tid == caller->t_globalid) {
/* To thread who is waiting for us or sends to myself */
do_ipc(caller, to_thr);
} else if (to_thr && to_thr->state == T_INACTIVE &&
GLOBALID_TO_TID(to_thr->utcb->t_pager) == GLOBALID_TO_TID(caller->t_globalid)) {
if (ipc_read_mr(caller, 0) == 0x00000003) {
/* thread start protocol */
memptr_t sp = ipc_read_mr(caller, 2);
size_t stack_size = ipc_read_mr(caller, 3);
dbg_printf(DL_IPC, "IPC: %t thread start\n", to_tid);
to_thr->stack_base = sp - stack_size;
to_thr->stack_size = stack_size;
thread_init_ctx((void *) sp, (void *) ipc_read_mr(caller, 1), to_thr);
caller->state = T_RUNNABLE;
/* Start thread */
to_thr->state = T_RUNNABLE;
} else {
do_ipc(caller, to_thr);
to_thr->state = T_INACTIVE;
}
} else {
/* No waiting, block myself */
caller->state = T_SEND_BLOCKED;
caller->utcb->intended_receiver = to_tid;
dbg_printf(DL_IPC, "IPC: %t sending\n", caller->t_globalid);
return;
}
}
if (from_tid != L4_NILTHREAD) {
/* Only receive phases, simply lock myself */
caller->state = T_RECV_BLOCKED;
caller->ipc_from = from_tid;
dbg_printf(DL_IPC, "IPC: %t receiving\n", caller->t_globalid);
}
}
// Key1 callback: do RGB_LED test
void user_key1_clicked_callback(void)
{
user_log_trace();
user_log("user_key1_clicked_callback");
rgb_led_test_flag = false;
return;
}
// Key2 callback: do DC Motor test
void user_key2_clicked_callback(void)
{
user_log_trace();
user_log("user_key2_clicked_callback");
dc_motor_set(0); // dc motor test
return;
}
void user_key2_long_pressed_callback(void)
{
user_log_trace();
user_log("user_key2_long_pressed_callback");
dc_motor_set(1); // dc motor test
return;
}
void user_key1_long_pressed_callback(void)
{
user_log_trace();
user_log("user_key1_long_pressed_callback");
rgb_led_test_flag = true;
return;
}
/* user main function, called by AppFramework.
*/
OSStatus user_main( app_context_t * const app_context )
{
user_log_trace();
OSStatus err = kUnknownErr;
user_log("User main task start...");
err = user_uartInit();
require_noerr_action( err, exit, user_log("ERROR: user_uartInit err = %d.", err) );
user_log("start photo...");
unsigned char* image="hello world";
user_uartSend( image,strlen(image));
char aa[200];
memset(aa, '\0', 200);
mico_thread_sleep(5);
int len=user_uartRecv((unsigned char *)aa, 200);
user_log("uart_data_recv: [%d][%.*s]", len, len,(unsigned char*)aa);
user_log("end...");
#if (MICO_CLOUD_TYPE != CLOUD_DISABLED)
/* start fogcloud msg handle task */
err = start_fog_msg_handler(app_context);
require_noerr_action( err, exit, user_log("ERROR: start_fog_msg_handler err = %d.", err) );
/* start properties notify task(upload data) */
err = mico_start_properties_notify(app_context, service_table,
MICO_PROPERTIES_NOTIFY_INTERVAL_MS,
STACK_SIZE_NOTIFY_THREAD);
require_noerr_action( err, exit, user_log("ERROR: mico_start_properties_notify err = %d.", err) );
#endif
/* main loop for user display */
while(1){
// check every 1 seconds
mico_thread_sleep(1);
// system work state show on OLED
system_state_display(app_context, &g_user_context);
}
exit:
user_log("ERROR: user_main exit with err=%d", err);
return err;
}
/* FogCloud msg handle thread */
void user_cloud_msg_handle_thread(void* arg)
{
OSStatus err = kUnknownErr;
fogcloud_msg_t *recv_msg = NULL;
mico_fogcloud_msg_t mico_fog_msg;
int retCode = MSG_PROP_UNPROCESSED;
mico_Context_t *mico_context = (mico_Context_t *)arg;
require_action(mico_context, exit, err=kParamErr);
while(1){
mico_thread_msleep(100); // in case of while (1)
err = MicoFogCloudMsgRecv(mico_context, &recv_msg, 0);
if(kNoErr == err){
user_log("Msg recv: topic[%d]=[%.*s]\tdata[%d]=[%.*s]",
recv_msg->topic_len, recv_msg->topic_len, recv_msg->data,
recv_msg->data_len, recv_msg->data_len, recv_msg->data + recv_msg->topic_len);
// msg structure format transfer
mico_fog_msg.topic = (const char*)(recv_msg->data);
mico_fog_msg.topic_len = recv_msg->topic_len;
mico_fog_msg.data = recv_msg->data + recv_msg->topic_len;
mico_fog_msg.data_len = recv_msg->data_len;
err = mico_fogcloud_msg_dispatch(mico_context, service_table, &mico_fog_msg, &retCode);
if(kNoErr != err){
user_log("ERROR: mico_cloudmsg_dispatch error, err=%d", err);
}
else{
}
// NOTE: msg memory must be free after been used.
if(NULL != recv_msg){
free(recv_msg);
recv_msg = NULL;
}
}
}
exit:
user_log("ERROR: user_cloud_msg_handle_thread exit with err=%d", err);
return;
}
/* user main function, called by AppFramework after FogCloud connected.
*/
OSStatus user_main( mico_Context_t * const mico_context )
{
user_log_trace();
OSStatus err = kUnknownErr;
/* init user modules (pins && sensor init)*/
err = user_modules_init();
require_noerr_action( err, exit, user_log("ERROR: user_modules_init err=%d.", err) );
/* recovery user settings from flash && set initail state of user modules */
//err = user_settings_recovery(mico_context, &g_user_context);
//require_noerr_action( err, exit, user_log("ERROR: user_settings_recovery err=%d.", err) );
#if (MICO_CLOUD_TYPE != CLOUD_DISABLED)
/* start properties notify task */
err = mico_start_properties_notify(mico_context, service_table,
MICO_PROPERTIES_NOTIFY_INTERVAL_MS,
STACK_SIZE_NOTIFY_THREAD);
require_noerr_action( err, exit, user_log("ERROR: mico_start_properties_notify err = %d.", err) );
#endif
while(1){
/* user thread running state */
user_display(&g_user_context);
user_test(&g_user_context);
/* check every 1 seconds */
mico_thread_msleep(1000);
/* save user settings into flash */
//err = user_settings_update(mico_context, &g_user_context);
//require_noerr_action( err, exit, user_log("ERROR: user_settings_update err=%d.", err) );
}
exit:
user_log("ERROR: user_main exit with err=%d", err);
return err;
}
void update_dht11_sensor(void)
{
uint8_t dht11_ret = 1;
char temp_value[10];
char hum_value[10];
dht11_ret = DHT11_Read_Data(&dht11_temp_data, &dht11_hum_data);
if(0 == dht11_ret)
{
itoa(dht11_temp_data,temp_value);
itoa(dht11_hum_data,hum_value);
if(ARRAYENT_SUCCESS!=ArrayentSetProperty("temp",temp_value))
{
user_log("service have rejected!\n\r");
}
mico_thread_msleep(200);
if(ARRAYENT_SUCCESS!=ArrayentSetProperty("hsv",hum_value))
{
user_log("service have rejected!\n\r");
}
}
}
OSStatus SntpInit(app_context_t * const app_context)
{
u8 cnt = 0;
user_log("[DBG]SntpInit: waiting for cloud connected...");
// will wait for 3 second
while(cnt < 6) {
if(app_context->appStatus.fogcloudStatus.isCloudConnected == false) {
mico_thread_msleep(500);
}
else {
break;
}
cnt++;
}
if(cnt >= 6) {
user_log("[WRN]SntpInit: cloud disconnected");
return kGeneralErr;
}
return sntp_client_start();
}
void property_recv(void *inContext)
{
uint16_t len = 0;
char property[150];
app_context_t * app_context = (app_context_t*)inContext;
while(1)
{
if(!app_context->appStatus.arrayentStatus.isCloudConnected){
mico_thread_sleep(1);
continue;
}
len = sizeof(property);
memset(property, 0, len);
if(ARRAYENT_SUCCESS == ArrayentRecvProperty(property,&len,10000)){//receive property data from server
user_log("recv property=%s\n\r",property);
if(0 != checkCmd(property, inContext)){//parse cmd success
user_log("checkCmd error: property=%s", property);
}
}
}
}
void update_light_sensor(void)
{
int light_ret = 0;
char light_value[10];
light_ret = light_sensor_read(&light_sensor_data);
if(0 == light_ret)
{
itoa(light_sensor_data,light_value);
if(ARRAYENT_SUCCESS!=ArrayentSetProperty("light",light_value))
{
user_log("service have rejected!\n\r");
}
}
}
static OSStatus ParseControllerBus(SCBusHeader* header, uint8_t* payload)
{
OSStatus err = kGeneralErr;
switch(header->cmd) {
case CONTROLLERBUS_CMD_GETTRACKNUM: err = ParseTrackNumber(header, payload); break;
case CONTROLLERBUS_CMD_GETTRQACKNAME: err = ParseTrackName(header, payload); break;
case CONTROLLERBUS_CMD_PLAY: err = ParseTrackPlay(payload); break;
case CONTROLLERBUS_CMD_VOLUME: err = ParseVolume(payload); break;
case CONTROLLERBUS_CMD_TFSTATUS: err = ParseTFCardStatus(payload); break;
case CONTROLLERBUS_CMD_EXIT: err = ParseQuitResp(payload); break;
default: user_log("[ERR]ParseControllerBus: error cmd 0x%02x", header->cmd); break;
}
return err;
}
void update_infrared_sensor(void)
{
int infrared_ret = 0;
char infrared_value[10];
infrared_ret = infrared_reflective_read(&infrared_reflective_data);
if(0 == infrared_ret)
{
itoa(infrared_reflective_data,infrared_value);
if(ARRAYENT_SUCCESS!=ArrayentSetProperty("infrared",infrared_value))
{
user_log("service have rejected!\n\r");
}
}
}
/* user main function, called by AppFramework after system init done && wifi
* station on in user_main thread.
*/
OSStatus user_main( app_context_t * const app_context )
{
user_log_trace();
OSStatus err = kUnknownErr;
require(app_context, exit);
hsb2rgb_led_init(); // rgb led init
while(1){
mico_thread_sleep(1);
// system work state show on OLED
system_state_display(app_context);
}
exit:
user_log("ERROR: user_main exit with err=%d", err);
return err;
}
bool on_get_user_logs::on_finished(const std::vector<ioremap::elliptics::data_pointer>& data)
{
std::string result_str;
if(!data.empty()) {
rapidjson::Document d; // creates json document
d.SetObject();
rapidjson::Value user_logs(rapidjson::kArrayType); // creates vector value for user one's day log
for (auto it = data.begin(), end = data.end(); it != end; ++it) {
rapidjson::Value user_log(it->data<char>(), it->size(), d.GetAllocator()); // creates vector value for user one's day log
user_logs.PushBack(user_log, d.GetAllocator());
}
d.AddMember("logs", user_logs, d.GetAllocator()); // adds logs array to json document
rapidjson::StringBuffer buffer; // creates string buffer for serialized json
rapidjson::Writer<rapidjson::StringBuffer> writer(buffer); // creates json writer
d.Accept(writer); // accepts writer by json document
result_str = buffer.GetString();
}
ioremap::swarm::http_response reply;
reply.set_code(ioremap::swarm::http_response::ok);
auto &headers = reply.headers();
headers.set_content_length(result_str.size());
headers.set_content_type("text/json");
get_reply()->send_headers(std::move(reply),
boost::asio::buffer(result_str),
std::bind(&on_get_user_logs::on_send_finished,
shared_from_this(),
result_str));
return false;
}
void user_display(user_context_t *user_context)
{
// display H/T on OLED
char temp_hum_str[16] = {0};
int run_flag_display = 0;
if(running_status_flag){
run_flag_display = 1;
running_status_flag = false;
}
else{
run_flag_display = 0;
running_status_flag = true;
}
// temperature/humidity display on OLED
memset(temp_hum_str, 0, sizeof(temp_hum_str));
user_log("DHT11: T=%d, H=%d.",
user_context->status.temperature, user_context->status.humidity);
sprintf(temp_hum_str, "%d T: %dC H: %d%%", run_flag_display,
user_context->status.temperature, user_context->status.humidity);
OLED_ShowString(0,6,(uint8_t*)temp_hum_str);
}
void main(int argc, char **argv) {
int delay = 1;
int delays[512];
int delays2[1024];
int exit_status;
int* a;
a = (int*)malloc(sizeof(int) * 100);
int cnt = 0;
user_log("Init program has PID(%d)", GetPid());
int pid = Fork();
char* tmp[] = {NULL};
if(argc >= 1) {
delay = atoi(argv[0]);
}
user_log("My pid is %d, fork return pid %d", GetPid(), pid);
if(pid != 0) {
user_log("I am parent with PID(%d), user Wait() for my children...", GetPid());
int cpid = Wait(&exit_status);
user_log("Wait my child(%d) done, return meaning of life %d", cpid, exit_status);
while(1) {
user_log("I have no children, so lonley, going to delay %d seconds", delay);
Delay(delay);
}
} else {
while(1) {
user_log("I am child with PID(%d), about to exe", GetPid());
Exec("src/goexec", tmp);
user_log("PID(%d) try exec fail", GetPid());
Exit(1);
}
}
// Never reached
return;
}
/* user main function, called by AppFramework.
*/
OSStatus user_main( mico_Context_t * const mico_context )
{
user_log_trace();
OSStatus err = kUnknownErr;
user_log("User main task start...");
err = user_uartInit();
require_noerr_action( err, exit, user_log("ERROR: user_uartInit err = %d.", err) );
user_log("user_uartInit ok");
#if (MICO_CLOUD_TYPE != CLOUD_DISABLED)
/* start fogcloud msg handle task */
err = start_fog_msg_handler(mico_context);
require_noerr_action( err, exit, user_log("ERROR: start_fog_msg_handler err = %d.", err) );
/* start properties notify task(upload data) */
err = mico_start_properties_notify(mico_context, service_table,
MICO_PROPERTIES_NOTIFY_INTERVAL_MS,
STACK_SIZE_NOTIFY_THREAD);
require_noerr_action( err, exit, user_log("ERROR: mico_start_properties_notify err = %d.", err) );
#endif
/* main loop for user display */
while(1){
// check every 1 seconds
mico_thread_sleep(1);
// system work state show on OLED
system_state_display(mico_context, &g_user_context);
}
exit:
user_log("ERROR: user_main exit with err=%d", err);
return err;
}
/* user main function, called by AppFramework after system init done && wifi
* station on in user_main thread.
*/
OSStatus user_main( app_context_t * const app_context )
{
user_log_trace();
OSStatus err = kUnknownErr;
unsigned char rdata[64];
unsigned char sdata[64];
uint16_t datalen;
require(app_context, exit);
// platform initialize
AaSysComInit();
AaSysLogInit();
// application initialize
ControllerBusInit();
OuterTriggerInit(NULL);
TemperatureInit(); // will be support in release 2
BatteryInit();
// reset f411 and wait until it startup
ResetF411();
#if 1
MOInit();
#endif
err = SntpInit(app_context);
if(kNoErr != err) {
AaSysLogPrint(LOGLEVEL_ERR, "SntpInit finished with err code %d", err);
}
else {
AaSysLogPrint(LOGLEVEL_INF, "SntpInit success");
}
#if 1
DeviceInit(app_context);
HealthInit(app_context);
LightsInit(app_context);
MusicInit(app_context);
// start the downstream thread to handle user command
err = mico_rtos_create_thread(&user_downstrem_thread_handle, MICO_APPLICATION_PRIORITY, "user_downstream",
user_downstream_thread, STACK_SIZE_USER_DOWNSTREAM_THREAD,
app_context );
require_noerr_action( err, exit, user_log("ERROR: create user_downstream thread failed!") );
#endif
user_log("[DBG]net_main: Appilcation Initialize success @"SOFTWAREVERSION);
// user_main loop, update oled display every 1s
while(1){
#if 1
mico_thread_sleep(MICO_WAIT_FOREVER);
#else
mico_thread_sleep(5);
datalen = user_uartRecv(rdata, 5);
if(datalen) {
user_log("[DBG]user_main: Usart recevice datalen %d", datalen);
user_log("[DBG]user_main: receive %.*s", datalen, rdata);
}
else {
user_log("[DBG]user_main: Usart didn't recevice data");
}
mico_thread_sleep(2);
sprintf(sdata, "hello, world!\r\n");
user_uartSend(sdata, strlen(sdata));
#endif
}
exit:
if(kNoErr != err){
user_log("[ERR]user_main: user_main thread exit with err=%d", err);
}
mico_rtos_delete_thread(NULL); // delete current thread
return err;
}
/* user main function, called by AppFramework after system init done && wifi
* station on in user_main thread.
*/
OSStatus user_main( app_context_t * const app_context )
{
user_log_trace();
OSStatus err = kUnknownErr;
json_object *send_json_object = NULL;
const char *upload_data = NULL;
uint8_t ret = 0;
uint8_t dht11_temperature = 0;
uint8_t dht11_humidity = 0;
// update 2~4 lines on OLED
char oled_show_line[OLED_DISPLAY_MAX_CHAR_PER_ROW+1] = {'\0'};
require(app_context, exit);
// init humiture sensor DHT11
ret = DHT11_Init();
if(0 != ret) // init error
{
err = kNoResourcesErr;
user_log("DHT11 init failed!");
goto exit;
}
else
{
err = kNoErr;
}
while(1)
{
mico_thread_sleep(2); // data acquisition && upload every 2 seconds
// check fogcloud connect status
if(!app_context->appStatus.fogcloudStatus.isCloudConnected)
{
continue;
}
// fogcloud connected, do data acquisition
ret = DHT11_Read_Data(&dht11_temperature, &dht11_humidity);
if(0 != ret)
{
err = kReadErr;
}
else
{
err = kNoErr;
// temperature/humidity display on OLED, each line 16 chars max
OLED_ShowString(OLED_DISPLAY_COLUMN_START, OLED_DISPLAY_ROW_2, "Demo Read H/T "); // clean line2
memset(oled_show_line, '\0', OLED_DISPLAY_MAX_CHAR_PER_ROW+1);
snprintf(oled_show_line, OLED_DISPLAY_MAX_CHAR_PER_ROW+1, "T: %2dC ", dht11_temperature);
OLED_ShowString(OLED_DISPLAY_COLUMN_START, OLED_DISPLAY_ROW_3, (uint8_t*)oled_show_line);
memset(oled_show_line, '\0', OLED_DISPLAY_MAX_CHAR_PER_ROW+1);
snprintf(oled_show_line, OLED_DISPLAY_MAX_CHAR_PER_ROW+1, "H: %2d%% ", dht11_humidity);
OLED_ShowString(OLED_DISPLAY_COLUMN_START, OLED_DISPLAY_ROW_4, (uint8_t*)oled_show_line);
// create json object && upload to cloud
send_json_object = json_object_new_object();
if(NULL == send_json_object)
{
user_log("create json object error!");
err = kNoMemoryErr;
}
else
{
// create json object && data string to upload
json_object_object_add(send_json_object, "dht11_temperature", json_object_new_int(dht11_temperature));
json_object_object_add(send_json_object, "dht11_humidity", json_object_new_int(dht11_humidity));
upload_data = json_object_to_json_string(send_json_object);
if(NULL == upload_data)
{
user_log("create upload data string error!");
err = kNoMemoryErr;
}
else
{
// upload data string to fogcloud, the seconde param(NULL) means send to defalut topic: '<device_id>/out'
MiCOFogCloudMsgSend(app_context, NULL, (unsigned char*)upload_data, strlen(upload_data));
user_log("upload data success!\r\ntopic=%s/out\tdht11_temperature=%d, dht11_humidity=%d",
app_context->appConfig->fogcloudConfig.deviceId,
dht11_temperature, dht11_humidity);
err = kNoErr;
}
// free json object memory
json_object_put(send_json_object);
send_json_object = NULL;
}
}
}
exit:
user_log("ERROR: user_main exit with err=%d", err);
return err;
}
void handler::handle_get_user_logs(fastcgi::Request* req, fastcgi::HandlerContext*)
{
m_logger->debug("Handlle get user logs request\n");
try {
fastcgi::RequestStream stream(req);
if (!req->hasArg(consts::USER_ITEM))
throw std::invalid_argument("Required parameters are missing");
std::vector<ioremap::elliptics::data_pointer> res;
if(req->hasArg(consts::KEYS_ITEM)) {
std::string keys_value = req->getArg(consts::KEYS_ITEM);
std::vector<std::string> keys;
boost::split(keys, keys_value, boost::is_any_of(":"));
res = m_provider->get_user_logs(req->getArg(consts::USER_ITEM),
keys); // gets user logs from historydb library
}
else if(req->hasArg(consts::BEGIN_TIME_ITEM) && req->hasArg(consts::END_TIME_ITEM)) {
res = m_provider->get_user_logs(req->getArg(consts::USER_ITEM),
boost::lexical_cast<uint64_t>(req->getArg(consts::BEGIN_TIME_ITEM)),
boost::lexical_cast<uint64_t>(req->getArg(consts::END_TIME_ITEM))); // gets user logs from historydb library
}
else
throw std::invalid_argument("Required parameters are missing");
rapidjson::Document d; // creates json document
d.SetObject();
rapidjson::Value user_logs(rapidjson::kArrayType); // creates vector value for user one's day log
for (auto it = res.begin(), end = res.end(); it != end; ++it) {
rapidjson::Value user_log(it->data<char>(), it->size(), d.GetAllocator()); // creates vector value for user one's day log
user_logs.PushBack(user_log, d.GetAllocator());
}
d.AddMember("logs", user_logs, d.GetAllocator()); // adds logs array to json document
rapidjson::StringBuffer buffer; // creates string buffer for serialized json
rapidjson::Writer<rapidjson::StringBuffer> writer(buffer); // creates json writer
d.Accept(writer); // accepts writer by json document
auto json = buffer.GetString();
m_logger->debug("Result json: %s\n", json);
req->setHeader("Content-Length", boost::lexical_cast<std::string>(buffer.Size()));
stream << json; // writes result json to fastcgi stream
req->setStatus(200);
}
catch(ioremap::elliptics::error&) {
req->setHeader("Content-Length", "0");
req->setStatus(500);
}
catch(...) {
req->setHeader("Content-Length", "0");
req->setStatus(400);
}
}
void sys_ipc(uint32_t *param1)
{
/* TODO: Checking of recv-mask */
tcb_t *to_thr = NULL;
l4_thread_t to_tid = param1[REG_R0], from_tid = param1[REG_R1];
uint32_t timeout = param1[REG_R2];
if (to_tid == L4_NILTHREAD &&
from_tid == L4_NILTHREAD) {
caller->state = T_INACTIVE;
if (timeout)
sys_ipc_timeout(timeout);
return;
}
if (to_tid != L4_NILTHREAD) {
to_thr = thread_by_globalid(to_tid);
if (to_tid == TID_TO_GLOBALID(THREAD_LOG)) {
user_log(caller);
caller->state = T_RUNNABLE;
return;
} else if (to_tid == TID_TO_GLOBALID(THREAD_IRQ_REQUEST)) {
user_interrupt_config(caller);
caller->state = T_RUNNABLE;
return;
} else if ((to_thr && to_thr->state == T_RECV_BLOCKED)
|| to_tid == caller->t_globalid) {
/* To thread who is waiting for us or sends to myself */
do_ipc(caller, to_thr);
return;
} else if (to_thr && to_thr->state == T_INACTIVE &&
GLOBALID_TO_TID(to_thr->utcb->t_pager) == GLOBALID_TO_TID(caller->t_globalid)) {
if (ipc_read_mr(caller, 0) == 0x00000005) {
/* mr1: thread func, mr2: stack addr, mr3: stack size*/
/* mr4: thread entry, mr5: thread args */
/* thread start protocol */
memptr_t sp = ipc_read_mr(caller, 2);
size_t stack_size = ipc_read_mr(caller, 3);
uint32_t regs[4]; /* r0, r1, r2, r3 */
dbg_printf(DL_IPC, "IPC: %t thread start\n", to_tid);
to_thr->stack_base = sp - stack_size;
to_thr->stack_size = stack_size;
regs[REG_R0] = (uint32_t)&kip;
regs[REG_R1] = (uint32_t)to_thr->utcb;
regs[REG_R2] = ipc_read_mr(caller, 4);
regs[REG_R3] = ipc_read_mr(caller, 5);
thread_init_ctx((void *) sp, (void *) ipc_read_mr(caller, 1),
regs, to_thr);
caller->state = T_RUNNABLE;
/* Start thread */
to_thr->state = T_RUNNABLE;
return;
} else {
do_ipc(caller, to_thr);
to_thr->state = T_INACTIVE;
return;
}
} else {
/* No waiting, block myself */
caller->state = T_SEND_BLOCKED;
caller->utcb->intended_receiver = to_tid;
dbg_printf(DL_IPC, "IPC: %t sending\n", caller->t_globalid);
if (timeout)
sys_ipc_timeout(timeout);
return;
}
}
if (from_tid != L4_NILTHREAD) {
tcb_t *thr = NULL;
if (from_tid == L4_ANYTHREAD) {
int i;
/* Find out if there is any sending thread waiting for caller */
for (i = 1; i < thread_count; ++i) {
thr = thread_map[i];
if (thr->state == T_SEND_BLOCKED &&
thr->utcb->intended_receiver == caller->t_globalid) {
do_ipc(thr, caller);
return;
}
}
} else if (from_tid != TID_TO_GLOBALID(THREAD_INTERRUPT)) {
thr = thread_by_globalid(from_tid);
if (thr->state == T_SEND_BLOCKED &&
thr->utcb->intended_receiver == caller->t_globalid) {
do_ipc(thr, caller);
return;
}
}
/* Only receive phases, simply lock myself */
caller->state = T_RECV_BLOCKED;
caller->ipc_from = from_tid;
if (from_tid == TID_TO_GLOBALID(THREAD_INTERRUPT)) {
/* Threaded interrupt is ready */
user_interrupt_handler_update(caller);
}
if (timeout)
sys_ipc_timeout(timeout);
dbg_printf(DL_IPC, "IPC: %t receiving\n", caller->t_globalid);
return;
}
caller->state = T_SEND_BLOCKED;
}
/* MICO user callback: Restore default configuration provided by user
* called when Easylink buttion long pressed
*/
void userRestoreDefault_callback(mico_Context_t *mico_context)
{
user_log("INFO: restore user configuration.");
//userParams_RestoreDefault(mico_context, &g_user_context);
}
