RES_CODE usb_remote_hid_t::set_report(const void* buf, uint32_t len, uint32_t rep_type, uint32_t rep_id)
{
RES_CODE res;
//read status
TRACELN1("hid: set report");
req.bmRequestType = USB_REQ_OUT_CLASS_INTERFACE;
req.bRequest = HIDRequest_SET_REPORT;
req.wIndex = pid->bInterfaceNumber; // Interface number
req.wValue = (rep_type << 8) | rep_id; // HID_REPORTTYPE_INPUT / OUTPUT / FEATURE
req.wLength = len;
res = std_request((void*)buf);
return res;
}
void esp8266_module::wifi_process_tout(void)
{
CSocket* sock;
HANDLE list;
RES_CODE res;
if(wifi_tout)
{
if(!--wifi_tout)
{
if(!used_sockets)
{
//--- deactivate the context?
for(int i=0; i < 3; i++ )
{
if(wifi_send_cmd("+CWQAP", 150) & WIFI_CMD_STATE_OK)
{
wifi_send_cmd("+CWJAP?", 50);
break;
}
}
wifi_on_disconnect(this);
TRACELN1("WIFI OFF");
list = waiting_open;
waiting_open = NULL;
while(list)
{
sock = (CSocket*)list;
list = sock->next;
sock->res = RES_BUSY;
res = wifi_sock_open(sock);
if(res & FLG_SIGNALED)
usr_HND_SET_STATUS(sock, res);
}
if(!used_sockets)
wifi_drv_off();
}
}
}
}
void DAC_DCR(DAC_DRIVER_INFO* drv_info, unsigned int reason, HANDLE hnd)
{
DAC_DRIVER_DATA *drv_data = drv_info->drv_data;
DAC_DRIVER_MODE *dac_mode = (DAC_DRIVER_MODE *)(hnd->mode.as_voidptr);
switch(reason)
{
case DCR_RESET:
RCCPeripheralReset(drv_info->info.peripheral_indx);
RCCPeripheralDisable(drv_info->info.peripheral_indx); // ??? turn off
#if USE_DAC_DMA_DRIVER
drv_data->dac_dma_hnd[0].client.drv_index = drv_info->info.drv_index;
drv_data->dac_dma_hnd[1].client.drv_index = drv_info->info.drv_index;
#endif
break;
case DCR_OPEN:
{
if(dac_mode && dac_mode->dac_ch <2 && drv_data->dac_mode[dac_mode->dac_ch] == NULL)
{
if(!drv_data->dac_mode[0] && !drv_data->dac_mode[1])
{
if(!ConfigureDac(drv_info))
break;
}
ConfigureDacChannel(drv_info->hw_base, dac_mode);
drv_data->dac_mode[dac_mode->dac_ch] = dac_mode;
hnd->res = RES_OK;
}
break;
}
case DCR_CLOSE:
#if USE_DAC_DMA_DRIVER
drv_data->dac_dma_hnd[dac_mode->dac_ch].close();
#endif
drv_data->dac_mode[dac_mode->dac_ch] = NULL;
if(!drv_data->dac_mode[0] && !drv_data->dac_mode[1])
{
//Disable ?
NVIC_DisableIRQ(drv_info->info.drv_index);
RCCPeripheralDisable(drv_info->info.peripheral_indx);
PIO_Free_List(drv_info->dac_pins);
}
break;
case DCR_CANCEL:
// can only cancel dma transfers
#if USE_DAC_DMA_DRIVER
if(drv_data->dac_dma_hnd[dac_mode->dac_ch].res & FLG_BUSY)
drv_data->dac_dma_hnd[dac_mode->dac_ch].hcontrol(DCR_CANCEL);
#endif
break;
case DCR_SIGNAL:
#if USE_DAC_DMA_DRIVER
TRACELN1("DAC sig");
if(hnd == &drv_data->dac_dma_hnd[0])
{
hnd = drv_data->pending[0];
if(hnd)
{
if(hnd->len > drv_data->dac_dma_hnd[0].len)
{
hnd->src.as_byteptr += hnd->len - drv_data->dac_dma_hnd[0].len;
hnd->len = drv_data->dac_dma_hnd[0].len;
}
drv_data->pending[0] = NULL;
if (__get_CONTROL() & 2)
usr_HND_SET_STATUS(hnd, RES_SIG_OK);
else
svc_HND_SET_STATUS(hnd, RES_SIG_OK);
}
} else
{
if(hnd == &drv_data->dac_dma_hnd[1])
{
hnd = drv_data->pending[1];
if(hnd)
{
if(hnd->len > drv_data->dac_dma_hnd[1].len)
{
hnd->src.as_byteptr += hnd->len - drv_data->dac_dma_hnd[1].len;
hnd->len = drv_data->dac_dma_hnd[1].len;
}
drv_data->pending[1] = NULL;
usr_HND_SET_STATUS(hnd, RES_SIG_OK);
}
}
}
#endif
break;
}
}
RES_CODE esp8266_module::process_write(CSocket* sock)
{
unsigned size;//, newsize, id;
// unsigned int start_size, write_size, sock_state;
CSTRING cmd;
unsigned char snd_pending;
while(1)
{
size = sock->len;
if(!size)
{
TRACELN1("WIFI: write OK");
return RES_SIG_OK;
}
if(size >1022)
size = 1022;
if(sock->sock_state != SOCKET_CONECTED)
break;
// Send command
cmd.format("+CIPSEND=%u,%u", sock->sock_id, size);
TRACELN("WIFI: WRITE %d?", size);
cmd_state |= WIFI_CMD_STATE_HND;
if(wifi_send_cmd(cmd.c_str(), 20) != WIFI_CMD_STATE_RETURNED)
{
wifi_net_error(NET_ERR_SOCK_WRITE);
return RES_SIG_ERROR;
}
// Send data
snd_pending = '>';
do
{
process_input(rcv_hnd.signal, cmd.c_str(), snd_pending);
if ( cmd_state >= WIFI_CMD_STATE_HND )
{
if ( cmd_state & WIFI_CMD_STATE_HND )
{
unsigned int mytime;
cmd_state &= ~WIFI_CMD_STATE_HND;
snd_pending = 0;
rcv_hnd.tsk_start_read(&received_ch, 1);
mytime = CURRENT_TASK->time;
tsk_sleep(55); // data sheet recomendation
if( snd_hnd.tsk_write(sock->src.as_voidptr, size, WIFI_WRITE_TOT) != RES_OK)
break;
CURRENT_TASK->time = mytime;
} else
{
if ( cmd_state >= WIFI_CMD_STATE_OK )
break; // command completed with OK, ERROR ..
}
}
} while(tsk_resume_wait_signal(rcv_hnd.signal));
// wifi_on_blink_transfer(this, GPRS_TRANSFER_INDICATOR);
//Check the result
if(cmd_state & WIFI_CMD_STATE_OK)
{
TRACE1(" done!");
sock->src.as_byteptr += size;
sock->len -= size;
continue;
}
if (cmd_state & WIFI_CMD_STATE_CMES)
{
TRACE_ERROR("\r\nWIFI:%s write ERROR", sock->client.task->name);
}
break;
}
wifi_sleep(120);
wifi_net_error(NET_ERR_SOCK_WRITE);
return RES_SIG_ERROR;
}
extern "C" void sys_kernel_init( void)
{
DRIVER_INFO drv_info;
char *ptr;
int i;
#if TRACE_IS > TRACE_DISABLED
/*
//--------------- Start trace -----------------------------//
CDBG->CDBG_DEMCR |= CDBG_DEMCR_TRCENA;
//TPIU
TPIU->TPIU_FFCR = 0x00; //Formatter and Flush Control Register
TPIU->TPIU_SPPR = TPIU_SPPR_ASYNC_MANCHESTER; //Selected Pin Protocol Register
TPIU->TPIU_FFCR = 0x00; //Formatter and Flush Control Register
TPIU->TPIU_CSPSR = TPIU_CSPSR_WORD; //Current Sync Port Size Register
TPIU->TPIU_ACPR = 0x04; //Async Clock Prescaler Register
//ITM
//Lock Access Register
ITM->ITM_LAR = ITM_LAR_KEY;
//Trace Control Register = trace ID = 1, ITM and DTW enabled
ITM->ITM_TCR = 0x10000 | ITM_TCR_DWTENA | ITM_TCR_ITMENA;
ITM->ITM_TER = 0xFFFFFFFF ; //Trace Enable = all stimulus ports
ITM->ITM_TPR = 0x0; //Trace Privilege = all
*/
TRACELN1("===== " __DATE__ " === " __TIME__ " ===== "); //few more spaces (a clock change follows)
#endif
//------------- initialize dynamic memory ---------------//
#if USE_TMOS_STDLIB
svc_pool_init(&end, (void*)(BASE_SRAM + RAM_SIZE));
#endif
// initialize main task
usr_task_init_static(&main_task_desc, false);
PMAIN_TASK->tlist = PMAIN_TASK;
//extra initialization needed for main_task
PMAIN_TASK->time = 0; // current time is 000000000
PMAIN_TASK->state = TSKSTATE_READY; // leave it suspend ???
#if USE_MEMORY_TRACKING
PMAIN_TASK->aloc_mem = 0;
PMAIN_TASK->aloc_ptrs =0;
#endif
// Reset the drivers i
for (i = SysTick_IRQn; i < INALID_DRV_INDX; i++)
{
ptr = DRV_TABLE[i];
drv_info = (DRIVER_INFO) (void*) (ptr - 1);
drv_info->dcr(drv_info, DCR_RESET, NULL);
}
// Application level init
app_init();
#if USE_STATIC_CONSTRUCTORS
sys_call_static_ctors();
#endif
}
