/**
 * \brief Example 2 main application routine
 */
int main( void )
{
    /* Initialize interrupt controller, board and sysclock */
    pmic_init();
    sysclk_init();

    /* Enable global interrupts */
    cpu_irq_enable();

    /*
      Set up first PWM channel
    */

    /* Set PWM to TC E0, channel A (PE0 = LED0), 75 Hz */
    pwm_init(&pwm_1_cfg, PWM_TCE0, PWM_CH_A, 75);

    /* Set callback function on TC overflow */
    pwm_overflow_int_callback(&pwm_1_cfg, pwm_callback_1);

    /*
      Set up second PWM channel
    */

    /* Set PWM to TC E1, channel A (PE4 = LED4), 250 Hz */
    pwm_init(&pwm_2_cfg, PWM_TCE1, PWM_CH_A, 250);

    /* Set callback function on TC overflow */
    pwm_overflow_int_callback(&pwm_2_cfg, pwm_callback_2);

    /*
      Start PWM
    */

    pwm_start(&pwm_1_cfg, duty_cycle_percent_1);
    pwm_start(&pwm_2_cfg, duty_cycle_percent_2);

    while(1) {
        /* Do nothing. Everything is handled by interrupts. */
    }
}

int main(void)
{
	board_init();
	sysclk_init();

	/* Turn off LEDs to start with */
	LED_Off(LED0_GPIO);
	LED_Off(LED1_GPIO);
	LED_Off(LED2_GPIO);
	LED_Off(LED3_GPIO);

	/* Enable all three interrupt levels of the PMIC.
	 * Alternatively, use pmic_init() to achieve the same.
	 */
	pmic_enable_level(PMIC_LVL_LOW | PMIC_LVL_MEDIUM | PMIC_LVL_HIGH);

	/* Enable the timer/counter's clock. */
	sysclk_enable_module(SYSCLK_PORT_C, SYSCLK_TC0);

	/* Initialize count, period and compare registers of the timer/counter. */
	TCC0.CNT = 0x0000;
	TCC0.PER = 0xffff;
	TCC0.CCA = 0x5555;
	TCC0.CCB = 0xaaaa;

	/* Set up timer/counter in normal mode with two compare channels. */
	TCC0.CTRLB = TC0_CCAEN_bm | TC0_CCBEN_bm | TC_WGMODE_NORMAL_gc;

	/* Set levels for overflow and compare channel interrupts. */
	TCC0.INTCTRLA = TC_OVFINTLVL_HI_gc;
	TCC0.INTCTRLB = TC_CCAINTLVL_LO_gc | TC_CCBINTLVL_MED_gc;

	/* Start the timer/counter and enable interrupts. */
	TCC0.CTRLA = TC_CLKSEL_DIV64_gc;
	cpu_irq_enable();

	while (1) {
		/* Do nothing - LED toggling is managed by interrupts. */
	}
}

int main(void)
{
	irq_initialize_vectors();
	#if SAMD || SAMR21
	system_init();
	delay_init();
	#else
	sysclk_init();
	board_init();
	#endif
	SYS_Init();
	//sio2host_init();
	configure_console();
	printf("we made it");
	cpu_irq_enable();
	LED_On(LED0);
	appInit();
	while (1) {
		SYS_TaskHandler();
		//APP_TaskHandler();
	}
}

int main(void) {
  irq_initialize_vectors();
  cpu_irq_enable();
  sleepmgr_init();
  system_init();
  log_init();
  l("configure_pins");
  setup_led();
  l("ui_init");
  ui_init();

  l("ui_powerdown");
  ui_powerdown();

  // Start USB stack to authorize VBus monitoring
  l("udc_start");
  udc_start();

  while (true) {
    sleepmgr_enter_sleep();
  }
}

/*! \brief Main function. Execution starts here.
 */
int main(void)
{
	irq_initialize_vectors();
	cpu_irq_enable();

	// Initialize the sleep manager
	sleepmgr_init();

	sysclk_init();
	board_init();
	ui_init();
	ui_powerdown();

	// Start USB stack to authorize VBus monitoring
	udc_start();

	// The main loop manages only the power mode
	// because the USB management is done by interrupt
	while (true) {
		sleepmgr_enter_sleep();
	}
}

