// recv msg from queue OSStatus MicoFogCloudMsgRecv(mico_Context_t* const context, fogcloud_msg_t **msg, uint32_t timeout_ms) { fogcloud_log_trace(); OSStatus err = kUnknownErr; if(NULL == msg){ return kParamErr; } if(NULL != msg_recv_queue){ mico_rtos_lock_mutex(&msg_recv_queue_mutex); if(mico_rtos_is_queue_empty(&msg_recv_queue)){ mico_rtos_unlock_mutex(&msg_recv_queue_mutex); return kUnderrunErr; } err = mico_rtos_pop_from_queue(&msg_recv_queue, msg, timeout_ms); // just pop msg pointer from queue mico_rtos_unlock_mutex(&msg_recv_queue_mutex); if(kNoErr == err){ total_recv_buf_len -= (sizeof(fogcloud_msg_t) - 1 + (*msg)->topic_len + (*msg)->data_len); } } else{ err = kNotInitializedErr; } return err; }
int socket_queue_delete(app_context_t * const inContext, mico_queue_t *queue) { int i; socket_msg_t *msg; int ret = -1; mico_rtos_lock_mutex(&inContext->appStatus.queue_mtx); // remove queue for(i=0; i < MAX_QUEUE_NUM; i++) { if (queue == inContext->appStatus.socket_out_queue[i]) { inContext->appStatus.socket_out_queue[i] = NULL; ret = 0; } } mico_rtos_unlock_mutex(&inContext->appStatus.queue_mtx); // free queue buffer while(kNoErr == mico_rtos_pop_from_queue( queue, &msg, 0)) { socket_msg_free(msg); } // deinit queue mico_rtos_deinit_queue(queue); return ret; }
static void worker_thread_main( uint32_t arg ) { mico_worker_thread_t* worker_thread = (mico_worker_thread_t*) arg; while ( 1 ) { mico_event_message_t message; if ( mico_rtos_pop_from_queue( &worker_thread->event_queue, &message, MICO_WAIT_FOREVER ) == kNoErr ) { message.function( message.arg ); } } }
void* AaSysComReceiveHandler(SAaSysComSicad receiver, u32 timeout) { bool failed = false; SMsgInternalHeader header; if(kNoErr == mico_rtos_pop_from_queue(&msg_queue[receiver], &header, timeout)) { if(header.msg_id >= API_MESSAGE_ID_MAX) { AaSysLogPrint(LOGLEVEL_ERR, "receive message id 0x%04x failed", header.msg_id); failed = true; } if(header.target >= MsgQueue_MAX || header.sender >= MsgQueue_MAX) { AaSysLogPrint(LOGLEVEL_ERR, "receive target 0x%02x or sender 0x%02x failed", header.target, header.sender); failed = true; } SMsgHeader* msg_ptr = header.body; if(msg_ptr == NULL) { AaSysLogPrint(LOGLEVEL_ERR, "receive messgae body is NULL"); failed = true; } else if(header.body_size != (sizeof(SMsgHeader) + msg_ptr->pl_size)) { AaSysLogPrint(LOGLEVEL_ERR, "receive message body size %d is not match sizeof(SMsgHeader) %d + pl_size %d", header.body_size, sizeof(SMsgHeader), msg_ptr->pl_size); failed = true; } if(failed == true) { if(header.body != NULL) free(header.body); return NULL; } AaSysLogPrint(LOGLEVEL_DBG, "receive message id 0x%04x from %s success", header.msg_id, AaSysComPrintThreadName(header.sender)); return (void*)header.body; } else { return NULL; } }
OSStatus SysComHandleMsg(void* msg, SthreadId tid, u32 timeout_ms) { OSStatus err = kUnknownErr; void* queue_msg = NULL; mico_rtos_lock_mutex(&SysComMutex); err = mico_rtos_pop_from_queue(&SysComQueue[tid], &queue_msg, timeout_ms); if(err != kNoErr) { // SysCom_ERR("SysComHandleMsg: Receive queue_msg failed with err(%d)", err); } else { SysCom_DBG("SysComHandleMsg: msg(value: 0x%08X, addr: 0x%08X)", (addP_t)msg, (addP_t)&msg); SysCom_DBG("SysComHandleMsg: queue_msg(value: 0x%08X, addr: 0x%08X) pop from SysComQueue[%d] successfully", (addP_t)queue_msg, (addP_t)&queue_msg, tid); *(addP_t*)msg = (addP_t)queue_msg; SysCom_DBG("SysComHandleMsg: msg(value: 0x%08X, addr: 0x%08X)", (addP_t)msg, (addP_t)&msg); SysCom_DBG("SysComHandleMsg: queue_msg(value: 0x%08X, addr: 0x%08X)", (addP_t)queue_msg, (addP_t)&queue_msg); } mico_rtos_unlock_mutex(&SysComMutex); return err; }
// handle cloud msg here, for example: send to USART or echo to cloud OSStatus MicoFogCloudCloudMsgProcess(mico_Context_t* context, const char* topic, const unsigned int topicLen, unsigned char *inBuf, unsigned int inBufLen) { fogcloud_log_trace(); OSStatus err = kUnknownErr; uint32_t real_msg_len = 0; // push msg into queue fogcloud_msg_t *real_msg; fogcloud_msg_t *p_tem_msg = NULL; // msg pointer real_msg_len = sizeof(fogcloud_msg_t) + topicLen + inBufLen; if(FOGCLOUD_TOTAL_BUF_LENGTH < (total_recv_buf_len + real_msg_len)){ return kNoMemoryErr; } real_msg = (fogcloud_msg_t*)malloc(real_msg_len); if (real_msg == NULL){ return kNoMemoryErr; } total_recv_buf_len += real_msg_len; memset(real_msg, '\0', sizeof(real_msg)); real_msg->topic_len = topicLen; real_msg->data_len = inBufLen; memcpy(real_msg->data, topic, topicLen); memcpy(real_msg->data + topicLen, inBuf, inBufLen); //memcpy(real_msg->data + topicLen + inBufLen, '\0', 1); if(NULL != msg_recv_queue){ mico_rtos_lock_mutex(&msg_recv_queue_mutex); if(mico_rtos_is_queue_full(&msg_recv_queue)){ fogcloud_log("WARNGING: FogCloud msg overrun, abandon old messages!"); err = mico_rtos_pop_from_queue(&msg_recv_queue, &p_tem_msg, 0); // just pop old msg pointer from queue if(kNoErr == err){ if(NULL != p_tem_msg){ // delete msg, free msg memory free(p_tem_msg); p_tem_msg = NULL; } } else{ mico_rtos_unlock_mutex(&msg_recv_queue_mutex); fogcloud_log("WARNGING: FogCloud msg overrun, abandon current message!"); if(NULL != real_msg){ // queue full, new msg abandoned free(real_msg); real_msg = NULL; } return kOverrunErr; } } // insert a msg into recv queue if (kNoErr != mico_rtos_push_to_queue(&msg_recv_queue, &real_msg, 0)) { // just push msg pointer in queue free(real_msg); real_msg = NULL; err = kWriteErr; } else{ err = kNoErr; } mico_rtos_unlock_mutex(&msg_recv_queue_mutex); } else{ if(NULL != real_msg){ free(real_msg); real_msg = NULL; } return kNotInitializedErr; } return err; }
void localTcpClient_thread(void *inFd) { OSStatus err; int clientFd = *(int *)inFd; uint8_t *inDataBuffer = NULL; int len; int len_temp; fd_set readfds; fd_set writeSet; struct timeval_t t; int eventFd = -1; mico_queue_t queue; socket_msg_t *msg; int sent_len, errno; inDataBuffer = malloc(wlanBufferLen); require_action(inDataBuffer, exit, err = kNoMemoryErr); err = socket_queue_create(context, &queue); require_noerr( err, exit ); eventFd = mico_create_event_fd(queue); if (eventFd < 0) { server_log("create event fd error"); goto exit_with_queue; } t.tv_sec = 4; t.tv_usec = 0; while(1){ FD_ZERO(&readfds); FD_SET(clientFd, &readfds); FD_SET(eventFd, &readfds); select(24, &readfds, NULL, NULL, &t); /* send UART data */ if (FD_ISSET( eventFd, &readfds )) { // have data and can write FD_ZERO(&writeSet ); FD_SET(clientFd, &writeSet ); t.tv_usec = 100*1000; // max wait 100ms. select(1, NULL, &writeSet, NULL, &t); if((FD_ISSET( clientFd, &writeSet )) && (kNoErr == mico_rtos_pop_from_queue( &queue, &msg, 0))) { sent_len = write(clientFd, msg->data, msg->len); if (sent_len <= 0) { len = sizeof(errno); getsockopt(clientFd, SOL_SOCKET, SO_ERROR, &errno, &len); socket_msg_free(msg); server_log("write error, fd: %d, errno %d", clientFd, errno ); if (errno != ENOMEM) { goto exit_with_queue; } } else { socket_msg_free(msg); } } } /*Read data from tcp clients and process these data using HA protocol */ if (FD_ISSET(clientFd, &readfds)) { len = recv(clientFd, inDataBuffer, wlanBufferLen, 0); len_temp=len; tcp_date_num+=len; require_action_quiet(len>0, exit_with_queue, err = kConnectionErr); // sppWlanCommandProcess(inDataBuffer, &len, clientFd, context); // MicoUartSend(MFG_TEST, inDataBuffer, len_temp);//wcz wcz_add } } exit_with_queue: len = sizeof(errno); getsockopt(clientFd, SOL_SOCKET, SO_ERROR, &errno, &len); server_log("Exit: Client exit with err = %d, socket errno %d", err, errno); if (eventFd >= 0) { mico_delete_event_fd(eventFd); } socket_queue_delete(context, &queue); exit: SocketClose(&clientFd); if(inDataBuffer) free(inDataBuffer); mico_rtos_delete_thread(NULL); return; }
void remoteTcpClient_thread(void *inContext) { client_log_trace(); OSStatus err = kUnknownErr; int len; mico_Context_t *Context = inContext; struct sockaddr_t addr; fd_set readfds; fd_set writeSet; char ipstr[16]; struct timeval_t t; int remoteTcpClient_fd = -1; uint8_t *inDataBuffer = NULL; int eventFd = -1; mico_queue_t queue; socket_msg_t *msg; LinkStatusTypeDef wifi_link; int sent_len, errno; mico_rtos_init_semaphore(&_wifiConnected_sem, 1); /* Regisist notifications */ err = MICOAddNotification( mico_notify_WIFI_STATUS_CHANGED, (void *)clientNotify_WifiStatusHandler ); require_noerr( err, exit ); inDataBuffer = malloc(wlanBufferLen); require_action(inDataBuffer, exit, err = kNoMemoryErr); err = micoWlanGetLinkStatus( &wifi_link ); require_noerr( err, exit ); if( wifi_link.is_connected == true ) _wifiConnected = true; while(1) { if(remoteTcpClient_fd == -1 ) { if(_wifiConnected == false){ require_action_quiet(mico_rtos_get_semaphore(&_wifiConnected_sem, 200000) == kNoErr, Continue, err = kTimeoutErr); } err = gethostbyname((char *)Context->flashContentInRam.appConfig.remoteServerDomain, (uint8_t *)ipstr, 16); require_noerr(err, ReConnWithDelay); remoteTcpClient_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); addr.s_ip = inet_addr(ipstr); addr.s_port = Context->flashContentInRam.appConfig.remoteServerPort; err = connect(remoteTcpClient_fd, &addr, sizeof(addr)); require_noerr_quiet(err, ReConnWithDelay); client_log("Remote server connected at port: %d, fd: %d", Context->flashContentInRam.appConfig.remoteServerPort, remoteTcpClient_fd); err = socket_queue_create(Context, &queue); require_noerr( err, exit ); eventFd = mico_create_event_fd(queue); if (eventFd < 0) { client_log("create event fd error"); socket_queue_delete(Context, &queue); goto ReConnWithDelay; } }else{ FD_ZERO(&readfds); FD_SET(remoteTcpClient_fd, &readfds); FD_SET(eventFd, &readfds); FD_ZERO(&writeSet ); FD_SET(remoteTcpClient_fd, &writeSet ); t.tv_sec = 4; t.tv_usec = 0; select(1, &readfds, &writeSet, NULL, &t); /* send UART data */ if ((FD_ISSET( eventFd, &readfds )) && (FD_ISSET(remoteTcpClient_fd, &writeSet ))) {// have data and can write if (kNoErr == mico_rtos_pop_from_queue( &queue, &msg, 0)) { sent_len = write(remoteTcpClient_fd, msg->data, msg->len); if (sent_len <= 0) { len = sizeof(errno); getsockopt(remoteTcpClient_fd, SOL_SOCKET, SO_ERROR, &errno, &len); socket_msg_free(msg); if (errno != ENOMEM) { client_log("write error, fd: %d, errno %d", remoteTcpClient_fd,errno ); goto ReConnWithDelay; } } else { socket_msg_free(msg); } } } /*recv wlan data using remote client fd*/ if (FD_ISSET(remoteTcpClient_fd, &readfds)) { len = recv(remoteTcpClient_fd, inDataBuffer, wlanBufferLen, 0); if(len <= 0) { client_log("Remote client closed, fd: %d", remoteTcpClient_fd); goto ReConnWithDelay; } sppWlanCommandProcess(inDataBuffer, &len, remoteTcpClient_fd, Context); } Continue: continue; ReConnWithDelay: if (eventFd >= 0) { mico_delete_event_fd(eventFd); eventFd = -1; socket_queue_delete(Context, &queue); } if(remoteTcpClient_fd != -1){ SocketClose(&remoteTcpClient_fd); } sleep(CLOUD_RETRY); } } exit: if(inDataBuffer) free(inDataBuffer); client_log("Exit: Remote TCP client exit with err = %d", err); mico_rtos_delete_thread(NULL); return; }