void esp8266_module::wifi_cancelation(bool all)
{
CSocket* sock;
//cancel open waiting
sock = (CSocket*)waiting_open;
while(sock)
{
if(sock->mode1 || all)
{
sock->list_remove(waiting_open);
usr_HND_SET_STATUS(sock, RES_SIG_IDLE);
sock = (CSocket*)waiting_open;
} else
{
sock = (CSocket*)sock->next;
}
}
//cancel reading sockets
for(int sid=0; sid < WIFI_ESP8266_MAX_SOCKETS; sid++)
{
sock = alloc_sockets[sid];
if ( sock && (all || sock->mode1) && ((sock->res & RES_BUSY_WAITING) == RES_BUSY_WAITING))
{
usr_HND_SET_STATUS(sock, (sock->res & FLG_OK)| FLG_SIGNALED);
}
}
}
void GWindow::notify_message(WM_MESSAGE code, unsigned int param, GObject* dst)
{
GMessage msg(code, param, dst);
GUI_WIN_TRACE("\r\n\e[4;1;34m%s >> Notify ", CURRENT_TASK->name);
GUI_WIN_TRACE("%X[%d] ( %s %X )\e[m", dst, (dst)?dst->id:-1, szlist_at(wm_dbg_str, code), param);
Queue.push(msg);
if(hnd.res == (FLG_BUSY | FLG_OK))
usr_HND_SET_STATUS(&hnd, RES_SIG_OK); //signals the window thread
}
static inline void STOP_RX_HND(UART_Type *Uart, UART_DRIVER_INFO * drv_info, HANDLE hnd)
{
STOP_RX(Uart);
drv_info->drv_data->hnd_rcv = hnd->next;
hnd->len = drv_info->drv_data->rx_remaining;
usr_HND_SET_STATUS(hnd, RES_SIG_OK);
if( (hnd=drv_info->drv_data->hnd_rcv) )
START_RX_HND(Uart, drv_info, hnd);
else
START_RX_BUF(Uart, drv_info, drv_info->drv_data);
}
/** Stop receiving hnd
*
* @param pUsart
* @param drv_data
* @param hnd
*/
static void STOP_RX_HND(Usart* pUsart, UART_DRIVER_DATA drv_data, HANDLE hnd)
{
STOP_RX(pUsart);
drv_data->hnd_rcv = hnd->next;
hnd->len =pUsart->US_RCR;
hnd->dst.as_int = pUsart->US_RPR;
usr_HND_SET_STATUS(hnd, RES_SIG_OK);
if( (hnd=drv_data->hnd_rcv) )
START_RX_HND(pUsart, drv_data, hnd);
else
START_RX_BUF(pUsart, drv_data);
}
void DAC_ISR(DAC_DRIVER_INFO* drv_info)
{
DAC_DRIVER_DATA* drv_data = drv_info->drv_data;
DAC_TypeDef* dac = drv_info->hw_base;
uint32_t status;
HANDLE hnd;
status = dac->DAC_SR & (DAC_SR_DMAUDR1 | DAC_SR_DMAUDR2);
TRACELN("DAC isr %x", status);
if(status)//reset peripheral
{
// stop handles
#if USE_DAC_DMA_DRIVER
hnd = drv_data->pending[0];
if(hnd)
{
drv_data->pending[0] = NULL;
usr_HND_SET_STATUS(hnd, RES_SIG_ERROR);
}
hnd = drv_data->pending[1];
if(hnd)
{
drv_data->pending[1] = NULL;
usr_HND_SET_STATUS(hnd, RES_SIG_ERROR);
}
#endif
// clear status
dac->DAC_SR = status;
//reset peripheral
ConfigureDac(drv_info);
//reset channels
if(drv_data->dac_mode[0])
ConfigureDacChannel(dac, drv_data->dac_mode[0]);
if(drv_data->dac_mode[1])
ConfigureDacChannel(dac, drv_data->dac_mode[1]);
}
}
//*----------------------------------------------------------------------------
//* ISR function
//*----------------------------------------------------------------------------
void UART_ISR(UART_INFO drv_info )
{
HANDLE hnd;
unsigned int status;
Uart* pUart;
UART_DRIVER_DATA drv_data;
drv_data = drv_info->drv_data;
pUart = drv_info->hw_base;
status = pUart->UART_SR;
status &= pUart->UART_IMR;
// check the transmitter
if(status & UART_SR_TXBUFE)
{
pUart->UART_IDR = UART_IDR_TXBUFE;
if( (hnd=drv_data->hnd_snd) )
{
drv_data->hnd_snd = hnd->next;
hnd->len = 0;
hnd->src.as_int = pUart->UART_TPR;
usr_HND_SET_STATUS(hnd, RES_SIG_OK);
if( drv_data->hnd_snd )
START_TX_HND(pUart, drv_data->hnd_snd);
}
}
//check the receiver
if(status & UART_SR_ENDRX)
{
if( (hnd=drv_data->hnd_rcv) )
{
STOP_RX_HND(pUart, drv_data, hnd);
} else
START_RX_BUF(pUart, drv_data);
} else
{
// process tout
if( (hnd=drv_data->hnd_rcv) )
if(hnd->dst.as_int != pUart->UART_RPR)
if(drv_data->rtout)
if(!--drv_data->rtout)
{
STOP_RX_HND(pUart, drv_data, hnd);
}
}
}
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();
}
}
}
}
/** DACC Driver Interrupt
*
* @param drv_info
*/
void DACC_ISR(DACC_INFO drv_info )
{
DACC_DRIVER_DATA drv_data = drv_info->drv_data;
Dacc* pDacc = drv_info->hw_base;
if(pDacc->DACC_ISR & DACC_ISR_TXBUFE)
{
HANDLE hnd;
pDacc->DACC_IDR = DACC_IDR_TXBUFE;
if((hnd = drv_data->pending))
{
hnd->len = 0;
hnd->src.as_int = pDacc->DACC_TPR;
drv_data->pending = hnd->next;
if( drv_data->pending )
START_TX_HND(pDacc, drv_data->pending);
usr_HND_SET_STATUS(hnd, RES_SIG_OK);
}
}
}
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;
}
}
void isr_SerilaDriver(UART_DRIVER_INFO* drv_info )
{
UART_Type * Uart = drv_info->hw_base;
UART_DRIVER_DATA * drv_data = drv_info->drv_data;
HANDLE hnd;
unsigned int Status = Uart->UARTIntStatus(true);
Uart->UARTIntClear(Status);
if( Status & UART_INT_TX)
{
if((hnd=drv_data->hnd_snd))
{
while(Uart->UARTSpaceAvail())
{
if(!hnd->len)
{
drv_data->hnd_snd = hnd->next;
usr_HND_SET_STATUS(hnd, RES_SIG_OK);
if(!(hnd=drv_data->hnd_snd))
{
STOP_TX(Uart);
break;
}
}
hnd->len--;
Uart->DR = *hnd->src.as_charptr++;
}
if(hnd)
{
Uart->UARTTxIntModeSet(UART_TXINT_MODE_FIFO);
}
}
else
{
STOP_TX(Uart);
}
}
//check the receiver
if(Status&(UART_INT_RT|UART_INT_RX))
{
while(Uart->UARTCharsAvail())
{
drv_data->rx_remaining--;
*drv_data->rx_wrptr++ = Uart->DR;
if(drv_data->hnd_rcv && !drv_data->hnd_rcv->mode0)
drv_data->hnd_rcv->mode0 = 1;
if(!drv_data->rx_remaining )
{
if( (hnd=drv_data->hnd_rcv) )
STOP_RX_HND(Uart, drv_info, hnd);
else
START_RX_BUF(Uart, drv_info, drv_data);
}
#ifdef HW_VER_10
else
{
if(drv_data->mode.hw_flow && drv_info->info.drv_index != UART1_IRQn)
if((!drv_data->hnd_rcv) && (drv_data->rx_remaining < (RX_BUF_SIZE/4)))
{
if(drv_info->uart_pins[RTS_PIN])
PIO_SetOutput(drv_info->uart_pins[RTS_PIN]);
}
}
#endif
}
if( (Status&UART_INT_RT) && drv_data->mode.rx_tout )
{
if( (hnd=drv_data->hnd_rcv) )
{
if(drv_data->rx_remaining != hnd->len)
STOP_RX_HND(Uart, drv_info, hnd);
}
}
}
}
void gui_thread(GUI_DRIVER_INFO* drv_info)
{
unsigned int res, tmp, redraw;
WINDOW win;
WINDOW top;
WINDOW desktop; //main_dlg;
CHandle key_hnd;
CHandle gui_hnd;
//prevent these signals not to be used from task handles
ALLOCATE_SIGNAL(SIG_GUI_TASK);
//wait for static constructors (lcd object)
while(!detect_displays(drv_info))
tsk_sleep(10);
// start desktop
while( !(desktop = tsk_new_window(maindlg_cb)) )
{
tsk_sleep(10);
}
desktop->next = NULL;
top = desktop;
desktop->rect.x1 = drv_info->lcd[0]->size_x;
desktop->rect.y1 = drv_info->lcd[0]->size_y;
for(int i=0; i<GUI_DISPLAYS; i++)
{
if(drv_info->lcd[i])
{
#if GUI_DISPLAYS > 1
desktop->displays |= (1<<i);
#endif
drv_info->lcd[i]->lcd_init((GUI_CB)splashdlg_cb);
}
}
tsk_sleep(3000);
init_main_menu();
// start key handle
key_hnd.tsk_safe_open(KEY_DRV_INDX, 0);
key_hnd.src.as_int = 0;
key_hnd.tsk_start_read(&key_hnd.src.as_int, 1);
// start gui handle
gui_hnd.tsk_safe_open(GUI_DRV_INDX, 0); //mode = 1 - control handle
gui_hnd.tsk_start_read(NULL, 0);
for(;;)
{
res = tsk_wait_signal(-1u, 1000 - (CURRENT_TIME %1000));
redraw = res>>8;;
if(!res)
redraw = 0xFF;
// 1) get waiting objects
if(res & gui_hnd.signal)
{
drv_info->lcd[0]->backlight_signal();
gui_hnd.res &= ~FLG_SIGNALED;
win = (WINDOW)gui_hnd.dst.as_voidptr;
if(win)
{
top->next = win;
do
{
top = (WINDOW)top->next;
top->rect.x1 = desktop->rect.x1;
top->rect.y1 = desktop->rect.y1;
top->callback(NULL , WM_INIT);
#if GUI_DISPLAYS > 1
redraw |= top->displays;
#endif
} while( top->next );
}
gui_hnd.tsk_start_read(NULL, 0);
#if GUI_DISPLAYS == 1
redraw |= 1;
#endif
}
// 2) check keyboard
if(res & key_hnd.signal)
{
drv_info->lcd[0]->backlight_signal();
key_hnd.res &= ~FLG_SIGNALED;
//send to top
tmp = top->callback(key_hnd.src.as_int , WM_KEY);
if(tmp & FLG_BUSY) //FLG_BUSY returned to redraw
{
tmp ^= FLG_BUSY;
#if GUI_DISPLAYS > 1
redraw |= top->displays;
#else
redraw |= 1;
#endif
}
top->mode1 = tmp;
key_hnd.tsk_start_read(&key_hnd.src.as_int, 1);
}
// 3) command loop
top = NULL;
win = desktop;
do
{
// check for pending commands
if(win->mode0 & FLG_OK)
{
locked_clr_byte(&win->mode0, FLG_OK);
tmp = win->callback(win->dst.as_int, WM_USER);
if(tmp & FLG_BUSY) //FLG_BUSY returned to redraw
{
tmp ^= FLG_BUSY;
#if GUI_DISPLAYS > 1
redraw |= win->displays;
#else
redraw |= 1;
#endif
}
win->mode1 |= tmp;
}
//check for complete (close object)
if(top && ((win->mode0 | win->mode1) & FLG_SIGNALED) )
{
top->next = win->next;
#if GUI_DISPLAYS > 1
redraw |= win->displays;
#else
redraw |= 1;
#endif
usr_HND_SET_STATUS(win, win->mode1 | FLG_SIGNALED);
win = (WINDOW)top->next;
} else
{
top = win;
win = (WINDOW)win->next;
}
} while (win );
// 3) draw loop
for(int i=0; i<GUI_DISPLAYS; i++)
{
if( (redraw & (1<<i)) && drv_info->lcd[i])
{
drv_info->lcd[i]->redraw_screen(desktop);
}
}
}
}