/*! \brief Main function. Execution starts here.
 */
int main(void)
{
	irq_initialize_vectors();
	cpu_irq_enable();
#if !SAMD21 && !SAMR21
	sysclk_init();
	board_init();
#else
	system_init();
#endif
	// Initialize the sleep manager
	sleepmgr_init();
	ui_init();
	ui_powerdown();

	// Start USB stack to authorize VBus monitoring
	udc_start();

	// The main loop manages only the power mode
	// because the USB management is done by interrupt
	while (true) {
#ifdef USB_DEVICE_LOW_SPEED
		// No USB "Keep a live" interrupt available in low speed
		// to scan mouse interface then use main loop
		if (main_b_mouse_enable) {
			static volatile uint16_t virtual_sof_sub = 0;
			static uint16_t virtual_sof = 0;
			if (sysclk_get_cpu_hz()/50000 ==
				virtual_sof_sub++) {
				virtual_sof_sub = 0;
				static uint16_t virtual_sof = 0;
				ui_process(virtual_sof++);
			}
		}
#else /* #ifdef USB_DEVICE_LOW_SPEED */
		sleepmgr_enter_sleep();
#endif
	}
}

/**
 * \brief Run Wireless Module unit tests
 *
 * Initializes the clock system, board and USB.
 * Then runs the wireless task continuously.
 */
int main(void)
{
	irq_initialize_vectors();
	sysclk_init();

	/* Initialize the board.
	 * The board-specific conf_board.h file contains the configuration of
	 * the board initialization.
	 */
	board_init();

	sw_timer_init();
	tal_init();
	/* Enable interrupts */
	cpu_irq_enable();

	stdio_usb_init();

	while (1) {
		tal_task();
	}
}

static void initialize_EPD_timer(void) {
		
	uint32_t rc;
	/* Configure the PMC to enable the Timer/Counter (TC) module. */
	sysclk_enable_peripheral_clock(EPD_TC_TIMER_ID);
	
	/** TC  Configuration structure. */
	struct tc_control_reg tc_control_par = {
	/** TC Compare Output Mode  */
	.co_mode = CO_NORMAL,
	/** TC Waveform Generation Mode */	
	.wg_mode = CTC_Mode1,
	
	/** TC Clock Selection, Prescalar select */
	.cs_select = EPD_TC_ClockSignalSel
	};
	
	/** Init TC to timer ctc mode. */	
	tc_initc(EPD_TC_TIMER_ID, EPD_TC_TIMER_CHANNEL, &tc_control_par);

	/** Configure OVF value */
	rc = (sysclk_get_peripheral_bus_hz(EPD_TC_TIMER_ID) / 
		 divisors[EPD_TC_ClockSignalSel] ) /
	     1000 ;
	
	tc_write_cc(EPD_TC_TIMER_ID, EPD_TC_TIMER_CHANNEL, rc);
	
	/** Configure and enable interrupt on TC CTC compare match */
	tc_set_compa_interrupt_callback(EPD_TC_TIMER_ID, EPD_timer_handler);
	tc_enable_compa_int(EPD_TC_TIMER_ID);
	
	cpu_irq_enable();
	tc_start(EPD_TC_TIMER_ID, &tc_control_par);
	EPD_Counter=0;
	
	/** Configure the PMC to enable the Timer/Counter (TC) module. */
	sysclk_enable_peripheral_clock(EPD_TC_TIMER_ID);
		
}

/**
 * \brief Initialize the twi master module
 *
 * \param twi       Base address of the TWI (i.e. &TWIC).
 * \param *opt      Options for initializing the twi module
 *                  (see \ref twi_options_t)
 * \retval STATUS_OK        Transaction is successful
 * \retval ERR_INVALID_ARG  Invalid arguments in \c opt.
 */
status_code_t twi_master_init(TWI_t * twi,
    const twi_options_t * opt)
{
    uint8_t const ctrla =
        CONF_TWIM_INTLVL | TWI_MASTER_RIEN_bm | TWI_MASTER_WIEN_bm |
        TWI_MASTER_ENABLE_bm;

    twi->MASTER.BAUD = opt->speed_reg;
    twi->MASTER.CTRLA = ctrla;
    twi->MASTER.STATUS = TWI_MASTER_BUSSTATE_IDLE_gc;

    transfer.locked = false;
    transfer.status = STATUS_OK;

    /* Enable configured PMIC interrupt level. */

    PMIC.CTRL |= CONF_PMIC_INTLVL;

    cpu_irq_enable();

    return STATUS_OK;
}

