void LED_On(U32 leds)
{
// Use the LED descriptors to get the connections of a given LED to the MCU.
tLED_DESCRIPTOR *led_descriptor = &LED_DESCRIPTOR[0] - 1;
volatile avr32_gpio_port_t *led_gpio_port;
U8 led_shift;
// Make sure only existing LEDs are specified.
leds &= (1 << LED_COUNT) - 1;
// Update the saved state of all LEDs with the requested changes.
Set_bits(LED_State, leds);
// While there are specified LEDs left to manage...
while (leds)
{
// Select the next specified LED and turn it on.
led_shift = 1 + ctz(leds);
led_descriptor += led_shift;
led_gpio_port = &AVR32_GPIO.port[led_descriptor->GPIO.PORT];
led_gpio_port->ovrc = led_descriptor->GPIO.PIN_MASK;
led_gpio_port->oders = led_descriptor->GPIO.PIN_MASK;
led_gpio_port->gpers = led_descriptor->GPIO.PIN_MASK;
leds >>= led_shift;
}
}
/*!
* \brief Get the current joystick state.
*
* \param buf char buffer in which the joystick state is stored.
*
* \return true upon success, false if error.
*/
bool b_joystick_get_value( char* buf )
{
// input is pulled up, if 1 : input is not active
if ( !is_joystick_up() ) { Clr_bits(x_joystick, JS_EVENT_UP); }
else { Set_bits(x_joystick, JS_EVENT_UP); }
if ( !is_joystick_down() ) { Clr_bits(x_joystick, JS_EVENT_DOWN); }
else { Set_bits(x_joystick, JS_EVENT_DOWN); }
if ( !is_joystick_left() ) { Clr_bits(x_joystick, JS_EVENT_LEFT); }
else { Set_bits(x_joystick, JS_EVENT_LEFT); }
if ( !is_joystick_right() ) { Clr_bits(x_joystick, JS_EVENT_RIGHT); }
else { Set_bits(x_joystick, JS_EVENT_RIGHT); }
if ( !is_joystick_pressed() ) { Clr_bits(x_joystick, JS_EVENT_PUSH); }
else { Set_bits(x_joystick, JS_EVENT_PUSH); }
// Build the log string.
sprintf( buf, "%s\r\n", (portCHAR *)acpc_js_events[x_joystick]);
return true;
}
//!
//! This function returns a free navigator id.
//!
//! @return long : Id navigator allocated or -1 if none free
//!
long fsaccess_alloc_nav_id( void )
{
unsigned int j;
// get a free nav id
// NOTE: we start at FS_NB_RESERVED_NAV, because 2 is usually used as
// the navigator for file copy. 0 & 1 may be used independently of the fsaccess module.
for (j = FS_NB_RESERVED_NAV ; j < FS_NB_NAVIGATOR ; j++)
{
if (!Tst_bits(pvNavUsed, (1 << j)))
{
Set_bits(pvNavUsed, (1 << j));
return (j);
}
}
// no nav free for now
return(-1);
}
void LED_On(U32 leds)
{
tLED_DESCRIPTOR *led_descriptor = &LED_DESCRIPTOR[0] - 1;
volatile avr32_gpio_port_t *led_gpio_port;
U8 led_shift;
leds &= (1 << LED_COUNT) - 1;
Set_bits(LED_State, leds);
while (leds)
{
led_shift = 1 + ctz(leds);
led_descriptor += led_shift;
led_gpio_port = &AVR32_GPIO.port[led_descriptor->GPIO.PORT];
led_gpio_port->ovrc = led_descriptor->GPIO.PIN_MASK;
led_gpio_port->oders = led_descriptor->GPIO.PIN_MASK;
led_gpio_port->gpers = led_descriptor->GPIO.PIN_MASK;
leds >>= led_shift;
}
}
//! This function manages the SET FEATURE request. The USB test modes are
//! supported by this function.
//!
void usb_set_feature(void)
{
U16 wValue = usb_format_usb_to_mcu_data(16, Usb_read_endpoint_data(EP_CONTROL, 16));
U16 wIndex = usb_format_usb_to_mcu_data(16, Usb_read_endpoint_data(EP_CONTROL, 16));
U16 wLength = usb_format_usb_to_mcu_data(16, Usb_read_endpoint_data(EP_CONTROL, 16));
if (wLength)
goto unsupported_request;
if (bmRequestType==USB_SETUP_SET_STAND_DEVICE) {
#if (USB_REMOTE_WAKEUP_FEATURE == true)
if (FEATURE_DEVICE_REMOTE_WAKEUP == wValue)
{
device_status |= USB_DEV_STATUS_REMOTEWAKEUP;
remote_wakeup_feature = true;
Usb_ack_setup_received_free();
Usb_ack_control_in_ready_send();
return;
}
#endif
goto unsupported_request;
}
switch (wValue)
{
case FEATURE_ENDPOINT_HALT:
wIndex = Get_desc_ep_nbr(wIndex); // clear direction flag
if (bmRequestType != ENDPOINT_TYPE ||
wIndex == EP_CONTROL ||
!Is_usb_endpoint_enabled(wIndex))
goto unsupported_request;
Usb_enable_stall_handshake(wIndex);
Usb_ack_setup_received_free();
Usb_ack_control_in_ready_send();
break;
#if (USB_HIGH_SPEED_SUPPORT==true)
case FEATURE_TEST_MODE:
if (bmRequestType != DEVICE_TYPE ||
wIndex & 0x00FF)
goto unsupported_request;
switch (wIndex >> 8)
{
case TEST_J:
Usb_ack_setup_received_free();
Usb_ack_control_in_ready_send();
while (!Is_usb_control_in_ready());
Wr_bitfield(AVR32_USBB_udcon, AVR32_USBB_UDCON_SPDCONF_MASK, 2);
Set_bits(AVR32_USBB_udcon, AVR32_USBB_UDCON_TSTJ_MASK);
break;
case TEST_K:
Usb_ack_setup_received_free();
Usb_ack_control_in_ready_send();
while (!Is_usb_control_in_ready());
Wr_bitfield(AVR32_USBB_udcon, AVR32_USBB_UDCON_SPDCONF_MASK, 2);
Set_bits(AVR32_USBB_udcon, AVR32_USBB_UDCON_TSTK_MASK);
break;
case TEST_SE0_NAK:
Usb_ack_setup_received_free();
Usb_ack_control_in_ready_send();
while (!Is_usb_control_in_ready());
Wr_bitfield(AVR32_USBB_udcon, AVR32_USBB_UDCON_SPDCONF_MASK, 2);
break;
case TEST_PACKET:
{
static const U8 test_packet[] =
{
// 00000000 * 9
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 01010101 * 8
0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
// 01110111 * 8
0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE,
// 0, {111111S * 15}, 111111
0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
// S, 111111S, {0111111S * 7}
0x7F, 0xBF, 0xDF, 0xEF, 0xF7, 0xFB, 0xFD,
// 00111111, {S0111111 * 9}, S0
0xFC, 0x7E, 0xBF, 0xDF, 0xEF, 0xF7, 0xFB, 0xFD, 0x7E
};
Usb_ack_setup_received_free();
Usb_ack_control_in_ready_send();
while (!Is_usb_control_in_ready());
Wr_bitfield(AVR32_USBB_udcon, AVR32_USBB_UDCON_SPDCONF_MASK, 2);
Usb_disable_endpoint(EP_CONTROL);
Usb_unallocate_memory(EP_CONTROL);
(void)Usb_configure_endpoint(EP_CONTROL,
TYPE_BULK,
DIRECTION_IN,
64,
SINGLE_BANK);
Usb_reset_endpoint(EP_CONTROL);
Set_bits(AVR32_USBB_udcon, AVR32_USBB_UDCON_TSTPCKT_MASK);
usb_write_ep_txpacket(EP_CONTROL, &test_packet, sizeof(test_packet), NULL);
Usb_send_in(EP_CONTROL);
}
break;
case TEST_FORCE_ENABLE: // Only for downstream facing hub ports
default:
goto unsupported_request;
}
break;
#endif
case FEATURE_DEVICE_REMOTE_WAKEUP:
default:
goto unsupported_request;
}
return;
unsupported_request:
Usb_enable_stall_handshake(EP_CONTROL);
Usb_ack_setup_received_free();
}
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 ) );
}
//!
//! @brief Looks for mouse events.
//!
bool is_usb_mouse_event( void )
{
static uint8_t disp=1;
static uint16_t count=0;
#if BOARD != EVK1104 && BOARD != UC3C_EK && BOARD != EVK1105
static bool old_click_0=false; // false means released, true means pushed
static bool old_click_1=false; // false means released, true means pushed
#endif
#if BOARD == EVK1100
static bool old_click_2=false; // false means released, true means pushed
#endif
bool b_activity;
u8_report_buttons=0;
u8_report_disp_x=0;
u8_report_disp_y=0;
u8_report_disp_wheel=0;
b_activity=false;
#if BOARD == EVK1101
signed int res;
// Get accelerometer acquisition and process data
acc_update();
// Look joystick activity for the Wheel events
// input is pulled up, if 1 : input is not active
if( is_joystick_up() )
u8_report_disp_wheel=disp, b_activity=true;
if( is_joystick_down() )
u8_report_disp_wheel=-disp, b_activity=true;
// Look accelerometer activity for the X and Y events
if( 0!=(res=is_acc_abs_angle_x(40)) )
{
if( res>0 )
u8_report_disp_x=-10*disp, b_activity=true;
else if( res<0 )
u8_report_disp_x=10*disp, b_activity=true;
}
else if( 0!=(res=is_acc_abs_angle_x(30)) )
{
if( res>0 )
u8_report_disp_x=-6*disp, b_activity=true;
else if( res<0 )
u8_report_disp_x=6*disp, b_activity=true;
}
else if( 0!=(res=is_acc_abs_angle_x(20)) )
{
if( res>0 )
u8_report_disp_x=-4*disp, b_activity=true;
else if( res<0 )
u8_report_disp_x=4*disp, b_activity=true;
}
else if( 0!=(res=is_acc_abs_angle_x(15)) )
{
if( res>0 )
u8_report_disp_x=-2*disp, b_activity=true;
else if( res<0 )
u8_report_disp_x=2*disp, b_activity=true;
}
else if( 0!=(res=is_acc_abs_angle_x(10)) )
{
if( res>0 )
u8_report_disp_x=-disp, b_activity=true;
else if( res<0 )
u8_report_disp_x=disp, b_activity=true;
}
if( 0!=(res=is_acc_abs_angle_y(40)) )
{
if( res>0 )
u8_report_disp_y=-10*disp, b_activity=true;
else if( res<0 )
u8_report_disp_y=10*disp, b_activity=true;
}
else if( 0!=(res=is_acc_abs_angle_y(30)) )
{
if( res>0 )
u8_report_disp_y=-6*disp, b_activity=true;
else if( res<0 )
u8_report_disp_y=6*disp, b_activity=true;
}
else if( 0!=(res=is_acc_abs_angle_y(20)) )
{
if( res>0 )
u8_report_disp_y=-4*disp, b_activity=true;
else if( res<0 )
u8_report_disp_y=4*disp, b_activity=true;
}
else if( 0!=(res=is_acc_abs_angle_y(15)) )
{
if( res>0 )
u8_report_disp_y=-2*disp, b_activity=true;
else if( res<0 )
u8_report_disp_y=2*disp, b_activity=true;
}
else if( 0!=(res=is_acc_abs_angle_y(10)) )
{
if( res>0 )
u8_report_disp_y=-disp, b_activity=true;
else if( res<0 )
u8_report_disp_y=disp, b_activity=true;
}
#elif BOARD == EVK1100
// Look Joystick activity for the X and Y events
// input is pulled up, if 1 : input is not active
if (is_joystick_right())
u8_report_disp_x=disp, b_activity=true;
if (is_joystick_left())
u8_report_disp_x=-disp, b_activity=true;
if (is_joystick_down())
u8_report_disp_y=disp, b_activity=true;
if (is_joystick_up())
u8_report_disp_y=-disp, b_activity=true;
#elif BOARD == EVK1105
// Right
if (is_touch_sensor_2())
u8_report_disp_x=disp, b_activity=true;
// Left
if (is_touch_sensor_3())
u8_report_disp_x=-disp, b_activity=true;
// Down
if (is_touch_sensor_1())
u8_report_disp_y=disp, b_activity=true;
// Up
if (is_touch_sensor_0())
u8_report_disp_y=-disp, b_activity=true;
#elif BOARD == EVK1104
if (gpio_get_pin_value(GPIO_PUSH_BUTTON_SW2) == GPIO_PUSH_BUTTON_SW2_PRESSED)
u8_report_disp_y=-disp, b_activity=true;
#elif BOARD == UC3C_EK
// mouse pointer down
if( !gpio_get_pin_value(GPIO_PUSH_BUTTON_0)) {
u8_report_disp_y=disp, b_activity=true;
}
// mouse pointer up
if( !gpio_get_pin_value(GPIO_PUSH_BUTTON_1)) {
u8_report_disp_y=-disp, b_activity=true;
}
#endif
if( b_activity )
{
count++;
if( count >= DISP_LIMIT_HIGH )
disp=3;
else if( count >= DISP_LIMIT_LOW )
disp=2;
}
else
count=0, disp=1;
// Look for button activity
#if BOARD != EVK1104 && BOARD != UC3C_EK && BOARD != EVK1105
// input is pulled up, if 1 : input is not active
if( (!gpio_get_pin_value(GPIO_PUSH_BUTTON_0))
|| (is_joystick_pressed() ) )
{
Set_bits(u8_report_buttons, BUTTON_0_EVENT_PUSH);
if( old_click_0==false )
old_click_0=true, b_activity=true;
}
else
if( old_click_0==true )
old_click_0=false, b_activity=true;
if( !gpio_get_pin_value(GPIO_PUSH_BUTTON_1) )
{
Set_bits(u8_report_buttons, BUTTON_1_EVENT_PUSH);
if( old_click_1==false )
old_click_1=true, b_activity=true;
}
else
if( old_click_1==true )
old_click_1=false, b_activity=true;
#endif
#if BOARD == EVK1100
if( !gpio_get_pin_value(GPIO_PUSH_BUTTON_2) )
{
Set_bits(u8_report_buttons, BUTTON_2_EVENT_PUSH);
if( old_click_2==false )
old_click_2=true, b_activity=true;
}
else
if( old_click_2==true )
old_click_2=false, b_activity=true;
#endif
if( b_activity ) return true;
else return false;
}
int rtc_test(void)
{
uart_putchars("RTC Test\r\n", 10);
DDRB = 0;
// AVR-PIN Signal RTC-PIN
// PB0 CS Chipselect 3
// PB3 MOSI Master Output 9
// PB4 MISO Master Input 5
// PB5 SCK Serial Clock 4
Set_bits(DDRB, (1 << PB0) | (1 << PB3) | (1 << PB5) | (1 << PB2));
CS_OFF();
SPCR = (1<<SPE) | (1 << MSTR) | (0 << SPI2X) | (0 << SPR1) | (0 << SPR0);
// RTC Software Reset
CS_ON();
spi_transfer(RTC_CTRL_RESET | RTC_WRITE);
spi_transfer(RTC_RESET);
CS_OFF();
//debug_rtc();
_delay_ms(100);
// RTC Status
CS_ON();
uint8_t ctrl_Status = spi_transfer(RTC_CTRL_STATUS);
CS_OFF();
if(ctrl_Status & RTC_PON) {
//clear POWER-ON bit
ctrl_Status &= ~RTC_PON;
CS_ON();
spi_transfer(RTC_CTRL_STATUS | RTC_WRITE);
spi_transfer(ctrl_Status);
CS_OFF();
}
if(ctrl_Status & RTC_SR) {
//clear SELF-RECOVERY bit
ctrl_Status &= ~RTC_SR;
CS_ON();
spi_transfer(RTC_CTRL_STATUS | RTC_WRITE);
spi_transfer(ctrl_Status);
CS_OFF();
}
CS_ON();
spi_transfer(RTC_CTRL_INT_FLAG | RTC_WRITE);
spi_transfer(0);
CS_OFF();
CS_ON();
spi_transfer(RTC_CTRL_INT | RTC_WRITE);
spi_transfer(1);
CS_OFF();
CS_ON();
spi_transfer(RTC_EPROM_CTRL | RTC_WRITE);
spi_transfer(RTC_THE);
CS_OFF();
// set datetime
now.year = 16;
now.month = 5;
now.day = 12;
now.hour = 12;
now.minute = 00;
now.second = 00;
rtc_set_datetime(&now);
// set alarm
TDateTime alarm = { 0 };
alarm.second = 5 | RTC_AE_S;
//alarm.minute = 0 | RTC_AE_S;
rtc_set_alarm(&alarm);
rtc_debug();
uint8_t s = 0;
for (;;)
{
rtc_get_datetime(&now);
int temperature = rtc_get_temperature();
if(now.second != s) {
s = now.second;
char buf[50] = { 0 };
sprintf(buf, "%d.%d.%d - %d:%d:%d Temp:%d\r\n", now.day, now.month, now.year, now.hour, now.minute, now.second, temperature);
uart_putchars(buf, 50);
if(s == (alarm.second + 1))
{
rtc_clear_alarm_int();
}
}
}
}