// rewrite this interface by user
OSStatus MVDMsgTransformDevice2Cloud(unsigned char* inUsartString, unsigned int inUsartStringLen,
unsigned char** outJson, unsigned int* outJsonLen)
{
led_log_trace();
OSStatus err = kUnknownErr;
lm_usart_message_t usartMsg = {0};
json_object *object = NULL;
unsigned char *json_str = NULL;
if(NULL == inUsartString || inUsartStringLen <= 0
|| inUsartStringLen > sizeof(usartMsg)){
return kParamErr;
}
memcpy((void*)&usartMsg, inUsartString, inUsartStringLen);
//check response format
if( (LED_USART_MSG_HEAD != usartMsg.head) ||
(LED_USART_MSG_TAIL != usartMsg.tail) ||
(checksum(usartMsg) != usartMsg.checksum) ){
return kResponseErr;
}
// create json response to cloud
object = json_object_new_object();
require_action(object, exit, err = kNoMemoryErr);
switch(usartMsg.cmd){
case LED_RESP_SET_OK:{
json_object_object_add(object, "response",
json_object_new_string(LED_RESP_CMD_VALUE_OK));
break;
}
case LED_RESP_STATUS:{
json_object_object_add(object, "response",
json_object_new_string(LED_RESP_CMD_VALUE_STATUS));
json_object_object_add(object, LED_PARAM_WHITE, json_object_new_int(usartMsg.param1));
json_object_object_add(object, LED_PARAM_YELLOW, json_object_new_int(usartMsg.param2));
json_object_object_add(object, LED_PARAM_BRIGHTNESS, json_object_new_int(usartMsg.param3));
break;
}
default:
break;
}
//json string need to be free by user
json_str = (unsigned char*)json_object_to_json_string(object);
*outJsonLen = strlen((char*)(json_str));
*outJson = (unsigned char*)malloc(*outJsonLen);
if(NULL == (*outJson)){
return kNoMemoryErr;
}
memcpy(*outJson, json_str, *outJsonLen);
//led_log("outJson[%d]=%.*s", *outJsonLen, *outJsonLen, *outJson);
return kNoErr;
exit:
if(NULL != object){
json_object_put(object);
object = NULL;
}
return err;
}
void led_thread(void *inContext)
{
led_log_trace();
nearair_Context_t *airContext = inContext;
char mode_old;
char airclass_old;
bsp_InitLed();
mode_old = airContext->deviceStatus.mode;
airclass_old = airContext->airStatus.airclass;
mico_init_timer(&_led_init_timer, 500,led_init_handle, inContext);
mico_init_timer(&_led_sleep_timer,20, led_sleep_handle,inContext);
while(1)
{
if(mode_old != airContext->deviceStatus.mode)
{
if(mode_old == MODE_INIT)
mico_stop_timer(&_led_init_timer);
if(mode_old == MODE_SLEEP)
mico_stop_timer(&_led_sleep_timer);
mode_old = airContext->deviceStatus.mode;
switch(mode_old)
{
case MODE_CLOSE:
set_led_color(0,0,0);
break;
case MODE_INIT:
mico_start_timer(&_led_init_timer);
break;
case MODE_SMART:
switch( airContext->airStatus.airclass )
{
case AQ_GOOD:
set_led_color(0,0,99);
break;
case AQ_SOSO:
set_led_color(99,33,0);
break;
case AQ_BAD:
set_led_color(99,0,0);
break;
default:
break;
}
break;
case MODE_SLEEP:
mico_start_timer(&_led_sleep_timer);
break;
case MODE_FLY:
set_led_color(0,99,0);
break;
default:
break;
}
}
if(mode_old == MODE_SMART)
{
if(airclass_old != airContext->airStatus.airclass)
{
airclass_old = airContext->airStatus.airclass;
switch( airclass_old )
{
case AQ_GOOD:
set_led_color(0,0,99);
break;
case AQ_SOSO:
set_led_color(99,33,0);
break;
case AQ_BAD:
set_led_color(99,0,0);
break;
default:
break;
}
}
}
if(airContext->setStatus.led_enable)
{
set_led_color(airContext->setStatus.led_r,airContext->setStatus.led_g,\
airContext->setStatus.led_b);
}
}
}
// rewrite this function by user
OSStatus MVDMsgTransformCloud2Device(unsigned char* inJsonString, unsigned int inJsonStringLen,
unsigned char** outUsartMsg, unsigned int* outUsartMsgLen)
{
led_log_trace();
OSStatus err = kUnknownErr;
bool ret = false;
ret = LedControlMsgHandler(inJsonString, inJsonStringLen);
if (ret){
err = kNoErr;
}
else
{
err = kRequestErr;
}
return err;
/*
lm_usart_message_t usartMsg = {0};
char cmdString[MAX_SIZE_CMD] = {0};
json_object *new_obj = NULL;
if(NULL == inJsonString || inJsonStringLen <= 0){
return kParamErr;
}
// USART msg head && tail
usartMsg.head = LED_USART_MSG_HEAD;
usartMsg.tail = LED_USART_MSG_TAIL;
//parse json data for USART msg cmd && params.
new_obj = json_tokener_parse((char*)inJsonString);
require_action(new_obj, exit, err = kUnknownErr);
led_log("Recv json config object=%s", json_object_to_json_string(new_obj));
json_object_object_foreach(new_obj, key, val) {
if(!strcmp(key, "cmd")){
memset(cmdString, 0, MAX_SIZE_CMD);
strncpy(cmdString, json_object_get_string(val), MAX_SIZE_CMD);
led_log("cmd=[%s]", cmdString);
}
else if( (!strcmp(key, LED_PARAM_WHITE)) || (!strcmp(key, LED_PARAM_HOUR)) ){
usartMsg.param1 = (uint8_t)json_object_get_int(val);
led_log("param1=%d", usartMsg.param1);
}
else if( (!strcmp(key, LED_PARAM_YELLOW)) || (!strcmp(key, LED_PARAM_MINUTE)) ){
usartMsg.param2 = (uint8_t)json_object_get_int(val);
led_log("param2=%d", usartMsg.param2);
}
else if( (!strcmp(key, LED_PARAM_BRIGHTNESS)) || (!strcmp(key, LED_PARAM_SECOND)) ){
usartMsg.param3 = (uint8_t)json_object_get_int(val);
led_log("param3=%d", usartMsg.param3);
}
else {
}
}
json_object_put(new_obj);
// translate cmd value
switch(getCmdNum(cmdString, strlen(cmdString))){
case 1:{ // on
usartMsg.cmd = LED_CMD_ON;
break;
}
case 2:{ // off
usartMsg.cmd = LED_CMD_OFF;
break;
}
case 3:{ // delay
usartMsg.cmd = LED_CMD_DELAY;
break;
}
case 4:{ // status
usartMsg.cmd = LED_CMD_STATUS;
break;
}
default:
err = kUnknownErr;
led_log("ERROR: unknown cmd!");
break;
}
// USART msg checksum
usartMsg.checksum = checksum(usartMsg);
*outUsartMsg = (unsigned char*)malloc(sizeof(usartMsg));
require( *outUsartMsg, exit );
memset(*outUsartMsg, 0, sizeof(usartMsg));
memcpy(*outUsartMsg, (char*)(&usartMsg), sizeof(usartMsg));
*outUsartMsgLen = sizeof(usartMsg);
err = kNoErr;
exit:
return err;
*/
}