void init()
{
	// board init
	sysclk_init();
	board_init();
	busy_delay_init(BOARD_OSC0_HZ);
	
	// interrupts init
	cpu_irq_disable();
    INTC_init_interrupts();
	INTC_register_interrupt(&interrupt_J3,   AVR32_GPIO_IRQ_3, AVR32_INTC_INT1);
	cpu_irq_enable();

	//  stdio init
	stdio_usb_init(&CONFIG_USART_IF);

	// Specify that stdout and stdin should not be buffered.

#if defined(__GNUC__) && defined(__AVR32__)
	setbuf(stdout, NULL);
	setbuf(stdin,  NULL);
#endif
}

/*! \brief Initialize sensor board target resources
 *
 * This function should be called to ensure proper initialization
 * of sensor hardware connected to an Atmel AVR32 or XMEGA platform.
 *
 * \return  Nothing.
 */
void sensor_board_init(void)
{
	/* Configure all defined Xplained Sensor board I/O pins.
	 *
	 * \todo
	 * Determine whether the interrupt event flag (rising edge, falling
	 * edge, toggle, etc.) should be a statically configurable parameter
	 * for devices requiring more flexibility in how events are detected.
	 */
#if (EXT_BOARD == SENSORS_XPLAINED_INERTIAL_1) || \
	(EXT_BOARD == SENSORS_XPLAINED_INERTIAL_2) || \
	(EXT_BOARD == SENSORS_XPLAINED_INERTIAL_A1)

	gpio_configure_pin(SENSOR_BOARD_PIN3, PIN_INPUT_FLAGS);
	gpio_configure_pin(SENSOR_BOARD_PIN4, PIN_INPUT_FLAGS);
	gpio_configure_pin(SENSOR_BOARD_PIN5, PIN_INPUT_FLAGS);

#elif (EXT_BOARD == SENSORS_XPLAINED_PRESSURE_1)
	gpio_configure_pin(SENSOR_BOARD_PIN3, PIN_OUTPUT_FLAGS);
	gpio_configure_pin(SENSOR_BOARD_PIN4, PIN_INPUT_FLAGS);

#elif (EXT_BOARD == SENSORS_XPLAINED_LIGHTPROX_1)
	gpio_configure_pin(SENSOR_BOARD_PIN3, PIN_INPUT_FLAGS);

#elif (EXT_BOARD == SENSORS_XPLAINED_BREADBOARD)
	gpio_configure_pin(SENSOR_BOARD_PIN4, PIN_INPUT_FLAGS);
#endif

	/* Global Interrupt Disable */
	cpu_irq_disable();

	/* Initialize interrupt vector table support. */
	irq_initialize_vectors();

	/* Global Interrupt Enable */
	cpu_irq_enable();
}

/**************************************************************************//**
*  \brief Initialize QTouch.
******************************************************************************/
void BSP_InitQTouch(BSP_TouchEventHandler_t handler)
{
	/* initialise host app, pins, watchdog, etc */
	init_system();

	/* Reset touch sensing */
	qt_reset_sensing();

	/*Configure Burst Length*/
	burst_len_config();
	config_sensors();

	/* Initialise and set touch params */
	qt_init_sensing();
	qt_set_parameters();
	init_timer_isr();

	buzzer_init();

	/*  Address to pass address of user functions   */

	/*  This function is called after the library has made capacitive
	 * measurements,
	 *   but before it has processed them. The user can use this hook to
	 * apply filter
	 *   functions to the measured signal values.(Possibly to fix sensor
	 * layout faults)    */

	/* This function is also used to send signal values to simulate Accelero
	 * meter,
	 * Just for demo purpose */
	qt_filter_callback = qt_avr477_filter_cb;

	cpu_irq_enable();

	handler = handler;
}

/*! \brief Main function. Execution starts here.
 */
