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