/**
* \brief Initialize the timer counter (TC0).
*/
void sys_init_timing(void)
{
uint32_t ul_div;
uint32_t ul_tcclks;
/* Clear tick value. */
gs_ul_clk_tick = 0;
/* Configure PMC. */
pmc_enable_periph_clk(ID_TC0);
/* Configure TC for a 1kHz frequency and trigger on RC compare. */
tc_find_mck_divisor(1000,
sysclk_get_main_hz(), &ul_div, &ul_tcclks,
sysclk_get_main_hz());
tc_init(TC0, 0, ul_tcclks | TC_CMR_CPCTRG);
tc_write_rc(TC0, 0, (sysclk_get_main_hz() / ul_div) / 1000);
/* Configure and enable interrupt on RC compare. */
NVIC_EnableIRQ((IRQn_Type)ID_TC0);
tc_enable_interrupt(TC0, 0, TC_IER_CPCS);
/* Start timer. */
tc_start(TC0, 0);
}
void init_Usart (void)
{
ioport_set_pin_dir(PIO_PA21_IDX,IOPORT_DIR_INPUT);
ioport_set_pin_dir(PIO_PB4_IDX,IOPORT_DIR_OUTPUT);
const sam_usart_opt_t usart_console_settings = {
USART_SERIAL_BAUDRATE,
USART_SERIAL_CHAR_LENGTH,
USART_SERIAL_PARITY,
USART_SERIAL_STOP_BIT,
US_MR_CHMODE_NORMAL
};
#if SAM4L
sysclk_enable_peripheral_clock(USART_SERIAL);
#else
sysclk_enable_peripheral_clock(USART_SERIAL_ID);
#endif
usart_init_rs232(USART_SERIAL, &usart_console_settings,
sysclk_get_main_hz()/2);
usart_enable_tx(USART_SERIAL);
usart_enable_rx(USART_SERIAL);
// how to enable an interrupt( use three steps ):use these functions: -usart_enable_interrupt- Then -NVIC_EnableIRQ(USART_SERIAL_IRQ);- & Then add this function void USART_SERIAL_ISR_HANDLER(void)
usart_enable_interrupt(USART_SERIAL, US_IER_RXRDY);
NVIC_EnableIRQ(USART_SERIAL_IRQ);
}
/** Enables the target's PDI interface, holding the target in reset until PDI mode is exited. */
void XPROGTarget_EnableTargetPDI(void)
{
IsSending = false;
/* Turn on clock */
sysclk_enable_peripheral_clock(USART_PDI_ID);
/* Set Tx and XCK as outputs, Rx as input */
gpio_configure_pin(PIN_PDIDTX_GPIO, PIN_PDIDTX_OUT_FLAGS);
gpio_configure_pin(PIN_PDIDRX_GPIO, PIN_PDIDRX_FLAGS);
gpio_configure_pin(PIN_PDIC_GPIO, PIN_PDIC_OUT_FLAGS);
delay_us(50);
/* Set DATA line high for at least 90ns to disable /RESET functionality */
gpio_set_pin_high(PIN_PDIDTX_GPIO);
delay_us(10);
/* Set up the synchronous USART for XMEGA communications - 8 data bits, even parity, 2 stop bits */
const sam_usart_opt_t usart_pdid_settings = {
PDI_BAUD_RATE,
US_MR_CHRL_8_BIT,
US_MR_PAR_EVEN,
US_MR_NBSTOP_2_BIT,
US_MR_CHMODE_NORMAL
};
usart_init_sync_master(USART_PDI, &usart_pdid_settings, sysclk_get_main_hz());
/* Turn on clock */
gpio_configure_pin(PIN_PDIC_GPIO, PIN_PDIC_USART_FLAGS);
/* Send two IDLEs of 12 bits each to enable PDI interface (need at least 16 idle bits) */
XPROGTarget_SendIdle();
XPROGTarget_SendIdle();
}
/* Enables analog to digital conversion */
void adc_config(void)
{
pmc_enable_periph_clk(ID_ADC);
adc_init(ADC, sysclk_get_main_hz(), 20000000, 0);
adc_configure_timing(ADC, 0, 0, 0);
adc_set_resolution(ADC, ADC_MR_LOWRES);
adc_enable_channel(ADC, ADC_CHANNEL_10);
adc_configure_trigger(ADC, ADC_TRIG_SW, 0);
}
/**************************************************************************
Initializes the analog pins.
**************************************************************************/
int analogInit(void)
{
pmc_enable_periph_clk(ID_ADC);
adc_init(ADC,sysclk_get_main_hz(),1000000,8);
adc_configure_timing(ADC,0,ADC_SETTLING_TIME_3,1);
adc_set_resolution(ADC,ADC_MR_LOWRES_BITS_12);
adc_enable_channel(ADC,ADC_CHANNEL_7);
adc_enable_channel(ADC,ADC_CHANNEL_6);
adc_enable_channel(ADC,ADC_CHANNEL_5);
adc_configure_trigger(ADC,ADC_TRIG_SW,0);
}
/*
* Initializing A/D conversion.
*/
void adc_setup(void)
{
/* Enable the specified peripheral clock (ADC clock).
If function returns 0, then we can proceed... */
pmc_enable_periph_clk(ID_ADC);
/* init A/D conversion */
adc_init(ADC, sysclk_get_main_hz(), ADC_CLOCK, 8);
/* configure timing for A/D conversion */
adc_configure_timing(ADC, 0, ADC_SETTLING_TIME_3, 1);
/* set 12 bit resolution */
adc_set_resolution(ADC, ADC_MR_LOWRES_BITS_12);
/* enable ADC channel - specified in 'adc.h' */
/*adc_enable_channel(ADC, ADC_CHANNEL_LCDButtons);
adc_enable_channel(ADC, ADC_CHANNEL_Tank1);
adc_enable_channel(ADC, ADC_CHANNEL_Tank2);*/
ADC->ADC_CHER = 3200;
/* configure conversion to be triggered by software */
adc_configure_trigger(ADC, ADC_TRIG_SW, 0);
/* indicate everything's OK! */
}
/**
* \brief Main application function.
*
* Start the sensor task then start the scheduler.
*
* \return program return value.
*/
int main(void)
{
#if SAMD21
system_init();
#elif SAME70
sysclk_init();
board_init();
#endif
/* Initialize the UART console. */
configure_console();
/* Initialize the delay driver. */
delay_init();
/* Enable SysTick interrupt for non busy wait delay. */
#if SAMD21
if (SysTick_Config(system_cpu_clock_get_hz()/1000)) {
puts("main: SysTick configuration error!");
while (1);
}
#elif SAME70
if (SysTick_Config(sysclk_get_main_hz()/1000)) {
puts("main: SysTick configuration error!");
while (1);
}
#endif
/* Output example information */
puts(STRING_HEADER);
/* Start the demo task. */
demo_start();
return 0;
}
/**
* \brief Test data read/write API functions.
*
* This test calls the data read/write API functions and check the data consistency.
*
* \param test Current test case.
*/
static void run_test_data_read_write(const struct test_case *test)
{
twi_options_t opt;
uint8_t data;
/* Configure the options of TWI driver */
opt.master_clk = sysclk_get_main_hz();
opt.speed = AT24C_TWI_CLK;
if (twi_master_init(BOARD_AT24C_TWI_INSTANCE, &opt) != TWI_SUCCESS) {
puts("AT24CXX initialization is failed.\r");
}
if (at24cxx_write_byte(AT24C_MEM_ADDR, 0xA5) != AT24C_WRITE_SUCCESS) {
puts("AT24CXX write packet is failed.\r");
}
mdelay(10);
if (at24cxx_read_byte(AT24C_MEM_ADDR, &data) != AT24C_READ_SUCCESS) {
puts("AT24CXX read packet is failed.\r");
}
test_assert_true(test, data == 0xA5, "Data is not consistent!");
}
int analogInit(int pinNumber)
{
/*
* The pin number is the analog input pin on the DUe board, see http://www.arduino.cc/en/Hacking/PinMappingSAM3X
* Obviously it starts at analog 0 which is equivalent to the analog input on PA16
* so you need to figure out which AD channel this corresponds to
*
* See code example http://asf.atmel.com/docs/latest/sam.drivers.adc.adc_example.arduino_due_x/html/sam_adc_quickstart.html
* It is assumed that the AD-converter is using 12 bits
*/
pmc_enable_periph_clk(ID_ADC); /* power the clock for the ADC with pmc_enable_periph_clk(ID_ADC) */
adc_init(ADC,sysclk_get_main_hz(),1000000,8);
adc_configure_timing(ADC,0,ADC_SETTLING_TIME_3,1);
adc_set_resolution(ADC,ADC_MR_LOWRES_BITS_12);
adc_enable_channel(ADC,ADC_CHANNEL_7);
//adc_enable_channel(ADC,ADC_CHANNEL_6);
adc_configure_trigger(ADC,ADC_TRIG_SW,0);
return 0; /* if everything is ok */
}
int main(void)
{
int rx_len;
irq_initialize_vectors();
cpu_irq_enable();
unsigned char ch;
// Initialize the sleep manager
sleepmgr_init();
#if !SAM0
sysclk_init();
board_init();
#else
system_init();
#endif
configure_console();
printf("\nUSB CDC\n");
printf("CPU:%dHz\n", sysclk_get_cpu_hz());
printf("sysclk_get_peripheral_hz:%dHz\n", sysclk_get_peripheral_hz());
printf("sysclk_get_main_hz:%dHz\n", sysclk_get_main_hz());
ui_init();
ui_powerdown();
// Start USB stack to authorize VBus monitoring
udc_start();
port_interrupt_disible();
// The main loop manages only the power mode
// because the USB management is done by interrupt
unsigned long input_count=0;
while (true) {
ch = port_inbyte(1);
if(! port_in_is_error())
{
if('c'== ch)
{
port_outbyte('C');
xmodemReceive((unsigned char *)0x2000, 0x100000);
}
else if('x'== ch)
{
port_outbyte('X');
xmodemTransmit((unsigned char *)0x2000, 0x100000);
}
else if('u'== ch)
{
port_outbyte('U');
}
else if('m'== ch)
{
for(int j=0; j<20; j++)
{
//printf("S 64MB");
port_outbyte('+');
for(int i=0; i <1024*1024/4; i++)
{
memcpy((void *)(0x60000000), (void *)0x60010000, 1024*4);
}
//printf("E 64MB ");
}
}
else if('T'== ch)
{
while(1)
{
//delay_us(1);
rx_len = port_read(test_rx_buf, rx_block_len, 1);
//crc16_ccitt(test_rx_buf,rx_block_len);
memcpy(&test_rx_buf[rx_block_len], &test_rx_buf[0], rx_block_len);
if(rx_len != rx_block_len)
break;
#if 0
for(int i=0;i<rx_bulk_len; i++)
{
if('T'!=test_rx_buf[i])
break;
}
#endif
input_count += rx_block_len;
if(0==(input_count&(1024-1)))
{
//port_outbyte('K');
}
if(0==(input_count&(1024*1024-1)))
{
port_outbyte('M');
}
}
}
}
else
{
delay_us(10);
}
//sleepmgr_enter_sleep();
}
}
void board_init(void)
{
ioport_init();
//SPI interface initialization
#ifdef CONF_SPI
//MISO
ioport_set_pin_peripheral_mode(PIN_PA21, IOPORT_MODE_MUX_A);
//MOSI
ioport_set_pin_peripheral_mode(PIN_PA22, IOPORT_MODE_MUX_A);
//SCK
ioport_set_pin_peripheral_mode(PIN_PA23, IOPORT_MODE_MUX_A);
//CS0
ioport_set_pin_peripheral_mode(PIN_PA24, IOPORT_MODE_MUX_A);
//CS1
ioport_set_pin_peripheral_mode(PIN_PA13, IOPORT_MODE_MUX_C);
//CS2
ioport_set_pin_peripheral_mode(PIN_PA14, IOPORT_MODE_MUX_C);
//CS3
ioport_set_pin_peripheral_mode(PIN_PB12, IOPORT_MODE_MUX_B);
spi_enable_clock(SPI);
spi_disable(SPI);
spi_reset(SPI);
spi_set_master_mode(SPI);
spi_disable_mode_fault_detect(SPI);
spi_disable_loopback(SPI);
spi_set_variable_peripheral_select(SPI);
spi_disable_peripheral_select_decode(SPI);
//spi_set_peripheral_chip_select_value(SPI, SPI_CHSEL);
//spi_set_transfer_delay(SPI, 1, 50, 0);
//spi_set_delay_between_chip_select(SPI, 0);
for(char i = 0; i < 4; i++){
spi_set_bits_per_transfer(SPI, i, 8);
//spi_set_baudrate_div(SPI, i, spi_calc_baudrate_div(1000000, sysclk_get_cpu_hz()));
spi_set_baudrate_div(SPI, i, (sysclk_get_cpu_hz() / 500000));
spi_configure_cs_behavior(SPI, i, SPI_CS_KEEP_LOW);
spi_set_clock_polarity(SPI, i, 0);
spi_set_clock_phase(SPI, i, 0);
}
spi_enable(SPI);
#endif
//USART0 initialization
#ifdef CONF_USART0
//USART0 RXD
ioport_set_pin_peripheral_mode(PIN_PA11, IOPORT_MODE_MUX_A);
#if SAM4L
sysclk_enable_peripheral_clock(USART0);
#endif
//USART0 configuration struct
const sam_usart_opt_t usart0_console_settings = {
CONF_USART_0_BAUDRATE,
CONF_USART_0_CHAR_LENGTH,
CONF_USART_0_PARITY,
CONF_USART_0_STOP_BITS,
US_MR_CHMODE_NORMAL
};
usart_init_rs232(USART0, &usart0_console_settings, sysclk_get_main_hz());
usart_enable_tx(USART0);
usart_enable_rx(USART0);
usart_enable_interrupt(USART0, US_IER_RXRDY);
NVIC_SetPriority(USART0_IRQn, 10);
NVIC_EnableIRQ(USART0_IRQn);
#endif
//USART1 initialization
#ifdef CONF_USART1
//USART1 TXD
ioport_set_pin_peripheral_mode(PIN_PA16, IOPORT_MODE_MUX_A);
//USART1 RXD
ioport_set_pin_peripheral_mode(PIN_PA15, IOPORT_MODE_MUX_A);
#if SAM4L
sysclk_enable_peripheral_clock(USART1);
#endif
//USART1 configuration struct
const sam_usart_opt_t usart1_console_settings = {
CONF_USART_1_BAUDRATE,
CONF_USART_1_CHAR_LENGTH,
CONF_USART_1_PARITY,
CONF_USART_1_STOP_BITS,
US_MR_CHMODE_NORMAL
};
usart_init_rs232(USART1, &usart1_console_settings, sysclk_get_main_hz());
usart_enable_tx(USART1);
usart_enable_rx(USART1);
usart_enable_interrupt(USART1, US_IER_RXRDY);
//NVIC_SetPriority(USART0_IRQn, 10);
NVIC_EnableIRQ(USART1_IRQn);
#endif
#ifdef CONF_TWIMS1
//SDA
ioport_set_pin_peripheral_mode(PIN_PB00, IOPORT_MODE_MUX_A);
//SCL
ioport_set_pin_peripheral_mode(PIN_PB01, IOPORT_MODE_MUX_A);
/* Set TWIM options */
uint32_t cpu_speed = 0;
cpu_speed = sysclk_get_peripheral_bus_hz(EXAMPLE_TWIM);
struct twim_config opts = {
.twim_clk = sysclk_get_cpu_hz(), //Importante
.speed = TWIM_MASTER_SPEED,
.hsmode_speed = 0,
.data_setup_cycles = 0,
.hsmode_data_setup_cycles = 0,
.smbus = false,
.clock_slew_limit = 0,
.clock_drive_strength_low = 0,
.data_slew_limit = 0,
.data_drive_strength_low = 0,
.hs_clock_slew_limit = 0,
.hs_clock_drive_strength_high = 0,
.hs_clock_drive_strength_low = 0,
.hs_data_slew_limit = 0,
.hs_data_drive_strength_low = 0,
};
/* Initialize the TWIM Module */
twim_set_callback(EXAMPLE_TWIM, 0, twim_default_callback, 1);
twim_set_config(EXAMPLE_TWIM, &opts);
#endif
//ADS 1294R initialization
#ifdef CONF_ADS
ADS_ioconfig();
Soft_Reset_ADS1298();
delay_us(50);
Stop_Read_Data_Continuous();
/*Configuration register 1*/
ADS1298_SPI_Address_Byte_Count(WRITE_CONFIG_1_REGISTER , SINGLE_BYTE);
ADS1298_SPI_Data(0x06);
/*Configuration register 2*/
ADS1298_SPI_Address_Byte_Count(WRITE_CONFIG_2_REGISTER , SINGLE_BYTE);
ADS1298_SPI_Data(0x00);
/*Configuration register 3*/
ADS1298_SPI_Address_Byte_Count(WRITE_CONFIG_3_REGISTER , SINGLE_BYTE);
ADS1298_SPI_Data(0xDC);
/*Channel 1 register*/
ADS1298_SPI_Address_Byte_Count(WRITE_CHANNEL_1_SET_REGISTER, SINGLE_BYTE);
ADS1298_SPI_Data(0x00);
/*Channel 2 register*/
ADS1298_SPI_Address_Byte_Count(WRITE_CHANNEL_2_SET_REGISTER , SINGLE_BYTE);
ADS1298_SPI_Data(0x00);
/*Channel 3 register*/
ADS1298_SPI_Address_Byte_Count(WRITE_CHANNEL_3_SET_REGISTER , SINGLE_BYTE);
ADS1298_SPI_Data(0x00);
/*RLD_SENSP register*/
ADS1298_SPI_Address_Byte_Count(WRITE_RIGHT_LEG_DRIVE_SENSE_POSITIVE_REGISTER, SINGLE_BYTE);
ADS1298_SPI_Data(0x0F);
/*RLD_SENSN register*/
ADS1298_SPI_Address_Byte_Count(WRITE_RIGHT_LEG_DRIVE_SENSE_NEGATIVE_REGISTER, SINGLE_BYTE);
ADS1298_SPI_Data(0x0F);
/*Respiration control register*/
//Respiration channel not enabled
#endif
}
