/*---------------------------------------------------------------------------------------------------------*/ static uint8_t receiving_data(void) { size_t total_length; // uint8_t *pBufferStart; //size_t newStartPos; ioctl_get_data_buffer_t data_buffer_info; DEV_IOCTL(server_device, IOCTL_GET_AND_LOCK_DATA_BUFFER , &data_buffer_info); total_length=data_buffer_info.TotalLength; // lastTotSize=total_length; // lastStartPos=newStartPos; // PRINTF_DBG("-tot_size=%d ,newStartPos=%d\r\n" , total_length,newStartPos ); if(total_length < leftDataToReceive) { // PRINT_DATA_DBG(data_buffer_info.pBufferStart , total_length ); leftDataToReceive -= total_length; DEV_IOCTL(server_device, IOCTL_SET_BYTES_CONSUMED_IN_DATA_BUFFER , &total_length); SystemTick_API_StartTimeoutTimer(timeoutTimer,ESP8266_TIMEOUT); return 0; } else { // PRINT_DATA_DBG(data_buffer_info.pBufferStart , leftDataToReceive ); DEV_IOCTL(server_device, IOCTL_SET_BYTES_CONSUMED_IN_DATA_BUFFER , &leftDataToReceive); currentState = ESP8266_State_Wait_For_Receiving_Data_Complete; leftDataToReceive = 0; return 1; } return 0; }
/*---------------------------------------------------------------------------------------------------------*/ uint8_t LM35_ioctl( void * const aHandle ,const uint8_t aIoctl_num , void * aIoctl_param1 , void * aIoctl_param2) { switch(aIoctl_num) { #if LM35_CONFIG_NUM_OF_DYNAMIC_INSTANCES > 0 case IOCTL_GET_PARAMS_ARRAY_FUNC : *(const dev_param_t**)aIoctl_param1 = LM35_Dev_Params; *(uint8_t*)aIoctl_param2 = sizeof(LM35_Dev_Params)/sizeof(dev_param_t); //size break; case IOCTL_LM35_SET_SERVER_DEVICE : INSTANCE(aHandle)->adc_server_device = DEV_OPEN((uint8_t*)aIoctl_param1); break; #endif case IOCTL_LM35_GET_CURRENT_TEMPERATURE_mC : if(NULL != INSTANCE(aHandle)->adc_server_device) { DEV_IOCTL(INSTANCE(aHandle)->adc_server_device , IOCTL_ADC_GET_CURRENT_VALUE_mV , aIoctl_param1); *(uint32_t*)aIoctl_param1 = (*(uint32_t*)aIoctl_param1)*100; } break; case IOCTL_DEVICE_START : break; default : return 1; } return 0; }
int ioctl(int fd, u_long cmd, char *arg) { #if !defined(LIBSA_NO_FD_CHECKING) || !defined(LIBSA_NO_RAW_ACCESS) struct open_file *f = &files[fd]; #endif #if !defined(LIBSA_NO_FD_CHECKING) if ((unsigned int)fd >= SOPEN_MAX || f->f_flags == 0) { errno = EBADF; return -1; } #endif #if !defined(LIBSA_NO_RAW_ACCESS) if (f->f_flags & F_RAW) { errno = DEV_IOCTL(f->f_dev)(f, cmd, arg); if (errno) return -1; return 0; } #endif errno = EIO; return -1; }
/*---------------------------------------------------------------------------------------------------------*/ static uint8_t ESP8266_ioctl(void * const aHandle ,const uint8_t aIoctl_num , void * aIoctl_param1 , void * aIoctl_param2) { xMessage_t queueMsg; uint32_t retVal; uint32_t param_len; retVal = 0 ; switch(aIoctl_num) { case IOCTL_GET_PARAMS_ARRAY_FUNC : *(const dev_param_t**)aIoctl_param1 = ESP8266_Dev_Params; *(uint8_t*)aIoctl_param2 = sizeof(ESP8266_Dev_Params)/sizeof(dev_param_t); //size break; case IOCTL_SET_ISR_CALLBACK_DEV : client_device = (pdev_descriptor)aIoctl_param1; break; case IOCTL_ESP8266_SET_SERVER_DEVICE : server_device = DEV_OPEN((uint8_t*)aIoctl_param1); if (NULL!=server_device) { DEV_IOCTL(server_device,IOCTL_SET_ISR_CALLBACK_DEV, this_dev); } break; case IOCTL_ESP8266_SET_SSID_NAME : param_len = strnlen((char*)aIoctl_param1,MAX_SSID_NAME_LEN+1) + 1; // +1 for '\0' termination if((MAX_SSID_NAME_LEN+1) < param_len) return 1; memcpy(ssid_name,(uint8_t*)aIoctl_param1,param_len); break; case IOCTL_ESP8266_SET_SSID_PSWRD : param_len = strnlen((char*)aIoctl_param1,MAX_SSID_PSWRD_LEN+1) + 1; // +1 for '\0' termination if((MAX_SSID_PSWRD_LEN+1) < param_len) return 1; memcpy(ssid_pswrd,(uint8_t*)aIoctl_param1,param_len); break; case IOCTL_ESP8266_SET_SSID_NAME_REDANDENCY : param_len = strnlen((char*)aIoctl_param1,MAX_SSID_NAME_LEN+1) + 1; // +1 for '\0' termination if((MAX_SSID_NAME_LEN+1) < param_len) return 1; memcpy(ssid_name_redandency,(uint8_t*)aIoctl_param1,param_len); break; case IOCTL_ESP8266_SET_SSID_PSWRD_REDANDENCY : param_len = strnlen((char*)aIoctl_param1,MAX_SSID_PSWRD_LEN+1) + 1; // +1 for '\0' termination if((MAX_SSID_PSWRD_LEN+1) < param_len) return 1; memcpy(ssid_pswrd_redandency,(uint8_t*)aIoctl_param1,param_len); break; case IOCTL_ESP8266_SOCKET_CLOSE : queueMsg.type = CLOSE_SOCKET; queueMsg.msg_data.Msg_close_socket.socket = ((pdev_descriptor)aIoctl_param1)->handle; retVal = send_message_and_wait(&queueMsg); break; case IOCTL_ESP8266_SOCKET_OPEN: queueMsg.type = OPEN_SOCKET; queueMsg.msg_data.Msg_open_socket.socket = ((ioctl_socket_open_t*)aIoctl_param1)->new_socket_descriptor; queueMsg.msg_data.Msg_open_socket.ip_strs = ((ioctl_socket_open_t*)aIoctl_param1)->strIP; queueMsg.msg_data.Msg_open_socket.port = ((ioctl_socket_open_t*)aIoctl_param1)->strPort; retVal = send_message_and_wait(&queueMsg); break; case IOCTL_ESP8266_GET_IP: queueMsg.type = GET_IP; queueMsg.msg_data.Msg_getIP.IPstr = (uint8_t*)aIoctl_param1; retVal = send_message_and_wait(&queueMsg); break; case IOCTL_DEVICE_START : ESP8266_Start(); break; default : return 1; } return retVal; }
/*---------------------------------------------------------------------------------------------------------*/ static void ESP8266_Task( void *pvParameters ) { xMessage_t xRxedMessage; // ESP8266_Instance_t *pInstance=(ESP8266_Instance_t*)pvParameters; size_t data_left_in_buffer,isMessageRecieved; currentState = ESP8266_State_StartReset; // data_used_in_buffer_info.BytesWasTested=0; for( ;; ) { isMessageRecieved = xQueueReceive( xQueue, &( xRxedMessage ), ( TickType_t )1000/* portMAX_DELAY*/ ) ; data_left_in_buffer=1; while (data_left_in_buffer) { data_left_in_buffer = 0; if( isMessageRecieved ) { // PRINTF_DBG("---ESP msg type= %d , currState=%d\r\n" , xRxedMessage.type,currentState); if(DATA_FROM_UART == xRxedMessage.type) { if(ESP8266_State_Receiving_Data == currentState) { data_left_in_buffer = receiving_data(); } else { data_left_in_buffer = parse_incoming_data(); } // PRINTF_DBG("---ESP dataLeft =%d, currState=%d\r\n" , data_left_in_buffer ,currentState); DEV_IOCTL(server_device, IOCTL_SET_UNLOCK_DATA_BUFFER , (void*)0); } else { // PRINTF_DBG("---ESP msg pend= %d \r\n" , xRxedMessage.type); memcpy(&pendingMessage,&xRxedMessage,sizeof(xMessage_t)); isMessagePending=1; } } else { if(ESP8266_State_Idle != currentState) { if(SystemTick_API_IsTimeoutTimerExpired(timeoutTimer)) { PRINTF_DBG( "--esp timeout crSt=%d\r\n",currentState); switch(currentState) { case ESP8266_State_StartReset : DEV_IOCTL(server_device,IOCTL_SET_ISR_CALLBACK_DEV, NULL);//skip garbage on uart vTaskDelay( 1 ); send_to_chip((uint8_t*) ESP8266_RESET_STR , sizeof(ESP8266_RESET_STR)-1); DEV_IOCTL(server_device,IOCTL_SET_ISR_CALLBACK_DEV, this_dev); SystemTick_API_StartTimeoutTimer(timeoutTimer,10000); currentState = ESP8266_State_Resetting; break; case ESP8266_State_Resetting : currentState = ESP8266_State_Setting_Mode ; send_to_chip( (uint8_t*)ESP8266_ECHO_OFF , sizeof(ESP8266_ECHO_OFF)-1); vTaskDelay( 1 ); send_to_chip( (uint8_t*)ESP8266_SET_MODE_STR , sizeof(ESP8266_SET_MODE_STR)-1); SystemTick_API_StartTimeoutTimer(timeoutTimer,2); break; case ESP8266_State_Setting_AP: send_str_to_chip( (uint8_t*)ESP8266_CONNECT_TO_AP_STR ); send_str_to_chip( ssid_name_redandency ); send_str_to_chip( (uint8_t*)"\",\"" ); send_str_to_chip( ssid_pswrd_redandency ); send_str_to_chip( (uint8_t*)"\"\r\n" ); currentState = ESP8266_State_Setting_Redundent_Ap ; SystemTick_API_StartTimeoutTimer(timeoutTimer,AP_CONNECT_TIMEOUT); break; case ESP8266_State_Setting_Mode: case ESP8266_State_Setting_Redundent_Ap : send_str_to_chip( (uint8_t*)ESP8266_CONNECT_TO_AP_STR ); send_str_to_chip( ssid_name ); send_str_to_chip( (uint8_t*)"\",\"" ); send_str_to_chip( ssid_pswrd ); send_str_to_chip( (uint8_t*)"\"\r\n" ); currentState = ESP8266_State_Setting_AP ; SystemTick_API_StartTimeoutTimer(timeoutTimer,AP_CONNECT_TIMEOUT); break; case ESP8266_State_Receiving_Data: currentState = returnFromDataReceiveState ; SystemTick_API_StartTimeoutTimer(timeoutTimer,ESP8266_TIMEOUT); break; case ESP8266_State_Wait_For_Send_Ready : case ESP8266_State_Wait_Send_Complete : case ESP8266_State_Wait_For_IP : case ESP8266_State_Openning_Socket : case ESP8266_State_Closing_Socket : lCurrError = 1; lRequest_done=1; currentState = ESP8266_State_Idle; break ; default: break ; } } } } if(isMessagePending && (ESP8266_State_Idle == currentState)) { process_message(); isMessagePending=0; } }// end of while(data_left_in_buffer) #if (1==INCLUDE_uxTaskGetStackHighWaterMark ) { static size_t stackLeft,minStackLeft=0xffffffff; stackLeft = uxTaskGetStackHighWaterMark( NULL ); if(minStackLeft > stackLeft) { minStackLeft = stackLeft; PRINTF_DBG("%s stack left = %d\r\n" , __FUNCTION__ ,minStackLeft); } } #endif } }
/*---------------------------------------------------------------------------------------------------------*/ static uint8_t parse_incoming_data(/*const uint8_t *str_to_seek,uint16_t str_to_seek_len ,uint8_t **start_of_found_str ,uint16_t *length_of_found_str*/) { uint8_t validCommadFound; size_t curr_buff_pos; size_t total_length; uint8_t *pBufferStart; ioctl_get_data_buffer_t data_buffer_info; uint8_t *pStartOfHttpRequest; callback_new_data_from_socket_t newDataFromSocketInfo; uint32_t timeout ; size_t lastTestedBytePos=0; // *start_of_found_str = NULL; // *length_of_found_str =0 ; // PRINTF_DBG("s0=%d",currentState); DEV_IOCTL(server_device, IOCTL_GET_AND_LOCK_DATA_BUFFER , &data_buffer_info); total_length = data_buffer_info.TotalLength; pBufferStart= data_buffer_info.pBufferStart; if(data_buffer_info.bufferWasOverflowed) { curr_buff_pos = 0; } else { curr_buff_pos = lastTestedBytePos; } // lastTotSize=total_length; // lastStartPos=data_buffer_info->NewStartPos; // PRINTF_DBG("tot_size=%d ,newStartPos=%d\r\n" , total_length,newStartPos ); while(curr_buff_pos < total_length) { validCommadFound = 0; while ((curr_buff_pos < total_length) && (0 == validCommadFound)) { switch(pBufferStart[curr_buff_pos]) { case '\r': /* Enter */ case '\n': //PRINT_DATA_DBG((uint8_t*)"\r\n" , 2 ); validCommadFound=1; break; default : //PRINT_DATA_DBG(&pBufferStart[curr_buff_pos] , 1 ); break; } curr_buff_pos++; } if(1 == validCommadFound) { if(ESP8266_State_Setting_Mode < currentState) { if( (ESP8266_State_Setting_Timeout < currentState) && (0==memcmp("+IPD",(uint8_t*)pBufferStart,4))) { leftDataToReceive = atoi((char*)&pBufferStart[7]); pStartOfHttpRequest = ((uint8_t*)memchr((char*)pBufferStart,':',curr_buff_pos)) +1; if((NULL != pStartOfHttpRequest) && (curr_buff_pos > 8) && (0 < leftDataToReceive) && (4096 > leftDataToReceive) && (pBufferStart[5] >= '0')&&(pBufferStart[5]<='3')) { // currSocket=&socketHandles[startOfString[5]-'0']; // PRINTF_DBG( (uint8_t*)"---ESP2 socket=%d\r\n",startOfString[5]-'0'); newDataFromSocketInfo.pData = pStartOfHttpRequest; newDataFromSocketInfo.DataLen = curr_buff_pos -((int)pStartOfHttpRequest - (int)pBufferStart); if(NULL!=client_device) { DEV_CALLBACK_2_PARAMS( client_device,CALLBACK_NEW_DATA_ARRIVED , &sockets[pBufferStart[5]-'0'] , &newDataFromSocketInfo) ; } returnFromDataReceiveState = currentState; currentState = ESP8266_State_Receiving_Data; SystemTick_API_StartTimeoutTimer(timeoutTimer,ESP8266_TIMEOUT); } DEV_IOCTL(server_device, IOCTL_SET_BYTES_CONSUMED_IN_DATA_BUFFER , (void*)((size_t)pStartOfHttpRequest - (size_t)pBufferStart)); return 1; } if(ESP8266_State_Idle != currentState) { // *start_of_found_str = (uint8_t*)pBufferStart; // *length_of_found_str = curr_buff_pos ; // PRINTF_DBG("s=%d\r\n",currentState); timeout = ESP8266_TIMEOUT; switch(currentState) { case ESP8266_State_Wait_For_IP: if((curr_buff_pos > 5)&&(isdigit(*pBufferStart))) { memcpy(pendingMessage.msg_data.Msg_getIP.IPstr,pBufferStart , curr_buff_pos); pendingMessage.msg_data.Msg_getIP.IPstr[curr_buff_pos]=0; currentState = ESP8266_State_Wait_For_IP_Complete; } break; case ESP8266_State_Wait_For_IP_Complete: if (0==memcmp("OK",(uint8_t*)pBufferStart,sizeof("OK")-1)) { lRequest_done = 1; currentState = ESP8266_State_Idle; } break; case ESP8266_State_Wait_Send_Complete: if (0==memcmp("SEND OK",(uint8_t*)pBufferStart,sizeof("SEND OK")-1)) { lRequest_done = 1; currentState = ESP8266_State_Idle; } else if (0==memcmp("link is not",(uint8_t*)pBufferStart,sizeof("link is not")-1)) { lRequest_done = 1; lCurrError = 1; currentState = ESP8266_State_Idle; } break; case ESP8266_State_Openning_Socket : if (0==memcmp("OK",(uint8_t*)pBufferStart,sizeof("OK")-1)) { lRequest_done = 1; currentState = ESP8266_State_Idle; } else if ((0==memcmp("ERROR",(uint8_t*)pBufferStart,sizeof("ERROR")-1)) || (0==memcmp("ALREAY CONN",(uint8_t*)pBufferStart,sizeof("ALREAY CONN")-1))) { lCurrError = 1; lRequest_done = 1; currentState = ESP8266_State_Idle; } else if (0==memcmp("Link typ ERROR",(uint8_t*)pBufferStart,sizeof("Link typ ERROR")-1)) { lCurrError = 1; lRequest_done = 1; currentState = ESP8266_State_StartReset; } break; case ESP8266_State_Closing_Socket : if (0==memcmp("OK",(uint8_t*)pBufferStart,sizeof("OK")-1)) { lRequest_done = 1; currentState = ESP8266_State_Idle; } break; case ESP8266_State_Wait_For_Setting_Timeout_Complete : if (0==memcmp("OK",(uint8_t*)pBufferStart,sizeof("OK")-1)) { currentState = ESP8266_State_Idle; } break; case ESP8266_State_Setting_AP: if (0==memcmp("OK",(uint8_t*)pBufferStart,sizeof("OK")-1)) { send_to_chip( (uint8_t*)ESP8266_SET_MULTIPLE_CONNECTIONS_STR , sizeof(ESP8266_SET_MULTIPLE_CONNECTIONS_STR)-1); currentState = ESP8266_State_Setting_Connection_Type; PRINTF_DBG("wifi connected \r\n"); } else if (0==memcmp("FAIL",(uint8_t*)pBufferStart,sizeof("FAIL")-1)) { send_str_to_chip( (uint8_t*)ESP8266_CONNECT_TO_AP_STR ); send_str_to_chip( ssid_name_redandency ); send_str_to_chip( (uint8_t*)"\",\"" ); send_str_to_chip( ssid_pswrd_redandency ); send_str_to_chip( (uint8_t*)"\"\r\n" ); currentState = ESP8266_State_Setting_Redundent_Ap ; } timeout = AP_CONNECT_TIMEOUT; break; case ESP8266_State_Setting_Redundent_Ap: if (0==memcmp("OK",(uint8_t*)pBufferStart,sizeof("OK")-1)) { send_to_chip( (uint8_t*)ESP8266_SET_MULTIPLE_CONNECTIONS_STR , sizeof(ESP8266_SET_MULTIPLE_CONNECTIONS_STR)-1); currentState = ESP8266_State_Setting_Connection_Type; PRINTF_DBG("wifi connected \r\n"); } else if (0==memcmp("FAIL",(uint8_t*)pBufferStart,sizeof("FAIL")-1)) { send_str_to_chip( (uint8_t*)ESP8266_CONNECT_TO_AP_STR ); send_str_to_chip( ssid_name ); send_str_to_chip( (uint8_t*)"\",\"" ); send_str_to_chip( ssid_pswrd ); send_str_to_chip( (uint8_t*)"\"\r\n" ); currentState = ESP8266_State_Setting_AP ; } timeout = AP_CONNECT_TIMEOUT; break; case ESP8266_State_Setting_Connection_Type: if (0==memcmp("OK",(uint8_t*)pBufferStart,sizeof("OK")-1)) { send_to_chip( (uint8_t*)ESP8266_SET_HTTP_SERVER_STR , sizeof(ESP8266_SET_HTTP_SERVER_STR)-1); currentState = ESP8266_State_Setting_Timeout; } break; case ESP8266_State_Setting_Timeout: if (0==memcmp("OK",(uint8_t*)pBufferStart,sizeof("OK")-1)) { send_to_chip( (uint8_t*)ESP8266_SET_SERVER_TIMEOUT_STR , sizeof(ESP8266_SET_SERVER_TIMEOUT_STR)-1); currentState = ESP8266_State_Wait_For_Setting_Timeout_Complete; } break; case ESP8266_State_Wait_For_Receiving_Data_Complete: if (0==memcmp("OK",(uint8_t*)pBufferStart,sizeof("OK")-1)) { currentState = returnFromDataReceiveState ; // PRINTF_DBG("receive_done st=%d\r\n",currentState); } break; default : break; } SystemTick_API_StartTimeoutTimer(timeoutTimer , timeout); DEV_IOCTL(server_device, IOCTL_SET_BYTES_CONSUMED_IN_DATA_BUFFER , (void*)curr_buff_pos); return 1; } } pBufferStart=&pBufferStart[curr_buff_pos]; // PRINTF_DBG("tot_size2=%d currPpos=%d\r\n" , total_length ,curr_buff_pos); total_length -= curr_buff_pos; while (( total_length) && (('\r'==*pBufferStart)||('\n'==*pBufferStart))) { // PRINTF_DBG("1 \n"); pBufferStart++; total_length--; curr_buff_pos++; //PRINT_DATA_DBG( &pBufferStart[curr_buff_pos],1); } DEV_IOCTL(server_device, IOCTL_SET_BYTES_CONSUMED_IN_DATA_BUFFER , (void*) curr_buff_pos); curr_buff_pos=0; } else { if(ESP8266_State_Wait_For_Send_Ready == currentState) { if (0==memcmp(">",(uint8_t*)pBufferStart,sizeof(">")-1)) { send_to_chip( pendingMessage.msg_data.Msg_send_data_to_socket.data , pendingMessage.msg_data.Msg_send_data_to_socket.data_length); currentState = ESP8266_State_Wait_Send_Complete; SystemTick_API_StartTimeoutTimer(timeoutTimer,ESP8266_TIMEOUT); DEV_IOCTL(server_device, IOCTL_SET_BYTES_CONSUMED_IN_DATA_BUFFER , (void*)1); return 1; } } } } lastTestedBytePos = curr_buff_pos; DEV_IOCTL(server_device, IOCTL_SET_BYTES_CONSUMED_IN_DATA_BUFFER , 0); return 0; }
/*---------------------------------------------------------------------------------------------------------*/ uint8_t sw_uart_wrapper_ioctl(void * const aHandle ,const uint8_t aIoctl_num , void * aIoctl_param1 , void * aIoctl_param2) { rx_int_size_t WritePos,ReadPos; #if SW_UART_WRAPPER_CONFIG_MAX_RX_BUFFER_SIZE>0 WritePos=INSTANCE(aHandle)->WritePos; ReadPos=INSTANCE(aHandle)->ReadPos; #endif switch(aIoctl_num) { #if SW_UART_WRAPPER_CONFIG_NUM_OF_DYNAMIC_INSTANCES > 0 case IOCTL_GET_PARAMS_ARRAY_FUNC : *(const dev_param_t**)aIoctl_param1 = SW_UART_WRAPPER_Dev_Params; *(uint8_t*)aIoctl_param2 = sizeof(SW_UART_WRAPPER_Dev_Params)/sizeof(dev_param_t); //size break; case IOCTL_SET_SERVER_DEVICE : INSTANCE(aHandle)->server_dev = DEV_OPEN((uint8_t*)aIoctl_param1); if (NULL!=INSTANCE(aHandle)->server_dev) { DEV_IOCTL(INSTANCE(aHandle)->server_dev,IOCTL_SET_ISR_CALLBACK_DEV, (void*)INSTANCE(aHandle)->this_dev); } break; #if SW_UART_WRAPPER_CONFIG_MAX_RX_BUFFER_SIZE>0 case IOCTL_SW_UART_WRAPPER_SET_BUFF_SIZE : INSTANCE(aHandle)->rx_buff_size = atoi((char*)aIoctl_param1); INSTANCE(aHandle)->rx_buff = (uint8_t*)malloc(INSTANCE(aHandle)->rx_buff_size); break; case IOCTL_SET_ISR_CALLBACK_DEV : INSTANCE(aHandle)->client_dev = (pdev_descriptor)aIoctl_param1; break; #endif //for SW_UART_WRAPPER_CONFIG_MAX_RX_BUFFER_SIZE>0 #endif // for SW_UART_WRAPPER_CONFIG_NUM_OF_DYNAMIC_INSTANCES > 0 #if SW_UART_WRAPPER_CONFIG_MAX_RX_BUFFER_SIZE>0 case IOCTL_GET_AND_LOCK_DATA_BUFFER : INSTANCE(aHandle)->isDataInUse=1; // should be modified first ((ioctl_get_data_buffer_t *)aIoctl_param1)->bufferWasOverflowed = INSTANCE(aHandle)->bufferWasOverflowed ; INSTANCE(aHandle)->bufferWasOverflowed = 0; ((ioctl_get_data_buffer_t *)aIoctl_param1)->TotalLength = WritePos - ReadPos; ((ioctl_get_data_buffer_t *)aIoctl_param1)->pBufferStart = &INSTANCE(aHandle)->rx_buff[ReadPos]; break; case IOCTL_SET_BYTES_CONSUMED_IN_DATA_BUFFER : INSTANCE(aHandle)->ReadPos += (size_t)aIoctl_param1; if( ReadPos > WritePos) { // should not be reached : INSTANCE(aHandle)->ReadPos = WritePos; } break; case IOCTL_SET_UNLOCK_DATA_BUFFER : INSTANCE(aHandle)->isDataInUse= 0 ; // should be modified last break; #endif // for SW_UART_WRAPPER_CONFIG_MAX_RX_BUFFER_SIZE>0 case IOCTL_SW_UART_WRAPPER_RESET : DEV_IOCTL_0_PARAMS(INSTANCE(aHandle)->server_dev,IOCTL_UART_DISABLE_TX); break; case IOCTL_SW_UART_WRAPPER_USE_TASK : INSTANCE(aHandle)->use_task_for_out = (size_t)aIoctl_param1; break; case IOCTL_DEVICE_START : os_create_task("sw_uart_wrapper_task",SW_UART_WRAPPER_Send_Task, aHandle , SW_UART_WRAPPER_CONFIG_TASK_STACK_SIZE , SW_UART_WRAPPER_CONFIG_TASK_PRIORITY); break; default : return 1; } return 0; }