int main(void)
{
system_init();
//! [main_1]
//! [critical_section_start]
system_interrupt_enter_critical_section();
//! [critical_section_start]
//! [do_critical_code]
if (is_ready == true) {
/* Do something in response to the global shared flag */
is_ready = false;
}
//! [do_critical_code]
//! [critical_section_end]
system_interrupt_leave_critical_section();
//! [critical_section_end]
//! [main_1]
//! [main_2]
//! [module_int_enable]
system_interrupt_enable(SYSTEM_INTERRUPT_MODULE_RTC);
//! [module_int_enable]
//! [global_int_enable]
system_interrupt_enable_global();
//! [global_int_enable]
//! [main_2]
while (true) {
/* Infinite loop */
}
}
/*---------------------------------------------------------------------------*/
void
button_sensor_init(void)
{
struct extint_chan_conf config_extint_chan;
struct port_config pin_conf;
port_get_config_defaults(&pin_conf);
pin_conf.direction = PORT_PIN_DIR_INPUT;
pin_conf.input_pull = PORT_PIN_PULL_UP;
port_pin_set_config(BUTTON_0_PIN, &pin_conf);
// extint_enable();
extint_chan_get_config_defaults(&config_extint_chan);
config_extint_chan.gpio_pin = BUTTON_0_EIC_PIN;
config_extint_chan.gpio_pin_mux = BUTTON_0_EIC_MUX;
config_extint_chan.gpio_pin_pull = EXTINT_PULL_UP;
config_extint_chan.detection_criteria = EXTINT_DETECT_FALLING;
// config_extint_chan.detection_criteria = EXTINT_DETECT_BOTH;
extint_chan_set_config(BUTTON_0_EIC_LINE, &config_extint_chan);
extint_register_callback((extint_callback_t)extint_detection_callback,
BUTTON_0_EIC_LINE,
EXTINT_CALLBACK_TYPE_DETECT);
extint_chan_enable_callback(BUTTON_0_EIC_LINE, EXTINT_CALLBACK_TYPE_DETECT);
timer_set(&debouncetimer, 0);
system_interrupt_enable_global();
/* on by default */
button_sensor_configure(0, 1);
}
int main(void)
{
system_init();
//! [setup_init]
configure_usart();
configure_usart_callbacks();
//! [setup_init]
//! [main]
//! [enable_global_interrupts]
system_interrupt_enable_global();
//! [enable_global_interrupts]
//! [main_send_string]
uint8_t string[] = "Hello World!\r\n";
usart_write_buffer_job(&usart_instance, string, sizeof(string));
//! [main_send_string]
//! [main_loop]
while (true) {
//! [main_loop]
//! [main_read]
usart_read_buffer_job(&usart_instance,
(uint8_t *)rx_buffer, MAX_RX_BUFFER_LENGTH);
//! [main_read]
}
//! [main]
}
int main(void)
{
system_init();
//! [setup_init]
configure_adc();
configure_adc_callbacks();
//! [setup_init]
//! [main]
//! [enable_global_interrupts]
system_interrupt_enable_global();
//! [enable_global_interrupts]
//! [start_adc_job]
adc_read_buffer_job(&adc_instance, adc_result_buffer, ADC_SAMPLES);
//! [start_adc_job]
//! [job_complete_poll]
while (adc_read_done == false) {
/* Wait for asynchronous ADC read to complete */
}
//! [job_complete_poll]
//! [inf_loop]
while (1) {
/* Infinite loop */
}
//! [inf_loop]
//! [main]
}
/**
* \brief Application entry point.
*
* \return Unused (ANSI-C compatibility).
*/
int main(void)
{
//SystemInit();
// Set the registers for input and output
board_led_setup();
system_init();
port_pin_set_output_level(LED_DEBUG, false);
while ( !system_clock_source_is_ready(SYSTEM_CLOCK_SOURCE_DPLL) ) {
}
/* Initialize the SAM system */
// TCC Configuration
tcc_configure_function(); // Counter Configuration
tcc_callback_configuration(); // Timer Callback Configuration
// Run SERCOM Setup
bastian_complete_sercom_setup();
system_interrupt_enable_global(); // Enable all sources of interrupt
//spi_transceive_buffer_job(&spi_slave, slave_empty_response_buffer, slave_rx_buffer, SYSTEM_SLAVE_RX_BYTES_TO_RECEIVE);
// Send IrDA data only once
//
//usart_read_buffer_job(&irda_master, slave_rx_buffer, 1); // Read only one character
while (1) {
//usart_read_buffer_job(&irda_master, slave_rx_buffer, 1); // Read only one character
}
}
unsigned long millis(void)
{
system_interrupt_disable_global();
uint32_t tc_count = tc_get_count_value(&tc6_instance);
system_interrupt_enable_global();
return (((tc6_overflows<<16)+tc_count)*(1/8000.0));
}
int main(void)
{
system_init();
//! [setup_init]
_configure_i2s();
_configure_i2s_callbacks();
//! [setup_init]
//! [main]
//! [enable_global_interrupts]
system_interrupt_enable_global();
//! [enable_global_interrupts]
//! [start_job]
i2s_serializer_write_buffer_job(&i2s_instance,
I2S_SERIALIZER_0, data_buffer, 4);
//! [start_job]
//! [main_loop]
while (true) {
}
//! [main_loop]
//! [main]
}
int main (void)
{
system_init();
configure_port_pins();
configure_usart();
printf("--TEST prepare: ATMEL SAMD10 watchdog callback!\r\n");
configure_wdt();
configure_wdt_callbacks();
printf("--TEST prepare: Config WDT:4096 ms!\r\n");
printf("--TEST prepare: Config WDT:Early Warning,2048ms!\r\n");
system_interrupt_enable_global();
printf("--TEST prepare: Enable gobale Interrupt!\r\n");
printf("--TEST information: Waitting for WDT Early Warning Interrupt!\r\n");
printf("\r\n\r\n\r\n");
while(1)
{
;
}
/* Insert application code here, after the board has been initialized. */
}
int main(void)
{
//! [setup_init]
struct tc_module tc_instance;
struct events_resource example_event;
struct events_hook hook;
system_init();
system_interrupt_enable_global();
configure_event_channel(&example_event);
configure_event_user(&example_event);
configure_event_interrupt(&example_event, &hook);
configure_tc(&tc_instance);
//! [setup_init]
//! [main]
//! [main_1]
while (events_is_busy(&example_event)) {
/* Wait for channel */
};
//! [main_1]
//! [main_2]
tc_start_counter(&tc_instance);
//! [main_2]
while (true) {
/* Nothing to do */
}
//! [main]
}
int main(void)
{
system_init();
configure_usart();
configure_usart_callbacks();
struct port_config pin_conf;
port_get_config_defaults(&pin_conf);
/* Configure LEDs as outputs, turn them off */
pin_conf.direction = PORT_PIN_DIR_OUTPUT;
port_pin_set_config(LED_1_PIN, &pin_conf);
port_pin_set_output_level(LED_1_PIN, LED_1_INACTIVE);
/* Set buttons as inputs */
pin_conf.direction = PORT_PIN_DIR_INPUT;
pin_conf.input_pull = PORT_PIN_PULL_UP;
port_pin_set_config(BUTTON_1_PIN, &pin_conf);
#if USE_EIC == true
configure_extint();
#endif
#if USE_INTERRUPTS == true
# if USE_EIC == false
configure_systick_handler();
# else
configure_eic_callback();
# endif
system_interrupt_enable_global();
uint16_t temp;
while (true) {
/* Do nothing - use interrupts */
//if (usart_read_wait(&usart_instance, &temp) == STATUS_OK)
//{
//while (usart_write_wait(&usart_instance, temp) != STATUS_OK);
//}
usart_read_buffer_job(&usart_instance, (uint8_t *)rx_buffer, 1);
//sleepmgr_sleep(SLEEPMGR_STANDBY);
}
#else
# if USE_EIC == false
while (true) {
update_led_state();
}
# else
while (true) {
if (extint_chan_is_detected(BUTTON_1_EIC_LINE)) {
extint_chan_clear_detected(BUTTON_1_EIC_LINE);
update_led_state();
}
}
# endif
#endif
}
/*==============================================================================
hal_extIntInit()
=============================================================================*/
uint8_t hal_extIntInit( en_targetExtInt_t e_intSource,
pfn_intCallb_t pfn_intCallback )
{
int8_t c_ret = 0;
if( pfn_intCallback != NULL )
{
switch( e_intSource )
{
case E_TARGET_RADIO_INT:
//! [setup_init]
//extint_enable();
//! [conf_channel]
//! [setup_1]
extint_chan_get_config_defaults( &( radio_extInt.st_chan ) );
//! [setup_1]
//! [setup_2]
radio_extInt.st_chan.gpio_pin = radio_extInt.l_pin; //EXT1_IRQ_PIN;
radio_extInt.st_chan.gpio_pin_mux = radio_extInt.l_pinMux; //MUX_PB04A_EIC_EXTINT4;
radio_extInt.st_chan.gpio_pin_pull = radio_extInt.c_pinPull; //EXTINT_PULL_DOWN;
radio_extInt.st_chan.detection_criteria =
radio_extInt.c_detCrit; //EXTINT_DETECT_RISING;
//! [setup_2]
//! [setup_3]
extint_chan_set_config( (uint8_t)radio_extInt.l_line,
&( radio_extInt.st_chan ) );
//! [setup_3]
_radio_callback = pfn_intCallback;
//! [setup_4]
extint_register_callback(
(extint_callback_t)_isr_radio_callback,
(uint8_t)radio_extInt.l_line,
EXTINT_CALLBACK_TYPE_DETECT );
//! [setup_4]
//! [setup_5]
extint_chan_enable_callback( (uint8_t)radio_extInt.l_line, //EXT1_IRQ_INPUT,
EXTINT_CALLBACK_TYPE_DETECT );
//! [setup_6]
//! [conf_channel]
//! [setup_init]
system_interrupt_enable_global();
c_ret = 1;
break;
case E_TARGET_USART_INT:
break;
default:
break;
}
}
return c_ret;
} /* hal_extIntInit() */
/**
* \brief Init the radio
* \return Returns success/fail
* \retval 0 Success
*/
static int
rf212_init(void)
{
volatile uint8_t regtemp;
uint8_t radio_state; /* don't optimize this away, it's important */
//uint8_t temp;
PRINTF("RF212: init.\n");
/* init SPI and GPIOs, wake up from sleep/power up. */
//rf212_arch_init();
trx_spi_init();
/* reset will put us into TRX_OFF state */
/* reset the radio core */
port_pin_set_output_level(AT86RFX_RST_PIN, false);
delay_cycles_ms(1);
port_pin_set_output_level(AT86RFX_RST_PIN, true);
port_pin_set_output_level(AT86RFX_SLP_PIN, false); /*wakeup from sleep*/
/* before enabling interrupts, make sure we have cleared IRQ status */
regtemp = trx_reg_read(RF212_REG_IRQ_STATUS);
printf("After wake from sleep\n");
radio_state = rf212_status();
printf("After arch read reg: state 0x%04x\n", radio_state);
/* Assign regtemp to regtemp to avoid compiler warnings */
regtemp = regtemp;
if(radio_state == STATE_P_ON) {
trx_reg_write(RF212_REG_TRX_STATE, TRXCMD_TRX_OFF);
}
trx_irq_init((FUNC_PTR)rf212_interrupt_poll);
ENABLE_TRX_IRQ();
system_interrupt_enable_global();
/* Configure the radio using the default values except these. */
trx_reg_write(RF212_REG_TRX_CTRL_1, RF212_REG_TRX_CTRL_1_CONF);
trx_reg_write(RF212_REG_PHY_CC_CCA, RF212_REG_PHY_CC_CCA_CONF);
trx_reg_write(RF212_REG_PHY_TX_PWR_CONF, RF212_REG_PHY_TX_PWR_CONF);
//temp = rf212_arch_read_reg(RF212_REG_TRX_CTRL_2);
trx_reg_write(RF212_REG_TRX_CTRL_2, RF212_REG_TRX_CTRL_2_CONF);
trx_reg_write(RF212_REG_IRQ_MASK, RF212_REG_IRQ_MASK_CONF);
#if HW_CSMA_FRAME_RETRIES
trx_bit_write(SR_MAX_FRAME_RETRIES, 3);
trx_bit_write(SR_MAX_CSMA_RETRIES, 4);
#else
trx_bit_write(SR_MAX_FRAME_RETRIES, 0);
trx_bit_write(SR_MAX_CSMA_RETRIES, 7);
#endif
SetPanId(IEEE802154_CONF_PANID);
rf_generate_random_seed();
/* start the radio process */
process_start(&rf212_radio_process, NULL);
return 0;
}
/*==============================================================================
hwinit_init()
==============================================================================*/
int8_t hal_init (void)
{
system_init();
_hal_usartInit();
_hal_wdtInit();
_hal_tcInit();
_hal_ledInit();
delay_init();
system_interrupt_enable_global();
return 1;
}/* hal_init() */
/*==============================================================================
hwinit_init()
==============================================================================*/
int8_t hal_init( void )
{
system_init();
_hal_usartInit();
_hal_wdtInit();
_hal_tcInit();
#if LEDS_ON_BOARD == TRUE
_hal_ledInit();
#endif
delay_init();
system_interrupt_enable_global();
return 1;
}/* hal_init() */
int main (void)
{
system_init();
system_interrupt_enable_global();
/* Configure various sensors and their associated peripherals */
configure_i2c();
configure_mag_sw_int(extint_callback);
configure_S70FL01(S70FL01_CS1, false);
configure_SP1ML();
configure_ADXL375();
configure_sleepmode();
configure_rtc();
port_pin_set_output_level(SP1ML_EN_PIN,true);
configure_ADT7420();
configure_databuffers();
// Assume that we are in active mode during stationary period
ucActiveInactive_Mode = ACTIVE_MODE;
ucMotion_State = STATIONARY_MODE;
// Per Dr. Buck, 30C is the pivot point -- These don't necessarily have to be the same, they can build in some hysteresis depending upon the subject
ucActivityTemperatureThreshold = 30;
ucInactivityTemperatureThreshold = 30;
while(true)
{
if((uiAccelerometerMatrixPtr > (300 - 32)) || (ucTemperatureArrayPtr > 71)){
// Accelerometer total buffer size minus the ADXL375 internal FIFO size
// If either buffer is full enough that another set of samples cannot be stored, trigger an offload
offload_data();
uiAccelerometerMatrixPtr = 0;
ucTemperatureArrayPtr = 0;
}
// If we are at the end of the die, then switch die and reset the address pointer
// If we hit the end of the second die, then we restart at the beginning of the first die (ring buffer)
if(S70FL01_address >= S70FL01_MAX_ADDR){
S70FL01_active_die++;
S70FL01_active_die %= 2;
S70FL01_address = 0;
}
ADT7420_read_temp();
// Housekeeping done -- go back to sleep
sleep();
}
}
int main(void)
{
system_init();
//! [setup_init]
configure_extint_channel();
configure_extint_callbacks();
system_interrupt_enable_global();
//! [setup_init]
//! [main]
while (true) {
/* Do nothing - EXTINT will fire callback asynchronously */
}
//! [main]
}
int main(void) {
system_init();
cph_millis_init();
cph_stdio_init();
TRACE("DECAWAVE CPH \r\n");
TRACE(SOFTWARE_VER_STRING);
TRACE("\r\n");
uint32_t f = system_gclk_gen_get_hz(0);
TRACE("CPU FREQ: %lu\r\n", f);
// Blink LED for 5 seconds
for (int i = 0; i < (5 * 4); i++) {
port_pin_set_output_level(LED_PIN, false);
cph_millis_delay(125);
port_pin_set_output_level(LED_PIN, true);
cph_millis_delay(125);
}
// init cph_deca
//#ifdef ANCHOR
// anchor_init();
//#else
// tag_init();
//#endif
ss_twr_init(); // blocks
system_interrupt_enable_global();
uint32_t count = 0;
uint32_t timestamp = cph_get_millis();
uint32_t elapsed = 0;
while (1) {
cph_deca_run();
elapsed = (cph_get_millis() - timestamp);
if (elapsed > 5000) {
timestamp = cph_get_millis();
cph_deca_print_status(count++);
}
}
}
/*
* @fn nm_bsp_init
* @brief Initialize BSP
* @return 0 in case of success and -1 in case of failure
*/
sint8 nm_bsp_init(void)
{
gpfIsr = NULL;
/* Initialize chip IOs. */
init_chip_pins();
/* Make sure a 1ms Systick is configured. */
if (!(SysTick->CTRL & SysTick_CTRL_ENABLE_Msk && SysTick->CTRL & SysTick_CTRL_TICKINT_Msk)) {
delay_init();
}
/* Perform chip reset. */
nm_bsp_reset();
system_interrupt_enable_global();
return M2M_SUCCESS;
}
void sys_init_timing(void)
{
struct tc_config config_tc;
tc_get_config_defaults(&config_tc);
config_tc.counter_size = TC_COUNTER_SIZE_16BIT;
config_tc.wave_generation = TC_WAVE_GENERATION_MATCH_FREQ;
config_tc.counter_16_bit.compare_capture_channel[0] = 0x5DC0;
config_tc.clock_source = GCLK_GENERATOR_0;
config_tc.clock_prescaler = TC_CLOCK_PRESCALER_DIV2;
tc_init(&tc_instance, TIMER, &config_tc);
tc_enable(&tc_instance);
tc_register_callback(&tc_instance, tc_callback, TC_CALLBACK_CC_CHANNEL0);
tc_enable_callback(&tc_instance, TC_CALLBACK_CC_CHANNEL0);
/* Enable system interrupts. */
system_interrupt_enable_global();
}
int main(void)
{
system_init();
//! [setup_init]
configure_tcc();
configure_tcc_callbacks();
//! [setup_init]
//! [main]
//! [enable_global_interrupts]
system_interrupt_enable_global();
//! [enable_global_interrupts]
//! [main_loop]
while (true) {
}
//! [main_loop]
//! [main]
}
int main(void) {
system_init();
cph_millis_init();
cph_stdio_init();
uint32_t f = system_gclk_gen_get_hz(0);
printf("CPU FREQ: %lu\r\n", f);
system_interrupt_enable_global();
decawave_run();
// while (1) {
// printf("HELLO\r\n");
// port_pin_toggle_output_level(LED_PIN);
// cph_millis_delay(500);
// }
}
int main (void)
{
/* Prepare the hardware for the demo. */
prvSetupHardware();
//lepton kernel start
_start_kernel(0);
//lepton_start();
//
system_interrupt_enable_global();
//
/* Start the scheduler. */
vTaskStartScheduler();
/* If all is well, the scheduler will now be running, and the following line
will never be reached. If the following line does execute, then there was
insufficient FreeRTOS heap memory available for the idle and/or timer tasks
to be created. See the memory management section on the FreeRTOS web site
for more details. */
for( ;; );
}
int main(void)
{
system_init();
#if USE_EIC == true
configure_extint();
#endif
#if USE_INTERRUPTS == true
# if USE_EIC == false
configure_systick_handler();
# else
configure_eic_callback();
# endif
system_interrupt_enable_global();
while (true) {
/* Do nothing - use interrupts */
}
#else
# if USE_EIC == false
while (true) {
update_led_state();
}
# else
while (true) {
if (extint_chan_is_detected(BUTTON_0_EIC_LINE)) {
extint_chan_clear_detected(BUTTON_0_EIC_LINE);
update_led_state();
}
}
# endif
#endif
}
int main(void)
{
struct port_config pin;
unsigned int count;
unsigned char Write_Reg_DRATE[3]={0x53,0x01,0xc0};
unsigned char Read_Reg_DRATE[2]={0x11,0x02};
unsigned char read_buffer[10]={0};
unsigned char read_data;
unsigned int result;
unsigned char Init_Data[5]={0x51,0x02,0x08,0x20,0xA1};
unsigned char RDATAC[1]={0x03};
unsigned char SDATAC[1]={0x0F};
unsigned char RDATA[1] ={0x01};
system_init();
/*Configure UART console.*/
configure_console();
/*Initialize the delay driver*/
delay_init();
/* Output example information */
puts(STRING_HEADER);
/*Enable system interrupt*/
system_interrupt_enable_global();
//SPI0TX = 0x51; // ADS1256_CMD_WREG | ADS1256_REG_MUX;
//SPI0TX = 0x02; // write 3 registers starting REG_MUX
//SPI0TX = 0x08; // REG_MUX
//SPI0TX = 0x20; // REG_ADCON
//SPI0TX = 0xA1; // REG_DRATE, set to 1ksps
spi_init();
ss_enable(1);
delay_us(10);
spi_write(Init_Data,5);
delay_us(10);
ss_enable(0);
ss_enable(1);
delay_us(10);
spi_write(Read_Reg_DRATE,2);
spi_read(read_buffer,3);
delay_us(10);
ss_enable(0);
delay_us(10);
count = 1;
while(1)
{
result = 0;
ss_enable(1);
delay_us(2);
//spi_write(RDATAC,1);
spi_write(RDATA,1);
while(ADS1256_DRDY);
//while(1){
//while(!ADS1256_DRDY);
//if(ADS1256_DRDY == 0){
spi_read(read_buffer,3);
// break;
//}
//}
//spi_write(SDATAC,1);
delay_us(2);
ss_enable(0);
result = read_buffer[0] << 16 | read_buffer[1] << 8 | read_buffer[2];
printf("#%d,0x%x\r\n",count++,result );
delay_ms(100);
}
}
/**
* \brief getting-started Application entry point.
*
* \return Unused (ANSI-C compatibility).
*/
int main(void)
{
struct port_config pin;
unsigned char c;
system_init();
//Configure UART console.
configure_console();
configure_usart_callbacks();
usart_enable_rx_interrupt(&cdc_uart_module,&c);
usart_enable(&cdc_uart_module);
//Configures TC driver
configure_tc();
//Configures TC callback
configure_tc_callbacks();
//Initialize the delay driver
delay_init();
//Enable system interrupt
system_interrupt_enable_global();
//Configures PORT for LED0
port_get_config_defaults(&pin);
pin.direction = PORT_PIN_DIR_OUTPUT;
port_pin_set_config(LED0_PIN, &pin);
port_pin_set_output_level(LED0_PIN, LED0_INACTIVE);
port_pin_set_output_level(LED0_PIN, LED0_INACTIVE);
/*main loop*/
while(1)
{
if (is_running)
{
//Handle user's input
// if (uart_getc(&c))
// {
switch (c)
{
case 'w':
case ' ':
//ROTATE
tetris_rotate();
break;
case 's':
//DOWN
tetris_gravity();
break;
case 'd':
//RIGHT
tetris_move_right();
break;
case 'a':
//LEFT
tetris_move_left();
break;
default:
break;
}
c=0;
// }
// was here if(!iterate_game)
if(iterate_game)
{
//Update game
iterate_game = false;
tetris_gravity();
tetris_check_lines();
terminal_cursor_home();
tetris_print();
if (tetris_is_game_over())
{
is_running = false;
}
}
}
else
{
// if (uart_getc(&c))
// {
if (c == 'n')
{
c=0;
//Seed random function so we do not get same start condition
//for each new game. In essence we will not start a new game
//exactly at the same time.
srand(tick);
//New Game
is_running = true;
terminal_cursor_off();
terminal_clear();
tetris_init();
tetris_new_block();
terminal_cursor_home();
tetris_print();
}
// }
}
}
}
int main(void)
{
/**
* Initialize and configure system and generic clocks.
* Use conf_clocks.h to configure system and generic clocks.
*/
system_init();
hal_if_usart_init();
/**
* Enable global interrupts.
*/
system_interrupt_enable_global();
/**
* Initialize delay service.
*/
delay_init();
/* initialize timer */
timer_init();
/* Setup and enable generic clock source for PTC module. */
surface_configure_ptc_clock();
touch_time.measurement_period_ms = DEF_TOUCH_MEASUREMENT_PERIOD_MS;
/* Initialize touchpad input parameters */
qts_init_surface();
qts_sensors_config();
/*initialize event system*/
#if (DEF_SURF_LOW_POWER_SENSOR_ENABLE == 1)
init_evsys_config();
#endif
/* Configure System Sleep mode to STANDBY. */
system_set_sleepmode(SYSTEM_SLEEPMODE_STANDBY);
#ifdef POWER_OPT_ENABLE
turn_off_bod33();
configure_power_manager();
#endif
/* Calibration */
qts_start();
LOG("Hello QT6~\r\n");
/* Appl maintains this flag,
* marked as 1 initially to start measurement cycle.
*/
qts_process_done = 1u;
/* Appl maintains this flag,
* marked as 1 initially to start measurement cycle.
*/
touch_time.time_to_measure_touch = 1u;
while (1) {
/**
* Start touch surface process
*/
#if DEF_SURF_LOW_POWER_SENSOR_ENABLE == 1
qts_process_lp();
#else
if (qts_process_done == 1) {
qts_normal_process();
}
#endif
if (p_mutlcap_measure_data->measurement_done_touch == 1u) {
p_mutlcap_measure_data->measurement_done_touch = 0u;
}
system_sleep();
}
}
/**
* \brief Main Application Routine \n
* - Initialize the system clocks \n
* NOTE: The clock should be configured in conf_clock.h \n
* - Configure port pins (PA14 and PA16) are used here \n
* - Enable Global Interrupt \n
* - Configure and enable USART \n
* - Configure and enable ADC \n
* - Configure and enable DMAC and EVSYS if DMAC mode is chosen \n
* - Start first ADC conversion \n
* - Count idle loop count in forever loop \n
*/
int main(void)
{
/* Initialize system clocks */
system_init();
#if defined(ENABLE_PORT_TOGGLE)
/* Configure PORT pins PA14 and PA16 are configured here
* NOTE: Use oscilloscope to probe the pin.
*/
configure_port();
#endif
/* ENable Global interrupt */
system_interrupt_enable_global();
/* Start SysTick Timer */
systick_init();
/* Configure SERCOM - USART */
configure_usart();
/* Configure and enable ADC */
configure_adc();
/* Configure and enable EVSYS */
configure_event();
/* Configure and enable DMA channel and descriptor */
configure_dma();
/* Get the time stamp 1 before starting ADC transfer */
time_stamp1 = SysTick->VAL;
/*
* Trigger first ADC conversion through software.
* NOTE: In case of using DMA, further conversions are triggered through
* event generated when previous ADC result is transferred to destination
* (can be USART DATA register [or] RAM buffer).
* When DMA is not used, further conversions are triggered via software in
* ADC handler after each result ready.
*/
adc_start_conversion(&adc_instance);
while (1){
#if defined (ENABLE_PORT_TOGGLE)
/* Use oscilloscope to probe the pin. */
port_base->OUTTGL.reg = (1UL << PIN_PA16 % 32 );
#endif
/* Increment idle count whenever application reached while(1) loop */
idle_loop_count++;
/*
* Check if 1024 bytes transfer is done in either case (I.e. with or without
* using DMA.
* 'adc_conv_done' flag is set to true in the ADC handler once
* 'adc_sample_count' reaches BLOCK_COUNT.
* 'adc_dma_transfer_is_done' is set to true once DMA transfer is done
* in DMA call back for channel zero when 'ADC_DMAC_USART' is chosen.
* When choosing ADC_DMAC_MEM_MEM_USART mode, 'adc_dma_transfer_is_done'
* is set to true in DMA channel call back for channel 2.
* DMA channel is disabled once reaching BLOCK_COUNT (with DMA cases).
* ADC is disabled once reaching BLOBK_COUNT samples (without DMA cases).
*/
if (adc_dma_transfer_is_done == true){
/*
* Calculate number of cycles taken from the time stamp
* taken before start of the conversion and after 1024 transfer
* is completed.
* NOTE: This value in relation to the idle_loop_count is
* used in calculating CPU usage.
*/
cycles_taken = calculate_cycles_taken(time_stamp1,time_stamp2);
/* Write the CPU cycles taken on USART */
usart_write_buffer_wait(&usart_instance, (uint8_t *)&cycles_taken, sizeof(cycles_taken));
/* Print idle loop count on USART */
usart_write_buffer_wait(&usart_instance,(uint8_t *)&idle_loop_count, sizeof(idle_loop_count));
/*
* Enter into forever loop as all transfers are completed and
* DMAC/ADC is disabled
*/
while(1);
}
}
}//end of main
int
main(int argc, char *argv[])
{
node_id_restore();
/* init system: clocks, board etc */
system_init();
sio2host_init();
leds_init();
leds_on(LEDS_ALL);
system_interrupt_enable_global();
flash_init();
delay_init();
/* Initialize Contiki and our processes. */
#ifdef LOW_POWER_MODE
configure_tc3();
#else
clock_init();
#endif
process_init();
ctimer_init();
rtimer_init();
process_start(&etimer_process, NULL);
/* Set MAC address and node ID */
#ifdef NODEID
node_id = NODEID;
#ifdef BURN_NODEID
node_id_burn(node_id);
#endif /* BURN_NODEID */
#else/* NODE_ID */
#endif /* NODE_ID */
printf("\r\n\n\n\n Starting the SmartConnect-6LoWPAN \r\n Platform : Atmel IoT device \r\n");
print_reset_causes();
netstack_init();
#if BOARD == SAMR21_XPLAINED_PRO
eui64 = edbg_eui_read_eui64();
SetIEEEAddr(eui64);
#else
SetIEEEAddr(node_mac);
#endif
set_link_addr();
rf_set_channel(RF_CHANNEL);
printf("\r\n Configured RF channel: %d\r\n", rf_get_channel());
leds_off(LEDS_ALL);
process_start(&sensors_process, NULL);
energest_init();
ENERGEST_ON(ENERGEST_TYPE_CPU);
if(node_id > 0) {
printf(" Node id %u.\r\n", node_id);
} else {
printf(" Node id not set.\r\n");
}
/* Setup nullmac-like MAC for 802.15.4 */
#if SAMD
memcpy(&uip_lladdr.addr, node_mac, sizeof(uip_lladdr.addr));
#else
memcpy(&uip_lladdr.addr, eui64, sizeof(uip_lladdr.addr));
#endif
queuebuf_init();
printf(" %s %lu %d\r\n",
NETSTACK_RDC.name,
(uint32_t) (CLOCK_SECOND / (NETSTACK_RDC.channel_check_interval() == 0 ? 1:
NETSTACK_RDC.channel_check_interval())),
RF_CHANNEL);
process_start(&tcpip_process, NULL);
printf(" IPv6 Address: ");
{
uip_ds6_addr_t *lladdr;
int i;
lladdr = uip_ds6_get_link_local(-1);
for(i = 0; i < 7; ++i) {
printf("%02x%02x:", lladdr->ipaddr.u8[i * 2],
lladdr->ipaddr.u8[i * 2 + 1]);
}
printf("%02x%02x\r\n", lladdr->ipaddr.u8[14], lladdr->ipaddr.u8[15]);
}
{
uip_ipaddr_t ipaddr;
int i;
uip_ip6addr(&ipaddr, 0xfc00, 0, 0, 0, 0, 0, 0, 0);
uip_ds6_set_addr_iid(&ipaddr, &uip_lladdr);
uip_ds6_addr_add(&ipaddr, 0, ADDR_TENTATIVE);
printf("Tentative global IPv6 address ");
for(i = 0; i < 7; ++i) {
printf("%02x%02x:",
ipaddr.u8[i * 2], ipaddr.u8[i * 2 + 1]);
}
printf("%02x%02x\r\n",
ipaddr.u8[7 * 2], ipaddr.u8[7 * 2 + 1]);
}
print_processes(autostart_processes);
/* set up AES key */
#if ((THSQ_CONF_NETSTACK) & THSQ_CONF_AES)
#ifndef NETSTACK_AES_KEY
#error Please define NETSTACK_AES_KEY!
#endif /* NETSTACK_AES_KEY */
{
const uint8_t key[] = NETSTACK_AES_KEY;
netstack_aes_set_key(key);
}
printf("AES encryption is enabled\n");
#else /* ((THSQ_CONF_NETSTACK) & THSQ_CONF_AES) */
printf("\r\n Warning: AES encryption is disabled\n");
#endif /* ((THSQ_CONF_NETSTACK) & THSQ_CONF_AES) */
#ifdef ENABLE_LEDCTRL
ledctrl_init();
#endif
autostart_start(autostart_processes);
while(1){
int r = 0;
serial_data_handler();
do {
r = process_run();
} while(r > 0);
}
}
/*!
* @brief Initializes the whole system and runs the desired application
*
* This is the main function of the project. It calls initialization functions
* of the MCU and the sensors. In the infinite loop it repeatedly checks
* the USART module read buffer and Streams sensor data periodically (100 ms) via USART.
*
*/
int main(void)
{
/********************* Initialize global variables **********************/
bmf055_input_state = USART_INPUT_STATE_PRINT_DATA;
/************************* Initializations ******************************/
/*Initialize SAMD20 MCU*/
system_init();
/*Initialize clock module of SAMD20 MCU - Internal RC clock*/
//clock_initialize(); // done via conf_clocks.h --> ASF
/*SPI master for communicating with sensors*/
spi_initialize();
/*eeprom emulator for configuration storage */
eeprom_emulator_initialize();
/*Initialize timers */
tc_initialize();
/*Initialize UART for communication with PC*/
usart_initialize();
/*Enable the system interrupts*/
system_interrupt_enable_global();/* All interrupts have a priority of level 0 which is the highest. */
/* Initialize the sensors */
bmf055_sensors_initialize();
readEEPROM();
checkFirstTime(0);
//readEEPROM();
configureReceiver();
initSensors();
previousTime = micros();
calibratingG = 400;
f.SMALL_ANGLES_25=1; // important for gyro only conf
if(conf.copterType == 0){//0=Bi,1=Tri,2=QUADP,3=QUADX,4=Y4,5=Y6,6=H6P,7=H6X,8=Vtail4
MULTITYPE = 4;
NUMBER_MOTOR = 2;
}
if(conf.copterType == 1){
MULTITYPE = 1;
NUMBER_MOTOR = 3;
}
if(conf.copterType == 2){
MULTITYPE = 2;
NUMBER_MOTOR = 4;
}
if(conf.copterType == 3){
MULTITYPE = 3;
NUMBER_MOTOR = 4;
}
if(conf.copterType == 4){
MULTITYPE = 9;
NUMBER_MOTOR = 4;
}
if(conf.copterType == 5){
MULTITYPE = 6;
NUMBER_MOTOR = 6;
}
if(conf.copterType == 6){
MULTITYPE = 7;
NUMBER_MOTOR = 6;
}
if(conf.copterType == 7){
MULTITYPE = 10;
NUMBER_MOTOR = 6;
}
if(conf.copterType == 8){
MULTITYPE = 17;
NUMBER_MOTOR = 4;
}
initOutput();
/************************** Infinite Loop *******************************/
while (true)
{
static uint8_t rcDelayCommand; // this indicates the number of time (multiple of RC measurement at 50Hz) the sticks must be maintained to run or switch off motors
static uint8_t beepon = 0;
uint8_t axis,i;
int16_t error,errorAngle;
int16_t delta,deltaSum;
int16_t PTerm=0,ITerm=0,PTermACC=0,ITermACC=0,PTermGYRO=0,ITermGYRO=0,DTerm=0;
static int16_t lastGyro[3] = {0,0,0};
static int16_t delta1[3],delta2[3];
static int16_t errorGyroI[3] = {0,0,0};
static int16_t errorAngleI[2] = {0,0};
static uint32_t rcTime = 0;
static uint32_t BeepTime = 0;
static uint8_t stickarmed = 0;
//static int16_t initialThrottleHold;
if(!rcOptions[BOXARM] && stickarmed == 0 && f.ARMED == 0){
if(rcData[YAW]<conf.MINCHECK && rcData[ROLL]>conf.MAXCHECK){
conf.calibState=1;
writeParams(1);
while(true){
//blinkLED(10,30,1);
}
}
}
while(SetupMode == 1){
checkSetup();
}
if(conf.RxType == 1 || conf.RxType == 2){
if (rcFrameComplete) computeRC();
}
if(!rcOptions[BOXARM] && stickarmed == 0) {
f.ARMED = 0;
}
if (currentTime > rcTime ) { // 50Hz
rcTime = currentTime + 20000;
if(failsave < 250)failsave++;
debug[0] = failsave;
if(conf.RxType != 1 && conf.RxType != 2){
computeRC();
}
if ((rcData[THROTTLE] < conf.MINCHECK && s3D == 0) || (rcData[THROTTLE] > (1500-conf.MIDDLEDEADBAND) && rcData[THROTTLE] < (1500+conf.MIDDLEDEADBAND) && s3D == 1 && f.ARMED == 0)) {
errorGyroI[ROLL] = 0; errorGyroI[PITCH] = 0; errorGyroI[YAW] = 0;
errorAngleI[ROLL] = 0; errorAngleI[PITCH] = 0;
rcDelayCommand++;
if (rcData[YAW] < conf.MINCHECK && rcData[PITCH] < conf.MINCHECK && !f.ARMED) {
if (rcDelayCommand == 20 && failsave < 20) {
calibratingG=400;
}
}else if (rcData[YAW] > conf.MAXCHECK && rcData[PITCH] > conf.MAXCHECK && !f.ARMED) {
if (rcDelayCommand == 20) {
previousTime = micros();
}
}else if (conf.activate[BOXARM] > 0) {
if ( rcOptions[BOXARM] && f.OK_TO_ARM && good_calib) {
f.ARMED = 1;
stickarmed = 0;
} else if (f.ARMED) f.ARMED = 0;
rcDelayCommand = 0;
} else if ( (rcData[YAW] < conf.MINCHECK ) && f.ARMED && !rcOptions[BOXARM] && s3D == 0 && conf.ArmRoll == 0) {
if (rcDelayCommand == 20) f.ARMED = 0; // rcDelayCommand = 20 => 20x20ms = 0.4s = time to wait for a specific RC command to be acknowledged
} else if ( (rcData[YAW] > conf.MAXCHECK ) && rcData[PITCH] < conf.MAXCHECK && !f.ARMED && calibratingG == 0 && f.ACC_CALIBRATED && !rcOptions[BOXARM] && s3D == 0 && conf.ArmRoll == 0) {
if (rcDelayCommand == 20 && good_calib) {
f.ARMED = 1;
stickarmed = 1;
}
} else if ( (rcData[ROLL] < conf.MINCHECK ) && f.ARMED && !rcOptions[BOXARM] && s3D == 0 && conf.ArmRoll == 1) {
if (rcDelayCommand == 20) f.ARMED = 0; // rcDelayCommand = 20 => 20x20ms = 0.4s = time to wait for a specific RC command to be acknowledged
} else if ( (rcData[ROLL] > conf.MAXCHECK ) && rcData[PITCH] < conf.MAXCHECK && !f.ARMED && calibratingG == 0 && f.ACC_CALIBRATED && !rcOptions[BOXARM] && s3D == 0 && conf.ArmRoll == 1) {
if (rcDelayCommand == 20 && good_calib) {
f.ARMED = 1;
stickarmed = 1;
}
} else
rcDelayCommand = 0;
} else if (rcData[THROTTLE] > conf.MAXCHECK && !f.ARMED) {
if (rcData[YAW] < conf.MINCHECK && rcData[PITCH] < conf.MINCHECK) { // throttle=max, yaw=left, pitch=min
if (rcDelayCommand == 20) calibratingA=400;
rcDelayCommand++;
} else if (rcData[PITCH] > conf.MAXCHECK) {
conf.angleTrim[PITCH]+=2;writeParams(1);
} else if (rcData[PITCH] < conf.MINCHECK) {
conf.angleTrim[PITCH]-=2;writeParams(1);
} else if (rcData[ROLL] > conf.MAXCHECK) {
conf.angleTrim[ROLL]+=2;writeParams(1);
} else if (rcData[ROLL] < conf.MINCHECK) {
conf.angleTrim[ROLL]-=2;writeParams(1);
} else {
rcDelayCommand = 0;
}
}
uint16_t auxState = 0;
for(i=0;i<4;i++)
auxState |= (rcData[AUX1+i]<1300)<<(3*i) | (1300<rcData[AUX1+i] && rcData[AUX1+i]<1700)<<(3*i+1) | (rcData[AUX1+i]>1700)<<(3*i+2);
for(i=0;i<CHECKBOXITEMS;i++)
rcOptions[i] = (auxState & conf.activate[i])>0;
if(failsave > 200 && f.ARMED){
rcOptions[BOXACC] = 1;
s3D = 0;
rcData[THROTTLE] = 1190;
rcCommand[THROTTLE] = 1190;
}
if (rcOptions[BOXACC] && s3D == 0) {
// bumpless transfer to Level mode
if (!f.ACC_MODE) {
errorAngleI[ROLL] = 0; errorAngleI[PITCH] = 0;
f.ACC_MODE = 1;
}
} else {
// failsafe support
f.ACC_MODE = 0;
}
if (rcOptions[BOXBEEP]) {
f.FSBEEP = 1;
if(currentTime > BeepTime){
BeepTime = currentTime + 50000;
if(beepon == 0){
if(conf.RxType == 0){
//digitalWrite(A2,HIGH);
}else{
//digitalWrite(8,HIGH);
}
beepon = 1;
}else{
if(conf.RxType == 0){
//digitalWrite(A2,LOW);
}else{
//digitalWrite(8,LOW);
}
beepon = 0;
}
}
} else {
f.FSBEEP = 0;
if(conf.RxType == 0){
//digitalWrite(A2,LOW);
}else{
//digitalWrite(8,LOW);
}
}
if (rcOptions[BOXHORIZON] && s3D == 0) {
// bumpless transfer to Horizon mode
if (!f.HORIZON_MODE) {
errorAngleI[ROLL] = 0; errorAngleI[PITCH] = 0;
f.HORIZON_MODE = 1;
}
} else {
f.HORIZON_MODE = 0;
}
if (rcOptions[BOX3D] && conf.F3D == 1) {
if(f.ARMED == 0 && s3D == 0){
s3D = 1;
f.ACC_MODE = 0;
f.HORIZON_MODE = 0;
}
} else if(f.ARMED == 0){
s3D = 0;
}
if (rcOptions[BOXARM] == 0) f.OK_TO_ARM = 1;
}
computeIMU();
int16_t prop;
if (f.HORIZON_MODE)
prop = max(abs(rcCommand[PITCH]),abs(rcCommand[ROLL])); // range [0;500]
if (f.ACC_MODE){
if(Zadd > 0)Zadd--;
if(Zadd < 0)Zadd++;
}else{
Zadd = 0;
}
//**** PITCH & ROLL & YAW PID ****
for(axis=0;axis<3;axis++) {
if ((f.ACC_MODE || f.HORIZON_MODE) && axis<2 ) { //LEVEL MODE
// 50 degrees max inclination
errorAngle = constrain(2*rcCommand[axis],-500,+500) - angle[axis] + conf.angleTrim[axis]; //16 bits is ok here
#ifdef LEVEL_PDF
PTermACC = -(int32_t)angle[axis]*conf.P8[PIDLEVEL]/100 ;
#else
PTermACC = (int32_t)errorAngle*conf.P8[PIDLEVEL]/100 ; // 32 bits is needed for calculation: errorAngle*P8[PIDLEVEL] could exceed 32768 16 bits is ok for result
#endif
PTermACC = constrain(PTermACC,-conf.D8[PIDLEVEL]*5,+conf.D8[PIDLEVEL]*5);
errorAngleI[axis] = constrain(errorAngleI[axis]+errorAngle,-10000,+10000); // WindUp //16 bits is ok here
ITermACC = ((int32_t)errorAngleI[axis]*conf.I8[PIDLEVEL])>>12; // 32 bits is needed for calculation:10000*I8 could exceed 32768 16 bits is ok for result
}
if ( !f.ACC_MODE || f.HORIZON_MODE || axis == 2 ) { // MODE relying on GYRO or YAW axis
if (abs(rcCommand[axis])<350) error = rcCommand[axis]*10*8/conf.P8[axis] ; // 16 bits is needed for calculation: 350*10*8 = 28000 16 bits is ok for result if P8>2 (P>0.2)
else error = (int32_t)rcCommand[axis]*10*8/conf.P8[axis] ; // 32 bits is needed for calculation: 500*5*10*8 = 200000 16 bits is ok for result if P8>2 (P>0.2)
error -= gyroData[axis];
PTermGYRO = rcCommand[axis];
errorGyroI[axis] = constrain(errorGyroI[axis]+error,-16000,+16000); // WindUp 16 bits is ok here
if (abs(gyroData[axis])>640) errorGyroI[axis] = 0;
ITermGYRO = (errorGyroI[axis]/125*conf.I8[axis])>>6; // 16 bits is ok here 16000/125 = 128 ; 128*250 = 32000
}
if ( f.HORIZON_MODE && axis<2) {
PTerm = ((int32_t)PTermACC*(500-prop) + (int32_t)PTermGYRO*prop)/500;
ITerm = ((int32_t)ITermACC*(500-prop) + (int32_t)ITermGYRO*prop)/500;
} else {
if ( f.ACC_MODE && axis<2) {
PTerm = PTermACC;
ITerm = ITermACC;
} else {
PTerm = PTermGYRO;
ITerm = ITermGYRO;
}
}
if (abs(gyroData[axis])<160) PTerm -= gyroData[axis]*dynP8[axis]/10/8; // 16 bits is needed for calculation 160*200 = 32000 16 bits is ok for result
else PTerm -= (int32_t)gyroData[axis]*dynP8[axis]/10/8; // 32 bits is needed for calculation
delta = gyroData[axis] - lastGyro[axis]; // 16 bits is ok here, the dif between 2 consecutive gyro reads is limited to 800
lastGyro[axis] = gyroData[axis];
deltaSum = delta1[axis]+delta2[axis]+delta;
delta2[axis] = delta1[axis];
delta1[axis] = delta;
if (abs(deltaSum)<640) DTerm = (deltaSum*dynD8[axis])>>5; // 16 bits is needed for calculation 640*50 = 32000 16 bits is ok for result
else DTerm = ((int32_t)deltaSum*dynD8[axis])>>5; // 32 bits is needed for calculation
axisPID[axis] = PTerm + ITerm - DTerm;
}
/* Timer 0 Initialization */
void timer_init(void)
{
struct tc_config conf_tc;
struct tc_events conf_tc_events = {.generate_event_on_compare_channel[0] = 1};
tc_get_config_defaults(&conf_tc);
conf_tc.clock_source = GCLK_GENERATOR_0;
conf_tc.wave_generation = TC_WAVE_GENERATION_MATCH_FREQ;
conf_tc.counter_16_bit.compare_capture_channel[0] = 0xFFFF;
tc_init(&tc_inst, TC0, &conf_tc);
tc_enable_events(&tc_inst, &conf_tc_events);
tc_enable(&tc_inst);
tc_stop_counter(&tc_inst);
/* Enable TC0 match/capture channel 0 interrupt */
TC0->COUNT16.INTENSET.bit.MC0 = 1;
/* Enable TC0 module interrupt */
NVIC_EnableIRQ(TC0_IRQn);
}
/* DAC Initialization */
void dac_initialize(void)
{
struct dac_config conf_dac;
struct dac_events conf_dac_events = {.on_event_start_conversion = 1};
dac_get_config_defaults(&conf_dac);
conf_dac.clock_source = GCLK_GENERATOR_3;
conf_dac.reference = DAC_REFERENCE_INT1V;
dac_init(&dac_inst, DAC, &conf_dac);
dac_enable_events(&dac_inst, &conf_dac_events);
dac_enable(&dac_inst);
}
/* Event System Initialization */
void evsys_init(void)
{
struct events_resource conf_event_resource;
struct events_config conf_event;
events_get_config_defaults(&conf_event);
conf_event.edge_detect = EVENTS_EDGE_DETECT_NONE;
conf_event.path = EVENTS_PATH_ASYNCHRONOUS;
conf_event.generator = EVSYS_ID_GEN_TC0_MCX_0;
events_allocate(&conf_event_resource, &conf_event);
events_attach_user(&conf_event_resource, EVSYS_ID_USER_DAC_START);
}
/* Initialize the selected waveform buffer with output data */
void buffer_init(void)
{
#if WAVE_MODE==SINE_WAVE
for (i = 0; i < DEGREES_PER_CYCLE; i++) {
sine_wave_buf[i] = (uint16_t)(500 + (500*sin((double)i*DEGREE)));
}
#elif WAVE_MODE==SAW_TOOTH_WAVE
for (i = 0; i < 256; i++) {
sawtooth_wave_buf[i] = i*4;
}
#elif WAVE_MODE==TRIANGLE_WAVE
for (i = 0; i < 128; i++) {
triangle_wave_buf[i] = i*8;
}
for (i = 128; i < 256; i++) {
triangle_wave_buf[i] = 1023 - (i*8);
}
#endif
}
/* Main function */
int main(void)
{
system_init();
timer_init();
dac_initialize();
evsys_init();
buffer_init();
/* Set the TC0 compare value corresponding to specified frequency */
#if WAVE_MODE==SINE_WAVE
tc_set_compare_value(&tc_inst, 0, \
system_gclk_gen_get_hz(GCLK_GENERATOR_0)/(FREQUENCY*360));
#else
tc_set_compare_value(&tc_inst, 0, \
system_gclk_gen_get_hz(GCLK_GENERATOR_0)/(FREQUENCY*256));
#endif
/* Start TC0 timer */
tc_start_counter(&tc_inst);
/* Enable global interrupt */
system_interrupt_enable_global();
while (true) {
}
}
