WEAK void backlight_thread(LCD_MODULE *lcd)
{
ALLOCATE_SIGNAL(SIG_BACKLIGHT_TASK);
PIO_CfgOutput1(lcd->pins[BKLT_PIN_INDX]);
while(1)
{
PIO_SetOutput(lcd->pins[BKLT_PIN_INDX]);
if(tsk_wait_signal(SIG_BACKLIGHT_TASK, backlight_time ))
continue;
if(backlight_time)
{
// reduce the current consumption to 5%
int t = 20;
while(!tsk_test_signal(SIG_BACKLIGHT_TASK))
{
PIO_SetOutput(lcd->pins[BKLT_PIN_INDX]);
tsk_sleep(t);
PIO_ClrOutput(lcd->pins[BKLT_PIN_INDX]);
tsk_sleep(20 - t--);
if(!t)
t=1;
}
}
tsk_get_signal(SIG_BACKLIGHT_TASK);
}
}
/**
* \brief Configures a list of Pin instances, each of which can either hold a single
* pin or a group of pins, depending on the mask value; all pins are configured
* by this function. The size of the array must also be provided and is easily
* computed using PIO_LISTSIZE whenever its length is not known in advance.
*
* \param list Pointer to a list of Pin instances.
* \param size Size of the Pin list (calculated using PIO_LISTSIZE).
*
* \return 1 if the pins have been configured properly; otherwise 0.
*/
uint8_t PIO_Configure( const Pin *list, uint32_t size )
{
/* Configure pins */
while ( size > 0 )
{
switch ( list->type )
{
case PIO_PERIPH_A:
PIO_SetPeripheralA(list->pio,
list->mask,
(list->attribute & PIO_PULLUP) ? 1 : 0);
break;
case PIO_PERIPH_B:
PIO_SetPeripheralB(list->pio,
list->mask,
(list->attribute & PIO_PULLUP) ? 1 : 0);
break;
case PIO_PERIPH_C:
PIO_SetPeripheralC(list->pio,
list->mask,
(list->attribute & PIO_PULLUP) ? 1 : 0);
break;
case PIO_PERIPH_D:
PIO_SetPeripheralD(list->pio,
list->mask,
(list->attribute & PIO_PULLUP) ? 1 : 0);
break;
case PIO_INPUT:
#ifndef __FPGA
PMC_EnablePeripheral(list->id);
#endif
PIO_SetInput(list->pio,
list->mask,
list->attribute);
break;
case PIO_OUTPUT_0:
case PIO_OUTPUT_1:
PIO_SetOutput(list->pio,
list->mask,
(list->type == PIO_OUTPUT_1),
(list->attribute & PIO_OPENDRAIN) ? 1 : 0,
(list->attribute & PIO_PULLUP) ? 1 : 0);
break;
default: return 0;
}
list++;
size--;
}
return 1;
}
//------------------------------------------------------------------------------
/// Configures a list of Pin instances, each of which can either hold a single
/// pin or a group of pins, depending on the mask value; all pins are configured
/// by this function. The size of the array must also be provided and is easily
/// computed using PIO_LISTSIZE whenever its length is not known in advance.
/// \param list Pointer to a list of Pin instances.
/// \param size Size of the Pin list (calculated using PIO_LISTSIZE).
/// \return 1 if the pins have been configured properly; otherwise 0.
//------------------------------------------------------------------------------
unsigned char PIO_Configure(const Pin *list, unsigned int size)
{
// Configure pins
while (size > 0) {
switch (list->type) {
case PIO_PERIPH_A:
PIO_SetPeripheralA(list->pio,
list->mask,
(list->attribute & PIO_PULLUP) ? 1 : 0);
break;
case PIO_PERIPH_B:
PIO_SetPeripheralB(list->pio,
list->mask,
(list->attribute & PIO_PULLUP) ? 1 : 0);
break;
case PIO_INPUT:
AT91C_BASE_PMC->PMC_PCER = 1 << list->id;
PIO_SetInput(list->pio,
list->mask,
(list->attribute & PIO_PULLUP) ? 1 : 0,
(list->attribute & PIO_DEGLITCH)? 1 : 0);
#if defined(AT91C_PIOA_IFDGSR) //PIO3 with Glitch or Debouncing selection
//if glitch input filter enabled, set it
if(list->attribute & PIO_DEGLITCH)//Glitch input filter enabled
PIO_SetFilter(list->pio,
list->inFilter.filterSel,
list->inFilter.clkDivider);
#endif
break;
case PIO_OUTPUT_0:
case PIO_OUTPUT_1:
PIO_SetOutput(list->pio,
list->mask,
(list->type == PIO_OUTPUT_1),
(list->attribute & PIO_OPENDRAIN) ? 1 : 0,
(list->attribute & PIO_PULLUP) ? 1 : 0);
break;
default: return 0;
}
list++;
size--;
}
return 1;
}
//------------------------------------------------------------------------------
// Exported functions
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
/// Configures a list of Pin instances, which can either hold a single pin or a
/// group of pins, depending on the mask value; all pins are configured by this
/// function.
/// Returns 1 if the configuration has been performed successfully; otherwise 0.
/// \param list Pointer to a list of Pin instances.
/// \param size Size of the Pin list (see <PIO_LISTSIZE>).
//------------------------------------------------------------------------------
unsigned char PIO_Configure(const Pin *list, unsigned int size)
{
// Configure pins
while (size > 0) {
switch (list->type) {
case PIO_PERIPH_A:
PIO_SetPeripheralA(list->pio,
list->mask,
(list->attribute & PIO_PULLUP) ? 1 : 0);
break;
case PIO_PERIPH_B:
PIO_SetPeripheralB(list->pio,
list->mask,
(list->attribute & PIO_PULLUP) ? 1 : 0);
break;
case PIO_INPUT:
AT91C_BASE_PMC->PMC_PCER = 1 << list->id;
PIO_SetInput(list->pio,
list->mask,
(list->attribute & PIO_PULLUP) ? 1 : 0,
(list->attribute & PIO_DEGLITCH)? 1 : 0);
break;
case PIO_OUTPUT_0:
case PIO_OUTPUT_1:
PIO_SetOutput(list->pio,
list->mask,
(list->type == PIO_OUTPUT_1),
(list->attribute & PIO_OPENDRAIN) ? 1 : 0,
(list->attribute & PIO_PULLUP) ? 1 : 0);
break;
default: return 0;
}
list++;
size--;
}
return 1;
}
void LCD_MODULE::lcd_init(GUI_CB splash)
{
#if GUI_DISPLAYS > 1
if(display == 1)
#endif
{
usr_task_init_static(&backlight_task_desc, false);
backlight_task.sp->r0.as_voidptr = this;
usr_task_schedule(backlight_task_desc.tsk);
}
// LCD Reset
PIO_CfgOutput0(pins[RST_PIN_INDX]);
tsk_sleep(20);
PIO_SetOutput(pins[RST_PIN_INDX]);
tsk_sleep(20);
//LCD Handle initialization (LCD attached to SPI)
lcd_hnd->tsk_safe_open(lcd_hnd->drv_index, lcd_hnd->mode.as_voidptr);
lcd_reset();
}
extern void digitalWrite( uint32_t ulPin, uint32_t ulVal )
{
/* Handle */
if ( g_APinDescription[ulPin].ulPinType == PIO_NOT_A_PIN )
{
return ;
}
if ((g_pinStatus[ulPin] & 0xF) == PIN_STATUS_PWM) {
pinMode(ulPin, OUTPUT);
}
g_pinStatus[ulPin] = (g_pinStatus[ulPin] & 0x0F) | (ulVal << 4) ;
if ( PIO_GetOutputDataStatus( g_APinDescription[ulPin].pPort, g_APinDescription[ulPin].ulPin ) == 0 )
{
PIO_PullUp( g_APinDescription[ulPin].pPort, g_APinDescription[ulPin].ulPin, ulVal ) ;
}
else
{
PIO_SetOutput( g_APinDescription[ulPin].pPort, g_APinDescription[ulPin].ulPin, ulVal, 0, PIO_PULLUP ) ;
}
}
extern void digitalWrite( uint32_t ulPin, uint32_t ulVal )
{
/* Handle */
if ( g_APinDescription[ulPin].ulPinType == PIO_NOT_A_PIN )
{
return ;
}
/* Added by Y.Ishioka */
if( ulPin == 13 ) {
led_set( ulVal & 0x01 ) ;
return ;
}
if ( PIO_GetOutputDataStatus( g_APinDescription[ulPin].pPort, g_APinDescription[ulPin].ulPin ) == 0 )
{
PIO_PullUp( g_APinDescription[ulPin].pPort, g_APinDescription[ulPin].ulPin, ulVal ) ;
}
else
{
PIO_SetOutput( g_APinDescription[ulPin].pPort, g_APinDescription[ulPin].ulPin, ulVal, 0, PIO_PULLUP ) ;
}
}
/**
*
* \return 1 if the pins have been configured properly; otherwise 0.
*/
extern uint32_t PIO_Configure( Pio* pPio, const EPioType dwType, const uint32_t dwMask, const uint32_t dwAttribute )
{
/* Configure pins */
switch ( dwType )
{
case PIO_PERIPH_A :
case PIO_PERIPH_B :
#if (defined _SAM3S_) || (defined _SAM3S8_) || (defined _SAM3N_)
case PIO_PERIPH_C :
case PIO_PERIPH_D :
#endif /* (defined _SAM3S_) || (defined _SAM3S8_) || (defined _SAM3N_) */
/* Put the pin under control of peripheral */
PIO_SetPeripheral( pPio, dwType, dwMask ) ;
/* Disable interrupts on the pin(s) */
PIO_DisableInterrupt( pPio, dwMask ) ;
/* Enable Pullup */
PIO_PullUp( pPio, dwMask, (dwAttribute & PIO_PULLUP) ) ;
break;
case PIO_INPUT :
PIO_SetInput( pPio, dwMask, dwAttribute ) ;
break;
case PIO_OUTPUT_0 :
case PIO_OUTPUT_1 :
PIO_SetOutput( pPio, dwMask, (dwType == PIO_OUTPUT_1),
(dwAttribute & PIO_OPENDRAIN) ? 1 : 0,
(dwAttribute & PIO_PULLUP) ? 1 : 0);
break ;
default :
return 0 ;
}
return 1 ;
}
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);
}
}
}
}
/**
* \brief Configures a list of Pin instances, each of which can either hold a single
* pin or a group of pins, depending on the mask value; all pins are configured
* by this function. The size of the array must also be provided and is easily
* computed using PIO_LISTSIZE whenever its length is not known in advance.
*
* \param list Pointer to a list of Pin instances.
* \param size Size of the Pin list (calculated using PIO_LISTSIZE).
*
* \return 1 if the pins have been configured properly; otherwise 0.
*/
extern uint32_t PIO_PinConfigure( const Pin* pPins, uint32_t dwSize )
{
uint32_t dwOptions=0 ;
/* Configure pins */
while ( dwSize > 0 )
{
switch ( pPins->type )
{
case PIO_PERIPH_A :
if ( pPins->attribute & PIO_PULLUP )
{
dwOptions=PIO_PULLUP ;
}
PIO_SetPeripheralA( pPins->pio, pPins->mask, dwOptions ) ;
break ;
case PIO_PERIPH_B :
if ( pPins->attribute & PIO_PULLUP )
{
dwOptions=PIO_PULLUP ;
}
PIO_SetPeripheralB( pPins->pio, pPins->mask, dwOptions ) ;
break ;
case PIO_INPUT :
PMC_EnablePeripheral( pPins->id ) ;
PIO_SetInput( pPins->pio, pPins->mask, pPins->attribute ) ;
break ;
case PIO_OUTPUT_0 :
case PIO_OUTPUT_1 :
if ( pPins->type == PIO_OUTPUT_1 )
{
dwOptions|=PIO_OUTPUT_HIGH ;
}
if ( pPins->attribute & PIO_OPENDRAIN )
{
dwOptions|=PIO_OPENDRAIN ;
}
if ( pPins->attribute & PIO_PULLUP )
{
dwOptions|=PIO_PULLUP ;
}
PIO_SetOutput( pPins->pio, pPins->mask, dwOptions ) ;
break ;
default :
return 0 ;
}
pPins++ ;
dwSize-- ;
}
return 1 ;
}
