/** \brief Prepare ADC for touch measuring.
*
* Register the interrupt handler, set sample, hold and startup time.
*/
static void inline rtouch_prepare_adc(void)
{
Disable_global_interrupt();
INTC_register_interrupt(&rtouch_adc_int_handler, RTOUCH_ADC_IRQ,
RTOUCH_ADC_INT_LEVEL);
Enable_global_interrupt();
#ifdef AVR32_ADCIFA
volatile avr32_adcifa_t *adcifa = &RTOUCH_ADC;
/* configure ADCIFA */
adcifa_configure(adcifa, &adcifa_opt, FOSC0);
#else
volatile avr32_adc_t *adc = &RTOUCH_ADC;
adc_configure(adc);
/* we need to lower the adc clock under 5MHz */
/* adc_clock = adc_input_clock /((prescaler + 1)*2) */
adc->mr |= 0x1 << AVR32_ADC_MR_PRESCAL_OFFSET;
#endif
}
/*!
* \brief Init the joystick sensor.
*
* \return true upon success, false if error.
*/
bool b_joystick_init ( void )
{
portCHAR token[6];
// Get the xCFGMutex.
if( pdTRUE == x_supervisor_SemaphoreTake( xCFGMutex, 0 ) )
{
// get the field
if (config_file_get_value(SENSOR_JS_CONFIG_FILE, "alarm" , token) >= 0)
{
// update value
if (!strcmp(token, "on"))
{
bAlarm = pdTRUE;
}
}
// Release the xCFGMutex.
x_supervisor_SemaphoreGive( xCFGMutex );
}
/* configure joystick up to produce IT on all state change */
gpio_enable_pin_interrupt(GPIO_JOYSTICK_UP , GPIO_PIN_CHANGE);
/* configure joystick down to produce IT on all state change */
gpio_enable_pin_interrupt(GPIO_JOYSTICK_DOWN , GPIO_PIN_CHANGE);
/* configure joystick right to produce IT on all state change */
gpio_enable_pin_interrupt(GPIO_JOYSTICK_RIGHT , GPIO_PIN_CHANGE);
/* configure joystick left to produce IT on all state change */
gpio_enable_pin_interrupt(GPIO_JOYSTICK_LEFT , GPIO_PIN_CHANGE);
/* configure joystick press to produce IT on all state change */
gpio_enable_pin_interrupt(GPIO_JOYSTICK_PUSH , GPIO_PIN_CHANGE);
/* Disable all interrupts */
Disable_global_interrupt();
/* register joystick handler on level 3 */
INTC_register_interrupt( (__int_handler)&vjoystick_ISR, AVR32_GPIO_IRQ_0 + (GPIO_JOYSTICK_UP/8), AVR32_INTC_INT3);
INTC_register_interrupt( (__int_handler)&vjoystick_ISR, AVR32_GPIO_IRQ_0 + (GPIO_JOYSTICK_PUSH/8), AVR32_INTC_INT3);
/* Enable all interrupts */
Enable_global_interrupt();
return (true);
}
uint32_t readClock(Clock* timeClock){
//rtc_count_disable(&rtc_instance);
Disable_global_interrupt();
uint32_t timeCounter=0;
RTC->MODE0.CTRL.reg &= 0b1111111111111101;//disable timer
while(RTC->MODE0.STATUS.bit.SYNCBUSY==1);//wait timer disable
timeCounter=RTC->MODE0.COUNT.reg;
timeClock->second=timeManage.second;
timeClock->halfmillis=timeManage.halfmillis;
//timeCounter=0;
//Enable_global_interrupt();
timeClock->sign=true;
timeClock->halfmillis+=timeCounter;
timeClock->second+=timeClock->halfmillis/RTC_FREQ;
timeClock->halfmillis=timeClock->halfmillis%RTC_FREQ;
RTC->MODE0.CTRL.reg |= RTC_MODE0_CTRL_ENABLE; //enable timer
Enable_global_interrupt();
return timeCounter;
}
void ppsISR(void)
{
Disable_global_interrupt();
Clock timeCopy={0,0,true};
//Disable_global_interrupt();
Clock timeMaster={0,0,true};
readClock(&timeCopy);
//Enable_global_interrupt();
timeMaster.second=timeCopy.second;
timeMaster.halfmillis=timeCopy.halfmillis;
if(timeMaster.halfmillis>=RTC_FREQ/2){//for the accurate 500ms
timeMaster.second++;
}
timeMaster.halfmillis=0;
/*if((timeMaster.halfmillis>RTC_FREQ)||(timeMaster.halfmillis<0)){
printf("timeMasterpps");
printfClock(timeMaster);
}
if((timeCopy.halfmillis>RTC_FREQ)||(timeCopy.halfmillis<0)){
printf("timeCopypps:'");
printfClock(timeCopy);
}*/
timeProt.offset=subClock(timeMaster,timeCopy);
//timeProt.offset.second=0;
#ifdef MASTERMODE
updateClock();
#else
if(timeProt.offset.sign==true){
sprintf(messageHMIError," error pps: %lus %u t:%lus",timeProt.offset.second,(unsigned int)(timeProt.offset.halfmillis/2),timeMaster.second);
}
else{
sprintf(messageHMIError," error pps: -%lus %u t:%lus",timeProt.offset.second,(unsigned int)(timeProt.offset.halfmillis/2),timeMaster.second);
}
sendHMI(messageHMIError);
#endif
Enable_global_interrupt();
}
int pwm_init(const pwm_opt_t *opt)
{
volatile avr32_pwm_t *pwm = &AVR32_PWM;
Bool global_interrupt_enabled = Is_global_interrupt_enabled();
if (opt == 0 ) // Null pointer.
return PWM_INVALID_INPUT;
// Disable interrupt.
if (global_interrupt_enabled) Disable_global_interrupt();
pwm->idr = ((1 << (AVR32_PWM_LINES_MSB + 1)) - 1) << AVR32_PWM_IDR_CHID0_OFFSET;
pwm->isr;
if (global_interrupt_enabled) Enable_global_interrupt();
// Set PWM mode register.
pwm->mr =
((opt->diva)<<AVR32_PWM_DIVA_OFFSET) |
((opt->divb)<<AVR32_PWM_DIVB_OFFSET) |
((opt->prea)<<AVR32_PWM_PREA_OFFSET) |
((opt->preb)<<AVR32_PWM_PREB_OFFSET)
;
return PWM_SUCCESS;
}
//! host_disable_all_pipes
//!
//! This function disables all pipes for the host controller.
//! Useful to execute upon disconnection.
//!
//! @return Void
//!
void host_disable_all_pipes(void)
{
#if USB_HOST_PIPE_INTERRUPT_TRANSFER == ENABLE
Bool sav_glob_int_en;
#endif
U8 p;
#if USB_HOST_PIPE_INTERRUPT_TRANSFER == ENABLE
// Disable global interrupts
if ((sav_glob_int_en = Is_global_interrupt_enabled())) Disable_global_interrupt();
#endif
for (p = 0; p < MAX_PEP_NB; p++)
{ // Disable the pipe <p> (disable interrupt, free memory, reset pipe, ...)
Host_disable_pipe_interrupt(p);
Host_reset_pipe(p);
Host_unallocate_memory(p);
Host_disable_pipe(p);
}
#if USB_HOST_PIPE_INTERRUPT_TRANSFER == ENABLE
(void)Is_host_pipe_enabled(MAX_PEP_NB - 1);
// Restore the global interrupts to the initial state
if (sav_glob_int_en) Enable_global_interrupt();
#endif
}
void vDisableMACBOperations(volatile avr32_macb_t *macb)
{
bool global_interrupt_enabled = Is_global_interrupt_enabled();
#if ETHERNET_CONF_USE_PHY_IT == 1
#if EXTPHY_MACB_USE_EXTINT
volatile avr32_eic_t *eic = &AVR32_EIC;
eic->idr = 1 << EXTPHY_MACB_INTERRUPT;
eic->imr;
#else
volatile avr32_gpio_t *gpio = &AVR32_GPIO;
volatile avr32_gpio_port_t *gpio_port = &gpio->port[EXTPHY_MACB_INTERRUPT_PIN/32];
gpio_port->ierc = 1 << (EXTPHY_MACB_INTERRUPT_PIN%32);
#endif
#endif
// write the MACB control register : disable Tx & Rx
macb->ncr &= ~((1 << AVR32_MACB_RE_OFFSET) | (1 << AVR32_MACB_TE_OFFSET));
// We no more want to interrupt on Rx and Tx events.
if (global_interrupt_enabled) Disable_global_interrupt();
macb->idr = AVR32_MACB_IER_RCOMP_MASK | AVR32_MACB_IER_TCOMP_MASK;
macb->isr;
if (global_interrupt_enabled) Enable_global_interrupt();
}
void rtc_init_qt( void ) {
// Init touch_states
controller_clear();
// Disable all interrupts
Disable_global_interrupt();
// Register the RTC interrupt handler to the interrupt controller.
BSP_INTC_IntReg( &rtc_irq, AVR32_RTC_IRQ, AVR32_INTC_INT1);
// Initialize the RTC
rtc_init(&AVR32_RTC, RTC_OSC_32KHZ, 4);
rtc_set_top_value(&AVR32_RTC, 1);
// Enable the interrupts
rtc_enable_interrupt(&AVR32_RTC);
// Enable the RTC
rtc_enable(&AVR32_RTC);
// Enable global interrupts
Enable_global_interrupt();
}
void rtc_init_qt( void ) {
// Disable all interrupts. */
Disable_global_interrupt();
// Register the RTC interrupt handler to the interrupt controller.
INTC_register_interrupt(&rtc_irq, AVR32_RTC_IRQ, AVR32_INTC_INT0);
// Initialize the RTC
// Frtc = 1024Hz
rtc_init(&AVR32_RTC, RTC_OSC_32KHZ, 4);
// Set top value to 0 to generate an interrupt every seconds */
rtc_set_top_value(&AVR32_RTC, 1);
// Enable the interrupts
rtc_enable_interrupt(&AVR32_RTC);
// Enable the RTC
rtc_enable(&AVR32_RTC);
// Enable global interrupts
Enable_global_interrupt();
}
/**
* \brief The main function.
*
* It sets up the USART module on EXAMPLE_USART. The terminal settings are 57600
* 8N1.
* Then it sets up the interrupt handler and waits for a USART interrupt to
* trigger.
*/
int main(void)
{
static const gpio_map_t USART_GPIO_MAP =
{
{EXAMPLE_USART_RX_PIN, EXAMPLE_USART_RX_FUNCTION},
{EXAMPLE_USART_TX_PIN, EXAMPLE_USART_TX_FUNCTION}
};
// USART options.
static const usart_options_t USART_OPTIONS =
{
.baudrate = EXAMPLE_USART_BAUDRATE,
.charlength = 8,
.paritytype = USART_NO_PARITY,
.stopbits = USART_1_STOPBIT,
.channelmode = USART_NORMAL_CHMODE
};
#if BOARD == EVK1100 || BOARD == EVK1101 || BOARD == UC3C_EK \
|| BOARD == EVK1104 || BOARD == EVK1105 || BOARD == STK600_RCUC3L0 \
|| BOARD == STK600_RCUC3D
/*
* Configure Osc0 in crystal mode (i.e. use of an external crystal
* source, with frequency FOSC0) with an appropriate startup time then
* switch the main clock source to Osc0.
*/
pcl_switch_to_osc(PCL_OSC0, FOSC0, OSC0_STARTUP);
#elif BOARD == STK1000
pm_reset();
#elif BOARD == UC3L_EK
/*
* Note: on the AT32UC3L-EK board, there is no crystal/external clock
* connected to the OSC0 pinout XIN0/XOUT0. We shall then program the
* DFLL and switch the main clock source to the DFLL.
*/
pcl_configure_clocks(&pcl_dfll_freq_param);
/*
* Note: since it is dynamically computing the appropriate field values
* of the configuration registers from the parameters structure, this
* function is not optimal in terms of code size. For a code size
* optimal solution, it is better to create a new function from
* pcl_configure_clocks_dfll0() and modify it to use preprocessor
* computation from pre-defined target frequencies.
*/
#endif
// Assign GPIO to USART.
gpio_enable_module(USART_GPIO_MAP,
sizeof(USART_GPIO_MAP) / sizeof(USART_GPIO_MAP[0]));
// Initialize USART in RS232 mode.
usart_init_rs232(EXAMPLE_USART, &USART_OPTIONS,
EXAMPLE_TARGET_PBACLK_FREQ_HZ);
print(EXAMPLE_USART, ".: Using interrupts with the USART :.\r\n\r\n");
// Disable all interrupts.
Disable_global_interrupt();
// Initialize interrupt vectors.
INTC_init_interrupts();
/*
* Register the USART interrupt handler to the interrupt controller.
* usart_int_handler is the interrupt handler to register.
* EXAMPLE_USART_IRQ is the IRQ of the interrupt handler to register.
* AVR32_INTC_INT0 is the interrupt priority level to assign to the
* group of this IRQ.
*/
INTC_register_interrupt(&usart_int_handler, EXAMPLE_USART_IRQ,
AVR32_INTC_INT0);
// Enable USART Rx interrupt.
EXAMPLE_USART->ier = AVR32_USART_IER_RXRDY_MASK;
print(EXAMPLE_USART, "Type a character to use the interrupt handler."
"\r\nIt will show up on your screen.\r\n\r\n");
// Enable all interrupts.
Enable_global_interrupt();
/**
* We have nothing left to do in the main, so we may switch to a device
* sleep mode: we just need to be sure that the USART module will be
* still be active in the chosen sleep mode. The sleep mode to use is
* the FROZEN sleep mode: in this mode the PB clocks are still active
* (so the USART module which is on the Peripheral Bus will still be
* active while the CPU and HSB will be stopped).
* --
* Modules communicating with external circuits should normally be
* disabled before entering a sleep mode that will stop the module
* operation: this is not the case for the FROZEN sleep mode.
* --
* When the USART interrupt occurs, this will wake the CPU up which will
* then execute the interrupt handler code then come back to the
* while(1) loop below to execute the sleep instruction again.
*/
while(1)
{
/*
* If there is a chance that any PB write operations are
* incomplete, the CPU should perform a read operation from any
* register on the PB bus before executing the sleep
* instruction.
*/
AVR32_INTC.ipr[0]; // Dummy read
// Go to FROZEN sleep mode.
SLEEP(AVR32_PM_SMODE_FROZEN);
/*
* When the device wakes up due to an interrupt, once the
* interrupt has been serviced, go back into FROZEN sleep mode.
*/
}
}
void usb_task(void *pvParameters)
{
#endif // FREERTOS_USED
// Register the USB interrupt handler to the interrupt controller and enable
// the USB interrupt.
Disable_global_interrupt();
INTC_register_interrupt((__int_handler)&usb_general_interrupt, AVR32_USBB_IRQ, USB_INT_LEV);
Enable_global_interrupt();
#ifdef FREERTOS_USED
while (true)
{
// Wait for the semaphore
while (!xSemaphoreTake(usb_tsk_semphr, portMAX_DELAY));
#endif // FREERTOS_USED
// ---- DUAL-ROLE DEVICE/HOST USB MODE -----------------------------------------
#if USB_DEVICE_FEATURE == true && USB_HOST_FEATURE == true
#ifdef FREERTOS_USED
if (usb_device_tsk) vTaskDelete(usb_device_tsk), usb_device_tsk = NULL;
if (usb_host_tsk) vTaskDelete(usb_host_tsk), usb_host_tsk = NULL;
#endif
Usb_input_id_pin();
Usb_enable_id_pin();
if (Is_usb_id_device())
{
g_usb_mode = USB_MODE_DEVICE;
usb_device_task_init();
}
else
{
private_sof_counter = 0;
g_usb_mode = USB_MODE_HOST;
usb_host_task_init();
}
g_old_usb_mode = g_usb_mode; // Store current USB mode, for mode change detection
Usb_raise_id_transition(); // Check no ID transition has been missed during initialization
Usb_enable_id_interrupt();
Enable_global_interrupt();
// -----------------------------------------------------------------------------
// ---- DEVICE-ONLY USB MODE ---------------------------------------------------
#elif USB_DEVICE_FEATURE == true
#ifdef FREERTOS_USED
if (usb_device_tsk) vTaskDelete(usb_device_tsk), usb_device_tsk = NULL;
#endif
Usb_force_device_mode();
usb_device_task_init();
// -----------------------------------------------------------------------------
// ---- REDUCED-HOST-ONLY USB MODE ---------------------------------------------
#elif USB_HOST_FEATURE == true
#ifdef FREERTOS_USED
if (usb_host_tsk) vTaskDelete(usb_host_tsk), usb_host_tsk = NULL;
#endif
private_sof_counter = 0;
Usb_force_host_mode();
usb_host_task_init();
// -----------------------------------------------------------------------------
// ---- ERROR, NO MODE true -------------------------------------------------
#else
#error At least one of USB_DEVICE_FEATURE and USB_HOST_FEATURE must be enabled
#endif
// -----------------------------------------------------------------------------
#ifdef FREERTOS_USED
}
#endif
}
/*! \brief This function initializes the LIN controller and, if needed, the LIN
* interrupts.
*
* \param master \c true for master, \c false for slave
* \param l_node Node Value
* \param b_rate Baudrate Value
* \param pba_hz PBA Value
* \return Status PASS / FAIL
*
*/
U8 lin_init (bool master,
U8 l_node,
U16 b_rate,
long pba_hz) {
if (l_node == 0)
{
// Enable GPIO Alternate Functions
gpio_enable_module(USART_LIN_NODE0_GPIO_MAP,
sizeof(USART_LIN_NODE0_GPIO_MAP) / sizeof(USART_LIN_NODE0_GPIO_MAP[0]));
gpio_enable_pin_pull_up(USART_LIN_NODE0_RX_PIN);
// USART options.
if (master)
usart_init_lin_master(usart_lin_node0,b_rate,pba_hz);
else
usart_init_lin_slave(usart_lin_node0,b_rate,pba_hz);
Disable_global_interrupt();
if (master==false)
{
//! Enable Interrupt for Error flags and end ID Reception
#if ( defined (AVR32_USART_400_H_INCLUDED) || \
defined (AVR32_USART_410_H_INCLUDED) || \
defined (AVR32_USART_420_H_INCLUDED) )
usart_lin_node0->ier = AVR32_USART_IER_LINIR_MASK |
AVR32_USART_IER_LINBE_MASK |
AVR32_USART_IER_LINISFE_MASK |
AVR32_USART_IER_LINIPE_MASK |
AVR32_USART_IER_LINCE_MASK |
AVR32_USART_IER_LINSNRE_MASK;
//! Register Interrupt for LIN
INTC_register_interrupt(&lin_int_handler_node0,
USART_LIN_NODE0_USART_IRQ,
USART_LIN_NODE0_USART_IRQ_LEVEL);
#else
usart_lin_node0->ier = AVR32_USART_IER_LINID_MASK |
AVR32_USART_IER_LINBE_MASK |
AVR32_USART_IER_LINISFE_MASK |
AVR32_USART_IER_LINIPE_MASK |
AVR32_USART_IER_LINCE_MASK |
AVR32_USART_IER_LINSNRE_MASK;
//! Register Interrupt for LIN
INTC_register_interrupt(&lin_int_handler_node0,
USART_LIN_NODE0_USART_IRQ,
USART_LIN_NODE0_USART_IRQ_LEVEL);
#endif
}
//! Register Interrupt for PDCA Transfer TX
INTC_register_interrupt(&lin_pdca_int_tx_handler_node0,
USART_LIN_NODE0_PDCA_TX_IRQ,
USART_LIN_NODE0_PDCA_TX_IRQ_LEVEL);
//! Register Interrupt for PDCA Transfer RX
INTC_register_interrupt(&lin_pdca_int_rx_handler_node0,
USART_LIN_NODE0_PDCA_RX_IRQ,
USART_LIN_NODE0_PDCA_RX_IRQ_LEVEL);
}
#ifdef USART_LIN_NODE1_INSTANCE
else
{
// Enable GPIO Alternate Functions
gpio_enable_module(USART_LIN_NODE1_GPIO_MAP,
sizeof(USART_LIN_NODE1_GPIO_MAP) / sizeof(USART_LIN_NODE1_GPIO_MAP[0]));
gpio_enable_pin_pull_up(USART_LIN_NODE1_RX_PIN);
// USART options.
if (master)
usart_init_lin_master(usart_lin_node1,b_rate,pba_hz);
else
usart_init_lin_slave(usart_lin_node1,b_rate,pba_hz);
Disable_global_interrupt();
if (master==false)
{
//! Enable Interrupt for Error flags and end ID Reception
#if ( defined (AVR32_USART_400_H_INCLUDED) || \
defined (AVR32_USART_410_H_INCLUDED) || \
defined (AVR32_USART_420_H_INCLUDED) )
usart_lin_node1->ier = AVR32_USART_IER_LINIR_MASK |
AVR32_USART_IER_LINBE_MASK |
AVR32_USART_IER_LINISFE_MASK |
AVR32_USART_IER_LINIPE_MASK |
AVR32_USART_IER_LINCE_MASK |
AVR32_USART_IER_LINSNRE_MASK;
//! Register Interrupt for LIN
INTC_register_interrupt(&lin_int_handler_node1,
USART_LIN_NODE1_USART_IRQ,
USART_LIN_NODE1_USART_IRQ_LEVEL);
#else
usart_lin_node1->ier = AVR32_USART_IER_LINID_MASK |
AVR32_USART_IER_LINBE_MASK |
AVR32_USART_IER_LINISFE_MASK |
AVR32_USART_IER_LINIPE_MASK |
AVR32_USART_IER_LINCE_MASK |
AVR32_USART_IER_LINSNRE_MASK;
//! Register Interrupt for LIN
INTC_register_interrupt(&lin_int_handler_node1,
USART_LIN_NODE1_USART_IRQ,
USART_LIN_NODE1_USART_IRQ_LEVEL);
#endif
}
//! Register Interrupt for PDCA Transfer TX
INTC_register_interrupt(&lin_pdca_int_tx_handler_node1,
USART_LIN_NODE1_PDCA_TX_IRQ,
USART_LIN_NODE1_PDCA_TX_IRQ_LEVEL);
//! Register Interrupt for PDCA Transfer RX
INTC_register_interrupt(&lin_pdca_int_rx_handler_node1,
USART_LIN_NODE1_PDCA_RX_IRQ,
USART_LIN_NODE1_PDCA_RX_IRQ_LEVEL);
}
#endif
return PASS;
}
/** Main function to configure the CAN, and begin transfers. */
int main(void)
{
/* Initialize the system clocks */
sysclk_init();
/* Setup the generic clock for CAN */
scif_gc_setup(AVR32_SCIF_GCLK_CANIF,
SCIF_GCCTRL_OSC0,
AVR32_SCIF_GC_NO_DIV_CLOCK,
0);
/* Now enable the generic clock */
scif_gc_enable(AVR32_SCIF_GCLK_CANIF);
init_dbg_rs232(FPBA_HZ);
/* Disable all interrupts. */
Disable_global_interrupt();
/* Initialize interrupt vectors. */
INTC_init_interrupts();
static const gpio_map_t CAN_GPIO_MAP = {
{AVR32_CANIF_RXLINE_0_0_PIN, AVR32_CANIF_RXLINE_0_0_FUNCTION},
{AVR32_CANIF_TXLINE_0_0_PIN, AVR32_CANIF_TXLINE_0_0_FUNCTION}
};
/* Assign GPIO to CAN. */
gpio_enable_module(CAN_GPIO_MAP,
sizeof(CAN_GPIO_MAP) / sizeof(CAN_GPIO_MAP[0]));
/* Initialize channel 0 */
can_init(CAN_CHANNEL_EXAMPLE, ((uint32_t)&mob_ram_ch0[0]),
CANIF_CHANNEL_MODE_LISTENING, can_out_callback_channel0);
/* Enable all interrupts. */
Enable_global_interrupt();
print_dbg("\r\nUC3C CAN Examples 1\r\n");
print_dbg(CAN_Wakeup);
/* Initialize CAN Channel 0 */
can_init(CAN_CHANNEL_EXAMPLE, ((uint32_t)&mob_ram_ch0[0]),
CANIF_CHANNEL_MODE_NORMAL, can_out_callback_channel0);
/* Allocate one mob for RX */
appli_rx_msg.handle = can_mob_alloc(CAN_CHANNEL_EXAMPLE);
/* Initialize RX message */
can_rx(CAN_CHANNEL_EXAMPLE, appli_rx_msg.handle, appli_rx_msg.req_type,
appli_rx_msg.can_msg);
/* Enable Async Wake Up Mode */
pm_asyn_wake_up_enable(CAN_WAKEUP_MASK_EXAMPLE);
/* ---------SLEEP MODE PROCEDURE------------- */
/* Disable CAN Channel 0 */
CANIF_disable(CAN_CHANNEL_EXAMPLE);
/* Wait CAN Channel 0 is disabled */
while(!CANIF_channel_enable_status(CAN_CHANNEL_EXAMPLE));
/* Enable Wake-Up Mode */
CANIF_enable_wakeup(CAN_CHANNEL_EXAMPLE);
/* Go to sleep mode. */
SLEEP(AVR32_PM_SMODE_STATIC);
/* ---------SLEEP MODE PROCEDURE------------- */
print_dbg(CAN_WakeupD);
/* Initialize again CAN Channel 0 */
can_init(CAN_CHANNEL_EXAMPLE, ((uint32_t)&mob_ram_ch0[0]),
CANIF_CHANNEL_MODE_NORMAL, can_out_callback_channel0);
/* Allocate one mob for RX */
appli_rx_msg.handle = can_mob_alloc(CAN_CHANNEL_EXAMPLE);
/* Initialize RX message */
can_rx(CAN_CHANNEL_EXAMPLE, appli_rx_msg.handle, appli_rx_msg.req_type,
appli_rx_msg.can_msg);
for (;;) {
/* Do nothing; interrupts handle the DAC conversions */
}
}
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();
}
void aic23b_dac_start(uint32_t sample_rate_hz,
uint8_t num_channels,
uint8_t bits_per_sample,
bool swap_channels,
void (*callback)(uint32_t arg),
uint32_t callback_opt,
uint32_t pba_hz)
{
#if AIC23B_CTRL_INTERFACE == AIC23B_CTRL_INTERFACE_SPI
static const spi_options_t AIC23B_SPI_OPTIONS =
{
.reg = AIC23B_SPI_NPCS,
.baudrate = AIC23B_SPI_MASTER_SPEED,
.bits = AIC23B_CTRL_SIZE,
.spck_delay = 0,
.trans_delay = 0,
.stay_act = 0,
.spi_mode = 3,
.modfdis = 1
};
spi_setupChipReg(AIC23B_SPI, &AIC23B_SPI_OPTIONS, pba_hz);
#endif
aic23b_dac_stop();
gpio_enable_module(AIC23B_SSC_DAC_GPIO_MAP,
sizeof(AIC23B_SSC_DAC_GPIO_MAP) / sizeof(AIC23B_SSC_DAC_GPIO_MAP[0]));
aic23b_pdc_t pdc;
pdc.data = AIC23B_DEFAULT(AIC23B_PDC);
pdc.off = 0;
pdc.clk = 0;
pdc.osc = 0;
pdc.out = 0;
pdc.dac = 0;
pdc.adc = 1;
pdc.mic = 1;
pdc.line = 1;
aic23b_set_power_down_state(pdc);
aic23b_dac_setup(sample_rate_hz,
num_channels,
bits_per_sample,
swap_channels,
callback,
callback_opt,
pba_hz);
aic23b_aapc_t aapc;
aapc.data = AIC23B_DEFAULT(AIC23B_AAPC);
aapc.ste = 0;
aapc.dac = 1;
aapc.byp = 0;
aapc.micm = 1;
aapc.micb = 0;
aic23b_set_analog_audio_path(aapc);
aic23b_dapc_t dapc;
dapc.data = AIC23B_DEFAULT(AIC23B_DAPC);
dapc.dacm = 0;
dapc.deemp = AIC23B_DAPC_DEEMP_NONE;
dapc.adchp = 1;
aic23b_set_digital_audio_path(dapc);
// set an acceptable start volume
aic23b_set_headphone_volume(AIC23B_LEFT_CHANNEL | AIC23B_RIGHT_CHANNEL,
-30,
true);
aic23b_activate_dig_audio(true);
INTC_register_interrupt(&aic23b_ssc_tx_pdca_int_handler,
AIC23B_SSC_TX_PDCA_IRQ,
AIC23B_SSC_TX_PDCA_INT_LEVEL);
}
void aic23b_dac_setup(uint32_t sample_rate_hz,
uint8_t num_channels,
uint8_t bits_per_sample,
bool swap_channels,
void (*callback)(uint32_t arg),
uint32_t callback_opt,
uint32_t pba_hz)
{
#if defined(AIC23B_DAC_USE_RX_CLOCK) && AIC23B_DAC_USE_RX_CLOCK == true
#if defined(AIC23B_DAC_RX_CLOCK_SET_CALLBACK)
AIC23B_DAC_RX_CLOCK_SET_CALLBACK(2 * sample_rate_hz *
((bits_per_sample <= 16) ? 16 :
(bits_per_sample <= 20) ? 20 :
(bits_per_sample <= 24) ? 24 :
32));
#endif
ssc_i2s_init(AIC23B_SSC,
sample_rate_hz,
bits_per_sample,
(bits_per_sample <= 16) ? 16 :
(bits_per_sample <= 20) ? 20 :
(bits_per_sample <= 24) ? 24 :
32,
SSC_I2S_MODE_STEREO_OUT_EXT_CLK,
pba_hz);
#else
ssc_i2s_init(AIC23B_SSC,
sample_rate_hz,
bits_per_sample,
(bits_per_sample <= 16) ? 16 :
(bits_per_sample <= 20) ? 20 :
(bits_per_sample <= 24) ? 24 :
32,
SSC_I2S_MODE_STEREO_OUT,
pba_hz);
#endif
pdca_channel_options_t aic23b_ssc_pdca_options =
{
.addr = NULL,
.size = 0,
.r_addr = NULL,
.r_size = 0,
.pid = AIC23B_SSC_TX_PDCA_PID,
.transfer_size = (bits_per_sample <= 8) ? PDCA_TRANSFER_SIZE_BYTE :
(bits_per_sample <= 16) ? PDCA_TRANSFER_SIZE_HALF_WORD :
PDCA_TRANSFER_SIZE_WORD
};
pdca_init_channel(AIC23B_SSC_TX_PDCA_CHANNEL, &aic23b_ssc_pdca_options);
pdca_enable(AIC23B_SSC_TX_PDCA_CHANNEL);
#if !defined(AIC23B_DAC_USE_RX_CLOCK) || AIC23B_DAC_USE_RX_CLOCK == false || \
!defined(AIC23B_DAC_RX_CLOCK_SET_CALLBACK)
// Set DAC frequency
aic23b_configure_freq(AIC23B_MCLK_HZ, sample_rate_hz);
#endif
aic23b_daif_t daif;
daif.data = AIC23B_DEFAULT(AIC23B_DAIF);
daif.ms = AIC23B_DAIF_MS_SLAVE;
daif.lrswap = swap_channels;
daif.lrp = 0;
daif.iwl = (bits_per_sample <= 16) ? AIC23B_DAIF_IWL_16 :
(bits_per_sample <= 20) ? AIC23B_DAIF_IWL_20 :
(bits_per_sample <= 24) ? AIC23B_DAIF_IWL_24 :
AIC23B_DAIF_IWL_32;
daif.fmt = AIC23B_DAIF_FMT_I2S;
aic23b_write_reg(AIC23B_DAIF, daif.data);
aic23b_output_params.num_channels = num_channels;
aic23b_output_params.callback = callback;
aic23b_output_params.callback_opt = callback_opt;
}
#endif
bool aic23b_dac_output(void *sample_buffer, size_t sample_length)
{
bool global_interrupt_enabled;
if (!(pdca_get_transfer_status(AIC23B_SSC_TX_PDCA_CHANNEL) &
PDCA_TRANSFER_COUNTER_RELOAD_IS_ZERO))
return false;
if (sample_length)
{
if (aic23b_output_params.num_channels == 1)
{
int16_t *s16_sample_buffer = sample_buffer;
int i;
for (i = sample_length - 1; i >= 0; i--)
{
s16_sample_buffer[2 * i + 1] =
s16_sample_buffer[2 * i] = s16_sample_buffer[i];
}
}
// The PDCA is not able to synchronize its start of transfer with the SSC
// start of period, so this has to be done by polling the TF pin.
// Not doing so may result in channels being swapped randomly.
if ((global_interrupt_enabled = Is_global_interrupt_enabled()))
Disable_global_interrupt();
if (pdca_get_transfer_status(AIC23B_SSC_TX_PDCA_CHANNEL) &
PDCA_TRANSFER_COMPLETE)
{
while (gpio_get_pin_value(AIC23B_SSC_TX_FRAME_SYNC_PIN));
while (!gpio_get_pin_value(AIC23B_SSC_TX_FRAME_SYNC_PIN));
}
pdca_reload_channel(AIC23B_SSC_TX_PDCA_CHANNEL, sample_buffer, sample_length * 2);
pdca_get_reload_size(AIC23B_SSC_TX_PDCA_CHANNEL);
if (global_interrupt_enabled)
Enable_global_interrupt();
if (aic23b_output_params.callback_opt & AUDIO_DAC_OUT_OF_SAMPLE_CB)
pdca_enable_interrupt_transfer_complete(AIC23B_SSC_TX_PDCA_CHANNEL);
if (aic23b_output_params.callback_opt & AUDIO_DAC_RELOAD_CB)
pdca_enable_interrupt_reload_counter_zero(AIC23B_SSC_TX_PDCA_CHANNEL);
}
return true;
}
int main (void)
{
// Variables -- Misc
const twim_options_t twi_option_GYRO = twi_opt_GYRO;
const twim_options_t twi_option_ACC = twi_opt_ACC;
const twim_options_t twi_option_MAGN = twi_opt_MAGN;
// Variables -- Control system
float prev_e_z = 0;
float prev_e_roll = 0;
float prev_e_pitch = 0;
float prev_e_yaw = 0;
float eint_z = 0;
float eint_roll = 0;
float eint_pitch = 0;
float eint_yaw = 0;
float pitch_ederiv = 0; // Error derivative
float roll_ederiv = 0;
float prev_deriv_e_roll = 0;
float yaw_ederiv = 0;
float z_ederiv = 0;
float e = 0;
float dt; // Time between samples
unsigned long t1 = 0;
unsigned long t2 = 0;
float u1, u2, u3, u4 = 0;
float m1, m2, m3, m4 = 0;
float g_force = 240;
int xcount = 0;
float gain = 1;
int time_to_update_data = 0;
int deriv_count=0;
const usart_options_t usart_option = usart_opt;
const usart_options_t usart_option_2 = usart_opt_2;
// Setting up the board
pcl_configure_clocks(&pcl_freq_param);
board_init();
// Initialize Bluetooth
configure_AT(FPBA_HZ, usart_option);
irq_initialize_vectors();
cpu_irq_enable();
Disable_global_interrupt();
// Initialize interrupt vectors.
INTC_init_interrupts();
INTC_register_interrupt(&usart_int_handler, USART_IRQ, AVR32_INTC_INT0);
USART->ier = AVR32_USART_IER_RXRDY_MASK;
// Enable all interrupts.
Enable_global_interrupt();
// Enable Ultrasonic sensors
enable_Ultrasonic();
// Initialize motors
initialize_PWM();
tc_start(tc1, PWM_MOTOR1_CHANNEL);
tc_start(tc0, PWM_MOTOR2_CHANNEL);
tc_start(tc1, PWM_MOTOR3_CHANNEL);
tc_start(tc1, PWM_MOTOR4_CHANNEL);
// Waits for button press here after battery is connected
while (gpio_get_pin_value(GPIO_PUSH_BUTTON_0));
delay_ms(1000);
/*
while(1){
while (motor2_speed<60)
{
motor2_speed += 1;
update_Motors();
delay_ms(300);
}
while (motor2_speed>0)
{
motor2_speed -= 1;
update_Motors();
delay_ms(300);
}
}
while (gpio_get_pin_value(GPIO_PUSH_BUTTON_0));*/
//delay_ms(3000);
// Initialize RTC
//AVR32_RTC->ctrl & AVR32_RTC_CTRL_BUSY_MASK = 0;
rtc_init(&AVR32_RTC, RTC_OSC_32KHZ, 1);
rtc_enable(&AVR32_RTC);
// Initialize IMU parts
initialize_IMU();
// TESTING ONLY
float test_array[2000];
float test_array_2[2000];
float test_array_3[2000];
for (int k = 0; k < FILTER_LENGTH; k++){
FIFO_deriv_roll[k] = roll;
}
time_to_update_data = 0;
// Control system code begins
while(1)
{
t1 = rtc_get_value(&AVR32_RTC); // Current time in ms
dt = ((float)(t1-t2))*0.001*0.125; // dt in seconds
if (t1 < t2) // Timer overflowed
{
dt = ((float)(t1 + rtc_get_top_value(&AVR32_RTC))*0.001*0.125);
}
t2 = t1;
get_Angles();
//pitch = 0;
yaw = 0;
e = des_z-z; //calculating height error
eint_z = eint_z + ((e+prev_e_z)/2)*dt; //calculate error integral term
z_ederiv = (e - prev_e_z)/dt; //calculate error derivative term
u1 =(KP_Z*e) + (KI_Z*eint_z) + (KD_Z*z_ederiv)+g_force; //calculating control output
prev_e_z=e;
//ROLL
e = des_roll-roll; //calculating roll error
eint_roll = eint_roll + ((e+prev_e_roll)/2)*dt; //calculate error integral term
prev_e_roll=e;
for (int i = 0; i < (FILTER_LENGTH - 1); i++)
{
FIFO_deriv_roll[i] = FIFO_deriv_roll[i+1];
}
FIFO_deriv_roll[FILTER_LENGTH-1] = e;
roll_ederiv = (FIFO_deriv_roll[FILTER_LENGTH-1] - FIFO_deriv_roll[0])/(FILTER_LENGTH*dt);
u2 =(KP_ROLL*e) + (KI_ROLL*eint_roll) + (KD_ROLL*roll_ederiv); //calculating control output
if(xcount < 2000){
test_array[xcount] = roll_ederiv;
test_array_2[xcount] = roll;
test_array_3[xcount] = g_roll;
}
xcount++;
//PITCH
e = des_pitch-pitch; //calculating pitch error
eint_pitch = eint_pitch + ((e+prev_e_pitch)/2)*dt; //calculate error integral term
pitch_ederiv = (e - prev_e_pitch)/dt; //calculate error derivative term
u3 =(KP_PITCH*e) + (KI_PITCH*eint_pitch) + (KD_PITCH*pitch_ederiv); //calculating control output
prev_e_pitch=e;
//YAW
e = des_yaw-yaw; //calculating yaw error
eint_yaw = eint_yaw + ((e+prev_e_yaw)/2)*dt; //calculate error integral term
yaw_ederiv = (e - prev_e_yaw)/dt; //calculate error derivative term
u4 =(KPYAW*e) + (KIYAW*eint_yaw) + (KDYAW*yaw_ederiv); //calculating control output
prev_e_yaw=e;
//MOTOR SPEEDS
m1=(0.25*u1+0.5*u2+0.25*u4)*gain;
m2=(0.25*u1+0.5*u3-0.25*u4)*gain;
m3=(0.25*u1-0.5*u2+0.25*u4)*gain;
m4=(0.25*u1-0.5*u3-0.25*u4)*gain;
if (m1 > 95)
m1 = 95;
else if (m1 < 5)
m1 = 5;
if (m2 > 95)
{
m2 = 95;
}
else if (m2 < 5)
{
m2 = 5;
}
if (m3 > 95)
{
m3 = 95;
}
else if (m3 < 5)
{
m3 = 5;
}
if (m4 > 95)
{
m4 = 95;
}
else if (m4 < 5)
{
m4 = 5;
}
motor1_speed = m2; //m2
motor2_speed = m1; //m3
motor3_speed = m4; //m4
motor4_speed = m3; //m1..... the imu was turned 90 degrees....
update_Motors();
//Bluetooth Send
if (time_to_update_data > 3)
{
// Get Ultrasonic data
update_Ultrasonic();
// Send out update through Bluetooth
meas_roll = roll;
meas_pitch = pitch;
meas_yaw = yaw;
transmitted_data();
time_to_update_data = 0;
received_data();
}
else
{
delay_ms(7);
}
time_to_update_data++;
}
}
// main function
int main(void) {
pm_switch_to_osc0(&AVR32_PM, FOSC0, OSC0_STARTUP);
// Enable edge-triggered interrupt.
eic_options[0].eic_mode = EIC_MODE_EDGE_TRIGGERED;
// Interrupt will trigger on falling edge (this is a must-do for the keypad scan
// feature if the chosen mode is edge-triggered).
eic_options[0].eic_edge = EIC_EDGE_RISING_EDGE;
// Initialize in synchronous mode : interrupt is synchronized to the clock
eic_options[0].eic_async = EIC_SYNCH_MODE;
// Set the interrupt line number.
eic_options[0].eic_line = QT1081_EIC_EXTINT_INT;
// Activate LED0 & LED1 & LED2 & LED3 pins in GPIO output mode and switch them off.
gpio_set_gpio_pin(LED0_GPIO);
gpio_set_gpio_pin(LED1_GPIO);
gpio_set_gpio_pin(LED2_GPIO);
gpio_set_gpio_pin(LED3_GPIO);
gpio_enable_module_pin( QT1081_EIC_EXTINT_PIN, QT1081_EIC_EXTINT_FUNCTION);
#if( INT_MODE == INT_MODE_GPIO)
Disable_global_interrupt();
#if __GNUC__
INTC_init_interrupts();
/* Register interrupt handler to the interrupt controller
* up, down buttons on PB22, PB23 -> GPIO_IRQ_6
*/
INTC_register_interrupt(&touch_button_isr, AVR32_GPIO_IRQ_6, 0);//AVR32_INTC_INT0);
/* Other buttons on PB[24..26] -> GPIO_IRQ_7 (PB23 - PB31) */
INTC_register_interrupt(&touch_button_isr, AVR32_GPIO_IRQ_7, 0);
#endif
gpio_enable_pin_interrupt(QT1081_TOUCH_SENSOR_0, GPIO_RISING_EDGE);
gpio_enable_pin_interrupt(QT1081_TOUCH_SENSOR_1, GPIO_RISING_EDGE);
gpio_enable_pin_interrupt(QT1081_TOUCH_SENSOR_2, GPIO_RISING_EDGE);
gpio_enable_pin_interrupt(QT1081_TOUCH_SENSOR_3, GPIO_RISING_EDGE);
gpio_enable_pin_interrupt(QT1081_TOUCH_SENSOR_4, GPIO_RISING_EDGE);
Enable_global_interrupt();
#endif
#if(INT_MODE == INT_MODE_EIC)
Disable_global_interrupt();
#if __GNUC__
INTC_init_interrupts();
/* Register the EXTINT1 interrupt handler to the interrupt controller
*/
INTC_register_interrupt(&touch_button_isr, QT1081_EIC_EXTINT_IRQ, AVR32_INTC_INT0);
#endif
// Init the EIC controller with the options
eic_init(&AVR32_EIC, eic_options, 1);
// Enable the EIC lines.
eic_enable_lines(&AVR32_EIC, (1<<eic_options[0].eic_line));
// Enable the interrupt for each EIC line.
eic_enable_interrupt_lines(&AVR32_EIC, (1<<eic_options[0].eic_line));
Enable_global_interrupt();
#endif
while(true);
return 0;
}
void boardsupport_init(central_data_t *central_data)
{
irq_initialize_vectors();
cpu_irq_enable();
Disable_global_interrupt();
// Initialize the sleep manager
sleepmgr_init();
sysclk_init();
board_init();
delay_init(sysclk_get_cpu_hz());
time_keeper_init();
INTC_init_interrupts();
// Switch on the red LED
LED_On(LED2);
// servo_pwm_hardware_init();
pwm_servos_init( CS_ON_SERVO_7_8 );
// Init UART 0 for XBEE communication
xbee_init(UART0);
// Init UART 4 for wired communication
//console_init(CONSOLE_UART4);
// Init USB for wired communication
console_init(CONSOLE_USB);
// connect abstracted aliases to hardware ports
central_data->telemetry_down_stream = xbee_get_out_stream();
central_data->telemetry_up_stream = xbee_get_in_stream();
central_data->debug_out_stream = console_get_out_stream();
central_data->debug_in_stream = console_get_in_stream();
// init debug output
print_util_dbg_print_init(central_data->debug_out_stream);
print_util_dbg_print("Debug stream initialised\r\n");
// RC receiver initialization
spektrum_satellite_init();
// init imu & compass
i2c_driver_init(I2C0);
lsm330dlc_init();
print_util_dbg_print("LSM330 initialised \r\n");
hmc5883l_init_slow();
print_util_dbg_print("HMC5883 initialised \r\n");
// init radar or ultrasound (not implemented yet)
//i2c_driver_init(I2C1);
// init 6V enable
gpio_enable_gpio_pin(AVR32_PIN_PA04);
gpio_set_gpio_pin(AVR32_PIN_PA04);
Enable_global_interrupt();
// Init piezo speaker
piezo_speaker_init_binary();
print_util_dbg_print("Board initialised\r\n");
}
/*************************************************************************************************
* firmware_backup_and_reboot_task
*
* Creates a backup of the current firmware in EEPROM and reboots the device afterwards
*/
static portTASK_FUNCTION( firmware_backup_and_reboot_task, pvParameters )
{
uint32_t current_flash_address = FIRMWARE_START_ADDRESS;
uint32_t last_used_flash_address = 0;
uint8_t buffer[EEPROM_PAGE_SIZE];
uint32_t buffer_index = 0;
wdt_opt_t wdt_opt = { .us_timeout_period = 1000000 };
/* find last used byte in flash */
for (last_used_flash_address = FIRMWARE_END_ADDRESS;
last_used_flash_address > FIRMWARE_START_ADDRESS;
last_used_flash_address--)
{
if (*((uint8_t *) (last_used_flash_address)) != 0xFF)
{
break;
}
}
registry_set_value("Firmware Backup Length", last_used_flash_address - FIRMWARE_START_ADDRESS + 1);
while (current_flash_address + buffer_index < last_used_flash_address + 1)
{
if (buffer_index < EEPROM_PAGE_SIZE)
{
buffer[buffer_index] = *((uint8_t *) (current_flash_address + buffer_index));
buffer_index++;
}
else
{
/* EEPROM_buffer is full, flush it */
eeprom_write(FIRMWARE_BACKUP_EEPROM_START + (current_flash_address - FIRMWARE_START_ADDRESS), buffer, buffer_index);
current_flash_address += buffer_index;
buffer[0] = *((uint8_t *) current_flash_address);
buffer_index = 1;
}
}
/* flush remainder of buffer */
eeprom_write(FIRMWARE_BACKUP_EEPROM_START + (current_flash_address - FIRMWARE_START_ADDRESS), buffer, buffer_index);
registry_set_value("Firmware Update State", FIRMWARE_STATE_FLASH_NEW_APPLICATION); // new application ready in EEPROM, backup complete
/* generate reset */
Disable_global_interrupt();
cpu_irq_disable();
wdt_enable(&wdt_opt);
while (1);
/* Kill this task (redundant, I know) */
vTaskDelete(NULL);
}
/*************************************************************************************************
* firmware_update_init
*
* Initializes the firmware update module
*/
void firmware_update_init(void)
{
registry_initialize_key("Firmware Update State", FIRMWARE_STATE_JUMP_TO_APPLICATION, true);
registry_initialize_key("Firmware Length", 0, true);
registry_initialize_key("Firmware Backup Length", 0, true);
if (registry_get_value("Firmware Update State") == FIRMWARE_STATE_RESTORE_BACKUP)
{
/* FIRMWARE_STATE_RESTORE_BACKUP is activated automatically after a new version has been flashed */
current_firmware_update_status = SUCCESSFUL_ASK_USER_TO_KEEP;
}
}
//! This function is the generic control pipe management function.
//! This function is used to send and receive control requests over control pipe.
//!
//! @todo Fix all time-out errors and disconnections in active wait loop.
//!
//! @param data_pointer void *: Pointer to data to transfer
//!
//! @return Status_t: Status
//!
//! @note This function uses the usb_request global structure. Hence, this
//! structure should be filled before calling this function.
//!
Status_t host_transfer_control(void *data_pointer)
{
int status = CONTROL_GOOD;
bool sav_int_sof_enable;
bool sav_glob_int_en;
U16 data_length;
U8 c;
Usb_ack_event(EVT_HOST_SOF);
sav_int_sof_enable = Is_host_sof_interrupt_enabled();
Host_enable_sof_interrupt(); // SOF software detection is in interrupt subroutine
while (!Is_usb_event(EVT_HOST_SOF)) // Wait 1 SOF
{
if (Is_host_emergency_exit())
{
Host_freeze_pipe(P_CONTROL);
Host_reset_pipe(P_CONTROL);
status = CONTROL_TIMEOUT;
goto host_transfer_control_end;
}
}
Host_configure_pipe_token(P_CONTROL, TOKEN_SETUP);
Host_ack_setup_ready();
Host_unfreeze_pipe(P_CONTROL);
// Build and send the setup request fields
Host_reset_pipe_fifo_access(P_CONTROL);
Host_write_pipe_data(P_CONTROL, 8, usb_request.bmRequestType);
Host_write_pipe_data(P_CONTROL, 8, usb_request.bRequest);
Host_write_pipe_data(P_CONTROL, 16, usb_format_mcu_to_usb_data(16, usb_request.wValue));
Host_write_pipe_data(P_CONTROL, 16, usb_format_mcu_to_usb_data(16, usb_request.wIndex));
Host_write_pipe_data(P_CONTROL, 16, usb_format_mcu_to_usb_data(16, usb_request.wLength));
Host_send_setup();
while (!Is_host_setup_ready()) // Wait for SETUP ack
{
if (Is_host_emergency_exit())
{
Host_freeze_pipe(P_CONTROL);
Host_reset_pipe(P_CONTROL);
status = CONTROL_TIMEOUT;
goto host_transfer_control_end;
}
if (Is_host_pipe_error(P_CONTROL)) // Any error?
{
c = Host_error_status(P_CONTROL);
Host_ack_all_errors(P_CONTROL);
status = c; // Send error status
goto host_transfer_control_end;
}
}
// Setup token sent; now send IN or OUT token
// Before just wait 1 SOF
Usb_ack_event(EVT_HOST_SOF);
Host_freeze_pipe(P_CONTROL);
data_length = usb_request.wLength;
while (!Is_usb_event(EVT_HOST_SOF)) // Wait 1 SOF
{
if (Is_host_emergency_exit())
{
Host_freeze_pipe(P_CONTROL);
Host_reset_pipe(P_CONTROL);
status = CONTROL_TIMEOUT;
goto host_transfer_control_end;
}
}
// IN request management ---------------------------------------------
if (usb_request.bmRequestType & 0x80) // Data stage IN (bmRequestType.D7 == 1)
{
Host_disable_continuous_in_mode(P_CONTROL);
Host_configure_pipe_token(P_CONTROL, TOKEN_IN);
Host_ack_control_in_received_free();
while (data_length)
{
Host_unfreeze_pipe(P_CONTROL);
private_sof_counter = 0; // Reset the counter in SOF detection subroutine
while (!Is_host_control_in_received())
{
if (Is_host_emergency_exit())
{
Host_freeze_pipe(P_CONTROL);
Host_reset_pipe(P_CONTROL);
status = CONTROL_TIMEOUT;
goto host_transfer_control_end;
}
if (Is_host_pipe_error(P_CONTROL)) // Any error?
{
c = Host_error_status(P_CONTROL);
Host_ack_all_errors(P_CONTROL);
status = c; // Send error status
goto host_transfer_control_end;
}
if (Is_host_stall(P_CONTROL))
{
Host_ack_stall(P_CONTROL);
status = CONTROL_STALL;
goto host_transfer_control_end;
}
#if TIMEOUT_DELAY_ENABLE == ENABLE
if (1000 < host_get_timeout()) // Count 1s
{
Host_freeze_pipe(P_CONTROL);
Host_reset_pipe(P_CONTROL);
status = CONTROL_TIMEOUT;
goto host_transfer_control_end;
}
#endif
}
Host_reset_pipe_fifo_access(P_CONTROL);
c = Host_get_pipe_size(P_CONTROL) - Host_byte_count(P_CONTROL);
data_length = host_read_p_rxpacket(P_CONTROL, data_pointer, data_length, &data_pointer);
if (usb_request.incomplete_read || c) data_length = 0;
Host_freeze_pipe(P_CONTROL);
Host_ack_control_in_received_free();
// In low-speed mode, the USB IP may have not yet sent the ACK at this
// point. The USB IP does not support a new start of transaction request
// from the firmware if the ACK has not been sent. The only means of
// making sure the ACK has been sent is to wait for the next Keep-Alive
// before starting a new transaction.
if (Is_usb_low_speed_mode())
{
Usb_ack_event(EVT_HOST_SOF);
if ((sav_glob_int_en = Is_global_interrupt_enabled())) Disable_global_interrupt();
Host_ack_sof();
(void)Is_host_sof_interrupt_enabled();
if (sav_glob_int_en) Enable_global_interrupt();
Host_enable_sof_interrupt();
while (!Is_usb_event(EVT_HOST_SOF)) // Wait for next Keep-Alive
{
if (Is_host_emergency_exit())
{
Host_freeze_pipe(P_CONTROL);
Host_reset_pipe(P_CONTROL);
status = CONTROL_TIMEOUT;
goto host_transfer_control_end;
}
}
}
} // End of IN data stage
Host_configure_pipe_token(P_CONTROL, TOKEN_OUT);
Host_ack_control_out_ready_send();
Host_unfreeze_pipe(P_CONTROL);
while (!Is_host_control_out_ready())
{
if (Is_host_emergency_exit())
{
Host_freeze_pipe(P_CONTROL);
Host_reset_pipe(P_CONTROL);
status = CONTROL_TIMEOUT;
goto host_transfer_control_end;
}
if (Is_host_pipe_error(P_CONTROL)) // Any error?
{
c = Host_error_status(P_CONTROL);
Host_ack_all_errors(P_CONTROL);
status = c; // Send error status
goto host_transfer_control_end;
}
if (Is_host_stall(P_CONTROL))
{
Host_ack_stall(P_CONTROL);
status = CONTROL_STALL;
goto host_transfer_control_end;
}
}
Host_ack_control_out_ready();
}
// OUT request management --------------------------------------------
else // Data stage OUT (bmRequestType.D7 == 0)
{
Host_configure_pipe_token(P_CONTROL, TOKEN_OUT);
Host_ack_control_out_ready();
while (data_length)
{
Host_unfreeze_pipe(P_CONTROL);
Host_reset_pipe_fifo_access(P_CONTROL);
data_length = host_write_p_txpacket(P_CONTROL, data_pointer, data_length, (const void **)&data_pointer);
Host_send_control_out();
while (!Is_host_control_out_ready())
{
if (Is_host_emergency_exit())
{
Host_freeze_pipe(P_CONTROL);
Host_reset_pipe(P_CONTROL);
status = CONTROL_TIMEOUT;
goto host_transfer_control_end;
}
if (Is_host_pipe_error(P_CONTROL)) // Any error?
{
c = Host_error_status(P_CONTROL);
Host_ack_all_errors(P_CONTROL);
status = c; // Send error status
goto host_transfer_control_end;
}
if (Is_host_stall(P_CONTROL))
{
Host_ack_stall(P_CONTROL);
status = CONTROL_STALL;
goto host_transfer_control_end;
}
}
Host_ack_control_out_ready();
} // End of OUT data stage
Host_freeze_pipe(P_CONTROL);
Host_configure_pipe_token(P_CONTROL, TOKEN_IN);
Host_ack_control_in_received_free();
Host_unfreeze_pipe(P_CONTROL);
while (!Is_host_control_in_received())
{
if (Is_host_emergency_exit())
{
Host_freeze_pipe(P_CONTROL);
Host_reset_pipe(P_CONTROL);
status = CONTROL_TIMEOUT;
goto host_transfer_control_end;
}
if (Is_host_pipe_error(P_CONTROL)) // Any error?
{
c = Host_error_status(P_CONTROL);
Host_ack_all_errors(P_CONTROL);
status = c; // Send error status
goto host_transfer_control_end;
}
if (Is_host_stall(P_CONTROL))
{
Host_ack_stall(P_CONTROL);
status = CONTROL_STALL;
goto host_transfer_control_end;
}
}
Host_ack_control_in_received();
Host_freeze_pipe(P_CONTROL);
Host_free_control_in();
}
host_transfer_control_end:
if (!sav_int_sof_enable) // Restore SOF interrupt enable
{
if ((sav_glob_int_en = Is_global_interrupt_enabled())) Disable_global_interrupt();
Host_disable_sof_interrupt();
(void)Is_host_sof_interrupt_enabled();
if (sav_glob_int_en) Enable_global_interrupt();
}
return status;
}
//! This function checks if the device class is supported.
//! The function looks in all interfaces declared in the received descriptors if
//! one of them matches an entry of the CLASS/SUB_CLASS/PROTOCOL table.
//! If HOST_AUTO_CFG_ENDPOINT is enabled, a pipe is configured for each endpoint
//! of supported interfaces.
//!
//! @return bool: Status
//!
bool host_check_class(void)
{
U8 *descriptor, *conf_end;
U8 device_class, device_subclass, device_protocol;
U8 c;
#if HOST_AUTO_CFG_ENDPOINT == ENABLE
U8 nb_endpoint_to_configure = 0;
U8 ep_index = 0;
U8 physical_pipe = P_1; // P_1 because physical pipe 0 is reserved for control
// By default, the host is configured when returning
Host_set_configured();
#endif
// First, assume no interface is supported
nb_interface_supported = 0;
// Check if configuration descriptor
if (data_stage[OFFSET_FIELD_DESCRIPTOR_TYPE] != CONFIGURATION_DESCRIPTOR) return false;
bmattributes = data_stage[OFFSET_FIELD_BMATTRIBUTES];
maxpower = data_stage[OFFSET_FIELD_MAXPOWER];
conf_end = data_stage +
min(usb_format_usb_to_mcu_data(16, *(U16 *)(data_stage + OFFSET_FIELD_TOTAL_LENGTH)),
SIZEOF_DATA_STAGE - OFFSET_FIELD_PROTOCOL);
// Look in all interfaces declared in the configuration
for (descriptor = data_stage + data_stage[OFFSET_DESCRIPTOR_LENGTH]; descriptor < conf_end;
descriptor += descriptor[OFFSET_DESCRIPTOR_LENGTH])
{
// Find next interface descriptor
switch (descriptor[OFFSET_FIELD_DESCRIPTOR_TYPE])
{
case INTERFACE_DESCRIPTOR:
// Check the number of supported interfaces does not exceed the maximum
if (nb_interface_supported >= MAX_INTERFACE_SUPPORTED) return true;
#if HOST_AUTO_CFG_ENDPOINT == ENABLE
// If there are still endpoints to configure although a new interface descriptor has been found
if (nb_endpoint_to_configure)
{
// Mark the host as not configured
Host_clear_configured();
// Reset the number of endpoints to configure
nb_endpoint_to_configure = 0;
}
#endif
// Found an interface descriptor
// Get characteristics of this interface
device_class = descriptor[OFFSET_FIELD_CLASS];
device_subclass = descriptor[OFFSET_FIELD_SUB_CLASS];
device_protocol = descriptor[OFFSET_FIELD_PROTOCOL];
// Look in registered class table for match
for (c = 0; c < REG_CLASS_CNT; c += 3)
{
if (registered_class[c] == device_class && // Class is correct
registered_class[c + 1] == device_subclass && // Subclass is correct
registered_class[c + 2] == device_protocol) // Protocol is correct
{
// Store this interface as supported interface
// Memorize its interface nb
interface_supported[nb_interface_supported].interface_nb = descriptor[OFFSET_FIELD_INTERFACE_NB];
// its alternate setting
interface_supported[nb_interface_supported].altset_nb = descriptor[OFFSET_FIELD_ALT];
// its USB class
interface_supported[nb_interface_supported].uclass = device_class;
// its USB subclass
interface_supported[nb_interface_supported].subclass = device_subclass;
// its USB protocol
interface_supported[nb_interface_supported].protocol = device_protocol;
// the number of endpoints associated with this interface
#if HOST_AUTO_CFG_ENDPOINT == ENABLE
ep_index = 0;
nb_endpoint_to_configure =
#endif
interface_supported[nb_interface_supported].nb_ep = min(descriptor[OFFSET_FIELD_NB_OF_EP], MAX_EP_PER_INTERFACE);
// Update the number of supported interfaces
nb_interface_supported++;
// Class/subclass/protocol is registered, so look for next interface descriptor
break;
}
}
break;
#if HOST_AUTO_CFG_ENDPOINT == ENABLE
case ENDPOINT_DESCRIPTOR:
// If there are still endpoints to configure while there are free pipes
if (physical_pipe < MAX_PEP_NB && nb_endpoint_to_configure)
{
nb_endpoint_to_configure--;
// Reconfigure the new physical pipe to get rid of any previous configuration
#if USB_HOST_PIPE_INTERRUPT_TRANSFER == ENABLE
Disable_global_interrupt();
#endif
Host_disable_pipe(physical_pipe);
#if USB_HOST_PIPE_INTERRUPT_TRANSFER == ENABLE
(void)Is_host_pipe_enabled(physical_pipe);
Enable_global_interrupt();
#endif
Host_unallocate_memory(physical_pipe);
Host_enable_pipe(physical_pipe);
// Fix HW, set freq at 0 in case of no interrupt endpoint
if( TYPE_INTERRUPT != descriptor[OFFSET_FIELD_EP_TYPE] ) descriptor[OFFSET_FIELD_EP_INTERVAL] = 0;
// Build the pipe configuration according to the endpoint descriptor fields received
(void)Host_configure_pipe(
physical_pipe, // Pipe nb in USB interface
descriptor[OFFSET_FIELD_EP_INTERVAL], // Interrupt period (for interrupt pipe)
Get_desc_ep_nbr(descriptor[OFFSET_FIELD_EP_ADDR]), // Pipe endpoint number
descriptor[OFFSET_FIELD_EP_TYPE], // Pipe type (isochronous/bulk/interrupt)
Get_pipe_token(descriptor[OFFSET_FIELD_EP_ADDR]), // Pipe token (IN/OUT)
descriptor[OFFSET_FIELD_EP_SIZE] |
descriptor[OFFSET_FIELD_EP_SIZE + 1] << 8, // Pipe size
((TYPE_ISOCHRONOUS == (descriptor[OFFSET_FIELD_EP_TYPE] & TRANSFER_TYPE_MASK))
|| (TYPE_BULK == (descriptor[OFFSET_FIELD_EP_TYPE] & TRANSFER_TYPE_MASK))
? DOUBLE_BANK : SINGLE_BANK) // Number of banks to allocate for pipe
);
#if (USB_HIGH_SPEED_SUPPORT==true)
if( (TYPE_BULK == Host_get_pipe_type(physical_pipe))
&& (TOKEN_OUT == Host_get_pipe_token(physical_pipe)) )
{
if( !Is_usb_full_speed_mode() )
{
// Enable PING management for bulk OUT endpoint each micro frame
Host_configure_pipe_int_req_freq(physical_pipe,0);
Host_enable_ping(physical_pipe);
}
}
#endif
// Update endpoint pipe table in supported interface structure
interface_supported[nb_interface_supported - 1].ep_pipe[ep_index++] = physical_pipe++;
}
break;
#endif
}
// Call user callback to look more deeply into the configuration descriptor
Host_user_check_class_action(descriptor);
}
#if HOST_AUTO_CFG_ENDPOINT == ENABLE
// If there are still endpoints to configure although all descriptors have been parsed
if (nb_endpoint_to_configure)
{
// Mark the host as not configured
Host_clear_configured();
}
#endif
return (nb_interface_supported > 0);
}
void boardsupport_init(central_data_t *central_data)
{
irq_initialize_vectors();
cpu_irq_enable();
Disable_global_interrupt();
// Initialize the sleep manager
sleepmgr_init();
sysclk_init();
board_init();
delay_init(sysclk_get_cpu_hz());
time_keeper_init();
INTC_init_interrupts();
// Switch on the red LED
LED_On(LED2);
// servo_pwm_hardware_init();
pwm_servos_init( CS_ON_SERVO_7_8 );
// Init UART 0 for XBEE communication
xbee_init(UART0);
// Init UART 3 for GPS communication
gps_ublox_init(&(central_data->gps), UART3);
// Init UART 4 for wired communication
//console_init(CONSOLE_UART4);
// Init USB for wired communication
console_init(CONSOLE_USB);
// connect abstracted aliases to hardware ports
central_data->telemetry_down_stream = xbee_get_out_stream();
central_data->telemetry_up_stream = xbee_get_in_stream();
central_data->debug_out_stream = console_get_out_stream();
central_data->debug_in_stream = console_get_in_stream();
// init debug output
print_util_dbg_print_init(central_data->debug_out_stream);
print_util_dbg_print("Debug stream initialised\r\n");
// Bind RC receiver with remote
// spektrum_satellite_bind();
// RC receiver initialization
spektrum_satellite_init();
// Init analog rails
analog_monitor_conf_t analog_monitor_config = analog_monitor_default_config;
//analog_monitor_config.conv_factor[ANALOG_RAIL_6] = 0.00023485f * 6.6f;
//analog_monitor_config.conv_factor[ANALOG_RAIL_7] = 0.00023485f * 6.6f;
//analog_monitor_config.conv_factor[ANALOG_RAIL_10] = -0.0002409f * 11.0f;
//analog_monitor_config.conv_factor[ANALOG_RAIL_11] = -0.0002409f * 11.0f;
analog_monitor_init(¢ral_data->analog_monitor, &analog_monitor_config);
// init imu & compass
i2c_driver_init(I2C0);
lsm330dlc_init();
print_util_dbg_print("LSM330 initialised \r\n");
hmc5883l_init_slow();
print_util_dbg_print("HMC5883 initialised \r\n");
bmp085_init(¢ral_data->pressure);
// init radar or ultrasound (not implemented yet)
//i2c_driver_init(I2C1);
// init 6V enable
gpio_enable_gpio_pin(AVR32_PIN_PA04);
gpio_set_gpio_pin(AVR32_PIN_PA04);
Enable_global_interrupt();
// Init piezo speaker
piezo_speaker_init_binary();
print_util_dbg_print("Board initialised\r\n");
}
bool xMACBInit(volatile avr32_macb_t *macb)
{
bool global_interrupt_enabled = Is_global_interrupt_enabled();
volatile unsigned long status;
// generate an hardware reset of the phy
ethernet_phy_hw_reset();
// generate a software reset of the phy
ethernet_phy_sw_reset(macb);
// set up registers
macb->ncr = 0;
macb->tsr = ~0UL;
macb->rsr = ~0UL;
if (global_interrupt_enabled) Disable_global_interrupt();
macb->idr = ~0UL;
status = macb->isr;
if (global_interrupt_enabled) Enable_global_interrupt();
#if ETHERNET_CONF_USE_RMII_INTERFACE
// RMII used, set 0 to the USRIO Register
macb->usrio &= ~AVR32_MACB_RMII_MASK;
#else
// RMII not used, set 1 to the USRIO Register
macb->usrio |= AVR32_MACB_RMII_MASK;
#endif
// Load our MAC address into the MACB.
prvSetupMACAddress(macb);
// Setup the buffers and descriptors.
prvSetupDescriptors(macb);
#if ETHERNET_CONF_SYSTEM_CLOCK <= 20000000
macb->ncfgr |= (AVR32_MACB_NCFGR_CLK_DIV8 << AVR32_MACB_NCFGR_CLK_OFFSET);
#elif ETHERNET_CONF_SYSTEM_CLOCK <= 40000000
macb->ncfgr |= (AVR32_MACB_NCFGR_CLK_DIV16 << AVR32_MACB_NCFGR_CLK_OFFSET);
#elif ETHERNET_CONF_SYSTEM_CLOCK <= 80000000
macb->ncfgr |= AVR32_MACB_NCFGR_CLK_DIV32 << AVR32_MACB_NCFGR_CLK_OFFSET;
#elif ETHERNET_CONF_SYSTEM_CLOCK <= 160000000
macb->ncfgr |= AVR32_MACB_NCFGR_CLK_DIV64 << AVR32_MACB_NCFGR_CLK_OFFSET;
#else
# error System clock too fast
#endif
// Are we connected?
if( prvProbePHY(macb) == true )
{
// Enable the interrupt!
portENTER_CRITICAL();
{
prvSetupMACBInterrupt(macb);
}
portEXIT_CRITICAL();
// Enable Rx and Tx, plus the stats register.
macb->ncr = AVR32_MACB_NCR_TE_MASK | AVR32_MACB_NCR_RE_MASK;
return (true);
}
return (false);
}
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();
}
/*! \brief Example application entry function.
*/
int
main (void)
{
/* BEFORE USING THE EXAMPLE PROJECTS.
1. For support queries on,
- QTouch Library usage
- Capacitive Touch Sensor Tuning
- Capacitive Touch Schematic design
- Capacitive Touch Sensor design
refer to http://www.atmel.com/design-support/
2. For more QTouch Library documentation,
refer Atmel QTouch Library User Guide doc8207.pdf.
For Capacitive Touch Sensor tuning guidelines,
refer QTAN0062: QTouch and QMatrix Sensitivity Tuning for Keys, Sliders and Wheels.
For Capacitive Touch Sensor design,
refer doc10620.pdf: Touch Sensors Design Guide.
http://www.atmel.com/dyn/products/app_notes.asp?family_id=697
3. The Example application uses a CPU, PBA and PBB clock of 48MHz.
When using a different frequency setting, the following parameters must be
changed accordingly to ensure proper QTouch operation.
a. QTx_CAT_CLK_DIV.
b. TOUCH_SPREAD_SPECTRUM_MAX_DEV, when Spread spectrum is enabled.
c. PBA_HZ, when using qdebug/SPI_Master.c
d. TARGET_PBA_FREQ_HZ and TARGET_CPU_FREQ_HZ, when using qdebug/SERIAL.c
4. STK600-QTouch Test setup pin information.
The following table indicates the STK600 pin connections for the STK600-QTouch
test setup.
Important Note: The (csa1/csab1) and (csa2/csb2) Touch channel connections are
multiplexed with the JTAG pins. So, when using the JTAG debugging mode, these
Touch channel connections MUST be removed. In the Flash mode, this will not
cause any issues.
----------------------------------------------
CAT CSA/CSB name - STK600 board Port-pin name
----------------------------------------------
ROTOR/WHEEL
csa1 - pa1 (This pair is multiplexed with JTAG pins.
csb1 - pa6 Remove Touch connections on these pins during JTAG debug mode.)
csa2 - pa0 (This pair is multiplexed with JTAG pins.
csb2 - pa7 Remove Touch connections on these pins during JTAG debug mode.)
csa5 - pb2
csb5 - pb4
SLIDER
csa9 - pd0
csb9 - pd1
csa7 - pa4
csb7 - pa5
csa8 - pc0
csb8 - pc1
KEY 1
csa15 - pe4
csb15 - pe1
KEY 2
csa16 - pe3
csb16 - pe2
----------------------------------------------
QT600 USB Bridge
'TOUCH DATA' Header Pin name - STK600 board Port-pin name
----------------------------------------------
PA22 - 'TOUCH DATA' header pin 8 - clk - pc6
PA21 - 'TOUCH DATA' header pin 7 - miso - pc5
PA20 - 'TOUCH DATA' header pin 6 - mosi - pc4
PA14 - 'TOUCH DATA' header pin 5 - nss - pb6
5. When two or more acquisition methods are used, care must be taken such that a
given port pin is not used by more than one method at the same time. The following
pin configuration options available in touch_config_at32uc3l.h must be carefully
chosen to avoid any overlapping.
a. QMatrix Pin Configuration Options.
b. Autonomous QTouch Pin Configuration Options.
c. QTouch Group A Pin Configuration Options.
d. QTouch Group B Pin Configuration Options.
e. Touch Sync Pin option.
*/
touch_ret_t touch_ret = TOUCH_SUCCESS;
touch_qt_dma_t qt_dma_ch;
/* Initialize host clock, pins, watchdog, etc. */
init_system ();
/* Disable interrupts. */
Disable_global_interrupt ();
/* The INTC driver has to be used only for GNU GCC for AVR32. */
#if (defined __GNUC__)
/* initialize interrupt vectors. */
INTC_init_interrupts ();
/* Register the Timer interrupt handler to the interrupt controller. */
INTC_register_interrupt (&tc_irq, EXAMPLE_TC_IRQ, AVR32_INTC_INT0);
/* Register the Touch Library CAT interrupt handler to the interrupt controller.
Note: This interrupt registration is a MUST before using the Touch Library
with the GCC compiler.
For the case of IAR the registration of interrupt is automatically taken
care by the compiler. The Touch Libary CAT interrupt level for the case
of IAR is fixed to Interrupt level 3. */
INTC_register_interrupt (&touch_acq_done_irq, AVR32_CAT_IRQ,
AVR32_INTC_INT3);
#endif
/* Enable interrupts. */
Enable_global_interrupt ();
/* Configure timer to fire ISR regularly. */
init_timer ();
/* Initialize touch library and uc3l cat module for QTouch Group A operation. */
touch_ret = touch_qt_sensors_init (TOUCH_QT_GRP_A, &touch_config);
if (touch_ret != TOUCH_SUCCESS)
{
while (1u); /* Check API Error return code. */
}
#if DEF_TOUCH_QDEBUG_ENABLE == 1
/* Initialize the debug interface. */
QDebug_Init ();
#endif
/* configure the touch library sensors. */
touch_ret = config_qt_grp_a_touch_sensors ();
if (touch_ret != TOUCH_SUCCESS)
{
while (1u); /* Check API Error return code. */
}
/* Initialize touch sensing. */
touch_ret = touch_qt_sensors_calibrate (TOUCH_QT_GRP_A);
if (touch_ret != TOUCH_SUCCESS)
{
while (1u); /* Check API Error return code. */
}
/* Provide the dma channel to be used by the CAT module. For each
acquisition cycle, any different dma channel from 0 to 11 can be provided.
The touch library can handle a different dma channel for each call of the
touch_qt_sensors_start_acquisition API. */
qt_dma_ch = QTA_DMA_CHANNEL_0;
/* Loop forever */
for (;;)
{
/* Process touch library events. The touch_event_dispatcher API needs to
be called as frequently as possible in order to have a good touch response. */
touch_event_dispatcher ();
if (time_to_measure_touch == 1u)
{
/* Clear flag: it's time to measure touch */
time_to_measure_touch = 0u;
/* Start a touch sensors measurement process. */
touch_ret = touch_qt_sensors_start_acquisition (TOUCH_QT_GRP_A,
current_time_ms_touch,
qt_dma_ch,
NORMAL_ACQ_MODE,
touch_qta_measure_complete_callback);
if ((touch_ret != TOUCH_SUCCESS) &&
(touch_ret != TOUCH_ACQ_INCOMPLETE))
{
while (1);
/* Reaching this point can be due to -
1. The api has retured an error due to a invalid input parameter.
2. The api has been called during a invalid Touch Library state. */
}
}
/* Host application code goes here */
if (qta_measurement_done_touch == 1u)
{
/* Clear flag: QTouch Group A measurement complete. */
qta_measurement_done_touch = 0u;
#if DEF_TOUCH_QDEBUG_ENABLE == 1
/* QT600 two-way QDebug communication application Example. */
/* Process any commands received from QTouch Studio. */
QDebug_ProcessCommands ();
/* Send out the Touch debug information data each time when Touch
measurement process is completed . */
QDebug_SendData (p_qta_measure_data->acq_status);
#endif
}
} /* Loop forever */
}
/*============================================================================
Name : main
------------------------------------------------------------------------------
Purpose : main code entry point.
Input : n/a
Output : n/a
Notes :
============================================================================*/
int main( void )
{
/* BEFORE USING THE EXAMPLE PROJECTS.
1. The Example application uses a CPU, PBA and PBB clock of 48MHz.
When using a different frequency setting, the following parameters must be
changed accordingly to ensure proper QMatrix operation.
a. QM_GCLK_CAT_DIV.
b. QM_CAT_CLK_DIV.
c. TOUCH_SPREAD_SPECTRUM_MAX_DEV, when Spread spectrum is enabled.
d. PBA_HZ, when using QDebug/SPI_Master.c
e. TARGET_PBA_FREQ_HZ and TARGET_CPU_FREQ_HZ, when using QDebug/SERIAL.c
2. In the UC3L-Evaluation kit (Rev2), the R42 and R54 (both 470KOhm) resistors
MUST be replaced to 910KOhms.
3. The QTouch library uses PDCA channels 0 and 1.
(QM_DMA_CHANNEL_0, QM_DMA_CHANNEL_1).
Similarly, the QDebug/SERIAL.c uses PDCA channels 2 and 3.
(PDCA_CHANNEL_RX_USART, PDCA_CHANNEL_TX_USART)
4. For QMatrix operation, the Analog comparators channels are used (using the
ACIFB interface) depending on the Y Lines enabled. For example, when
Y lines Y2 and Y7 are enabled the Analog comparator channels 2 and 7
are used by the CAT module for QMatrix operation. The user can uses the rest
of the Analog comparator channels in the main application. The QTouch Library
enables the ACIFB using the Control register (if not already enabled by the main
application) when the touch_qm_sensors_init API is called.
5. When two or more acquisition methods are used, care must be taken such that a
given port pin is not used by more than one method at the same time. The following
pin configuration options available in touch_config_at32uc3l.h must be carefully
chosen to avoid any overlapping.
a. QMatrix Pin Configuration Options.
b. Autonomous QTouch Pin Configuration Options.
c. QTouch Group A Pin Configuration Options.
d. QTouch Group B Pin Configuration Options.
e. Touch Sync Pin option.
*/
touch_ret_t touch_ret = TOUCH_SUCCESS;
touch_qm_dma_t qm_dma;
/* Initialize host clock, pins, watchdog, etc. */
init_system();
/* Disable interrupts. */
Disable_global_interrupt();
/* The INTC driver has to be used only for GNU GCC for AVR32. */
#if (defined __GNUC__)
/* initialize interrupt vectors. */
INTC_init_interrupts();
/* Register the Timer interrupt handler to the interrupt controller. */
INTC_register_interrupt(&tc_irq, EXAMPLE_TC_IRQ, AVR32_INTC_INT1);
/* Register the Touch Library CAT interrupt handler to the interrupt controller.
Note: This interrupt registration is a MUST before using the Touch Library
with the GCC compiler.
For the case of IAR the registration of interrupt is automatically taken
care by the compiler. The Touch Library CAT interrupt level for the case
of IAR is fixed to Interrupt level 3. */
INTC_register_interrupt(&touch_acq_done_irq, AVR32_CAT_IRQ, AVR32_INTC_INT3);
#endif
/* Enable interrupts. */
Enable_global_interrupt();
/* Configure timer to fire ISR regularly. */
init_timer();
/* Initialize touch library and uc3l cat module for QMatrix operation.
Note: Set up the GCLK_CAT for proper QMatrix operation. Refer init_system(). */
touch_ret = touch_qm_sensors_init( &touch_config );
if(touch_ret != TOUCH_SUCCESS)
{
while(1u); /* Check API Error return code. */
}
#if DEF_TOUCH_QDEBUG_ENABLE == 1
/* Initialize the debug interface. */
QDebug_Init();
#endif
/* configure the touch library sensors. */
touch_ret = config_uc3lek_touch_sensors();
if(touch_ret != TOUCH_SUCCESS)
{
while(1u); /* Check API Error return code. */
}
/* Initialize touch sensing. */
touch_ret = touch_qm_sensors_calibrate();
if(touch_ret != TOUCH_SUCCESS)
{
while(1u); /* Check API Error return code. */
}
/* Provide the dma channels to be used by the CAT module. For each
acquisition cycle, any different combination of dma channels from 0 to 11
can be provided. The touch library can also handle a different combination
of dma channels for each call of the touch_qm_sensors_start_acquisition API. */
qm_dma.dma_ch1 = QM_DMA_CHANNEL_0;
qm_dma.dma_ch2 = QM_DMA_CHANNEL_1;
// Initialize the PWMA module
demo_init_pwma();
// At the start of the demo, automatically change several times the PWMA duty
// cycle (i.e. the intensity) of all LEDs.
demo_automatic_ledshow_play(DEMO_INIT_NB_AUTOMATIC_CHANGES);
/* Loop forever */
for( ; ; )
{
/* Process touch library events. The touch_event_dispatcher API needs to
be called as frequently as possible in order to have a good touch response. */
touch_event_dispatcher();
if( time_to_measure_touch == 1u )
{
/* Clear flag: it's time to measure touch */
time_to_measure_touch = 0u;
/* Start a touch sensors measurement process. */
touch_ret = touch_qm_sensors_start_acquisition( current_time_ms_touch,
&qm_dma,
NORMAL_ACQ_MODE,
touch_qm_measure_complete_callback);
if( (touch_ret != TOUCH_SUCCESS) &&
(touch_ret != TOUCH_ACQ_INCOMPLETE) )
{
gpio_clr_gpio_pin(LED0_GPIO); // LED0
gpio_clr_gpio_pin(LED1_GPIO); // LED1
gpio_clr_gpio_pin(LED2_GPIO); // LED2
gpio_clr_gpio_pin(LED3_GPIO); // LED3
do{
delay_ms(50);
gpio_tgl_gpio_pin(LED0_GPIO); gpio_tgl_gpio_pin(LED1_GPIO);
gpio_tgl_gpio_pin(LED2_GPIO); gpio_tgl_gpio_pin(LED3_GPIO);
}while(1);
/* Reaching this point can be due to -
1. The api has returned an error due to a invalid input parameter.
2. The api has been called during a invalid Touch Library state. */
}
}
/* Host application code goes here */
/* Led demo application. */
if(qm_measurement_done_touch == 1u)
{
#if DEF_TOUCH_QDEBUG_ENABLE == 1
/* UC3L_EK two-way QDebug communication application Example. */
/* Process any commands received from QTouch Studio. */
QDebug_ProcessCommands();
/* Send out the Touch debug information data each time when Touch */
/* measurement process is completed . */
QDebug_SendData(p_qm_measure_data->acq_status);
#endif
// New touch data measurement are available.
process_qtouchlib_data();
/* Clear flag: QMatrix measurement complete. */
qm_measurement_done_touch = 0u;
// Once the latest touch data measurements have been processed, clear them.
// Here we clear only the measurements that are used by the application.
p_qm_measure_data->p_sensor_states[0] = 0;
p_qm_measure_data->acq_status = TOUCH_NO_ACTIVITY;
p_qm_measure_data->p_rotor_slider_values[0] = 0;
}
else
process_qtouchlib_data();
// Note: we cannot go deeper than the IDLE sleep mode because the QMatrix lib
// uses the PDMA.
SLEEP(AVR32_PM_SMODE_IDLE);
}
}
/**
* \internal
* \brief Transmit PPLC command to Proxy PLC controller
*
* \param uc_cmd PPLC command to send
* \param us_addr Address where is the data to apply command
* \param us_len Number of bytes in operation
* \param ptr_buf Pointer to data buffer
* \param uc_bytes_rep Number of repetitions(only use in PPLC_CMD_WRITE_REP
* command)
*
* \retval true if there is no error
* \retval false if there is an error
*/
static int8_t _pplc_cmd_op(uint8_t uc_cmd, uint16_t us_addr, uint16_t us_len,
uint8_t *ptr_buf, uint8_t uc_bytes_rep)
{
uint8_t *ptr_data_buf;
uint16_t uc_num_tx_bytes;
uint16_t us_data_len, us_data_len_acc;
uint16_t us_address;
Disable_global_interrupt();
if (!uc_pplc_is_busy) {
uc_pplc_is_busy = true;
ptr_data_buf = ptr_buf;
us_data_len = us_len;
us_data_len_acc = 0;
us_address = us_addr;
while (us_data_len) {
/* protection to data length */
if (us_data_len > PDC_PPLC_BUFFER_SIZE) {
us_data_len = PDC_PPLC_BUFFER_SIZE - 4;
}
uc_num_tx_bytes = us_data_len + 4;
/* Configure PPLC Tx buffer */
gs_pplc_tx_buffer[0] = uc_cmd;
gs_pplc_tx_buffer[1] = (uint8_t)(us_address >> 8);
gs_pplc_tx_buffer[2] = (uint8_t)(us_address);
if (uc_cmd == PPLC_CMD_WRITE_REP) {
gs_pplc_tx_buffer[3] = uc_bytes_rep;
} else {
gs_pplc_tx_buffer[3] = 0;
}
/* Fill data */
if (uc_cmd == PPLC_CMD_READ) {
memset(&gs_pplc_tx_buffer[4], 0, us_data_len);
} else {
memcpy(&gs_pplc_tx_buffer[4], ptr_data_buf, us_data_len);
}
/* Configure DMA channels */
g_pplc_rx_packet.ul_addr = (uint32_t)gs_pplc_rx_buffer;
g_pplc_rx_packet.ul_size = uc_num_tx_bytes;
pdc_rx_init(g_pplc_pdc, &g_pplc_rx_packet, NULL);
g_pplc_tx_packet.ul_addr = (uint32_t)gs_pplc_tx_buffer;
g_pplc_tx_packet.ul_size = uc_num_tx_bytes;
pdc_tx_init(g_pplc_pdc, &g_pplc_tx_packet, NULL);
/* Enable the RX and TX PDC transfer requests */
pdc_enable_transfer(g_pplc_pdc,
PERIPH_PTCR_RXTEN | PERIPH_PTCR_TXTEN);
/* Waiting transfer done*/
while ((spi_read_status(PPLC_SPI_MODULE) &
SPI_SR_RXBUFF) == 0) {
}
/* Disable the RX and TX PDC transfer requests */
pdc_disable_transfer(g_pplc_pdc,
PERIPH_PTCR_RXTDIS | PERIPH_PTCR_TXTDIS);
/* copy rcv data */
if (uc_cmd == PPLC_CMD_READ) {
memcpy(ptr_data_buf, &gs_pplc_rx_buffer[4], us_data_len);
}
/* update buffer pointers */
ptr_data_buf += us_data_len;
us_address += us_data_len;
/* update data length */
us_data_len_acc += us_data_len;
us_data_len = us_len - us_data_len_acc;
}
uc_pplc_is_busy = false;
Enable_global_interrupt();
return true;
} else {
void initialise_board(void) {
int i;
central_data_t *central_data=central_data_get_pointer_to_struct();
irq_initialize_vectors();
cpu_irq_enable();
Disable_global_interrupt();
// Initialize the sleep manager
sleepmgr_init();
sysclk_init();
INTC_init_interrupts();
delay_init(sysclk_get_cpu_hz());
time_keeper_init();
// time_keeper_init_synchronisation();
init_LEDs();
switch_LED(1, LED_ON);
switch_LED(0, LED_ON);
pwm_servos_init(true);
// set up UART for main telemetry
uart_int_set_usart_conf(0, asv_xbee_uart_conf());
uart_int_init(0);
uart_int_register_write_stream(uart_int_get_uart_handle(0), ¢ral_data->xbee_out_stream);
//init_UART_DMA(0);
//register_write_stream_dma(get_UART_handle(0), ¢ral_data->xbee_out_stream);
buffer_make_buffered_stream(&(central_data->xbee_in_buffer), &(central_data->xbee_in_stream));
uart_int_register_read_stream(uart_int_get_uart_handle(0), &(central_data->xbee_in_stream));
uart_int_set_usart_conf(4, asv_debug_uart_conf());
uart_int_init(4);
uart_int_register_write_stream(uart_int_get_uart_handle(4), ¢ral_data->wired_out_stream);
//init_UART_DMA(0);
//register_write_stream_dma(get_UART_handle(0), ¢ral_data->wired_out_stream);
buffer_make_buffered_stream(&(central_data->wired_in_buffer), &(central_data->wired_in_stream));
uart_int_register_read_stream(uart_int_get_uart_handle(4), &(central_data->wired_in_stream));
// set up UART for GPS
uart_int_set_usart_conf(3, asv_gps_uart_conf());
uart_int_init(3);
uart_int_register_write_stream(uart_int_get_uart_handle(3), ¢ral_data->gps_out_stream);
buffer_make_buffered_stream(&(central_data->gps_in_buffer), &(central_data->gps_in_stream));
uart_int_register_read_stream(uart_int_get_uart_handle(3), &(central_data->gps_in_stream));
multistream_init(¢ral_data->multi_telemetry_down_stream);
multistream_init(¢ral_data->multi_telemetry_up_stream);
multistream_add_stream(¢ral_data->multi_telemetry_down_stream, ¢ral_data->wired_out_stream);
multistream_add_stream(¢ral_data->multi_telemetry_down_stream, ¢ral_data->xbee_out_stream);
multistream_add_stream(¢ral_data->multi_telemetry_up_stream, ¢ral_data->wired_in_stream);
multistream_add_stream(¢ral_data->multi_telemetry_up_stream, ¢ral_data->xbee_in_stream);
/*
can_bus_init(1, asv_can1_conf());
can_bus_register_write_stream(¢ral_data->ext_can_out_stream_data, ¢ral_data->ext_can_out_stream, 1, MAVLINK_COMPONENT_ID, 0x3ff);
can_bus_register_read_stream(¢ral_data->ext_can_in_stream_data, ¢ral_data->ext_can_in_stream, 1, MAVLINK_COMPONENT_ID, 0x00);
*/
// set telemetry stream for mavlink
//central_data->telemetry_down_stream=&(central_data->xbee_out_stream);
//central_data->telemetry_up_stream =&(central_data->xbee_in_stream);
//central_data->telemetry_down_stream=&(central_data->wired_out_stream);
//central_data->telemetry_up_stream =&(central_data->wired_in_stream);
central_data->telemetry_down_stream= multistream_get_stream(¢ral_data->multi_telemetry_down_stream);
central_data->telemetry_up_stream = multistream_get_stream(¢ral_data->multi_telemetry_up_stream);
central_data->debug_out_stream=¢ral_data->wired_out_stream;
central_data->debug_in_stream=¢ral_data->wired_in_stream;
//central_data->debug_out_stream = ¢ral_data->xbee_out_stream;
//central_data->debug_in_stream = ¢ral_data->xbee_in_stream;
print_util_dbg_print_init(central_data->debug_out_stream);
// init error handler as plain text until mavlink is configured
error_handler_init_plaintext(central_data->debug_out_stream);
// init mavlink
// Init mavlink communication
mavlink_communication_conf_t mavlink_config =
{
.scheduler_config =
{
.max_task_count = 30,
.schedule_strategy = ROUND_ROBIN,
.debug = true
},
.mavlink_stream_config =
{
.rx_stream = central_data->telemetry_up_stream,
.tx_stream = central_data->telemetry_down_stream,
.sysid = MAVLINK_SYS_ID,
.compid = MAVLINK_COMPONENT_ID,
.use_dma = false
},
.message_handler_config =
int main(void)
{
//-------------------------USART INTERRUPT REGISTRATION.------------//
// Set Clock: Oscillator needs to initialized once: First
pcl_switch_to_osc(PCL_OSC0, FOSC0, OSC0_STARTUP);
// -------------- USART INIT -----------------------------------------------
static const gpio_map_t USART_GPIO_MAP =
{
{AVR32_USART0_RXD_0_0_PIN, AVR32_USART0_RXD_0_0_FUNCTION},
{AVR32_USART0_TXD_0_0_PIN, AVR32_USART0_TXD_0_0_FUNCTION}
};
// USART options.
static const usart_options_t USART_OPTIONS =
{
.baudrate = USART_BAUDRATE,
.charlength = 8,
.paritytype = USART_NO_PARITY,
.stopbits = USART_1_STOPBIT,
.channelmode = USART_NORMAL_CHMODE
};
// Assign GPIO to USART
gpio_enable_module(USART_GPIO_MAP, sizeof(USART_GPIO_MAP) / sizeof(USART_GPIO_MAP[0]));
// Init USART
usart_init_rs232(USART_0, &USART_OPTIONS, FOSC0);
Disable_global_interrupt();
INTC_init_interrupts(); // Init Interrupt Table: Once at first
// Register USART Interrupt (hinzufügen)
INTC_register_interrupt(&usart_int_handler, AVR32_USART0_IRQ, AVR32_INTC_INT0);
USART_0->ier = AVR32_USART_IER_RXRDY_MASK; // Activate ISR on RX Line
Enable_global_interrupt();
// -----------------------------------------------------------------------------------
// -------------------------- Display INIT ----------------------------------
// Map SPI Pins
static const gpio_map_t DIP204_SPI_GPIO_MAP =
{
{DIP204_SPI_SCK_PIN, DIP204_SPI_SCK_FUNCTION }, // SPI Clock.
{DIP204_SPI_MISO_PIN, DIP204_SPI_MISO_FUNCTION}, // MISO.
{DIP204_SPI_MOSI_PIN, DIP204_SPI_MOSI_FUNCTION}, // MOSI.
{DIP204_SPI_NPCS_PIN, DIP204_SPI_NPCS_FUNCTION} // Chip Select NPCS.
};
// add the spi options driver structure for the LCD DIP204
spi_options_t spiOptions =
{
.reg = DIP204_SPI_NPCS,
.baudrate = 1000000,
.bits = 8,
.spck_delay = 0,
.trans_delay = 0,
.stay_act = 1,
.spi_mode = 0,
.modfdis = 1
};
// SPI Inits: Assign I/Os to SPI
gpio_enable_module(DIP204_SPI_GPIO_MAP,
sizeof(DIP204_SPI_GPIO_MAP) / sizeof(DIP204_SPI_GPIO_MAP[0]));
// Initialize as master
spi_initMaster(DIP204_SPI, &spiOptions);
// Set selection mode: variable_ps, pcs_decode, delay
spi_selectionMode(DIP204_SPI, 0, 0, 0);
// Enable SPI
spi_enable(DIP204_SPI);
// setup chip registers
spi_setupChipReg(DIP204_SPI, &spiOptions, FOSC0);
// initialize delay driver: Muss vor dip204_init() ausgeführt werden
delay_init( FOSC0 );
// initialize LCD
dip204_init(backlight_PWM, TRUE);
// ---------------------------------------------------------------------------------------
// ----------------- Timer Counter Init ---------------------------------
// Timer Configs: Options for waveform generation.
static const tc_waveform_opt_t WAVEFORM_OPT =
{
.channel = TC_CHANNEL, // Channel selection.
.bswtrg = TC_EVT_EFFECT_NOOP, // Software trigger effect on TIOB.
.beevt = TC_EVT_EFFECT_NOOP, // External event effect on TIOB.
.bcpc = TC_EVT_EFFECT_NOOP, // RC compare effect on TIOB.
.bcpb = TC_EVT_EFFECT_NOOP, // RB compare effect on TIOB.
.aswtrg = TC_EVT_EFFECT_NOOP, // Software trigger effect on TIOA.
.aeevt = TC_EVT_EFFECT_NOOP, // External event effect on TIOA.
.acpc = TC_EVT_EFFECT_NOOP, // RC compare effect on TIOA: toggle.
.acpa = TC_EVT_EFFECT_NOOP, // RA compare effect on TIOA: toggle
.wavsel = TC_WAVEFORM_SEL_UP_MODE_RC_TRIGGER,// Count till RC and reset (S. 649): Waveform selection
.enetrg = FALSE, // External event trigger enable.
.eevt = 0, // External event selection.
.eevtedg = TC_SEL_NO_EDGE, // External event edge selection.
.cpcdis = FALSE, // Counter disable when RC compare.
.cpcstop = FALSE, // Counter clock stopped with RC compare.
.burst = FALSE, // Burst signal selection.
.clki = FALSE, // Clock inversion.
.tcclks = TC_CLOCK_SOURCE_TC3 // Internal source clock 3, connected to fPBA / 8.
};
// TC Interrupt Enable Register
static const tc_interrupt_t TC_INTERRUPT =
{ .etrgs = 0, .ldrbs = 0, .ldras = 0, .cpcs = 1, .cpbs = 0, .cpas = 0, .lovrs = 0, .covfs = 0
};
// 0 = No Effect | 1 = Enable ( CPCS = 1 enables the RC Compare Interrupt )
// ***************** Timer Setup ***********************************************
// Initialize the timer/counter.
tc_init_waveform(tc, &WAVEFORM_OPT); // Initialize the timer/counter waveform.
// Set the compare triggers.
tc_write_rc(tc, TC_CHANNEL, RC); // Set RC value.
tc_configure_interrupts(tc, TC_CHANNEL, &TC_INTERRUPT);
// Start the timer/counter.
tc_start(tc, TC_CHANNEL); // And start the timer/counter.
// *******************************************************************************
Disable_global_interrupt();
// Register TC Interrupt
INTC_register_interrupt(&tc_irq, AVR32_TC_IRQ0, AVR32_INTC_INT3);
Enable_global_interrupt();
// ---------------------------------------------------------------------------------------
imu_init();
//-------------------------------TWI R/W ---------------------------------------------------
sensorDaten imu_data = {0};
char disp1[30], disp2[30], disp3[30], disp4[30];
short GX,GY,GZ, AX, AY, AZ; //shifted comlete Data
RPY currMoveRPY;
Quaternion currQuat;
currQuat.q0 = 1.0;
currQuat.q1 = 0;
currQuat.q2 = 0;
currQuat.q3 = 0;
Quaternion deltaQuat;
RotMatrix rot = {0};
RPY reconverted;
calibrate_all(&imu_data);
while(1){
if(exe){
exe = false;
read_sensor(&imu_data);
AX = imu_data.acc_x + imu_data.acc_x_bias;
AY = imu_data.acc_y + imu_data.acc_y_bias;
AZ = imu_data.acc_z + imu_data.acc_z_bias;
GX = imu_data.gyro_x + imu_data.gyro_x_bias;
GY = imu_data.gyro_y + imu_data.gyro_y_bias;
GZ = imu_data.gyro_z + imu_data.gyro_z_bias;
//convert to 1G
float ax = (float)AX * (-4.0);
float ay = (float)AY * (-4.0); //wegen 2^11= 2048, /2 = 1024 entspricht 4G -> 1G = (1024/4)
float az = (float)AZ * (-4.0);
//convert to 1°/s
gx = ((float)GX/ 14.375); // in °/s
gy = ((float)GY/ 14.375);
gz = ((float)GZ/ 14.375);
//Integration over time
dGx = (gx*0.03);
dGy = (gy*0.03);
dGz = (gz*0.03);
currMoveRPY.pitch = -dGx;
currMoveRPY.roll = dGy;
currMoveRPY.yaw = dGz;
//aufaddieren auf den aktuellen Winkel IN GRAD
gxDeg += dGx;
gyDeg += dGy;
gzDeg += dGz;
//RPY in Quaternion umwandeln
RPYtoQuat(&deltaQuat, &currMoveRPY);
//normieren
normQuat(&deltaQuat);
//aufmultiplizeiren
quatMultiplication(&deltaQuat, &currQuat, &currQuat);
//nochmal normieren
normQuat(&currQuat);
//rücktransformation nicht nötig!!
char send[80];
sprintf(send,"$,%f,%f,%f,%f,#", currQuat.q0, currQuat.q1, currQuat.q2, currQuat.q3);
usart_write_line(USART_0,send);
sprintf(disp1,"q0:%.3f, GX:%3.0f",currQuat.q0,gxDeg);
sprintf(disp2,"q1:%.3f, GY:%3.0f",currQuat.q1, gyDeg);
sprintf(disp3,"q2:%.3f, GZ:%3.0f",currQuat.q2, gzDeg);
sprintf(disp4,"q3:%.3f",currQuat.q3);
dip204_clear_display();
dip204_set_cursor_position(1,1);
dip204_write_string(disp1);
dip204_set_cursor_position(1,2);
dip204_write_string(disp2);
dip204_set_cursor_position(1,3);
dip204_write_string(disp3);
dip204_set_cursor_position(1,4);
dip204_write_string(disp4);
//sprintf(data,"TEST:%s",high);
//print_dbg(data);
}
}
}
/**
** PDCA Init.
**/
void init_pdca(void)
{
// PDCA channel 0/1 options
static const pdca_channel_options_t PDCA_CH_OPTIONS =
{
.addr = (void *)aDataTransfered, // memory address
.pid = AVR32_PDCA_PID_USART2_TX, // select peripheral - data are transmit on USART TX line.
.size = 0, // transfer counter
.r_addr = (void *)aDataTransfered, // next memory address
.r_size = sizeof(aDataTransfered), // next transfer counter
.transfer_size = PDCA_TRANSFER_SIZE_BYTE, // select size of one data packet
.etrig = true // Trigger transfer on event.
};
Disable_global_interrupt();
// Initialize interrupt vectors.
INTC_init_interrupts();
// Register the PDCA interrupt handler to the interrupt controller.
INTC_register_interrupt(&pdca_int_handler, PDCA_CHANNEL_IRQ, AVR32_INTC_INT0);
Enable_global_interrupt();
// Init PDCA channel with the pdca_options.
pdca_init_channel(PDCA_CHANNEL_USART, &PDCA_CH_OPTIONS);
pdca_channel = pdca_get_handler(PDCA_CHANNEL_USART); // For use in the pdca interrupt handler.
// Enable pdca transfer error interrupt & transfer complete interrupt.
pdca_enable_interrupt_transfer_error(PDCA_CHANNEL_USART);
pdca_enable_interrupt_transfer_complete(PDCA_CHANNEL_USART);
// Enable the PEVC channel "PDCA CHANNEL 0/1 ONE-ITEM-TRANSFER"
PEVC_CHANNELS_ENABLE(ppevc, 1<<PEVC_PDCA_SOT_USER);
// Enable the PDCA.
pdca_enable(PDCA_CHANNEL_USART);
}
/**
** AST Init.
**/
void init_ast(void)
{
avr32_ast_pir0_t pir = {
.insel = 14 // Set a event every second
};
ast_calendar_t ast_calendar;
ast_calendar.FIELD.sec = 30;
ast_calendar.FIELD.min = 45;
ast_calendar.FIELD.hour = 12;
ast_calendar.FIELD.day = 7;
ast_calendar.FIELD.month= 10;
ast_calendar.FIELD.year = 9;
scif_osc32_opt_t opt;
opt.mode = SCIF_OSC_MODE_2PIN_CRYSTAL;
opt.startup = AVR32_SCIF_OSCCTRL32_STARTUP_0_RCOSC;
// Start OSC_32KHZ
scif_start_osc32(&opt,true);
// Initialize the AST
if (!ast_init_calendar(&AVR32_AST, AST_OSC_32KHZ, AST_PSEL_32KHZ_1HZ, ast_calendar))
{
print_dbg("Error initializing the AST\r\n");
while(1);
}
ast_set_periodic0_value(&AVR32_AST,pir);
ast_enable_periodic0(&AVR32_AST);
// Clear All Interrupt
AVR32_AST.scr=0xFFFFFFFF;
// Enable the AST
ast_enable(&AVR32_AST);
}
/*! \brief Initializes the MCU system clocks.
*/
static void init_sys_clocks(void)
{
/*! \name System Clock Frequencies
*/
//! @{
static pcl_freq_param_t pcl_freq_param =
{
.cpu_f = FCPU_HZ,
.pba_f = FPBA_HZ,
.osc0_f = FOSC0,
.osc0_startup = OSC0_STARTUP
};
//! @}
// Configure system clocks.
if (pcl_configure_clocks(&pcl_freq_param) != PASS) {
while(1);
}
}
/*! \brief This example show a DMA transfer to USART controlled by the AST
periodic alarm using the PEVC.
*/
int main(void)
{
int i;
// Init the string with a simple recognizable pattern.
for(i=0;i<sizeof(aDataTransfered);i++)
aDataTransfered[i] = '0' + (i%36);
init_sys_clocks();
init_usart();
gpio_clr_gpio_pin(LED0_GPIO);
init_pevc();
init_ast();
init_pdca();
while(1)
{
gpio_tgl_gpio_pin(LED1_GPIO);
delay_ms(500); //Wait 500ms
}
}