int main(void)
{
    irq_initialize_vectors();
    cpu_irq_enable();

    /* Initialize ASF services */
    sleepmgr_init();
    sysclk_init();
    board_init();
    gfx_mono_init();
    sd_mmc_init();
    rtc_init();
    stdio_usb_init(); /* Initialize STDIO and start USB */
    udc_stop(); /* Stop USB by default */

    main_introduction();

    /* Initialize tasks */
    app_touch_init();
    app_cpu_load_init();
    app_sampling_init();

    /* The main loop */
    while (true) {
        /* Enter in sleep mode */
        app_cpu_load_enter_sleep();
        sleepmgr_enter_sleep();

        /* Execute tasks */
        app_usb_task();
        app_microsd_task();
        app_sampling_task();
        app_touch_task();
        app_cpu_load_task();
    }
}

/**
 * \brief main function
 */
int main (void)
{
	/* Initialize basic board support features.
	 * - Initialize system clock sources according to device-specific
	 *   configuration parameters supplied in a conf_clock.h file.
	 * - Set up GPIO and board-specific features using additional configuration
	 *   parameters, if any, specified in a conf_board.h file.
	 */
	sysclk_init();
	board_init();

	// Initialize interrupt vector table support.
	irq_initialize_vectors();

	// Enable interrupts
	cpu_irq_enable();

	/* Call a local utility routine to initialize C-Library Standard I/O over
	 * a USB CDC protocol. Tunable parameters in a conf_usb.h file must be
	 * supplied to configure the USB device correctly.
	 */
	stdio_usb_init();

	// Get and echo characters forever.

	uint8_t ch;

	while (true) {

		scanf("%c",&ch); // get one input character

		if (ch) {
			printf("%c",ch); // echo to output
		}
	}
}

/*! \brief Main function.
 */
int main(void)
{
	sysclk_init();
	/* Initialize the board.
	 * The board-specific conf_board.h file contains the configuration of
	 * the board initialization.
	 */
	board_init();

	/* Config the USART_SPI in master mode. */
	usart_spi_init(USART_SPI_EXAMPLE);
	usart_spi_setup_device(USART_SPI_EXAMPLE, &USART_SPI_DEVICE_EXAMPLE,
			SPI_MODE_0, USART_SPI_EXAMPLE_BAUDRATE, 0);
	usart_spi_enable(USART_SPI_EXAMPLE);

	/* Config the SPI module in slave mode. */
	spi_slave_init(SPI_SLAVE_EXAMPLE, SPI_MODE_0);
	spi_enable(SPI_SLAVE_EXAMPLE);

	/* Enable global interrupt */
	cpu_irq_enable();

	/* Show the test result by LED. */
	if (spi_usart_master_transfer() == true && spi_slave_transfer() ==
			true) {
		ioport_set_pin_level(SPI_SLAVE_EXAMPLE_LED_PIN,
				IOPORT_PIN_LEVEL_LOW);
	} else {
		ioport_set_pin_level(SPI_SLAVE_EXAMPLE_LED_PIN,
				IOPORT_PIN_LEVEL_HIGH);
	}

	while (1) {
		/* Do nothing */
	}
}

int main(void)
{
	const usart_serial_options_t usart_serial_options = {
		.baudrate   = CONF_TEST_BAUDRATE,
		.charlength = CONF_TEST_CHARLENGTH,
		.paritytype = CONF_TEST_PARITY,
		.stopbits   = CONF_TEST_STOPBITS,
	};

	/* Usual initializations */
	board_init();
	sysclk_init();
	sleepmgr_init();
	irq_initialize_vectors();
	cpu_irq_enable();
	stdio_serial_init(CONF_TEST_USART, &usart_serial_options);

	printf("\x0C\n\r-- ADC Calibration Example");
	printf("  (Compiled: %s %s)\n\r", __DATE__, __TIME__);

	/* ADC and DAC initializations */
	main_dac_init();
	main_adc_init();

	printf("\n\rConversion samples without correction:\n\r");
	main_conversions();

	/* Measure and enable corrections */
	main_adc_correction();

	printf("Conversion samples with correction:\n\r");
	main_conversions();

	while (1) {
	}
}

