static void irq_port1_line1(void) {
// print_dbg("\r\ninterrupt on PB08-PB15.");
// static event_t e;
// e.type = kSwitchEvents[swIdx];
// e.data = gpio_get_pin_value(kSwitchPins[swIdx]);
// event_post(&e);
// clock norm
if(gpio_get_pin_interrupt_flag(B09)) {
static event_t e;
e.type = kEventClockNormal;
e.data = !gpio_get_pin_value(B09);
event_post(&e);
gpio_clear_pin_interrupt_flag(B09);
}
// clock in
if(gpio_get_pin_interrupt_flag(B08)) {
// CLOCK BOUNCY WITHOUT THESE PRINTS
// print_dbg("\rclk: ");
// print_dbg_ulong(gpio_get_pin_value(B08));
// (*clock_pulse)(gpio_get_pin_value(B08));
static event_t e;
e.type = kEventClockExt;
e.data = gpio_get_pin_value(B08);
event_post(&e);
gpio_clear_pin_interrupt_flag(B08);
}
}
static void irq_port0_line3(void) {
// print_dbg("\r\n interrupt on port0_line3");
//SW_F0
if(gpio_get_pin_interrupt_flag(SW0_PIN)) {
gpio_clear_pin_interrupt_flag(SW0_PIN);
/// process_sw() will post an event, which calls cpu_irq_disable().
/// apparently, this also clears the GPIO interrupt flags
/// so clear the flag first to avoid triggering an infinite series of interrupts.
/// this might be problematic if we were expecting faster interrupts from switches,
/// but hardware pre-filtering should preclude this.
process_sw(0);
}
// SW_F1
if(gpio_get_pin_interrupt_flag(SW1_PIN)) {
gpio_clear_pin_interrupt_flag(SW1_PIN);
process_sw(1);
}
// SW_F2
if(gpio_get_pin_interrupt_flag(SW2_PIN)) {
gpio_clear_pin_interrupt_flag(SW2_PIN);
process_sw(2);
}
// SW_F3
if(gpio_get_pin_interrupt_flag(SW3_PIN)) {
gpio_clear_pin_interrupt_flag(SW3_PIN);
process_sw(3);
}
// SW_MODE
if(gpio_get_pin_interrupt_flag(SW_MODE_PIN)) {
gpio_clear_pin_interrupt_flag(SW_MODE_PIN);
process_sw(4);
}
}
static void irq_port1_line1(void) {
// print_dbg("\r\ninterrupt on PB08-PB15.");
// clock norm
// if(gpio_get_pin_interrupt_flag(B10)) {
// static event_t e;
// e.type = kEventTrNormal;
// e.data = !gpio_get_pin_value(B10);
// event_post(&e);
// gpio_clear_pin_interrupt_flag(B10);
// }
// clock in
if(gpio_get_pin_interrupt_flag(B08)) {
static event_t e;
e.type = kEventTr;
e.data = gpio_get_pin_value(B08);
event_post(&e);
gpio_clear_pin_interrupt_flag(B08);
}
// tr in
if(gpio_get_pin_interrupt_flag(B09)) {
static event_t e;
e.type = kEventTr;
e.data = gpio_get_pin_value(B09) + 2;
event_post(&e);
gpio_clear_pin_interrupt_flag(B09);
}
}
static void irq_port1_line3(void) {
// print_dbg("\r\n irq_port1_line3");
if(gpio_get_pin_interrupt_flag(FS0_PIN)) {
gpio_clear_pin_interrupt_flag(FS0_PIN);
process_sw(6);
}
if(gpio_get_pin_interrupt_flag(FS1_PIN)) {
gpio_clear_pin_interrupt_flag(FS1_PIN);
process_sw(7);
}
}
static void irq_port1_line1(void) {
// print_dbg("\r\b\interrupt on PB08-PB15.");
// ENC3_0
if(gpio_get_pin_interrupt_flag(ENC3_S0_PIN)) {
process_enc(3);
gpio_clear_pin_interrupt_flag(ENC3_S0_PIN);
}
// ENC3_1
if(gpio_get_pin_interrupt_flag(ENC3_S1_PIN)) {
process_enc(3);
gpio_clear_pin_interrupt_flag(ENC3_S1_PIN);
}
}
static void gpio_pin_change_interrupt_handler(void)
{
// Clear the pin change interrupt flag
gpio_clear_pin_interrupt_flag(GPIO_PIN_EXAMPLE_2);
// Toggle GPIO_PIN_EXAMPLE_3
gpio_tgl_gpio_pin(GPIO_PIN_EXAMPLE_3);
}
void board_init(void)
{
gpio_configure_pin(LED0_GPIO,GPIO_DIR_OUTPUT | GPIO_INIT_HIGH);
gpio_configure_pin(LED1_GPIO,GPIO_DIR_OUTPUT | GPIO_INIT_HIGH);
#if defined (CONF_BOARD_AT86RFX)
// AT86RFX SPI GPIO options.
static gpio_map_t AT86RFX_SPI_GPIO_MAP =
{
{AT86RFX_SPI_SCK_PIN, AT86RFX_SPI_SCK_FUNCTION },
{AT86RFX_SPI_MISO_PIN, AT86RFX_SPI_MISO_FUNCTION},
{AT86RFX_SPI_MOSI_PIN, AT86RFX_SPI_MOSI_FUNCTION},
{AT86RFX_SPI_NPCS_PIN, AT86RFX_SPI_NPCS_FUNCTION}
};
// Assign GPIO to SPI.
gpio_enable_module(AT86RFX_SPI_GPIO_MAP, sizeof(AT86RFX_SPI_GPIO_MAP) / sizeof(AT86RFX_SPI_GPIO_MAP[0]));
gpio_enable_pin_interrupt(AT86RFX_IRQ_PIN, GPIO_RISING_EDGE);
gpio_clear_pin_interrupt_flag(AT86RFX_IRQ_PIN);
gpio_configure_pin(AT86RFX_RST_PIN, GPIO_DIR_OUTPUT | GPIO_INIT_HIGH);
gpio_configure_pin(AT86RFX_SLP_PIN, GPIO_DIR_OUTPUT | GPIO_INIT_HIGH);
#endif
}
/*! \internal Sensor Board GPIO interrupt handler
*
* This is the default ISR for the Xplained Sensor board GPIO pins. If
* an external interrupt interface is available, the corresponding
* eic_pinX_handler will be used instead.
*
* \return Nothing.
*/
ISR(gpio_irq_handler, AVR32_GPIO_IRQ_GROUP, GPIO_INT_LVL)
{
if (gpio_get_pin_interrupt_flag(SENSOR_BOARD_PIN3)) {
sensor_pin3_handler(sensor_pin3_arg);
gpio_clear_pin_interrupt_flag(SENSOR_BOARD_PIN3);
} else if (gpio_get_pin_interrupt_flag(SENSOR_BOARD_PIN4)) {
sensor_pin4_handler(sensor_pin4_arg);
gpio_clear_pin_interrupt_flag(SENSOR_BOARD_PIN4);
} else if (gpio_get_pin_interrupt_flag(SENSOR_BOARD_PIN5)) {
sensor_pin5_handler(sensor_pin5_arg);
gpio_clear_pin_interrupt_flag(SENSOR_BOARD_PIN5);
}
}
__interrupt
#endif
static void dip204_example_Joy_int_handler(void)
{
if (gpio_get_pin_interrupt_flag(GPIO_JOYSTICK_UP))
{
dip204_set_cursor_position(19,1);
dip204_write_data(0xDE);
display = 1;
/* allow new interrupt : clear the IFR flag */
gpio_clear_pin_interrupt_flag(GPIO_JOYSTICK_UP);
}
if (gpio_get_pin_interrupt_flag(GPIO_JOYSTICK_DOWN))
{
dip204_set_cursor_position(19,3);
dip204_write_data(0xE0);
display = 1;
/* allow new interrupt : clear the IFR flag */
gpio_clear_pin_interrupt_flag(GPIO_JOYSTICK_DOWN);
}
if (gpio_get_pin_interrupt_flag(GPIO_JOYSTICK_LEFT))
{
dip204_set_cursor_position(18,2);
dip204_write_data(0xE1);
display = 1;
/* allow new interrupt : clear the IFR flag */
gpio_clear_pin_interrupt_flag(GPIO_JOYSTICK_LEFT);
}
if (gpio_get_pin_interrupt_flag(GPIO_JOYSTICK_RIGHT))
{
dip204_set_cursor_position(20,2);
dip204_write_data(0xDF);
display = 1;
/* allow new interrupt : clear the IFR flag */
gpio_clear_pin_interrupt_flag(GPIO_JOYSTICK_RIGHT);
}
if (gpio_get_pin_interrupt_flag(GPIO_JOYSTICK_PUSH))
{
dip204_set_cursor_position(19,2);
dip204_write_data(0xBB);
dip204_set_cursor_position(1,4);
dip204_write_string(" AT32UC3A Series ");
display = 1;
/* allow new interrupt : clear the IFR flag */
gpio_clear_pin_interrupt_flag(GPIO_JOYSTICK_PUSH);
}
}
static void irq_port0_line1(void) {
if(gpio_get_pin_interrupt_flag(NMI)) {
// print_dbg("\r\n ### NMI ### ");
event_t e = { .type = kEventFront, .data = gpio_get_pin_value(NMI) };
event_post(&e);
gpio_clear_pin_interrupt_flag(NMI);
}
}
static void inline rtouch_disable_detect_int(void)
{
/* Disable interrupt for Y lines. */
/* Clear the pin interrupt, or otherwise it will trigger when
* enabled again */
gpio_clear_pin_interrupt_flag(rtouch_gpio_ymap[0].pin);
gpio_disable_pin_interrupt(rtouch_gpio_ymap[0].pin);
}
static void irq_port1_line2(void) {
// print_dbg("\r\n interrupt on pb16-pb23 : ");
//SW_POWER
if(gpio_get_pin_interrupt_flag(SW_POWER_PIN)) {
gpio_clear_pin_interrupt_flag(SW_POWER_PIN);
process_sw(5);
}
}
static void interrupt_J3(void)
{
if ((gpio_get_pin_interrupt_flag(TEST_A))){
gpio_clear_pin_interrupt_flag(TEST_A);
A = true;
}
if ((gpio_get_pin_interrupt_flag(TEST_B))){
gpio_clear_pin_interrupt_flag(TEST_B);
B = true;
}
if ((gpio_get_pin_interrupt_flag(TEST_C))){
gpio_clear_pin_interrupt_flag(TEST_C);
C = true;
}
}
//!
//! @brief Suspend callback.
//!
//! This function enables the interrupts in order to send a remote wakeup to the host.
//!
void usb_suspend(void)
{
if(remote_wakeup_feature) {
// Enable ISR on switches
#if BOARD == EVK1105
gpio_clear_pin_interrupt_flag(QT1081_TOUCH_SENSOR_ENTER);
gpio_enable_pin_interrupt(QT1081_TOUCH_SENSOR_ENTER, GPIO_RISING_EDGE);
#endif
}
}
static void irq_port0_line0(void) {
for(int i=0;i<8;i++) {
if(gpio_get_pin_interrupt_flag(i)) {
// print_dbg("\r\n # A00");
event_t e = { .type = kEventTrigger, .data = i };
event_post(&e);
gpio_clear_pin_interrupt_flag(i);
}
}
}
__interrupt
#endif
static void dip204_example_PB_int_handler(void)
{
unsigned short i;
/* display all available chars */
if (gpio_get_pin_interrupt_flag(GPIO_CHARSET))
{
/* go to first column of 4th line */
dip204_set_cursor_position(1,4);
/* display 20 chars of charmap */
for (i = current_char; i < current_char + 0x10; i++)
{
dip204_write_data(i);
}
dip204_write_string(" ");
/* mark position in charmap */
current_char = i;
/* reset marker */
if (current_char >= 0xFF)
{
current_char = 0x10;
}
/* allow new interrupt : clear the IFR flag */
gpio_clear_pin_interrupt_flag(GPIO_CHARSET);
}
/* increase backlight power */
if (gpio_get_pin_interrupt_flag(GPIO_BACKLIGHT_PLUS))
{
dip204_set_backlight(backlight_power_increase);
/* allow new interrupt : clear the IFR flag */
gpio_clear_pin_interrupt_flag(GPIO_BACKLIGHT_PLUS);
}
/* decrease backlight power */
if (gpio_get_pin_interrupt_flag(GPIO_BACKLIGHT_MINUS))
{
dip204_set_backlight(backlight_power_decrease);
/* allow new interrupt : clear the IFR flag */
gpio_clear_pin_interrupt_flag(GPIO_BACKLIGHT_MINUS);
}
}
static void interrupt_J3(void)
{
if (gpio_get_pin_interrupt_flag(TEST_A)){
A_FLAG = true;
gpio_clear_pin_interrupt_flag(TEST_A);
}
else if(gpio_get_pin_interrupt_flag(TEST_B)){
B_FLAG = true;
gpio_clear_pin_interrupt_flag(TEST_B);
}
else if(gpio_get_pin_interrupt_flag(TEST_C)){
C_FLAG = true;
gpio_clear_pin_interrupt_flag(TEST_C);
}
}
__interrupt
#endif
void at42qt1060_detect_int_handler(void)
{
if(gpio_get_pin_interrupt_flag(AT42QT1060_DETECT_PIN))
{
gpio_clear_pin_interrupt_flag(AT42QT1060_DETECT_PIN);
if(at42qt1060.touch_detect_callback)
at42qt1060.touch_detect_callback();
}
}
static portBASE_TYPE prvpushb_ISR_NonNakedBehaviour( void )
{
if (gpio_get_pin_interrupt_flag(GPIO_PUSH_BUTTON_0))
{
// set the flag
bSendMail = pdTRUE;
// allow new interrupt : clear the IFR flag
gpio_clear_pin_interrupt_flag(GPIO_PUSH_BUTTON_0);
}
// no context switch required, task is polling the flag
return( pdFALSE );
}
static void irq_port1_line0(void) {
// print_dbg("\r\b\interrupt on PB00-PB07.");
// ENC0_0
if(gpio_get_pin_interrupt_flag(ENC0_S0_PIN)) {
process_enc(0);
gpio_clear_pin_interrupt_flag(ENC0_S0_PIN);
}
// ENC0_1
if(gpio_get_pin_interrupt_flag(ENC0_S1_PIN)) {
process_enc(0);
gpio_clear_pin_interrupt_flag(ENC0_S1_PIN);
}
// ENC1_0
if(gpio_get_pin_interrupt_flag(ENC1_S0_PIN)) {
process_enc(1);
gpio_clear_pin_interrupt_flag(ENC1_S0_PIN);
}
// ENC1_1
if(gpio_get_pin_interrupt_flag(ENC1_S1_PIN)) {
process_enc(1);
gpio_clear_pin_interrupt_flag(ENC1_S1_PIN);
}
// ENC2_0
if(gpio_get_pin_interrupt_flag(ENC2_S0_PIN)) {
process_enc(2);
gpio_clear_pin_interrupt_flag(ENC2_S0_PIN);
}
// ENC2_1
if(gpio_get_pin_interrupt_flag(ENC2_S1_PIN)) {
process_enc(2);
gpio_clear_pin_interrupt_flag(ENC2_S1_PIN);
}
}
static inline void manage_button_isr(int pin, enum joystick_status_t status_pressed, enum joystick_status_t status_released)
{
if (gpio_get_pin_interrupt_flag(pin))
{
// Clear current pin status
joystick_status &= ~(status_pressed | status_released);
if (gpio_get_pin_value(pin))
joystick_status |= status_pressed;
else
joystick_status |= status_released;
gpio_clear_pin_interrupt_flag(pin);
}
}
__interrupt
#endif
void touch_button_isr(void)
{
// Unfreeze the clock (this has been done in the SUSPEND state
Usb_unfreeze_clock();
// Launch the remote wakeup
Usb_initiate_remote_wake_up();
//Disable the GPIO activity detection
gpio_clear_pin_interrupt_flag(QT1081_TOUCH_SENSOR_ENTER);
gpio_disable_pin_interrupt(QT1081_TOUCH_SENSOR_ENTER);
}
/** \brief Register a normal pin interrupt for the touch event.
*
*/
void at42qt1060_register_int(void (*touch_detect_callback)(void))
{
at42qt1060.touch_detect_callback = touch_detect_callback;
Disable_global_interrupt();
INTC_register_interrupt(&at42qt1060_detect_int_handler, AVR32_GPIO_IRQ_0 + AT42QT1060_DETECT_PIN/8, 0 );
// For now we only react on falling edge
// Actually this is a level interrupt (low active)
gpio_enable_pin_interrupt(AT42QT1060_DETECT_PIN, GPIO_FALLING_EDGE);
gpio_clear_pin_interrupt_flag(AT42QT1060_DETECT_PIN);
Enable_global_interrupt();
return;
}
__interrupt
#endif
#if(INT_MODE == INT_MODE_GPIO)
void touch_button_isr(void){
// UP
if(gpio_get_pin_interrupt_flag(QT1081_TOUCH_SENSOR_0))
{
gpio_clear_pin_interrupt_flag(QT1081_TOUCH_SENSOR_0);
gpio_tgl_gpio_pin(LED0_GPIO);
}
// DOWN
if(gpio_get_pin_interrupt_flag(QT1081_TOUCH_SENSOR_1))
{
gpio_clear_pin_interrupt_flag(QT1081_TOUCH_SENSOR_1);
gpio_tgl_gpio_pin(LED1_GPIO);
}
// Right
if(gpio_get_pin_interrupt_flag(QT1081_TOUCH_SENSOR_2))
{
gpio_clear_pin_interrupt_flag(QT1081_TOUCH_SENSOR_2);
gpio_tgl_gpio_pin(LED2_GPIO);
}
// Left
if(gpio_get_pin_interrupt_flag(QT1081_TOUCH_SENSOR_3))
{
gpio_clear_pin_interrupt_flag(QT1081_TOUCH_SENSOR_3);
gpio_tgl_gpio_pin(LED3_GPIO);
}
// Push
if(gpio_get_pin_interrupt_flag(QT1081_TOUCH_SENSOR_4))
{
gpio_clear_pin_interrupt_flag(QT1081_TOUCH_SENSOR_4);
gpio_tgl_gpio_pin(LED0_GPIO);
}
}
__interrupt
#endif
void push_button_interrupt_handler(void)
{
if (gpio_get_pin_interrupt_flag(GPIO_PUSH_BUTTON_1))
{
// Switch to next state based on current state
switch (state_indicator)
{
case STATE_1:
state_indicator = STATE_2;
break;
case STATE_2:
state_indicator = STATE_1;
break;
}
// Set run_once variable to true
run_once = TRUE;
// Clear interrupt flag to allow new interrupts
gpio_clear_pin_interrupt_flag(GPIO_PUSH_BUTTON_1);
}
}
void init_PWM(int velocidad, int direccion){
int auxiliar;
switch(velocidad){
case 9:
auxiliar = 2;
break;
case 8:
auxiliar = 4;
break;
case 7:
auxiliar = 6;
break;
case 6:
auxiliar = 8;
break;
case 5:
auxiliar = 10;
break;
case 4:
auxiliar = 12;
break;
case 3:
auxiliar = 14;
break;
case 2:
auxiliar = 16;
break;
case 1:
auxiliar = 18;
break;
}//SWITCH
pwm_opt_t pwm_opt =
{
.diva = AVR32_PWM_DIVA_CLK_OFF,
.divb = AVR32_PWM_DIVB_CLK_OFF,
.prea = AVR32_PWM_PREA_MCK,
.preb = AVR32_PWM_PREB_MCK
};
avr32_pwm_channel_t pwm_channel = { .ccnt = 0 };
pwm_channel.cdty = auxiliar; /* Channel duty cycle, should be < CPRD. */
pwm_channel.cprd = 20; /* Channel period. */
pwm_channel.cupd = 0; /* Channel update is not used here. */
pwm_channel.CMR.calg = PWM_MODE_LEFT_ALIGNED; /* Channel mode. */
pwm_channel.CMR.cpol = PWM_POLARITY_LOW; /* Channel polarity. */
pwm_channel.CMR.cpd = PWM_UPDATE_DUTY; /* Not used the first time. */
pwm_channel.CMR.cpre = AVR32_PWM_CPRE_MCK_DIV_256; /* Channel prescaler. */
gpio_enable_module_pin(PWM_PIN_3, PWM_PIN_Function);
gpio_enable_module_pin(PWM_PIN_1, PWM_PIN_Function);
pwm_init(&pwm_opt);
if(direccion == 1){//FORWARD
pwm_channel_init(PWM_ID_3, &pwm_channel);
pwm_start_channels(1 << PWM_ID_3);
}
if(direccion == 0){//REVERSE
pwm_channel_init(PWM_ID_1, &pwm_channel);
pwm_start_channels(1 << PWM_ID_1);
}
}
void update_PWM(int velocidad, int direccion){
int auxiliar;
switch(velocidad){
case 9:
auxiliar = 2;
break;
case 8:
auxiliar = 4;
break;
case 7:
auxiliar = 6;
break;
case 6:
auxiliar = 8;
break;
case 5:
auxiliar = 10;
break;
case 4:
auxiliar = 12;
break;
case 3:
auxiliar = 14;
break;
case 2:
auxiliar = 16;
break;
case 1:
auxiliar = 18;
break;
}//SWITCH
avr32_pwm_channel_t pwm_channel = { .ccnt = 0 };
pwm_channel.cdty = auxiliar; /* Channel duty cycle, should be < CPRD. */
pwm_channel.cprd = 20; /* Channel period. */
pwm_channel.cupd = 0; /* Channel update is not used here. */
pwm_channel.CMR.calg = PWM_MODE_LEFT_ALIGNED; /* Channel mode. */
pwm_channel.CMR.cpol = PWM_POLARITY_LOW; /* Channel polarity. */
pwm_channel.CMR.cpd = PWM_UPDATE_DUTY; /* Not used the first time. */
pwm_channel.CMR.cpre = AVR32_PWM_CPRE_MCK_DIV_256; /* Channel prescaler. */
if(direccion == 1){//FORWARD
pwm_stop_channels(1<<PWM_ID_1);
pwm_stop_channels(1<<PWM_ID_3);
pwm_channel_init(PWM_ID_3, &pwm_channel);
pwm_start_channels(1 << PWM_ID_3);
}
if(direccion == 0){//REVERSE
pwm_stop_channels(1<<PWM_ID_1);
pwm_stop_channels(1<<PWM_ID_3);
pwm_channel_init(PWM_ID_1, &pwm_channel);
pwm_start_channels(1 << PWM_ID_1);
}
bandera = 0;
}
static void handler_interrupt(void){
if (gpio_get_pin_interrupt_flag(GPIO_JOYSTICK_UP)){
direccion = 1;
gpio_clear_pin_interrupt_flag(GPIO_JOYSTICK_UP);
}
if (gpio_get_pin_interrupt_flag(GPIO_JOYSTICK_DOWN)){
direccion = 0;
gpio_clear_pin_interrupt_flag(GPIO_JOYSTICK_DOWN);
}
bandera = 1;
}
void init_INTC(void){
gpio_enable_pin_interrupt(GPIO_JOYSTICK_UP , GPIO_FALLING_EDGE);
gpio_enable_pin_interrupt(GPIO_JOYSTICK_DOWN , GPIO_FALLING_EDGE);
Disable_global_interrupt();
INTC_init_interrupts();
INTC_register_interrupt( &handler_interrupt, AVR32_GPIO_IRQ_0 + (GPIO_JOYSTICK_UP/8), AVR32_INTC_INT1);
INTC_register_interrupt( &handler_interrupt, AVR32_GPIO_IRQ_0 + (GPIO_JOYSTICK_DOWN/8), AVR32_INTC_INT1);
Enable_global_interrupt();
}
static void inline rtouch_clear_detect_flag(void)
{
gpio_clear_pin_interrupt_flag(rtouch_gpio_ymap[0].pin);
}
/*********************************************************************
Functions
*********************************************************************/
int main (void)
{
int i;
// initialize
init();
gpio_configure_pin(TEST_A, GPIO_DIR_INPUT | GPIO_INIT_HIGH);
gpio_configure_pin(TEST_B, GPIO_DIR_INPUT | GPIO_INIT_HIGH);
gpio_configure_pin(TEST_C, GPIO_DIR_INPUT | GPIO_INIT_HIGH);
gpio_configure_pin(RESPONSE_A, GPIO_DIR_OUTPUT | GPIO_INIT_HIGH);
gpio_configure_pin(RESPONSE_B, GPIO_DIR_OUTPUT | GPIO_INIT_HIGH);
gpio_configure_pin(RESPONSE_C, GPIO_DIR_OUTPUT | GPIO_INIT_HIGH);
// ASS C
gpio_enable_pin_interrupt(TEST_A, GPIO_FALLING_EDGE );
gpio_enable_pin_interrupt(TEST_B, GPIO_FALLING_EDGE );
gpio_enable_pin_interrupt(TEST_C, GPIO_FALLING_EDGE );
// start code from here
while(1)
{
//gpio_toggle_pin(LED0_GPIO);
/*
if(gpio_pin_is_low(TEST_A)){
gpio_set_pin_low(RESPONSE_A);
busy_delay_us(5);
gpio_set_pin_high(RESPONSE_A);
}
if(gpio_pin_is_low(TEST_B)){
gpio_set_pin_low(RESPONSE_B);
busy_delay_us(5);
gpio_set_pin_high(RESPONSE_B);
}
if (gpio_pin_is_low(TEST_C)){
gpio_set_pin_low(RESPONSE_C);
busy_delay_us(5);
gpio_set_pin_high(RESPONSE_C);
}
*/
//gpio_set_pin_high(LED0_GPIO);
//busy_delay_ms(500);
//gpio_set_pin_low(LED0_GPIO);
//busy_delay_ms(500);
// INTERRUPTS
// AssD
if (A_FLAG){
gpio_set_pin_low(RESPONSE_A);
busy_delay_us(5);
gpio_set_pin_high(RESPONSE_A);
gpio_clear_pin_interrupt_flag(TEST_A);
A_FLAG = false;
}
else if(B_FLAG){
gpio_set_pin_low(RESPONSE_B);
busy_delay_us(5);
gpio_set_pin_high(RESPONSE_B);
gpio_clear_pin_interrupt_flag(TEST_B);
B_FLAG = false;
}
else if(C_FLAG){
gpio_set_pin_low(RESPONSE_C);
busy_delay_us(5);
gpio_set_pin_high(RESPONSE_C);
gpio_clear_pin_interrupt_flag(TEST_C);
C_FLAG = false;
}
}
}
static portBASE_TYPE prvjoystick_ISR_NonNakedBehaviour( void )
{
xLogDef *pxLog;
U32 u32CurrentCountValue = xTaskGetTickCount();
// Debouncing: ignore joystick events occuring in less than 250ms before the last
// valid joystick event.
if((( u32CurrentCountValue >= u32LastCountValue )
&& ( u32CurrentCountValue - u32LastCountValue <= 250))
||
(( u32CurrentCountValue < u32LastCountValue )
&& ( u32CurrentCountValue + (0xFFFFFFFF - u32LastCountValue) <= 250)))
{
// Clear all interrupts flag (it's no use checking which event has bouncing).
gpio_clear_pin_interrupt_flag(GPIO_JOYSTICK_PUSH);
Clr_bits(x_joystick, JS_EVENT_PUSH);
gpio_clear_pin_interrupt_flag(GPIO_JOYSTICK_LEFT);
Clr_bits(x_joystick, JS_EVENT_LEFT);
gpio_clear_pin_interrupt_flag(GPIO_JOYSTICK_RIGHT);
Clr_bits(x_joystick, JS_EVENT_RIGHT);
gpio_clear_pin_interrupt_flag(GPIO_JOYSTICK_UP);
Clr_bits(x_joystick, JS_EVENT_UP);
gpio_clear_pin_interrupt_flag(GPIO_JOYSTICK_DOWN);
Clr_bits(x_joystick, JS_EVENT_DOWN);
return(pdFALSE);
}
else
{
// Update last valid joystick event timestamp.
u32LastCountValue = u32CurrentCountValue;
// Check all events.
if (gpio_get_pin_interrupt_flag(GPIO_JOYSTICK_UP))
{
/* input is pulled up, if 1 : input is not active */
if (gpio_get_pin_value(GPIO_JOYSTICK_UP))
{
/* clear bit UP */
Clr_bits(x_joystick, JS_EVENT_UP);
}
else
{
Set_bits(x_joystick, JS_EVENT_UP);
}
/* allow new interrupt : clear the IFR flag */
gpio_clear_pin_interrupt_flag(GPIO_JOYSTICK_UP);
}
if (gpio_get_pin_interrupt_flag(GPIO_JOYSTICK_DOWN))
{
/* input is pulled up, if 1 : input is not active */
if (gpio_get_pin_value(GPIO_JOYSTICK_DOWN))
{
Clr_bits(x_joystick, JS_EVENT_DOWN);
}
else
{
Set_bits(x_joystick, JS_EVENT_DOWN);
}
/* allow new interrupt : clear the IFR flag */
gpio_clear_pin_interrupt_flag(GPIO_JOYSTICK_DOWN);
}
if (gpio_get_pin_interrupt_flag(GPIO_JOYSTICK_LEFT))
{
/* input is pulled up, if 1 : input is not active */
if (gpio_get_pin_value(GPIO_JOYSTICK_LEFT))
{
Clr_bits(x_joystick, JS_EVENT_LEFT);
}
else
{
Set_bits(x_joystick, JS_EVENT_LEFT);
#ifdef MMILCD_ENABLE
vMMI_UserMenuDisplayPreviousItem(pdTRUE);
#endif
}
/* allow new interrupt : clear the IFR flag */
gpio_clear_pin_interrupt_flag(GPIO_JOYSTICK_LEFT);
}
if (gpio_get_pin_interrupt_flag(GPIO_JOYSTICK_RIGHT))
{
/* input is pulled up, if 1 : input is not active */
if (gpio_get_pin_value(GPIO_JOYSTICK_RIGHT))
{
Clr_bits(x_joystick, JS_EVENT_RIGHT);
}
else
{
Set_bits(x_joystick, JS_EVENT_RIGHT);
#ifdef MMILCD_ENABLE
vMMI_UserMenuDisplayNextItem(pdTRUE);
#endif
}
/* allow new interrupt : clear the IFR flag */
gpio_clear_pin_interrupt_flag(GPIO_JOYSTICK_RIGHT);
}
if (gpio_get_pin_interrupt_flag(GPIO_JOYSTICK_PUSH))
{
/* input is pulled up, if 1 : input is not active */
if (gpio_get_pin_value(GPIO_JOYSTICK_PUSH))
{
Clr_bits(x_joystick, JS_EVENT_PUSH);
}
else
{
Set_bits(x_joystick, JS_EVENT_PUSH);
if ( bAlarm == pdTRUE )
{
// post alarm to SMTP task
v_SMTP_PostFromISR("Joystick Alarm", NULL);
}
#ifdef MMILCD_ENABLE
vMMI_UserMenuValidateItem(pdTRUE);
#endif
}
/* allow new interrupt : clear the IFR flag */
gpio_clear_pin_interrupt_flag(GPIO_JOYSTICK_PUSH);
}
}
// Alloc and init a log.
pxLog = pxdatalog_log_alloc_init_FromISR();
if( NULL == pxLog )
return( pdFALSE );
// Init the id field of the log.
pxLog->id = DATALOG_ID_JS;
/* set log event string */
pxLog->pcStringLog = (portCHAR *)acpc_js_events[x_joystick];
/* set free function pointer */
pxLog->pfFreeStringLog = NULL;
/* add the log entry */
return( x_datalog_AddLogFromISR( pxLog ) );
}
static void twi_init(U32 fpba_hz)
{
const gpio_map_t AT42QT1060_TWI_GPIO_MAP =
{
{AT42QT1060_TWI_SCL_PIN, AT42QT1060_TWI_SCL_FUNCTION},
{AT42QT1060_TWI_SDA_PIN, AT42QT1060_TWI_SDA_FUNCTION}
};
const twi_options_t AT42QT1060_TWI_OPTIONS =
{
.pba_hz = 24000000,
.speed = AT42QT1060_TWI_MASTER_SPEED,
.chip = AT42QT1060_TWI_ADDRESS
};
// Assign I/Os to SPI.
gpio_enable_module(AT42QT1060_TWI_GPIO_MAP,
sizeof(AT42QT1060_TWI_GPIO_MAP) / sizeof(AT42QT1060_TWI_GPIO_MAP[0]));
// Initialize as master.
twi_master_init(AT42QT1060_TWI, &AT42QT1060_TWI_OPTIONS);
}
/*! \brief Callback function for a detect event of the touch sensor device.
*/
void touch_detect_callback(void)
{
touch_detect = true;
}
struct at42qt1060_data touch_data;
void controller_task(void)
{
// if a touch is detected we read the status
if(touch_detect)
{
touch_data.detect_status =
at42qt1060_read_reg(AT42QT1060_DETECTION_STATUS);
// need to read input port status too to reset CHG line
at42qt1060_read_reg(AT42QT1060_INPUT_PORT_STATUS);
touch_detect = false;
}
}
static void controller_detect_int_handler(void)
{
if(gpio_get_pin_interrupt_flag(AT42QT1060_DETECT_PIN))
{
gpio_clear_pin_interrupt_flag(AT42QT1060_DETECT_PIN);
touch_detect_callback();
}
}
void controller_init(U32 fcpu_hz, U32 fhsb_hz, U32 fpbb_hz, U32 fpba_hz)
{
// Disable all interrupts
Disable_global_interrupt();
twi_init(fpba_hz);
// wait until the device settles its CHG line
cpu_delay_ms(230, fcpu_hz);
at42qt1060_init(fcpu_hz);
BSP_INTC_IntReg(&controller_detect_int_handler, AVR32_GPIO_IRQ_0 + AT42QT1060_DETECT_PIN/8, AVR32_INTC_INT1);
// For now we only react on falling edge
// Actually this is a level interrupt (low active)
gpio_enable_pin_interrupt(AT42QT1060_DETECT_PIN, GPIO_FALLING_EDGE);
gpio_clear_pin_interrupt_flag(AT42QT1060_DETECT_PIN);
//static_fcpu_hz = fcpu_hz;
cpu_set_timeout(cpu_ms_2_cy(JOYSTICK_KEY_DEBOUNCE_MS, static_fcpu_hz),
&joystick_key_sensibility_timer);
// Enable global interrupts
Enable_global_interrupt();
}
