/**
* \brief Test checking different registers of the USART module
*
* This function calls the different check functions and make sure they set the
* correct values.
*
* \param test Current test case.
*/
static void run_check_registers_test(const struct test_case *test)
{
bool success;
uint8_t data = 'b';
const usart_rs232_options_t options = {
.baudrate = CONF_UNIT_BAUDRATE,
.charlength = CONF_UNIT_CHARLENGTH,
.paritytype = CONF_UNIT_PARITY,
.stopbits = CONF_UNIT_STOPBITS
};
usart_init_rs232(&CONF_UNIT_USART, &options);
/* Test empty data register */
success = usart_data_register_is_empty(&CONF_UNIT_USART);
test_assert_true(test, success,
"Checking if the data register is empty failed");
/* Test finished data transfers */
usart_put(&CONF_UNIT_USART, data);
for(volatile uint16_t delay=0;delay<20000;delay++);
success = usart_rx_is_complete(&CONF_UNIT_USART);
usart_get(&CONF_UNIT_USART);
test_assert_true(test, success,
"Checking if the receive is finished failed");
success = usart_tx_is_complete(&CONF_UNIT_USART);
test_assert_true(test, success,
"Checking if the transmit is finished failed");
}
/**
* \brief Receive a data with the USART module
*
* This function returns the received data from the USART module.
*
* \param usart The USART module.
*
* \return The received data.
*/
uint8_t usart_getchar(USART_t *usart)
{
while (usart_rx_is_complete(usart) == false) {
}
return ((uint8_t)(usart)->DATA);
}
/**
* \internal
* \brief Helper function to read a byte from an arbitrary interface
*
* This function is used to hide what interface is used by the component
* driver, e.g. the component driver does not need to know if USART in SPI
* mode is used or the native SPI module.
*
* \retval uint8_t Byte of data read from the display controller
*/
__always_inline static uint8_t ili9341_read_byte(void)
{
uint8_t data;
#if defined(CONF_ILI9341_USART_SPI)
# if XMEGA
/* Workaround for clearing the RXCIF for XMEGA */
usart_rx_enable(CONF_ILI9341_USART_SPI);
usart_put(CONF_ILI9341_USART_SPI, 0xFF);
while (!usart_rx_is_complete(CONF_ILI9341_USART_SPI)) {
/* Do nothing */
}
data = usart_get(CONF_ILI9341_USART_SPI);
/* Workaround for clearing the RXCIF for XMEGA */
usart_rx_disable(CONF_ILI9341_USART_SPI);
# else
usart_spi_read_single(CONF_ILI9341_USART_SPI, &data);
# endif
#elif defined(CONF_ILI9341_SPI)
spi_write_single(CONF_ILI9341_SPI, 0xFF);
ili9341_wait_for_send_done();
/* Wait for RX to complete */
while (!spi_is_rx_full(CONF_ILI9341_SPI)) {
/* Do nothing */
}
spi_read_single(CONF_ILI9341_SPI, &data);
#endif
return data;
}
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 Averaging Example --\n\r");
printf("-- Compiled: %s %s --\n\r\n\r", __DATE__, __TIME__);
printf("Commands:\n\r");
printf("- key 'a' to enable averaging\n\r");
printf("- key 'd' to disable averaging\n\r");
/* ADC initialization */
main_adc_init();
main_adc_averaging_stop();
while (1) {
if (usart_rx_is_complete(CONF_TEST_USART)) {
char key = getchar();
if (key == 'a') {
main_adc_averaging_start();
}
if (key == 'd') {
main_adc_averaging_stop();
}
}
/* Wait sample with or without average */
uint16_t sample;
adc_wait_for_interrupt_flag(&ADCA, ADC_CH0);
sample = adc_get_unsigned_result(&ADCA, ADC_CH0);
printf("ADC Value: %4u\r", sample);
}
}
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 --\n\r");
printf("-- Compiled: %s %s --\n\r\n\r", __DATE__, __TIME__);
/* ADC initializations */
main_adc_init();
printf("Commands:\n\r");
printf("- key 'c' to enable correction\n\r");
printf("- key 'd' to disable correction\n\r");
main_adc_correction_stop();
while (1) {
if (usart_rx_is_complete(CONF_TEST_USART)) {
char key = getchar();
if (key == 'c') {
main_adc_correction_start();
}
if (key == 'd') {
main_adc_correction_stop();
}
}
printf(" %4d mV\r", main_adc_input());
}
}
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,
};
char binary[16 + 1];
uint8_t i;
bool oversampling_is_enabled;
/* 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 Over-sampling Example --\n\r");
printf("-- Compiled: %s %s --\n\r\n\r", __DATE__, __TIME__);
printf("Commands:\n\r");
printf("- key 'o' to enable over-sampling\n\r");
printf("- key 'd' to disable over-sampling\n\r");
/* ADC initializations */
main_adc_init();
main_adc_oversampling_stop();
oversampling_is_enabled = false;
while (1) {
if (usart_rx_is_complete(CONF_TEST_USART)) {
char key = getchar();
if (key == 'o') {
main_adc_oversampling_start();
oversampling_is_enabled = true;
}
if (key == 'd') {
main_adc_oversampling_stop();
oversampling_is_enabled = false;
}
}
/* Wait sample with or without over-sampling */
uint16_t sample;
adc_wait_for_interrupt_flag(&ADCA, ADC_CH0);
sample = adc_get_unsigned_result(&ADCA, ADC_CH0);
if (!oversampling_is_enabled) {
sample <<= 4;
}
i = 15;
do {
binary[i] = '0' + (sample & 1);
sample >>= 1;
} while (i--);
binary[16] = 0;
printf("ADC Value: %sb\r", binary);
}
}
/**
* \brief Main application routine
* - Configure system clock
* - Call QDec driver API to configure it and enable it
* - Call generator of quadrature encoder
* - Get position, direction and frequency and display its
*/
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,
};
qdec_config_t config;
uint16_t qdec_position, qdec_position_prev = 0;
uint32_t generator_qenc_freq = 2000 / QUADRATURE_RESOLUTION;
bool generator_qenc_dir = true;
/* 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-- QDec Example --\n\r");
printf("-- Compiled: %s %s --\n\r\n\r", __DATE__, __TIME__);
/* QDec configuration
* Here, we use the default hardware ressources
* proposed by default configuration.
*/
qdec_get_config_defaults(&config);
qdec_config_phase_pins(&config, CONF_QDEC_PORT, CONF_QDEC_PINS_BASE,
false, 1);
qdec_config_tc(&config, CONF_QDEC_TC);
qdec_config_enable_freq(&config, 1);
qdec_config_freq_tc(&config, CONF_QDEC_FREQ_TC);
qdec_config_revolution(&config, QUADRATURE_RESOLUTION);
/* QDec enable */
qdec_enabled(&config);
/* Generate quadrature encoder signals */
generator_qenc_enable(CONF_QDEC_PORT, CONF_QDEC_PINS_BASE,
CONF_GENERATOR_QENC_TC, QUADRATURE_RESOLUTION,
generator_qenc_freq, generator_qenc_dir);
while (1) {
/* read position */
qdec_position = qdec_get_position(&config);
if (qdec_position_prev != qdec_position) {
/* New position then display it */
qdec_position_prev = qdec_position;
printf("%02u", qdec_position);
/* display direction */
if (qdec_get_direction(&config)) {
printf(" ++");
} else {
printf(" --");
}
/* Display frequency */
printf(" %5umHz\r\n", qdec_get_frequency(&config));
}
/* Manage Quadrature encoder generator through UART */
if (usart_rx_is_complete(CONF_TEST_USART)) {
char key = getchar();
if (key == 'd') {
generator_qenc_dir = !generator_qenc_dir;
generator_qenc_set_direction(generator_qenc_dir);
}
if (key == '-') {
if (generator_qenc_freq > QUADRATURE_GENERATOR_FREQ_STEP) {
generator_qenc_freq -= QUADRATURE_GENERATOR_FREQ_STEP;
generator_qenc_set_freq(generator_qenc_freq);
}
}
if (key == '+') {
generator_qenc_freq += QUADRATURE_GENERATOR_FREQ_STEP;
generator_qenc_set_freq(generator_qenc_freq);
}
}
}
}
int bluetooth_is_rx_complete(void)
{
return usart_rx_is_complete(BLUETOOTH);
}
static uint8_t sim900_wait_data_on_usart(uint8_t seconds)
{
for(uint8_t d1=seconds;d1>0;--d1)
{
for(uint16_t d2=10000;d2>0;--d2)
{
#ifdef SIM900_USART_POLLED
if(usart_rx_is_complete(USART_GPRS)) {
#else
if(USART_RX_CBuffer_Data_Available(&sim900_usart_data)) {
#endif
return 0xFF;
}
delay_us(100);
}
}
debug_string(VERY_VERBOSE,PSTR("(sim900_wait_data_on_usart) timed-out\r\n"),PGM_STRING);
return 0;
}
static uint8_t sim900_read_string(char * const szBuf,uint8_t * const lenBuf)
{
const uint8_t ec = *lenBuf;
uint8_t l = 0;
uint8_t r = 0;
char c;
#ifndef SIM900_USART_POLLED
usart_buffer_flush(&sim900_usart_data);
#endif
while(1) {
if(!sim900_wait_data_on_usart(10)) {
debug_string(NORMAL,PSTR("(sim900_read_string) got timeout waiting for a character\r\n"),true);
r=1;
break;
}
#ifdef SIM900_USART_POLLED
c = usart_get(USART_GPRS);
#else
c = USART_RX_CBuffer_GetByte(&sim900_usart_data);
#endif
if(c=='\r') {
if(g_log_verbosity > NORMAL) usart_putchar(USART_DEBUG,'@');
} else if(c=='\n') {
if(g_log_verbosity > NORMAL) usart_putchar(USART_DEBUG,'#');
} else break;
}
if(r==0) while(l<ec) {
szBuf[l++] = c;
if(!sim900_wait_data_on_usart(10)) {
debug_string(NORMAL,PSTR("(sim900_read_string) got timeout waiting for a character\r\n"),true);
r=1;
break;
}
#ifdef SIM900_USART_POLLED
c = usart_get(USART_GPRS);
#else
c = USART_RX_CBuffer_GetByte(&sim900_usart_data);
#endif
if(c=='\r') {
//if(g_log_verbosity > NORMAL) usart_putchar(USART_DEBUG,'@');
break;
} else if(c=='\n') {
//if(g_log_verbosity > NORMAL) usart_putchar(USART_DEBUG,'#');
break;
}
//if(g_log_verbosity > NORMAL) usart_putchar(USART_DEBUG,'.');
}
if(ec==l) {
r = 2;
debug_string(NORMAL,PSTR("(sim900_read_string) Provided buffer is not big enough. Discarding chars\r\n"),true);
l -= 1;
}
szBuf[l] = 0;
//debug_string(VERBOSE,szBuf,RAM_STRING);
//debug_string(VERBOSE,szCRLF,PGM_STRING);
//debug_string(VERBOSE,PSTR("(sim900_read_string) out\r\n"),true);
*lenBuf = l;
return r;
}
static const char * sim900_wait4dictionary(const char * const dictionary[],uint8_t len)
{
uint8_t num = len;
const char * p[len];
#ifndef SIM900_USART_POLLED
usart_buffer_flush(&sim900_usart_data);
#endif
//debug_string(VERBOSE,PSTR("(sim900_wait4dictionary) IN\r\n"),true);
while(num--) {
p[num] = nvm_flash_read_word(dictionary+num);
}
while(1) {
if(!sim900_wait_data_on_usart(20)) {
debug_string(NORMAL,PSTR("(sim900_wait4dictionary) timeout waiting for sim900 response\r\n(sim900_wait4dictionary) OUT\r\n"),true);
return NULL;
}
#ifdef SIM900_USART_POLLED
const char c1 = usart_get(USART_GPRS);
#else
const char c1=USART_RX_CBuffer_GetByte(&sim900_usart_data);
#endif
for(uint8_t i=0;i<len;++i) {
const char c2 = nvm_flash_read_byte(p[i]);
if(c1!=c2)
{
p[i]=(char *) nvm_flash_read_word(dictionary+i);
continue;
}
p[i]++;
if(nvm_flash_read_byte(p[i])==0)
{
const char * const r = nvm_flash_read_word(dictionary+i);
//debug_string(VERY_VERBOSE,PSTR("(sim900_wait4dictionary) got: "),true);
//debug_string(VERY_VERBOSE,r,true);
//debug_string(VERY_VERBOSE,szCRLF,true);
//debug_string(NORMAL,PSTR("(sim900_wait4dictionary) OUT\r\n"),true);
return r;
}
}
}
}