void esp8266_module::wifi_driver_socket_close(unsigned int sid, unsigned int reason)
{
CSTRING cmd;
CSocket* sock;
sock = alloc_sockets[sid];
if(sock)
{
if(received_data[sid])
{
delete received_data[sid];
received_data[sid] = NULL;
received_size[sid] = 0;
}
sock->sock_id = SOCKET_ID_INVALID;
if(sock->sock_state & SOCKET_OPEN)
{
sock->sock_state = SOCKET_CLOSED;
// do we have to signal it?
if((sock->res & RES_BUSY_WAITING) == RES_BUSY_WAITING)
{
//How to signal it?
sock->error = reason;
TRACE_WIFI("\r\ndisconnect %d", sid);
tsk_HND_SET_STATUS(sock, (sock->res & FLG_OK)| FLG_SIGNALED);
}
else
{
TRACE_WIFI("\r\ndisconnect %d, err %d", sid, reason);
wifi_net_error(reason);
}
}
alloc_sockets[sid] = NULL;
#if USE_GPRS_LISTEN
listen_ports[sid] = 0;
accept_id[sid] = GPRS_LEON_MAX_SOCKETS;
#endif
if(!--used_sockets)
{
if(waiting_open)
wifi_tout = 1;
else
if(drv_info->drv_data->wifi_clients > 2)
wifi_tout = 5;
else
wifi_tout = 1;
}
}
}
void esp8266_module::wifi_data_received(const char* row)
{
uint32_t id, size, len;
if(2 == tmos_sscanf(row,"+IPD,%u,%u", &id, &size))
{
if(id < WIFI_ESP8266_MAX_SOCKETS)
{
CSocket* sock = alloc_sockets[id];
if(sock && sock->sock_state == SOCKET_CONECTED)
{
if (sock && ((sock->res & RES_BUSY_WAITING) == RES_BUSY_WAITING))
{
len = min(size, sock->len);
if( rcv_hnd.tsk_read_pkt(sock->dst.as_charptr, len, GPRS_READ_TOT) == RES_OK)
{
len -= rcv_hnd.len;
sock->len -= len;
sock->dst.as_ccharptr += len;
tsk_HND_SET_STATUS(sock, RES_SIG_OK);
}
else
{
len = size;
tsk_HND_SET_STATUS(sock, RES_SIG_ERROR);
}
size -= len;
}
if(size)
{
received_data[id] = (char*)tsk_realloc(received_data[id], received_size[id]+size);
if(received_data[id])
{
if( rcv_hnd.tsk_read_pkt(received_data[id]+received_size[id], size, GPRS_READ_TOT) == RES_OK)
{
received_size[id] += size;
}
} else
{
//ops out of memory..
received_size[id] = 0;
}
}
}
if(wifi_receive_check('\r') == RES_OK)
if(wifi_receive_check('\n') == RES_OK)
{
while(1)
{
switch(wifi_receive_check('\r'))
{
case RES_OK:
wifi_receive_check('\n');
return;
case RES_EOF:
break; // received "OK or something else"
default:
return; //error
}
}
}
//flush:
// if read \r
// if read \n
// while !read \r\n
//
}
}
}
void usbdrv_thread(USB_DRV_INFO drv_info)
{
CHandle helper;
CHandle req_hnd;
USBGenericRequest request;
bool requested = false;
unsigned int sig=0;
ALLOCATE_SIGNAL(USB_DRIVER_SIG);
helper.tsk_safe_open(drv_info->info.drv_index, 0);
helper.tsk_start_command(NULL, 0);
req_hnd.tsk_safe_open(drv_info->info.drv_index, USB_DRV_MODE(EPT_0, EPT_0));
while(1)
{
sig |= tsk_get_signal(SIGNAL_ANY);
// 2) get waiting clients
if(sig & helper.signal)
{
HANDLE client;
sig ^= helper.signal;
helper.res &= ~FLG_SIGNALED;
client = (HANDLE)helper.dst.as_voidptr;
if(client)
{
RES_CODE res;
res = ((USB_API_FUNC)client->src.as_voidptr)(drv_info, client);
if(res & FLG_SIGNALED)
{
tsk_HND_SET_STATUS(client, res);
}
}
helper.tsk_start_command(NULL, 0);
}
if(sig & req_hnd.signal)
{
sig ^= req_hnd.signal;
req_hnd.res &= ~FLG_SIGNALED;
#if USB_ENABLE_DEVICE
TRACE1_USB(" | req:");
if(req_hnd.res == RES_OK)
{
drv_info->drv_data->device.RequestHandler(drv_info, &request, &req_hnd);
} else
#endif
{
TRACE_USB(" res %x", req_hnd.res);
tsk_sleep(5);
}
requested = false;
}
if(!requested)
{
#if USB_ENABLE_HOST
if(sig == USB_DRIVER_SIG)
{
if(drv_info->drv_data->otg_h_sig & OTG_H_SIG_CON)
{
do
{
sig = atomic_fetch((volatile int*)&drv_info->drv_data->otg_h_sig);
sig &= ~OTG_H_SIG_CON;
} while(atomic_store((volatile int*)&drv_info->drv_data->otg_h_sig, sig));
//wait 1s for connect
for(int retries =0; retries <10; ++retries)
{
if(drv_info->drv_data->otg_flags & USB_OTG_FLG_HOST_RST)
break;
sig = tsk_wait_signal(USB_DRIVER_SIG, 100);
if (sig)
break;
}
if( !(drv_info->drv_data->otg_h_sig & OTG_H_SIG_RST))
{
usb_api_otg_off(drv_info, NULL);
}
}
if(drv_info->drv_data->otg_h_sig & OTG_H_SIG_RST)
{
do
{
sig = atomic_fetch((volatile int*)&drv_info->drv_data->otg_h_sig);
sig &= ~OTG_H_SIG_RST;
} while(atomic_store((volatile int*)&drv_info->drv_data->otg_h_sig, sig));
if(drv_info->drv_data->otg_flags & USB_OTG_FLG_HOST_RST)
{
RES_CODE res;
// Reset requested
for(int retries =0; retries <3; ++retries)
{
tsk_sleep(100);
res = usb_host_reset_bus(drv_info, &req_hnd);
if( res == RES_OK)
break;
}
// if(res != RES_OK)
// usb_api_otg_off(drv_info, NULL);
}
}
if(drv_info->drv_data->otg_h_sig & OTG_H_SIG_RESUME)
{
do
{
sig = atomic_fetch((volatile int*)&drv_info->drv_data->otg_h_sig);
sig &= ~OTG_H_SIG_RESUME;
} while(atomic_store((volatile int*)&drv_info->drv_data->otg_h_sig, sig));
usb_hal_host_resume(drv_info);
}
sig = 0;
}
if(drv_info->drv_data->otg_flags & USB_OTG_FLG_DEV_OK)
{
req_hnd.mode.as_ushort[1] = drv_info->drv_data->drv_state_cnt;
#endif
req_hnd.tsk_start_read(&request, 8);
TRACE_USB_NAME(drv_info);
TRACE1_USB(" st req:");
requested = true;
#if USB_ENABLE_HOST
}
#endif
}
}
}
