int main(void)
{
// Disable watchdog timer
wdt_disable(WDT);
// Enable peripheral clock to be able to read button state
pmc_enable_periph_clk(BUTTONS_PIO_ID);
while (!pmc_is_periph_clk_enabled(BUTTONS_PIO_ID));
// Configure pins
pio_set_output(LEDS_PIO, ALL_LEDS, 1, false, false);
pio_set_input(BUTTONS_PIO, ALL_BUTTONS, PIO_PULLUP);
while (true)
{
pio_set(LEDS_PIO, LED_ORANGE);
pio_clear(LEDS_PIO, LED_GREEN);
while (pio_get(BUTTONS_PIO, PIO_INPUT, BUTTON1));
pio_clear(LEDS_PIO, LED_ORANGE);
pio_set(LEDS_PIO, LED_GREEN);
while (pio_get(BUTTONS_PIO, PIO_INPUT, BUTTON2));
}
return 0;
}
/**
* Monitor buttons of joystick status.
* \param p_btn_status Pointer to button status bitmap.
* \param p_dx Pointer to fill x value.
* \param p_dy Pointer to fill y value.
*/
static uint8_t _buttons_monitor(uint8_t *btn_status, int8_t *dx, int8_t *dy)
{
uint8_t is_changed = 0;
btn_status = btn_status; /*dummy */
#ifdef NO_PUSHBUTTON
/* - Movement W S A D */
if (console_is_rx_ready())
{
uint8_t key = console_get_char();
*dx = 0;
*dy = 0;
switch (key)
{
case 'i':
case 'I':
*dy = -SPEED_Y;
is_changed = 1;
break;
case 'k':
case 'K':
*dy = +SPEED_Y;
is_changed = 1;
break;
case 'j':
case 'J':
*dx = -SPEED_X;
is_changed = 1;
break;
case 'l':
case 'L':
*dx = +SPEED_X;
is_changed = 1;
break;
default:
break;
}
}
#else
/* - Movement buttons, Joystick or Push buttons */
if (pio_get(&pins_joystick[JOYSTICK_LEFT]) == 0) {
*dx = -SPEED_X;
is_changed = 1;
} else if (pio_get(&pins_joystick[JOYSTICK_RIGHT]) == 0) {
*dx = SPEED_X;
is_changed = 1;
} else {
*dx = 0;
}
#endif
return is_changed;
}
int libsoc_mmap_gpio_request(mmap_gpio *pio, char port, uint32_t pin)
{
pio->port = port;
pio->pin = pin;
if (pio_get(gpio_mem, pio) == PIO_SUCCESS)
{
return 1;
}
return 0;
}
/**
* Interrupt handler for TC0 interrupt.
*/
void TC0_Handler(void)
{
volatile uint32_t ul_dummy;
/****************************************************************
* Devemos indicar ao TC que a interrupção foi satisfeita.
******************************************************************/
ul_dummy = tc_get_status(TC0,0);
if (flagB == 1)
{
/* Avoid compiler warning */
UNUSED(ul_dummy);
/** Muda o estado do LED */
if(pio_get(PIOA,PIO_OUTPUT_0,MASK_LED_BLUE))
{
pio_clear(PIOA,MASK_LED_BLUE);
}
else
{
pio_set(PIOA,MASK_LED_BLUE);
}
if (flagG == 2)
{
/** Muda o estado do LED */
if(pio_get(PIOA,PIO_OUTPUT_0,MASK_LED_GREEN))
{
pio_clear(PIOA,MASK_LED_GREEN);
}
else
{
pio_set(PIOA,MASK_LED_GREEN);
}
}
}
}
mmap_gpio* libsoc_mmap_gpio_request(char port, unsigned int pin)
{
mmap_gpio* gpio = calloc(sizeof(mmap_gpio), 1);
*(char*)&gpio->port = port;
*(int*)&gpio->pin = pin;
if (pio_get(gpio_mem, gpio) == PIO_SUCCESS)
{
return gpio;
}
return NULL;
}
extern "C" bool digitalRead(Pin pin)
{
if (pin > MaxPinNumber)
{
return false;
}
const PinDescription& pinDesc = g_APinDescription[pin];
if (pinDesc.ulPinType == PIO_NOT_A_PIN)
{
return false;
}
return (bool)pio_get(pinDesc.pPort, PIO_INPUT, pinDesc.ulPin);
}
/**
* \brief Main code entry point.
*/
int main( void )
{
xTimerHandle xMonitorTimer;
/* Prepare the hardware */
prvSetupHardware();
/* Init Prime Stack */
vPrimeStackInitTask();
/* Configure console */
configure_dbg_console();
puts(STRING_HEADER);
/* Debug port for AppEmu */
if (!pio_get(PIN_APPEMU_PIO, PIN_APPEMU_TYPE, PIN_APPEMU_MASK)) {
/* Init AppEmu Application */
vAppEmuInitTask();
}
/* Create timer to monitor tasks execution */
xMonitorTimer = xTimerCreate(
(const signed char *const)"Monitor timer",
SIGNALLING_TIMER_RATE,
pdTRUE,
NULL,
_prime_signalling
);
configASSERT(xMonitorTimer);
xTimerStart(xMonitorTimer, SIGNALLING_TIMER_RATE);
/* Start the tasks and timer running. */
vTaskStartScheduler();
/* If all is well, the scheduler will now be running, and the following
* line will never be reached. If the following line does execute, then
* there was insufficient FreeRTOS heap memory available for the idle
* and/or
* timer tasks to be created. See the memory management section on the
* FreeRTOS web site for more details. */
for (;;) {
}
}
/**
* \brief getting-started Application entry point.
*
* \return Unused (ANSI-C compatibility).
*/
int main(void)
{
int tests = 0;
int test_fail = 0;
printf("<?xml version=\"1.0\" encoding=\"UTF-8\">\r\n\r\n");
printf("<testsuite>\r\n");
printf(" <testcase classname=\"pio.setup\" name=\"Setup\">\r\n");
printf(" <system-out>\r\n");
/* Output example information */
console_example_info("PIO Testing Example");
/* Configure PIO for input acquisition */
pio_configure(&pio_input, 1);
pio_set_debounce_filter(&pio_input, 100);
/* Initialize pios interrupt with its handlers, see
* PIO definition in board.h. */
pio_configure_it(&pio_input);
pio_add_handler_to_group(pio_input.group, pio_input.mask, pio_handler, NULL);
/* Configure PIO for output generation */
pio_configure(&pio_output, 1);
/* Reset event counts */
_pio_event = 0;
printf(" </system-out>\r\n");
printf(" </testcase>\r\n");
printf("<testsuite>\r\n");
printf(" <testcase classname=\"pio.level.low\" name='PIO: Set/Get PIO LOW LEVEL'>\r\n");
printf(" <system-out>\r\n");
_pio_event = 0;
pio_clear(&pio_output);
timer_wait(10);
printf(" </system-out>\r\n");
if (!(pio_get(&pio_input) == 0) || !(pio_get(&pio_output) == 0)) {
test_fail++;
printf(" <error type=\"error\" />\r\n");
}
tests++;
printf(" </testcase>\r\n");
printf(" <testcase classname=\"pio.level.high\" name=\"PIO: Get PIO HIGH LEVEL\">\r\n");
printf(" <system-out>\r\n");
_pio_event = 0;
pio_set(&pio_output);
timer_wait(10);
printf(" </system-out>\r\n");
if (!(pio_get(&pio_input) == 1) || !(pio_get(&pio_output) == 1)) {
test_fail++;
printf(" <error type=\"error\" />\r\n");
}
tests++;
printf(" </testcase>\r\n");
printf(" <testcase classname=\"pio.irq.edge.falling\" name=\"PIO: Get PIO IRQ FALLING EDGE\">\r\n");
printf(" <system-out>\r\n");
_pio_event = 0;
pio_set(&pio_output);
pio_input.attribute |= PIO_IT_FALL_EDGE;
pio_configure(&pio_input, 1);
pio_enable_it(&pio_input);
pio_clear(&pio_output);
timer_wait(10);
printf(" </system-out>\r\n");
if (_pio_event != 1) {
test_fail++;
printf(" <error type=\"error\" />\r\n");
}
tests++;
pio_input.attribute &= ~PIO_IT_FALL_EDGE;
printf(" </test>\r\n");
printf(" <testcase classname=\"pio.irq.edge.rising\" name=\"PIO: Get PIO IRQ RISING EDGE\">\r\n");
printf(" <system-out>\r\n");
_pio_event = 0;
pio_clear(&pio_output);
pio_input.attribute |= PIO_IT_RISE_EDGE;
pio_configure(&pio_input, 1);
pio_enable_it(&pio_input);
pio_set(&pio_output);
timer_wait(10);
printf(" </system-out>\r\n");
if (_pio_event != 1) {
test_fail++;
printf(" <error error=\"error\">event(s): %d</error>\r\n", _pio_event);
}
tests++;
pio_input.attribute &= ~PIO_IT_RISE_EDGE;
printf(" </test>\r\n");
printf(" <testcase classname=\"pio.irq.edge.both\" name=\"PIO: Get PIO IRQ BOTH EDGE\">\r\n");
#ifdef PIO_IT_BOTH_EDGE
printf(" <system-out>\r\n");
_pio_event = 0;
pio_set(&pio_output);
pio_input.attribute |= PIO_IT_BOTH_EDGE;
pio_configure(&pio_input, 1);
pio_enable_it(&pio_input);
pio_clear(&pio_output);
timer_wait(10);
pio_set(&pio_output);
timer_wait(10);
printf(" </system-out>\r\n");
if (_pio_event != 2) {
test_fail++;
printf(" <error type=\"error\" />\r\n");
}
tests++;
pio_input.attribute &= ~PIO_IT_BOTH_EDGE;
#else
printf(" <skip />\r\n");
#endif
printf(" </testcase>\r\n");
printf(" <testcase classname=\"pio.irq.level.low\" name=\"PIO: Get PIO IRQ LEVEL LOW\">\r\n");
printf(" <system-out>\r\n");
pio_set(&pio_output);
pio_input.attribute |= PIO_IT_LOW_LEVEL;
pio_configure(&pio_input, 1);
pio_enable_it(&pio_input);
_pio_event = 0;
pio_clear(&pio_output);
timer_wait(10);
pio_set(&pio_output);
printf(" </system-out>\r\n");
if (_pio_event < 1) {
test_fail++;
printf(" <error type=\"error\" />\r\n");
}
tests++;
pio_input.attribute &= ~PIO_IT_LOW_LEVEL;
printf(" </testcase>\r\n");
printf(" <testcase classname=\"pio.irq.level.high\" name=\"PIO: Get PIO IRQ LEVEL HIGH\">\r\n");
printf(" <system-out>\r\n");
_pio_event = 0;
pio_clear(&pio_output);
pio_input.attribute |= PIO_IT_HIGH_LEVEL;
pio_configure(&pio_input, 1);
pio_enable_it(&pio_input);
pio_set(&pio_output);
timer_wait(10);
pio_clear(&pio_output);
printf(" </system-out>\r\n");
if (_pio_event < 1) {
test_fail++;
printf(" <error type=\"error\" />\r\n");
}
tests++;
pio_input.attribute &= ~PIO_IT_HIGH_LEVEL;
printf(" </test>\r\n");
printf(" <testcase classname=\"pio.mode.pull.up\" name=\"PIO: Get PIO PULL UP\">\r\n");
printf(" <system-out>\r\n");
pio_clear(&pio_output);
pio_output.type = PIO_INPUT;
pio_output.attribute |= PIO_PULLUP;
pio_configure(&pio_output, 1);
pio_configure(&pio_input, 1);
printf(" </system-out>\r\n");
if (pio_get(&pio_input) != 1) {
test_fail++;
printf(" <error type=\"error\" />\r\n");
}
tests++;
pio_output.attribute &= ~PIO_PULLUP;
pio_output.type = PIO_OUTPUT_0;
pio_configure(&pio_output, 1);
printf(" </testcase>\r\n");
printf(" <statistics>\r\n");
printf(" <failures>%d</failures>\r\n", test_fail);
printf(" <tests>%d</tests>\r\n", tests);
printf(" </statistics>\r\n");
printf("</testsuite>\r\n");
while (1);
}
