int usart_get_echo_line(volatile avr32_usart_t *usart)
{
int rx_char;
int retval = USART_SUCCESS;
while (1)
{
rx_char = usart_getchar(usart);
if (rx_char == USART_FAILURE)
{
usart_write_line(usart, "Error!!!\n");
break;
}
if (rx_char == '\x03')
{
retval = USART_FAILURE;
break;
}
usart_putchar(usart, rx_char);
if (rx_char == '\r')
{
usart_putchar(usart, '\n');
break;
}
}
return retval;
}
static void sim900_put_string(const char * const sz,const uint8_t isPGM)
{
// debug_string(NORMAL,PSTR("(sim900_put_string) IN\r\n"),true);
const char * p = sz;
if(isPGM) {
while(1) {
const char c = nvm_flash_read_byte((flash_addr_t)p++);
if(0==c) break;
while (usart_data_register_is_empty(USART_GPRS) == false) {}
usart_put(USART_GPRS, c);
if(g_log_verbosity>NORMAL) usart_putchar(USART_DEBUG,c);
}
} else {
while(1) {
const char c = *p++;
if(0==c) break;
while (usart_data_register_is_empty(USART_GPRS) == false) {}
usart_put(USART_GPRS, c);
if(g_log_verbosity>NORMAL) usart_putchar(USART_DEBUG,c);
}
}
// debug_string(NORMAL,PSTR("(sim900_put_string) OUT\r\n"),true);
}
/*
* putchar which translates LF->CRLF
*/
int putchar(int c)
{
if (c == '\n')
usart_putchar(CONF_UART, '\r');
usart_putchar(CONF_UART, c);
return c;
}
int main(void)
{
//init the UART -- uart_init() is in uart.c
usart_init ( MYUBRR );
sei();
while(1)
{
// fixed input
unsigned char f00 = usart_getchar();
unsigned char f01 = usart_getchar();
unsigned char f10 = usart_getchar();
unsigned char f11 = usart_getchar();
fix0 = ((int)f00 << 8) + ((int)f01);
fix1 = ((int)f10 << 8) + ((int)f11);
// test multiply
prod = multfix(fix0, fix1) ;
unsigned char out0 = (unsigned char)((prod >> 8) & 0xFF);
unsigned char out1 = (unsigned char)(prod & 0xFF);
usart_putchar(out0);
usart_putchar(out1);
}
}
int io_getc(char *c)
{
int ci;
int status;
status = usart_read_char(&CONFIG_CONSOLE_PORT, &ci);
if (status == USART_RX_EMPTY)
return 1;
if (status == USART_RX_ERROR) {
CONFIG_CONSOLE_PORT.cr = AVR32_USART_CR_RSTSTA_MASK;
return 1;
}
/* Echo char. */
if (ci == '\r')
usart_putchar(&CONFIG_CONSOLE_PORT, '\n');
else if (ci == '\b'){
usart_putchar(&CONFIG_CONSOLE_PORT, ci);
usart_putchar(&CONFIG_CONSOLE_PORT, ' ');
usart_putchar(&CONFIG_CONSOLE_PORT, ci);
}
else
usart_putchar(&CONFIG_CONSOLE_PORT, ci);
*c = ci;
return 0;
}
void print_uart(char *buffer)
{
int i;
// for (i=0;i<strlen(buffer);i++)
for (i=0;buffer[i] != '\0' ;i++)
usart_putchar(buffer[i]);
usart_putchar(0x0D);
usart_putchar(0x0A);
}
void bm_print_clear(void)
{
usart_enable_tx(BM_USART_USART);
usart_putchar(BM_USART_USART, BM_MSG_START_PATTERN);
usart_putchar(BM_USART_USART, 3 /* length */);
usart_putchar(BM_USART_USART, BM_PRINT_CLEAR);
usart_putchar(BM_USART_USART, BM_MSG_STOP_PATTERN);
while (!usart_is_tx_empty(BM_USART_USART));
usart_disable_tx(BM_USART_USART);
}
void bm_pullup_twi(bool state)
{
usart_enable_tx(BM_USART_USART);
usart_putchar(BM_USART_USART, BM_MSG_START_PATTERN);
usart_putchar(BM_USART_USART, 4 /* length */);
usart_putchar(BM_USART_USART, BM_PULLUP_TWI);
usart_putchar(BM_USART_USART, state);
usart_putchar(BM_USART_USART, BM_MSG_STOP_PATTERN);
while (!usart_is_tx_empty(BM_USART_USART));
usart_disable_tx(BM_USART_USART);
}
void bm_mouse_pointer_ctrl(bool state)
{
usart_enable_tx(BM_USART_USART);
usart_putchar(BM_USART_USART, BM_MSG_START_PATTERN);
usart_putchar(BM_USART_USART, 4 /* length */);
usart_putchar(BM_USART_USART, BM_POINTER_CTRL);
usart_putchar(BM_USART_USART, state);
usart_putchar(BM_USART_USART, BM_MSG_STOP_PATTERN);
while (!usart_is_tx_empty(BM_USART_USART));
usart_disable_tx(BM_USART_USART);
}
void bm_led_tgl(uint32_t led)
{
usart_enable_tx(BM_USART_USART);
usart_putchar(BM_USART_USART, BM_MSG_START_PATTERN);
usart_putchar(BM_USART_USART, 4 /* length */);
usart_putchar(BM_USART_USART, BM_LED_TGL);
usart_putchar(BM_USART_USART, led);
usart_putchar(BM_USART_USART, BM_MSG_STOP_PATTERN);
while (!usart_is_tx_empty(BM_USART_USART));
usart_disable_tx(BM_USART_USART);
}
bool bm_get_mcu_current(uint32_t* sleep_mode, float* current)
{
uint32_t current_d;
uint32_t c;
usart_enable_tx(BM_USART_USART);
usart_putchar(BM_USART_USART, BM_MSG_START_PATTERN);
usart_putchar(BM_USART_USART, 4 /* length */);
usart_putchar(BM_USART_USART, BM_MCU_GET_CURRENT);
usart_putchar(BM_USART_USART, *sleep_mode);
usart_putchar(BM_USART_USART, BM_MSG_STOP_PATTERN);
while (!usart_is_tx_empty(BM_USART_USART));
usart_disable_tx(BM_USART_USART);
usart_enable_rx(BM_USART_USART);
// Check first caracter is start pattern
usart_getchar(BM_USART_USART, &c);
if (c == BM_MSG_STOP_PATTERN) {
usart_getchar(BM_USART_USART, &c);
}
if (c != BM_MSG_START_PATTERN) {
return false;
}
// Check second caracter is length
usart_getchar(BM_USART_USART, &c);
if (c != 8) {
return false;
}
// Check third caracter is Current Command
usart_getchar(BM_USART_USART, &c);
if (c != BM_MCU_RET_CURRENT) {
return false;
}
// Check third caracter is sleepmode
usart_getchar(BM_USART_USART, &c);
*sleep_mode = c;
// Then read current
usart_getchar(BM_USART_USART, &c);
current_d = c<<24;
usart_getchar(BM_USART_USART, &c);
current_d |= c<<16;
usart_getchar(BM_USART_USART, &c);
current_d |= c<<8;
usart_getchar(BM_USART_USART, &c);
current_d |= c;
*current = *(float*)& current_d;
// Check last caracter is stop pattern
usart_getchar(BM_USART_USART, &c);
if (c != BM_MSG_STOP_PATTERN) {
return false;
}
usart_disable_rx(BM_USART_USART);
return true;
}
bool bm_get_fifo_free_size(uint16_t* free_size)
{
uint32_t start, length, stop, cmd_id, c;
// Wait for some microseconds in order to avoid fifo overrun
//
delay_ms(20);
usart_enable_tx(BM_USART_USART);
usart_putchar(BM_USART_USART, BM_MSG_START_PATTERN);
usart_putchar(BM_USART_USART, 3 /* length */);
usart_putchar(BM_USART_USART, BM_MCU_GET_FIFO_FREE_SIZE);
usart_putchar(BM_USART_USART, BM_MSG_STOP_PATTERN);
while (!usart_is_tx_empty(BM_USART_USART));
usart_disable_tx(BM_USART_USART);
usart_enable_rx(BM_USART_USART);
// Check first character is start pattern
usart_getchar(BM_USART_USART, &start);
if (start == BM_MSG_STOP_PATTERN) {
usart_getchar(BM_USART_USART, &start);
}
if (start != BM_MSG_START_PATTERN) {
return false;
}
// Check second character is length
usart_getchar(BM_USART_USART, &length);
if (length != 5) {
return false;
}
// Check third character is Current Command
usart_getchar(BM_USART_USART, &cmd_id);
if (cmd_id != BM_MCU_RET_FIFO_FREE_SIZE) {
return false;
}
// Get Fifo free size
usart_getchar(BM_USART_USART, &c);
*free_size = c << 8;
usart_getchar(BM_USART_USART, &c);
*free_size |= c;
// Check last character is stop pattern
usart_getchar(BM_USART_USART, &stop);
if (stop != BM_MSG_STOP_PATTERN) {
return false;
}
usart_disable_rx(BM_USART_USART);
return true;
}
bool bm_get_firmware_version(uint8_t* fw_minor_version, uint8_t* fw_major_version)
{
uint32_t start, length, stop, cmd_id, c;
// Wait for some microseconds in order to avoid fifo overrun
//
delay_ms(20);
usart_enable_tx(BM_USART_USART);
usart_putchar(BM_USART_USART, BM_MSG_START_PATTERN);
usart_putchar(BM_USART_USART, 3 /* length */);
usart_putchar(BM_USART_USART, BM_GET_FIRMWARE_VERSION);
usart_putchar(BM_USART_USART, BM_MSG_STOP_PATTERN);
while (!usart_is_tx_empty(BM_USART_USART));
usart_disable_tx(BM_USART_USART);
usart_enable_rx(BM_USART_USART);
// Check first character is start pattern
usart_getchar(BM_USART_USART, &start);
if (start == BM_MSG_STOP_PATTERN) {
usart_getchar(BM_USART_USART, &start);
}
if (start != BM_MSG_START_PATTERN) {
return false;
}
// Check second character is length
usart_getchar(BM_USART_USART, &length);
if (length != 5) {
return false;
}
// Check third character is Current Command
usart_getchar(BM_USART_USART, &cmd_id);
if (cmd_id != BM_RET_FIRMWARE_VERSION) {
return false;
}
// Get Fifo free size
usart_getchar(BM_USART_USART, &c);
*fw_major_version = c;
usart_getchar(BM_USART_USART, &c);
*fw_minor_version = c;
// Check last character is stop pattern
usart_getchar(BM_USART_USART, &stop);
if (stop != BM_MSG_STOP_PATTERN) {
return false;
}
usart_disable_rx(BM_USART_USART);
return true;
}
void usart_hex(unsigned char c){
#define HI(b) ((b>>4) & 0xf)
#define LO(b) (b & 0xf)
#define HE(b) (((b & 0x7)-1) | 0x40)
if (HI(c)>9)
usart_putchar(HE(HI(c)));
else
usart_putchar(0x30 | HI(c));
if (LO(c)>9)
usart_putchar(HE(LO(c)));
else
usart_putchar(0x30 | LO(c));
}
void bm_tgl_button(uint32_t timeout_ms)
{
usart_enable_tx(BM_USART_USART);
usart_putchar(BM_USART_USART, BM_MSG_START_PATTERN);
usart_putchar(BM_USART_USART, 7 /* length */);
usart_putchar(BM_USART_USART, BM_TGL_BUTTON);
usart_putchar(BM_USART_USART, timeout_ms & 0xff);
usart_putchar(BM_USART_USART, (timeout_ms >> 8 ) & 0xff);
usart_putchar(BM_USART_USART, (timeout_ms >> 16) & 0xff);
usart_putchar(BM_USART_USART, timeout_ms >> 24);
usart_putchar(BM_USART_USART, BM_MSG_STOP_PATTERN);
while (!usart_is_tx_empty(BM_USART_USART));
usart_disable_tx(BM_USART_USART);
}
void usart_init(void)
{
const uint16_t ubbr = 2000000UL / (2 * BAUD) - 1;
UBRR1H = ubbr >> 8;
UBRR1L = ubbr;
UCSR1B = (1<<RXEN1) | (1<<TXEN1);
/* 8 data bits, 1 stop bit */
UCSR1C = (1<<UCSZ11) | (1<<UCSZ10);
DDRD |= 1<<1;
usart_putchar('A', NULL);
usart_putchar('\n', NULL);
}
/*
Start the serial module to play the
strings via USART serail communication
*/
static void play_serial()
{
uint8_t recieved_byte;
bool canContinue = true;
while(canContinue) {
recieved_byte = usart_getchar(USART_SERIAL);
usart_putchar(USART_SERIAL, recieved_byte);
switch(recieved_byte) {
case '6':
solenoid_high_low(STRING_SIX);
break;
case '5':
solenoid_high_low(STRING_FIVE);
break;
case '4':
solenoid_high_low(STRING_FOUR);
break;
case '3':
solenoid_high_low(STRING_THREE);
break;
case '2':
solenoid_high_low(STRING_TWO);
break;
case '1':
solenoid_high_low(STRING_ONE);
break;
case '0':
canContinue = false;
break;
}
}
}
void BUFFERED_SIO_SendHandler (void)
{
// Something to send ?
if (BUFFERED_SIO_TxBuffer_StartPointer == BUFFERED_SIO_TxBuffer_EndPointer)
{
return;
}
BUFFERED_SIO_TxBuffer_StartPointer++;
// Rollover ?
if (BUFFERED_SIO_TX_BUFFER_SIZE <= BUFFERED_SIO_TxBuffer_StartPointer)
{
BUFFERED_SIO_TxBuffer_StartPointer = 0;
}
// Send char
usart_putchar (BUFFERED_SIO_USART, BUFFERED_SIO_TxBuffer[BUFFERED_SIO_TxBuffer_StartPointer]);
// Enable USART Tx interrupt for transmitting all chars
Disable_global_interrupt ();
BUFFERED_SIO_USART->IER.txempty = 1;
Enable_global_interrupt ();
}
void usart_putstr(char *str)
{
do
{
usart_putchar(*str++);
}while(*str!='\0');
}
/**
* \brief Test physical loop-back with some characters in sunc mode.
*
* This function sends a character over USART on loop back to verify that init
* and sending/receiving works. A jumper is connected on the USART.
*
* \param test Current test case.
*/
static void run_loopback_syncmode_test(const struct test_case *test)
{
uint8_t out_c = 'c';
uint8_t in_c = 0;
port_pin_t sck_pin;
sysclk_enable_module(POWER_RED_REG0, PRUSART0_bm);
usart_set_mode(&CONF_UNIT_USART, USART_CMODE_SYNCHRONOUS_gc);
sck_pin = IOPORT_CREATE_PIN(PORTE, 2);
ioport_configure_port_pin(ioport_pin_to_port(sck_pin),
ioport_pin_to_mask(sck_pin),
IOPORT_DIR_OUTPUT | IOPORT_INIT_HIGH );
usart_spi_set_baudrate(&CONF_UNIT_USART, CONF_UNIT_BAUDRATE,
sysclk_get_source_clock_hz());
usart_tx_enable(&CONF_UNIT_USART);
usart_rx_enable(&CONF_UNIT_USART);
usart_putchar(&CONF_UNIT_USART, out_c);
in_c = usart_getchar(&CONF_UNIT_USART);
test_assert_true(test, in_c == out_c,
"Read character through sync mode is not correct: %d != %d", in_c, out_c);
}
// BSB 20120810: Added rtos_delay
char read_dbg_char(char echo, char rtos_delay, char checksum_mode)
{
volatile static char dbg_checksum = 0; // should be uint8_t??
char read_data; // should be uint8_t??
// dbg_checksum is a crude checksum mechanism compatible by other debug code by BSB.
if (checksum_mode == DBG_CHECKSUM_NORMAL)
{
// Redirection to the debug USART.
if (rtos_delay == RTOS_WAIT) { // Wait for uart RX register to fill.
while (!usart_test_hit(DBG_USART))
vTaskDelay(120); // Giving 12ms to RTOS all the while
}
read_data = usart_getchar(DBG_USART); // returns int
if (echo == DBG_ECHO)
usart_putchar(DBG_USART, read_data);
dbg_checksum += read_data; // Checksum function is addition...
dbg_checksum &= 0xFF; // ... of which we save 8 lsbs. Redundant code line?
return read_data;
}
else if (checksum_mode==DBG_CHECKSUM_RESET)
dbg_checksum = 0;
// Last alternative, DBG_CHECKSUM_READOUT, not tested
return dbg_checksum;
}
int main (void)
{
sysclk_init();
pmic_init();
port_init();
tc_init();
wdt_set_timeout_period(WDT_TIMEOUT_PERIOD_32CLK);
wdt_enable();
usart_init();
spi_init();
char str[200];
uint8_t count ;
count = sprintf(str,"RESET");
for (uint8_t i=0;i<count;i++)
usart_putchar(&USARTE0,str[i]);
nrf_init(Address);
sei();
for (uint8_t i=0;i<Max_Robot;i++)
{
Robot_D_tmp[2][i].RID=12;
}
while (1)
{
}
}
void send2uart(char *buffer)
{
int i;
// for (i=0;i<strlen(buffer);i++)
for (i=0;buffer[i] != '\0' ;i++)
usart_putchar(buffer[i]);
}
/*! \brief Writes a number of bytes, at most \a size, from the memory area
* pointed to by \a buffer.
*
* If \a buffer is zero then \ref __write performs flushing of internal buffers,
* if any. In this case, \a handle can be \c -1 to indicate that all handles
* should be flushed.
*
* \param handle File handle to write to.
* \param buffer Pointer to buffer to read bytes to write from.
* \param size Number of bytes to write.
*
* \return The number of bytes written, or \c _LLIO_ERROR on failure.
*/
size_t __write(int handle, const unsigned char *buffer, size_t size)
{
size_t nChars = 0;
if (buffer == 0) {
// This means that we should flush internal buffers.
return 0;
}
// This implementation only writes to stdout and stderr.
// For all other file handles, it returns failure.
if (handle != _LLIO_STDOUT && handle != _LLIO_STDERR) {
return _LLIO_ERROR;
}
for (; size != 0; --size) {
if (usart_putchar(stdio_usart_base, *buffer++) < 0) {
return _LLIO_ERROR;
}
++nChars;
}
return nChars;
}
platform_result_t platform_uart_transmit_bytes( platform_uart_driver_t* driver, const uint8_t* data_out, uint32_t size )
{
UNUSED_PARAMETER(driver);
UNUSED_PARAMETER(data_out);
UNUSED_PARAMETER(size);
pdc_packet_t dma_packet;
/* Limitation: SAM4S doesn't support DMA transfer from embedded flash.
* If data_out address is not within RAM range, use normal write to THR.
*/
if ( data_out >= (const uint8_t*)RAM_START_ADDR && data_out < (const uint8_t*)RAM_END_ADDR )
{
/* Initialise TPR and TCR register values. TNPR and TNCR are unused */
dma_packet.ul_addr = (uint32_t)data_out;
dma_packet.ul_size = (uint32_t)size;
pdc_tx_init( usart_get_pdc_base( driver->peripheral->peripheral ), &dma_packet, NULL );
/* Enable Tx DMA transmission */
pdc_enable_transfer( usart_get_pdc_base( driver->peripheral->peripheral ), PERIPH_PTCR_TXTEN );
host_rtos_get_semaphore( &driver->tx_dma_complete, NEVER_TIMEOUT, WICED_FALSE );
}
else
{
while ( size > 0 )
{
usart_putchar( driver->peripheral->peripheral, (uint32_t)*data_out++ );
size--;
}
}
return PLATFORM_SUCCESS;
}
void USART_send(char* in, char number)
{
for (char c=0; c<number; c++)
{
usart_putchar(USART_SERIAL,*(in+c));
}
}
/*! \brief Receive one byte from an SPI device using USART in SPI mode.
*
* \param p_usart Base address of the USART instance.
* \param data Pointer to the data byte where to store the received data.
*
* \pre USART device must be selected with usart_spi_select_device() first.
*/
void usart_spi_read_single(Usart *p_usart, uint8_t *data)
{
/* Dummy write one data to slave in order to read data. */
usart_putchar(p_usart, CONFIG_USART_SPI_DUMMY);
usart_getchar(p_usart, (uint32_t*)data);
}
/* usart_out - prints out a C-string until it sees a null byte */
void
usart_out(char* str)
{
while (*str) {
usart_putchar(*str);
str++;
}
}
int usart_putchar(char c, FILE *stream) {
if (c == '\n') {
usart_putchar('\r', stream);
}
loop_until_bit_is_set(UCSR0A, UDRE0);
UDR0 = c;
return 0;
}
inline void sendUARTdata(uint8_t data[], uint8_t length) {
uint8_t i;
if (length > 1) {
for (i = 0; i < length; i++) {
usart_putchar(USART_SERIAL_EXAMPLE, data[i]);
}
} else {
usart_putchar(USART_SERIAL_EXAMPLE, data[0]);
usart_putchar(USART_SERIAL_EXAMPLE, '\r');
usart_putchar(USART_SERIAL_EXAMPLE, '\n');
}
}