int main (void)
{
	sysclk_init();
	ioport_init();
	
	ioport_set_pin_dir(LED_BLUE, IOPORT_DIR_OUTPUT);
	ioport_set_pin_dir(LED_GREEN, IOPORT_DIR_OUTPUT);
	ioport_set_pin_dir(LED_WHITE, IOPORT_DIR_OUTPUT);
	
	ioport_configure_pin(BUTTON_0, IOPORT_PULL_UP);
	ioport_configure_pin(BUTTON_1, IOPORT_PULL_UP);

	force_boot_loader();
	
	irq_initialize_vectors();
	cpu_irq_enable();
	udc_start();
	//board_init();

	while(1)
	{
		ioport_toggle_pin_level(LED_GREEN);
		delay_ms(100);
		ioport_set_pin_level(LED_BLUE, ioport_get_pin_level(BUTTON_0));
		ioport_set_pin_level(LED_WHITE, ioport_get_pin_level(BUTTON_1));
		
		char usb_in = udi_cdc_getc();
		char usb_out [17]=  "WHAT YOU TYPED: \r";//udi_cdc_getc();
		for (int i=0;i<16;i++)
		{
			udi_cdc_putc(usb_out[i]);
		}
		udi_cdc_putc(usb_in);
		udi_cdc_putc('\r');
	}
}

//---------------------------------
//----- static function definitions
// __attribute__((__interrupt__))
static void irq_pdca(void) {
#if 1
#else
  // Disable all interrupts.
  //  Disable_global_interrupt();
  cpu_irq_disable();
  // Disable interrupt channel.
  pdca_disable_interrupt_transfer_complete(AVR32_PDCA_CHANNEL_SPI_RX);
  //unselects the SD/MMC memory.
  sd_mmc_spi_read_close_PDCA();
  //.... example has a 5000 clock gimpy delay here.
  // using delay_us instead
  delay_ms(10);
  //  delay_ms(2);
  // Disable unnecessary channel
  pdca_disable(AVR32_PDCA_CHANNEL_SPI_TX);
  pdca_disable(AVR32_PDCA_CHANNEL_SPI_RX);
  // Enable all interrupts.
  cpu_irq_enable();
  //  Enable_global_interrupt();
  //  print_dbg("\r\n handled PDCA interrupt. \r\n");
  fsEndTransfer = true;
#endif
}

//! 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 = cpu_irq_is_enabled())) cpu_irq_disable();
#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) cpu_irq_enable();
#endif
}

// top-level peripheral init
static void init_avr32(void) {
  volatile avr32_tc_t *tc = APP_TC;
  // clocks
  // setup clocks
  sysclk_init();

  // not sure why but when need to explictly enable clock for static mem ctlr
  sysclk_enable_pbb_module(SYSCLK_SMC_REGS);
  flashc_set_bus_freq(FCPU_HZ);
  // need this for high-speed operation
  flashc_set_wait_state(1);

  /// interrupts
  //  print_dbg("\r\n  irq_initialize_vectors() ");
  irq_initialize_vectors();
  // disable all interrupts for now
  //  print_dbg("\r\n  cpu_irq_disable() ");
  cpu_irq_disable();

  // serial usb
  print_dbg("\r\n  init_ftdi_usart() ");
  init_ftdi_usart();
  // external sram
  print_dbg("\r\n  smc_init(FHSB_HZ) ");
  smc_init(FHSB_HZ);

  // initialize spi1: OLED, ADC, SD/MMC
  print_dbg("\r\n  init_spi1() ");
  init_spi1();
  // initialize PDCA controller

  print_dbg("\r\n  init_local_pdca() ");
  init_local_pdca();

  // initialize blackfin resources
  print_dbg("\r\n  init_bfin_resources() ");
  init_bfin_resources();

  // initialize application timer
  print_dbg("\r\n  init_tc(tc) ");
  init_tc(tc);

  // initialize other GPIO
  print_dbg("\r\n  init_gpio() ");
  init_gpio();

  // register interrupts
  print_dbg("\r\n  register_interrupts() ");
  register_interrupts();

  // initialize the OLED screen
  print_dbg("\r\n  init_oled() ");
  init_oled();

  // enable interrupts
  print_dbg("\r\n  cpu_irq_enable() ");
  cpu_irq_enable();

  // usb host controller
  init_usb_host();
  // initialize usb classes
  print_dbg("\r\n init_monome ");
  init_monome();
  //  init_midi();
  //  init_hid();
}