/**************************************************************************//**
* @brief
* Timeout function for keyboard scan timer.
* Scan keyboard to check for key press/release events.
* This function is called at a fixed rate.
*****************************************************************************/
static void ScanTimeout( void )
{
bool pushedPB0;
bool pushedPB1;
HIDKBD_KeyReport_t *report;
/* Check pushbutton PB0 */
pushedPB0 = GPIO_PinInGet( BUTTON0_PORT, BUTTON0_PIN ) == 0;
if ( pushedPB0 != keyPushed ) /* Any change in keyboard status ? */
{
if ( pushedPB0 )
{
report = (void*)&USBDESC_reportTable[ 0 ];
}
else
{
report = (void*)&USBDESC_noKeyReport;
}
/* Pass keyboard report on to the HID keyboard driver. */
HIDKBD_KeyboardEvent( report );
}
/* Keep track of the new keypush event (if any) */
if ( pushedPB0 && !keyPushed )
{
/* Advance to next position in report table */
keySeqNo++;
if ( keySeqNo == (sizeof(USBDESC_reportTable) / sizeof(HIDKBD_KeyReport_t)))
{
keySeqNo = 0;
}
}
keyPushed = pushedPB0;
/* Check pushbutton PB1 */
pushedPB1 = GPIO_PinInGet( BUTTON1_PORT, BUTTON1_PIN ) == 0;
if ( pushedPB1 != keyPushed ) /* Any change in keyboard status ? */
{
if ( pushedPB1 )
{
report = (void*)&USBDESC_reportTable[ 1 ];
}
else
{
report = (void*)&USBDESC_noKeyReport;
}
/* Pass keyboard report on to the HID keyboard driver. */
HIDKBD_KeyboardEvent( report );
}
keyPushed = pushedPB1;
/* Restart keyboard scan timer */
USBTIMER_Start( SCAN_TIMER, SCAN_RATE, ScanTimeout );
}
/******************************************************************************
* @brief Main function
*****************************************************************************/
int main(void)
{
/* Initialize chip */
CHIP_Init();
/* Enable code view */
setupSWO();
/* Initialize LCD */
SegmentLCD_Init(false);
/* Enable the HFPER clock */
CMU_ClockEnable(cmuClock_HFPER, true);
/* Configure RTC and GPIO */
rtc_setup();
gpio_setup();
/* Stay in this loop forever */
while (1)
{
/* Wait for Push Button 1 to be pressed */
while (GPIO_PinInGet(PB0_PORT, PB0_PIN)) ;
/* and released, so that we do not exit the while loop below immediately */
while (!GPIO_PinInGet(PB0_PORT, PB0_PIN)) ;
/* Reset time */
time = 0;
/* Disable LCD */
LCD_Enable(true);
/* Update time until Push Button 1 is pressed again */
while (1)
{
if (RTC_CounterGet() == 0)
{
SegmentLCD_Number(++time);
}
if (!GPIO_PinInGet(PB0_PORT, PB0_PIN))
break;
}
/* Delay while showing the result on the LCD */
for (uint32_t delay = 0; delay < 30; delay++)
{
/* Wait for the RTC to overflow once */
while (RTC_CounterGet() != 0) ;
while (RTC_CounterGet() == 0) ;
}
/* Disable LCD */
LCD_Enable(false);
}
}
/*****************************************************************************
* Enters 'bootloader mode' where a new encrypted firmware upgrade can be
* sent over UART.
*****************************************************************************/
void enterBootloaderMode(void)
{
FLASH_init();
/* Enable UART */
BLUART_init();
/* If the current firmware is invalid, but temp storage is
* enabled and contains a valid firmware, copy this firmware
* to boot region immediately. */
if ( USE_TEMP_STORAGE && !isFirmwareValid() && isTempStorageValid() )
{
copyFirmwareFromTempStorage();
markFirmwareAsVerified();
}
/* Check if bootloader pin is pulled low. If it is left high
* enter EM2 to save power. The MCU will wake up when pin is
* pulled low. */
if ( GPIO_PinInGet(BOOTLOADER_PIN) ) {
enterLowPowerWait();
}
/* Wait for commands over UART */
commandLoop();
}
// Function Name: bootloadForceActivation
// Description: Decides whether to continue launching the bootloader or vector
// to the application instead. This decision is usually based on
// some sort of GPIO logic.
// (ie. a hardware trigger).
// NOTE!!! This function is called extremely early in the boot process
// prior to the chip being fully configured and before memory
// is initialized, so limited functionality is available.
// If this function returns false any state altered should
// be returned to its reset state.
// Parameters: none
// Returns: false (0) if bootloader should not be launched.
// (This will try to execute the application if possible.)
// true (1) if bootloader should be launched.
//
bool bootloadForceActivation( void )
{
#if defined(USE_BUTTON_RECOVERY)
uint32_t i;
bool pressed;
// this provides an example of an alternative recovery mode activation
// method by utilizing one of the breakout board buttons
CMU_ClockEnable(cmuClock_HFPER, true);
CMU_ClockEnable(cmuClock_GPIO, true);
// Since the button may have decoupling caps, they may not be charged
// after a power-on and could give a false positive result. To avoid
// this issue, drive the output as an output for a short time to charge
// them up as quickly as possible
GPIO_PinModeSet(BUTTON0_PORT, BUTTON0, gpioModePushPull, 1);
GPIO_PinOutSet(BUTTON0_PORT, BUTTON0);
for(i=0; i<100; i++)
__no_operation();
// Reconfigure as an input with pullup to read the button state
GPIO_PinModeSet(BUTTON0_PORT, BUTTON0, gpioModeInputPull, 1);
// (IO was already set to enable the pullup above)
// We have to delay again here so that if the button is depressed the
// cap has time to discharge again after being charged up
// by the above delay
for(i=0; i<500; i++)
__no_operation();
pressed = GPIO_PinInGet(BUTTON0_PORT, BUTTON0) ? BUTTON_RELEASED : BUTTON_PRESSED;
return pressed;
#else
return false;
#endif
}
/***************************************************************************//**
* @brief
* RxTimer, Timer0 IRQHandler.
******************************************************************************/
void TIMER0_IRQHandler(void)
{
uint32_t irqFlags;
irqFlags = TIMER_IntGet(HIJACK_RX_TIMER);
TIMER_IntClear(HIJACK_RX_TIMER, irqFlags);
if (TIMER_IF_CC1 & irqFlags)
{
cur_stamp = TIMER_CaptureGet(HIJACK_RX_TIMER, 1);
TIMER_CounterSet(HIJACK_RX_TIMER, 0);
edge_occur = true;
/* Check what transition it was. */
if (GPIO_PinInGet(HIJACK_RX_GPIO_PORT, HIJACK_RX_GPIO_PIN))
{
cur_edge = rising;
BSP_LedSet( 0 );
}
else
{
cur_edge = falling;
BSP_LedClear( 0 );
}
}
}
/**************************************************************************//**
* @brief Main function
* Main is called from __iar_program_start, see assembly startup file
*****************************************************************************/
int main(void)
{
/* Initialize chip */
CHIP_Init();
/* Enable clock for GPIO module */
CMU_ClockEnable(cmuClock_GPIO, true);
/* Configure PD with alternate drive strength of 20mA */
GPIO_DriveModeSet(gpioPortD, gpioDriveModeHigh);
/* Configure PC12 as input with filter*/
GPIO_PinModeSet(gpioPortC, 12, gpioModeInput, 0);
/* Configure PD8 as push pull output */
GPIO_PinModeSet(gpioPortD, 8, gpioModePushPullDrive, 0);
while(1)
{
/* If PC12 is high, drive high PD8, else drive low */
if(GPIO_PinInGet(gpioPortC, 12))
GPIO_PinOutSet(gpioPortD, 8); /* Drive high PD8 */
else
GPIO_PinOutClear(gpioPortD, 8); /* Drive low PD8 */
}
}
inline uint8_t SX1276ReadDio4( void )
{
#ifdef DIO4_IOPORT
return GPIO_PinInGet( DIO4_IOPORT, DIO4_PIN );
#else
return 0;
#endif
}
void readGpioY(void)
{
gpio_data_y[0] = GPIO_PinInGet(gpioPortC, 0);
gpio_data_y[1] = GPIO_PinInGet(gpioPortC, 1);
gpio_data_y[2] = GPIO_PinInGet(gpioPortC, 2);
gpio_data_y[3] = GPIO_PinInGet(gpioPortD, 6);
gpio_data_y[4] = GPIO_PinInGet(gpioPortD, 7);
gpio_data_y[5] = GPIO_PinInGet(gpioPortD, 8);
gpio_data_y[6] = GPIO_PinInGet(gpioPortD, 13);
gpio_data_y[7] = GPIO_PinInGet(gpioPortD, 14);
}
void readGpioX(void)
{
gpio_data_x[0] = GPIO_PinInGet(gpioPortB, 10);
gpio_data_x[1] = GPIO_PinInGet(gpioPortB, 9);
gpio_data_x[2] = GPIO_PinInGet(gpioPortB, 11);
gpio_data_x[3] = GPIO_PinInGet(gpioPortB, 12);
gpio_data_x[4] = GPIO_PinInGet(gpioPortD, 15);
gpio_data_x[5] = GPIO_PinInGet(gpioPortD, 3);
gpio_data_x[6] = GPIO_PinInGet(gpioPortD, 4);
gpio_data_x[7] = GPIO_PinInGet(gpioPortD, 5);
}
void SysTick_Handler(void)
{
msTicks++; /* increment counter necessary in Delay()*/
if(msTicks%60000==0 )
{
++curr_time.m;
if(curr_time.m==60)
{
++curr_time.h;
curr_time.m=0;
}
}
if(curr_time.h==24)
curr_time.h=0;
if(msTicks%7 ==0)
{
if( op1==1 & GPIO_PinInGet(BTN_PORT, PB1)==0 )
{
if((1<current && current<6) | current==7 )
current--;
if(current==1)
{
oc=choice;
if(choice==1)
choice=2;
else
choice=1;
}
if(current==6) current=1;
}
op1= GPIO_PinInGet(BTN_PORT, PB1);
}
}
static int efm32_uart_hasrx(struct uart *dev) {
#if 1
static unsigned int neg_cnt;
while (1)
if (!GPIO_PinInGet(BSP_BCC_RXPORT, BSP_BCC_RXPIN)) {
LEUART_Tx((void *) dev->base_addr, '0');
neg_cnt++;
}
#endif
return 1;
}
rt_uint8_t rt_hw_led_state(rt_uint8_t num)
{
RT_ASSERT(num < LEDS_MAX_NUMBER);
#if defined(EFM32_G8XX_STK)
return (rt_uint8_t)GPIO_PinInGet(leds_list[num][0], leds_list[num][1]);
#elif (defined(EFM32_GXXX_DK) || defined(EFM32GG_DK3750))
return ((DVK_getLEDs() & (rt_uint16_t)(1 << num)) >> num);
#endif
}
/**************************************************************************//**
* @brief Increments the clock quickly while PB1 is pressed.
* A callback is used to update either the analog or the digital clock.
*
*****************************************************************************/
void fastForwardTime(void (*drawClock)(struct tm*, bool redraw))
{
unsigned int i = 0;
struct tm *time;
/* Wait 2 seconds before starting to adjust quickly */
int waitForPcntIrqCount = pcntIrqCount + 2;
while (pcntIrqCount != waitForPcntIrqCount)
{
/* Return if the button is released */
if (GPIO_PinInGet(gpioPortC, 9) == 1) {
timeIsFastForwarding = false;
return;
}
/* Keep updating the second counter while waiting */
if (updateDisplay)
{
time = localtime((time_t const *) &curTime);
drawClock(time, true);
}
EMU_EnterEM2(false);
}
/* Keep incrementing the time while the button is held */
while (GPIO_PinInGet(gpioPortC, 9) == 0)
{
if (i % 1000 == 0)
{
/* Increase time by 1 minute (60 seconds). */
curTime += 60;
time = localtime((time_t const *) &curTime);
drawClock(time, true);
}
i++;
}
timeIsFastForwarding = false;
}
/*==============================================================================
hal_pinGet()
=============================================================================*/
uint8_t hal_pinGet(void * p_pin)
{
s_hal_gpio_pin_t* p_gpioPin;
if(p_pin == NULL) {
return 0;
}
p_gpioPin = (s_hal_gpio_pin_t*)p_pin;
if( p_gpioPin->mode != gpioModeInput )
return p_gpioPin->val;
else
return GPIO_PinInGet( p_gpioPin->port, p_gpioPin->pin );
} /* hal_pinGet() */
/**********************************************************
* COG init sequence
**********************************************************/
void cogInit(void)
{
while ( GPIO_PinInGet(EPD_PIN_BUSY) );
/* Channel select */
spiSend(0x01, epdConfig.channelSelect, 8);
/* DC/DC frequency setting */
spiSend1(0x06, 0xFF);
/* High Power Mode Oscillator Setting */
spiSend1(0x07, 0x9D);
/* Disable ADC */
spiSend1(0x08, 0x00);
/* Set Vcom Level */
spiSend2(0x09, 0xD000);
/* Gate and Source Voltage Level*/
spiSend1(0x04, epdConfig.voltageLevel);
delayMs(5);
/* Driver latch on (cancel register noise) */
spiSend1(0x03, 0x01);
/* Driver latch off */
spiSend1(0x03, 0x00);
/* Start chargepump positive voltage. VGH and VDH on */
spiSend1(0x05, 0x01);
delayMs(30);
/* Stop PWM */
pwmDisable();
/* Start chargepump on negative voltage. VGL and VDL on */
spiSend1(0x05, 0x03);
delayMs(30);
/* Set chargepump Vcom driver to ON */
spiSend1(0x05, 0x0F);
delayMs(30);
/* Output enable to disable */
spiSend1(0x02, 0x24);
}
/***************************************************************************//**
* @brief
* Check status of the touch panel.
*
* @return
* 0 if panel is idle (not touched).
******************************************************************************/
int TOUCH_IsBusy(void)
{
if( (touch_state == TOUCH_INIT) )
{
return GPIO_PinInGet(TOUCH_X2);
}
if( (touch_state == TOUCH_CHECK_PRESS) )
{
return TOUCH_BUSY_CHECK;
}
return(TOUCH_BUSY_SCAN);
}
/* Measures the length (in microseconds) of a pulse on the pin; state is HIGH
* or LOW, the type of pulse to measure. Works on pulses from 2-3 microseconds
* to 3 minutes in length, but must be called at least a few dozen microseconds
* before the start of the pulse. */
uint32_t pulseIn( uint32_t pin, uint32_t state, uint32_t timeout )
{
// cache the port and bit of the pin in order to speed up the
// pulse width measuring loop and achieve finer resolution. calling
// digitalRead() instead yields much coarser resolution.
int port = dPorts[pin];
int pinId = dPins[pin];
uint32_t width = 0; // keep initialization out of time critical area
// convert the timeout from microseconds to a number of times through
// the initial loop; it takes 22 clock cycles per iteration.
uint32_t numloops = 0;
uint32_t maxloops = microsecondsToClockCycles(timeout) / 22;
// wait for any previous pulse to end
while (GPIO_PinInGet((GPIO_Port_TypeDef)port, pinId) == state)
if (numloops++ == maxloops)
return 0;
// wait for the pulse to start
while (GPIO_PinInGet((GPIO_Port_TypeDef)port, pinId) != state)
if (numloops++ == maxloops)
return 0;
// wait for the pulse to stop
while (GPIO_PinInGet((GPIO_Port_TypeDef)port, pinId) == state) {
if (numloops++ == maxloops)
return 0;
width++;
}
// convert the reading to microseconds. The loop has been determined
// to be 52 clock cycles long and have about 16 clocks between the edge
// and the start of the loop. There will be some error introduced by
// the interrupt handlers.
return clockCyclesToMicroseconds(width * 52 + 16);
}
/*****************************************************************************
* Bootloader entry point.
*****************************************************************************/
int main(void)
{
CHIP_Init();
gpioSetup();
uint32_t pinTest = GPIO_PinInGet(BOOTLOADER_PIN);
/* The bootloader pin is left high, boot normally */
if ( pinTest )
{
/* Verify firmware before booting */
if ( isFirmwareValid() )
{
BOOT_boot();
}
else
{
/* Firmware is invalid. Check temp storage */
if ( USE_TEMP_STORAGE && isTempStorageValid() )
{
FLASH_init();
copyFirmwareFromTempStorage();
markFirmwareAsVerified();
/* Application will boot after reset */
NVIC_SystemReset();
}
/* No valid application is present. Enter bootloader mode. */
else
{
enterBootloaderMode();
}
}
}
/* The bootloader pin is pulled high, enter bootloader */
else
{
enterBootloaderMode();
}
/* Never reached */
return 0;
}
/*****************************************************************************
* Waits in EM3 until the bootloader pin is pulled low. This saves power
* while waiting to install firmware.
*****************************************************************************/
void enterLowPowerWait(void)
{
/* Enable interrupt on GPIO pin. Note that
* if the pin is changed to an odd pin number
* the interrupt handler must also be changed */
GPIO_IntConfig(BOOTLOADER_PIN, true, false, true);
NVIC_EnableIRQ(GPIO_EVEN_IRQn);
/* Wait in EM3 until the pin is pulled low */
while ( GPIO_PinInGet(BOOTLOADER_PIN) ) {
EMU_EnterEM3(false);
}
/* Disable interrupts again */
GPIO_IntConfig(BOOTLOADER_PIN, false, false, false);
NVIC_DisableIRQ(GPIO_EVEN_IRQn);
}
/**************************************************************************//**
* @brief Main function
*****************************************************************************/
int main(void)
{
/* Chip errata */
CHIP_Init();
CMU_ClockEnable(cmuClock_GPIO, true);
GPIO_PinModeSet(BUTTON_PORT, BUTTON_PIN, gpioModeInput, 0);
// The initial state of the button is high when not pushed
bool past_button_state = 1;
// Start out not blinking
bool blinking = false;
while (1)
{
// Grab the state of the button, 1 for high voltage, 0 for low
bool live_button_state = GPIO_PinInGet(BUTTON_PORT, BUTTON_PIN);
// Invert the blinking mode every time a button is pressed
// which generates a low voltage on a pin
if (past_button_state == 1 && live_button_state == 0)
{
past_button_state = 0;
// Invert the blinking mode, so that it is buffered and will
// keep blinking/not blinking when the button is released
blinking = !blinking;
}
// Reset the past state when the button is released
if (live_button_state == 1)
{
past_button_state = 1;
}
// Finally decide if there is going to be a blink cycle or not
if (blinking)
{
blink_one_cycle();
}
}
}
/**************************************************************************//**
* @brief Get state MCU plugin board VBUS overcurrent flag.
* @return True if overcurrent situation exist, false otherwise.
*****************************************************************************/
bool BSP_McuBoard_UsbVbusOcFlagGet( void )
{
#ifdef BSP_MCUBOARD_USB
bool flag;
if ( !GPIO_PinInGet( BSP_USB_OCFLAG_PORT, BSP_USB_OCFLAG_PIN ) )
{
flag = true;
}
else
{
flag = false;
}
return flag;
#else
return false;
#endif
}
/***************************************************************************//**
* @brief
* Active SO Interrupt handler
* @param[in] *ref
*
******************************************************************************/
void SO_IRQ(void *ref)
{
(void) ref;
int p = GPIO_PinInGet(RX_PORT, RX_PIN);
if (p != 0)
{
// should never happen - we should only get the interrupt when the pin goes low
GPIO->IFC = 1 << RX_PIN;
so_spurious_irq_count++;
return;
}
// disable IRQ
GPIO_IntConfig(RX_PORT, RX_PIN,
false, // risingEdge
false, // fallingEdge
false); // enable
so_irq_count++;
if (! so_busy)
{
// should never happen
while (1)
;
}
GPIO_PinOutSet(CS_PORT, CS_PIN); // deassert CS
// copy completion fn ptr and ref arg, to avoid race condition
// if completion fn starts another SPI xfer
spi_completion_fn_t *completion = so_completion;
void *completion_ref = so_completion_ref;
so_busy = false;
if (completion)
completion(completion_ref);
}
/***************************************************************************//**
* @brief
* Active SO Interrupt handler
* @note
* Note: may be called synchronously (completion == NULL), in which case
* this function does not return until the SO interrupt occurs, or
* asynchronously (completion != NULL), in which case this function merely
* sets up the interrupt, returns to the caller, and the caller should do
* whatever is desired until the SO interrupt occurs, at which time the
* completion function is called.
* @param[in] level
* Determines Edge Level Interrupt: Rising/Falling, spiflash_info->so_done_level
* is the variable that is passed into the function and is initialized in the
* Device table found in spiflash.c
* @param[in] *completion
* Completion State machine callback function
* @param[in] *completion_ref
* Argument to be passed to completion callback
*******************************************************************************/
void spi_wait_so(uint8_t level,
spi_completion_fn_t *completion, // completion callback fn
void *completion_ref) // argument to be passed to completion callback
{
so_completion = completion;
so_completion_ref = completion_ref;
so_busy = true;
INT_Disable();
// enable IRQ
// The EFM32 has edge-triggered interrupts, so we'll never get an
// interrupt if the port pin was already at the desired level. To
// avoid deadlock, we check the pin state here, and if it's already
// at the desired level, simulate an edge interrupt.
p1 = GPIO_PinInGet(RX_PORT, RX_PIN);
if (p1 == level)
{
so_irq_fake_count++;
SO_IRQ(NULL);
}
else
{
// Note that GPIO_IntConfig will clear any pending IRQ for the pin
GPIO_IntConfig(RX_PORT, RX_PIN,
level, // risingEdge
!level, // fallingEdge
true); // enable
}
INT_Enable();
// if called synchronously, actually wait here
if (!completion)
while (so_busy)
enter_low_power_state();
}
/** @brief Indicate if device interrupt GPIO is pending
* @return true if device interrupt is pending, false otherwise
*/
bool halExtDeviceIntPending(void)
{
return (GPIO_PinInGet((GPIO_Port_TypeDef) RF_INT_PORT, RF_INT_PIN) == false);
}
int gpio_read(gpio_t pin)
{
return GPIO_PinInGet(_port_num(pin), _pin_num(pin));
}
inline uint8_t SX1276ReadDio2( void )
{
return GPIO_PinInGet( DIO2_IOPORT, DIO2_PIN );
}
/**
* Reads nIRQ pin of the EZRadio device.
*
* @return Value of nIRQ pin.
*/
uint8_t ezradio_hal_NirqLevel(void)
{
return GPIO_PinInGet( (GPIO_Port_TypeDef) RF_INT_PORT, RF_INT_PIN);
}
/**
* Reads GPIO1 pin of the EZRadio device.
*
* @return Value of GPIO1 pin.
*/
uint8_t ezradio_hal_Gpio1Level(void)
{
return GPIO_PinInGet( (GPIO_Port_TypeDef) RF_GPIO1_PORT, RF_GPIO1_PIN);
}
/***************************************************************************//**
* @brief
* Interrupt handler is executed with frequency ~28Hz when panel is not pressed
* and with frequency ~140Hz when panel is pressed - this will give ~50 readings per second
******************************************************************************/
void ADC0_IRQHandler(void)
{
switch (touch_state)
{
case TOUCH_INIT: /* enter this state if touch panel is not pressed */
GPIO_PinModeSet(TOUCH_Y1, gpioModePushPull, 1);
GPIO_PinModeSet(TOUCH_Y2, gpioModePushPull, 1);
GPIO_PinModeSet(TOUCH_X1, gpioModeInputPullFilter , 0);
GPIO_PinModeSet(TOUCH_X2, gpioModeInput, 0);
sInit.input = ADC_Y;
sInit.reference = adcRefVDD;
sInit.resolution = adcResOVS;
sInit.acqTime = adcAcqTime128; /* used to slow down */
if(GPIO_PinInGet(TOUCH_X2))
{
touch_state = TOUCH_MEASURE_Y;
GPIO_PinModeSet(TOUCH_X1, gpioModePushPull, 1);
GPIO_PinModeSet(TOUCH_X2, gpioModePushPull, 0);
GPIO_PinModeSet(TOUCH_Y1, gpioModeInput, 0);
GPIO_PinModeSet(TOUCH_Y2, gpioModeInput, 0);
sInit.input = ADC_X;
sInit.acqTime = adcAcqTime16; /* pressed, so speed-up */
}
ADC_InitSingle(ADC0, &sInit);
break;
case TOUCH_CHECK_PRESS: /* checks if touch panel is still pressed */
if( GPIO_PinInGet(TOUCH_X2) )
{
touch_state = TOUCH_MEASURE_Y;
GPIO_PinModeSet(TOUCH_X1, gpioModePushPull, 1);
GPIO_PinModeSet(TOUCH_X2, gpioModePushPull, 0);
GPIO_PinModeSet(TOUCH_Y1, gpioModeInput, 0);
GPIO_PinModeSet(TOUCH_Y2, gpioModeInput, 0);
sInit.input = ADC_X;
sInit.acqTime = adcAcqTime16; /* pressed, so speed-up */
ADC_InitSingle(ADC0, &sInit);
current_pos.pen = newpos.pen;
TOUCH_RecalculatePosition(&newpos);
if (newpos.pen)
{
int call_upcall = TOUCH_StateChanged();
if (call_upcall)
{
current_pos.x = newpos.x;
current_pos.y = newpos.y;
}
current_pos.adcx = newpos.adcx;
current_pos.adcy = newpos.adcy;
current_pos.pen = 1;
if (call_upcall) TOUCH_CallUpcall();
}
newpos.pen = 1;
}
else
{
touch_state = TOUCH_INIT;
newpos.pen = 0;
current_pos.pen = 0;
TOUCH_CallUpcall();
}
break;
case TOUCH_MEASURE_Y: /* touch panel pressed, measure Y position */
newpos.adcy = (ADC_DataSingleGet(ADC0) + 31) >> 6; /* reduce ADC resolution to 10-bits */
GPIO_PinModeSet(TOUCH_Y1, gpioModePushPull, 0); /* to avoid overflow in calibration routines */
GPIO_PinModeSet(TOUCH_Y2, gpioModePushPull, 1);
GPIO_PinModeSet(TOUCH_X1, gpioModeInput, 0);
GPIO_PinModeSet(TOUCH_X2, gpioModeInput, 0);
sInit.input = ADC_Y;
ADC_InitSingle(ADC0, &sInit);
touch_state = TOUCH_MEASURE_X;
break;
case TOUCH_MEASURE_X: /* touch panel pressed, measure X position */
newpos.adcx = (ADC_DataSingleGet(ADC0) + 31) >> 6;
GPIO_PinModeSet(TOUCH_Y1, gpioModePushPull, 1);
GPIO_PinModeSet(TOUCH_Y2, gpioModePushPull, 1);
GPIO_PinModeSet(TOUCH_X1, gpioModeInputPullFilter , 0);
GPIO_PinModeSet(TOUCH_X2, gpioModeInput, 0);
sInit.input = ADC_Y;
ADC_InitSingle(ADC0, &sInit);
touch_state = TOUCH_CHECK_PRESS;
break;
default: touch_state = TOUCH_INIT;
}
ADC_IntClear(ADC0, ADC_IF_SINGLE);
ADC_Start(ADC0, adcStartSingle);
}
__LINK_C bool hw_gpio_get_in(pin_id_t pin_id)
{
return (!!(gpio_pins_configured[pin_id.port] & (1<<pin_id.pin)))
&& GPIO_PinInGet(pin_id.port, pin_id.pin);
}