// 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;
}
