/* 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;
}
// get function: recv uart data
int uart_data_recv(struct mico_prop_t *prop, void *arg, void *val, uint32_t *val_len)
{
int ret = 0;
uint32_t recv_len = 0;
char string_display_on_oled[MAX_USER_UART_BUF_SIZE+1] = {'\0'};
if((NULL == val) || (NULL == val_len) || (NULL == prop) || (NULL == arg)){
return -1;
}
user_context_t *uct = (user_context_t*)arg;
// recv data from uart
memset(val, '\0', prop->maxStringLen);
recv_len = user_uartRecv((unsigned char*)val, prop->maxStringLen);
if(recv_len > 0){
*val_len = recv_len;
ret = 0;
properties_user_log("uart_data_recv: [%d][%*.s]", *val_len, *val_len, (char*)val);
// display string on OLED (max_len=32bytes)
properties_user_log("Show uart recv msg on OLED: [%d][%*.s]", *val_len, *val_len, (char*)val);
OLED_ShowString(OLED_DISPLAY_COLUMN_START, OLED_DISPLAY_ROW_2, (uint8_t*)"To Cloud: ");
memset(string_display_on_oled, ' ', MAX_USER_UART_BUF_SIZE); // clean display char
memcpy(string_display_on_oled, (uint8_t*)val, *val_len);
string_display_on_oled[MAX_USER_UART_BUF_SIZE] = '\0'; // display end
OLED_ShowString(OLED_DISPLAY_COLUMN_START, OLED_DISPLAY_ROW_3, (uint8_t*)string_display_on_oled);
ret = 0; // set always ok
uct->status.oled_keep_s = 3; // display 3s
}
else{
*val_len = 0;
ret = -1;
}
return ret;
}
/* 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;
}
/****************************************************************************
* Function : uartRecv_thread
* Description : uart Recv Thread uart 接收线程
* Input Para :
* Output Para :
* Return Value:
****************************************************************************/
void uartRecv_thread(void *inContext)
{
user_uart_log_trace();
//mico_Context_t *Context = inContext;
int recvlen;
tsSL_Message sMessage;
//OSStatus err = kUnknownErr;
uint8_t *inDataBuffer = malloc(USER_UART_ONE_PACKAGE_LENGTH); //接收数据缓冲
require(inDataBuffer, exit);
static uint8_t cmdIndex=0,msgQueIndex=0;
memset(zcbReceivedMessageQueue,0x00,ZCB_MAX_MESSAGE_QUEUES * sizeof(tsSL_Message));
while(1)
{
mico_thread_msleep(10); //延时10ms
memset(inDataBuffer,0x0,USER_UART_ONE_PACKAGE_LENGTH); //清空接收数据缓冲
recvlen = user_uartRecv(inDataBuffer, USER_UART_ONE_PACKAGE_LENGTH);//user uart 接收数据
if (recvlen <= 0)
continue;
recv_buff_parser((char*)inDataBuffer); //解析接收到的数据，把完整的数据包存储在 cmd 数组中
msgQueIndex = 0;
for(cmdIndex = 0; cmdIndex < cmdnum; cmdIndex++) //逐条处理 cmd
{
/* Initialise buffer */
sMessage.u16Type = 0x00;
/* Initialise length to large value so CRC is skipped if end received */
sMessage.u16Length = 0xFFFF;
//1.get the date from ControlBridge
if (eSL_ReadMessage(&sMessage.u16Type, &sMessage.u16Length, SL_MAX_MESSAGE_LENGTH, sMessage.au8Message,(unsigned char*)cmdbuff[cmdIndex],strlen(cmdbuff[cmdIndex])) == E_SL_OK)
{
user_uart_log("msg get,type:%d,length:%d",sMessage.u16Type,sMessage.u16Length); //消息类型
//if(0x8046 == sMessage.u16Type)
//{
//// user_uart_log("%d",msgQueIndex);
//}
//if(0x4D == sMessage.u16Type)
//{
// user_uart_log("%d",msgQueIndex);
//}
for(; msgQueIndex< ZCB_MAX_MESSAGE_QUEUES ; msgQueIndex++)
{
if(0 == zcbReceivedMessageQueue[msgQueIndex].u16Type)
{
//user_uart_log("%d saved at %d",sMessage.u16Type,msgQueIndex);
zcbReceivedMessageQueue[msgQueIndex].u16Type = sMessage.u16Type;
zcbReceivedMessageQueue[msgQueIndex].u16Length = sMessage.u16Length;
memcpy(zcbReceivedMessageQueue[msgQueIndex].au8Message,sMessage.au8Message,sMessage.u16Length);
break;
}
else
{
continue;
}
}
if(msgQueIndex == ZCB_MAX_MESSAGE_QUEUES)
user_uart_log("no space for Msg");
}
else
{
user_uart_log("msg not correct");
for(cmdIndex=0; cmdbuff[cmdnum][cmdIndex]!=0x0; cmdIndex++)
{
printf("%x ",cmdbuff[cmdnum][cmdIndex]);
}
printf("\r\n");
}
}
memset(cmdbuff[0], 0x0, sizeof(cmdbuff[0])* cmdnum);
cmdnum = 0;
}
exit:
if(inDataBuffer) free(inDataBuffer);
}
static void ControllerBusProtocolHandler(void* arg)
{
// avoid compiling warning
arg = arg;
uint16_t received_len;
AaSysLogPrint(LOGLEVEL_INF, "create controllerbus thread success");
while(1) {
received_len = user_uartRecv(recv_buffer, sizeof(SCBusHeader));
if(received_len == 0) {
AaSysLogPrint(LOGLEVEL_WRN, "do not received any header");
continue;
}
AaSysLogPrint(LOGLEVEL_DBG, "receive header length %d", received_len);
print_serial_data(recv_buffer, received_len);
if(received_len != sizeof(SCBusHeader)) {
AaSysLogPrint(LOGLEVEL_WRN, "received header length do not match");
continue;
}
SCBusHeader* header = (SCBusHeader*)recv_buffer;
// parse the header, get the data length and checksum
if(header->magic != CONTROLLERBUS_MAGIC || header->tail != CONTROLLERBUS_TAIL) {
AaSysLogPrint(LOGLEVEL_WRN, "magic 0x%02x or tail 0x%02x do not match",
header->magic, header->tail);
continue;
}
uint16_t datalen = header->datalen;
uint8_t checksum = header->checksum;
AaSysLogPrint(LOGLEVEL_DBG, "get datalen %d checksum 0x%02x", datalen, checksum);
if(datalen == 0) {
AaSysLogPrint(LOGLEVEL_WRN, "there is no data");
continue;
}
else if(datalen >= (CONTROLLERBUS_RECV_BUFFER_LENGTH - sizeof(SCBusHeader))) {
AaSysLogPrint(LOGLEVEL_WRN, "there is too much data and receive buffer %d is overflow",
CONTROLLERBUS_RECV_BUFFER_LENGTH);
continue;
}
// start to receive data
uint8_t* payload = recv_buffer + sizeof(SCBusHeader);
received_len = user_uartRecv(payload, datalen);
if(received_len == 0) {
AaSysLogPrint(LOGLEVEL_WRN, "do not received any data");
continue;
}
AaSysLogPrint(LOGLEVEL_DBG, "receive data length %d", received_len);
print_serial_data(payload, received_len);
if(received_len != datalen) {
AaSysLogPrint(LOGLEVEL_WRN, "received data length do not match");
continue;
}
#if 1
// check if data available
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 < datalen; idx++) {
data_checksum += *(payload + idx);
}
if(data_checksum != checksum) {
AaSysLogPrint(LOGLEVEL_WRN, "data checksum 0x%02x do not match received checksum 0x%02x, dropping",
data_checksum, checksum);
continue;
}
#endif
ParseControllerBus(header, payload);
AaSysLogPrint(LOGLEVEL_DBG, "parse package complete");
}
// normally should not access
AaSysLogPrint(LOGLEVEL_ERR, "some fatal error occur, thread dead");
mico_rtos_delete_thread(NULL); // delete current thread
}
