uint32 inittestapplication(void) {
uint32 devID;
instanceConfig_t instConfig;
int i, result;
SPI_ConfigFastRate(SPI_BaudRatePrescaler_16); //max SPI before PLLs configured is ~4M
i = 10;
//this is called here to wake up the device (i.e. if it was in sleep mode before the restart)
devID = instancereaddeviceid();
printf("devID %08X\r\n", devID);
//if the read of devide ID fails, the DW1000 could be asleep
if (DWT_DEVICE_ID != devID) {
// port_SPIx_clear_chip_select(); //CS low
// Sleep(1); //200 us to wake up then waits 5ms for DW1000 XTAL to stabilise
// port_SPIx_set_chip_select(); //CS high
// Sleep(7);
printf("asleep...wakeup!\r\n");
pio_set_pin_high(DW_WAKEUP_PIO_IDX);
Sleep(1);
pio_set_pin_low(DW_WAKEUP_PIO_IDX);
Sleep(7);
devID = instancereaddeviceid();
printf("devID %08X\r\n", devID);
// SPI not working or Unsupported Device ID
if (DWT_DEVICE_ID != devID) {
return (-1);
}
//clear the sleep bit - so that after the hard reset below the DW does not go into sleep
dwt_softreset();
}
//reset the DW1000 by driving the RSTn line low
reset_DW1000();
result = instance_init();
if (0 > result)
return (-2); // Some failure has occurred
SPI_ConfigFastRate(SPI_BaudRatePrescaler_4); //increase SPI to max
devID = instancereaddeviceid();
printf("devID %08X\r\n", devID);
if (DWT_DEVICE_ID != devID) // Means it is NOT MP device
{
// SPI not working or Unsupported Device ID
return (-3);
}
if (is_tag) {
instance_mode = TAG;
led_on(LED_PC7);
} else {
instance_mode = ANCHOR;
#if (DR_DISCOVERY == 1)
led_on(LED_PC6);
#else
if(instance_anchaddr & 0x1)
led_on(LED_PC6);
if(instance_anchaddr & 0x2)
led_on(LED_PC7);
#endif
}
instancesetrole(instance_mode); // Set this instance role
if (use_fast2wr) //if fast ranging then initialise instance for fast ranging application
{
instance_init_f(instance_mode); //initialise Fast 2WR specific data
//when using fast ranging the channel config is either mode 2 or mode 6
//default is mode 2
dr_mode = decarangingmode();
if ((dr_mode & 0x1) == 0)
dr_mode = 1;
} else {
instance_init_s(instance_mode);
dr_mode = decarangingmode();
}
instConfig.channelNumber = chConfig[dr_mode].channel;
instConfig.preambleCode = chConfig[dr_mode].preambleCode;
instConfig.pulseRepFreq = chConfig[dr_mode].prf;
instConfig.pacSize = chConfig[dr_mode].pacSize;
instConfig.nsSFD = chConfig[dr_mode].nsSFD;
instConfig.sfdTO = chConfig[dr_mode].sfdTO;
instConfig.dataRate = chConfig[dr_mode].datarate;
instConfig.preambleLen = chConfig[dr_mode].preambleLength;
instance_config(&instConfig); // Set operating channel etc
#if (DR_DISCOVERY == 0)
addressconfigure(); // set up initial payload configuration
#endif
instancesettagsleepdelay(POLL_SLEEP_DELAY, BLINK_SLEEP_DELAY); //set the Tag sleep time
//if TA_SW1_2 is on use fast ranging (fast 2wr)
if (use_fast2wr) {
//Fast 2WR specific config
//configure the delays/timeouts
instance_config_f();
} else //use default ranging modes
{
// NOTE: this is the delay between receiving the blink and sending the ranging init message
// The anchor ranging init response delay has to match the delay the tag expects
// the tag will then use the ranging response delay as specified in the ranging init message
// use this to set the long blink response delay (e.g. when ranging with a PC anchor that wants to use the long response times != 150ms)
if (use_long_blink_delay) {
instancesetblinkreplydelay(FIXED_LONG_BLINK_RESPONSE_DELAY);
} else //this is for ARM to ARM tag/anchor (using normal response times 150ms)
{
instancesetblinkreplydelay(FIXED_REPLY_DELAY);
}
//set the default response delays
instancesetreplydelay(FIXED_REPLY_DELAY, 0);
}
// return devID;
return 0;
}
/**
* \brief usart_rs485 Application entry point.
*
* Configure USART in RS485 mode. If the application starts earlier, it acts
* as a receiver. Otherwise, it should be a transmitter.
*
* \return Unused (ANSI-C compatibility).
*/
int main(void)
{
static uint8_t uc_sync = SYNC_CHAR;
uint32_t time_elapsed = 0;
uint32_t ul_i;
/* Initialize the SAM system. */
sysclk_init();
board_init();
/* Configure UART for debug message output. */
configure_console();
/* Output example information. */
puts(STRING_HEADER);
/* Configure USART. */
configure_usart();
/* Get board USART PDC base address and enable receiver and transmitter. */
g_p_pdc = usart_get_pdc_base(BOARD_USART);
pdc_enable_transfer(g_p_pdc, PERIPH_PTCR_RXTEN | PERIPH_PTCR_TXTEN);
/* 1ms tick. */
configure_systick();
/* Initialize receiving buffer to distinguish with the sent frame. */
memset(g_uc_receive_buffer, 0x0, BUFFER_SIZE);
/*
* Enable transmitter here, and disable receiver first, to avoid receiving
* characters sent by itself. It's necessary for half duplex RS485.
*/
usart_enable_tx(BOARD_USART);
usart_disable_rx(BOARD_USART);
/* Send a sync character XON (0x11). */
g_st_packet.ul_addr = (uint32_t)&uc_sync;
g_st_packet.ul_size = 1;
pdc_tx_init(g_p_pdc, &g_st_packet, NULL);
/* Delay until the line is cleared, an estimated time used. */
wait(50);
/* Read the acknowledgement. */
g_st_packet.ul_addr = (uint32_t)&uc_sync;
g_st_packet.ul_size = 1;
pdc_rx_init(g_p_pdc, &g_st_packet, NULL);
/* Then enable receiver. */
usart_enable_rx(BOARD_USART);
/* Wait until time out or acknowledgement is received. */
time_elapsed = get_tick_count();
while (!usart_is_rx_buf_end(BOARD_USART)) {
if (get_tick_count() - time_elapsed > TIMEOUT) {
break;
}
}
/* If acknowledgement received in a short time. */
if (usart_is_rx_buf_end(BOARD_USART)) {
/* Acknowledgement. */
if (uc_sync == ACK_CHAR) {
/* Act as transmitter, start transmitting. */
g_state = TRANSMITTING;
puts("-I- Start transmitting!\r");
g_st_packet.ul_addr = (uint32_t)g_uc_transmit_buffer;
g_st_packet.ul_size = PDC_BUF_SIZE;
pdc_tx_init(g_p_pdc, &g_st_packet, NULL);
/* Enable transmitting interrupt. */
usart_enable_interrupt(BOARD_USART, US_IER_ENDTX);
}
} else {
/* Start receiving, act as receiver. */
g_st_packet.ul_addr = (uint32_t)&uc_sync;
g_st_packet.ul_size = 1;
pdc_rx_init(g_p_pdc, &g_st_packet, NULL);
puts("-I- Receiving sync character.\r");
while (!usart_is_rx_buf_end(BOARD_USART)) {
}
/* Sync character is received. */
if (uc_sync == SYNC_CHAR) {
/* SEND XOff as acknowledgement. */
uc_sync = ACK_CHAR;
/*
* Delay to prevent the character from being discarded by
* transmitter due to responding too soon.
*/
wait(100);
pio_set_pin_high(PIN_RE_IDX);
g_st_packet.ul_addr = (uint32_t)&uc_sync;
g_st_packet.ul_size = 1;
pdc_tx_init(g_p_pdc, &g_st_packet, NULL);
g_state = RECEIVING;
puts("-I- Start receiving!\r");
g_st_packet.ul_addr = (uint32_t)g_uc_receive_buffer;
g_st_packet.ul_size = PDC_BUF_SIZE;
pdc_rx_init(g_p_pdc, &g_st_packet, NULL);
pio_set_pin_low(PIN_RE_IDX);
/* Enable receiving interrupt. */
usart_enable_interrupt(BOARD_USART, US_IER_ENDRX);
}
}
while (g_state != RECEIVED) {
}
ul_i = 0;
/* Print received frame out. */
while ((ul_i < BUFFER_SIZE) && (g_uc_receive_buffer[ul_i] != '\0')) {
if (g_uc_transmit_buffer[ul_i] != g_uc_receive_buffer[ul_i]) {
puts("-E- Error occurred while receiving!\r");
/* Infinite loop here. */
while (1) {
}
}
ul_i++;
}
puts("-I- Received successfully!\r");
while (1) {
}
}
/**
* \brief pio_capture Application entry point.
*
* \return Unused (ANSI-C compatibility).
*
*/
int main(void)
{
uint8_t uc_i;
uint8_t uc_flag;
uint32_t ul_mode;
uint8_t uc_key;
static uint8_t uc_rx_even_only;
static uint8_t uc_tx_without_en;
/* Initialize the SAM system. */
sysclk_init();
board_init();
/* Configure UART for debug message output. */
configure_console();
/* Configure PIOA clock. */
pmc_enable_periph_clk(ID_PIOA);
/* Output example information. */
puts(STRING_HEADER);
printf("Frequency: %d MHz.\r\n",
(uint8_t) (sysclk_get_cpu_hz() / 1000000));
puts("Press r to Receive data on PIO Parallel Capture.\r\n");
puts("Press s to Send data on PIO Parallel Capture.\r\n");
uc_key = 0;
while ((uc_key != 'r') && (uc_key != 's')) {
uart_read(CONSOLE_UART, &uc_key);
}
if (uc_key == 'r') {
puts("** RECEIVE mode **\r\n");
/* Set up PDC receive buffer, waiting for 64 bytes. */
packet_t.ul_addr = (uint32_t) pio_rx_buffer;
packet_t.ul_size = SIZE_BUFF_RECEPT;
p_pdc = pio_capture_get_pdc_base(PIOA);
pdc_rx_init(p_pdc, &packet_t, NULL);
/* Disable all PIOA I/O line interrupt. */
pio_disable_interrupt(PIOA, 0xFFFFFFFF);
/* Configure and enable interrupt of PIO. */
NVIC_DisableIRQ(PIOA_IRQn);
NVIC_ClearPendingIRQ(PIOA_IRQn);
NVIC_SetPriority(PIOA_IRQn, PIO_IRQ_PRI);
NVIC_EnableIRQ(PIOA_IRQn);
/* Configure the PIO capture interrupt mask. */
pio_capture_enable_interrupt(PIOA,
(PIO_PCIER_ENDRX | PIO_PCIER_RXBUFF));
/* Enable PDC transfer. */
pdc_enable_transfer(p_pdc, PERIPH_PTCR_RXTEN);
/* Clear Receive buffer. */
for (uc_i = 0; uc_i < SIZE_BUFF_RECEPT; uc_i++) {
pio_rx_buffer[uc_i] = 0;
}
/* Initialize PIO capture mode value. */
ul_mode = 0;
/* Set up the parallel capture mode data size as 8 bits. */
ul_mode |= 0 << PIO_PCMR_DSIZE_Pos;
puts("Press y to sample the data when both data enable pins are enabled.\r\n");
puts("Press n to sample the data, don't care the status of the data enable pins.\r\n");
uc_key = 0;
while ((uc_key != 'y') && (uc_key != 'n')) {
uart_read(CONSOLE_UART, &uc_key);
}
if (uc_key == 'y') {
/* Sample the data when both data enable pins are enabled. */
ul_mode &= ~PIO_PCMR_ALWYS;
puts("Receive data when both data enable pins are enabled.\r\n");
} else {
/* Sample the data, don't care the status of the data enable pins. */
ul_mode |= PIO_PCMR_ALWYS;
puts("Receive data, don't care the status of the data enable pins.\r\n");
}
puts("Press y to sample all the data\r\n");
puts("Press n to sample the data only one out of two.\r\n");
uc_key = 0;
while ((uc_key != 'y') && (uc_key != 'n')) {
uart_read(CONSOLE_UART, &uc_key);
}
if (uc_key == 'y') {
/* Sample all the data. */
ul_mode &= ~PIO_PCMR_HALFS;
puts("All data are sampled.\r\n");
} else {
/* Sample the data only one out of two. */
ul_mode |= PIO_PCMR_HALFS;
/* Only if half-Sampling is set, data with an even index are sampled. */
ul_mode &= ~PIO_PCMR_FRSTS;
puts("Only one out of two data is sampled, with an even index.\r\n");
}
while (1) {
/* Initialize PIO Parallel Capture function. */
g_uc_cbk_received = 0;
pio_capture_set_mode(PIOA, ul_mode);
pio_capture_enable(PIOA);
puts("Waiting...\r\n");
while (g_uc_cbk_received == 0) {
}
}
} else if (uc_key == 's') {
puts("** SEND mode **\r\n");
puts("This is for debug purpose only !\r\n");
puts("Frequency of PIO controller clock must be strictly superior");
puts("to 2 times the frequency of the clock of the device which");
puts(" generates the parallel data.\r\n");
puts("\r\nPlease connect the second board, ");
puts("and put it in receive mode.\r\n");
/* Configure PIO Parallel Capture pins which simulate as a sensor. */
pio_configure_pin_group(PIOA, PIO_CAPTURE_ALL_PIN_MSK,
PIO_CAPTURE_PIN_FLAGS);
/* Enable sync. output data. */
pio_enable_output_write(PIOA, PIO_CAPTURE_DATA_PINS_MASK);
/* Initialize the capture data line. */
pio_sync_output_write(PIOA, 0);
puts("Press y to send data with data enable pins.\r\n");
puts("Press n to send data without data enable pins.\r\n");
uc_key = 0;
while ((uc_key != 'y') && (uc_key != 'n')) {
uart_read(CONSOLE_UART, &uc_key);
}
if (uc_key == 'y') {
uc_tx_without_en = 0;
puts("Send data with both data enable pins enabled.\r\n");
} else {
uc_tx_without_en = 1;
puts("Send data without enabling the data enable pins.\r\n");
}
puts("Press y to indicate that receiver samples all data.\r\n");
puts("Press n to indicate that receiver samples data with an even index.\r\n");
uc_key = 0;
while ((uc_key != 'y') && (uc_key != 'n')) {
uart_read(CONSOLE_UART, &uc_key);
}
if (uc_key == 'y') {
uc_rx_even_only = 0;
puts("Receiver samples all data.\r\n");
} else {
uc_rx_even_only = 1;
puts("Receiver samples data with an even index.\r\n");
}
uc_flag = 0;
while (1) {
if (uc_tx_without_en) {
puts("\r\nSend data without enabling the data enable pins.\r\n");
} else {
puts("\r\nSend data with both data enable pins enabled.\r\n");
}
if (!uc_tx_without_en) {
/* Set enable pins. */
pio_set_pin_high(PIO_CAPTURE_EN1_IDX);
pio_set_pin_high(PIO_CAPTURE_EN2_IDX);
}
for (uc_i = 0; uc_i < SIZE_BUFF_RECEPT;) {
/* Send data. */
pio_sync_output_write(PIOA,
(uc_i << PIO_CAPTURE_DATA_POS));
/* Set clock. */
pio_set_pin_high(PIO_CAPTURE_CCLK_IDX);
wait(50);
/* Clear clock. */
pio_set_pin_low(PIO_CAPTURE_CCLK_IDX);
wait(50);
if (uc_rx_even_only) {
if (!uc_flag) {
uc_flag = 1;
} else {
uc_i++;
uc_flag = 0;
}
} else {
uc_i++;
}
}
if (!uc_tx_without_en) {
/* Clear enable pins. */
pio_set_pin_low(PIO_CAPTURE_EN1_IDX);
pio_set_pin_low(PIO_CAPTURE_EN2_IDX);
}
puts("Press a key.\r\n");
while (uart_read(CONSOLE_UART, &uc_key)) {
}
}
}
return 0;
}
