source: firmware/FSC/src/usart.c@ 16071

//-----------------------------------------------------------------------------

#include "usart.h"
#include "num_conversion.h"
#include <avr/interrupt.h>
//-----------------------------------------------------------------------------
#ifdef USART_USE_TX_IRQ

#endif

        U08 usart_tx_buffer[USART_TX_BUFFER_SIZE];
        U08 usart_tx_buffer_index = 0;
        bool usart_tx_buffer_overflow = false;  // true if usart_tx_buffer was full.



#ifdef USART_USE_RX_IRQ
  U08 usart_rx_buffer[USART_RX_BUFFER_SIZE];
  //U08 *usart_rx_buffer_ptr = &usart_rx_buffer[0];
  U08 usart_received_chars;
  volatile BOOL usart_rx_ready = false;
  static U08 usart_rx_buffer_index = 0;
  static U08 usart_receive_char;
  static BOOL usart_receive_suspended = false;
#endif
//-----------------------------------------------------------------------------

void usart_init(void)
{
  USART_SET_BAUDRATE(USART_BAUDRATE);

  UCSRA = 0x00;

  UCSRB = 0x00; // Disable receiver and transmitter and interrupts

#ifdef USART_USE_RX
  UCSRB |= (1 << RXEN);                 // Turn on receiver
        DDRD &= ~(1<<PD0);                              // PD0 is RXD
#endif

#ifdef USART_USE_RX_IRQ
  UCSRB |= (1 << RXCIE);                // Enable rx interrupt
#endif

#ifdef USART_USE_TX
  UCSRB |= (1 << TXEN);                 // Turn on transmitter
        DDRD |= 1<<PD1;                                         // PD1 is TXD
#endif

  UCSRC = (1 << URSEL) | (1 << UCSZ1) | (1 << UCSZ0); // 8-Bit character length
}
//-----------------------------------------------------------------------------

void usart_write_char(U08 data)
{
  while (!(UCSRA & (1 << UDRE))) ; // Wait until tx register is empty
  UDR = data;

//      if ( usart_tx_buffer_index < USART_TX_BUFFER_SIZE-1){
//              usart_tx_buffer[usart_tx_buffer_index] = data;
//              ++usart_tx_buffer_index;
//      } else {
//              usart_tx_buffer_overflow = true;
//      }
}
//-----------------------------------------------------------------------------

void usart_write_crlf(void)
{
  usart_write_char(USART_CHAR_CR);
  usart_write_char(USART_CHAR_LF);
}
//-----------------------------------------------------------------------------

void usart_write_str(pU08 str)
{
  while (*str)
  {
    usart_write_char(*str++);
  }
}
//-----------------------------------------------------------------------------

void usart_write_flash_str(fpU08 str)
{
  while (*str)
  {
    usart_write_char(*str++);
  }
}
//-----------------------------------------------------------------------------

void usart_writeln_flash_str(fpU08 str)
{
  while (*str)
  {
    usart_write_char(*str++);
  }

  usart_write_char(USART_CHAR_CR);
  usart_write_char(USART_CHAR_LF);
}
//-----------------------------------------------------------------------------

void usart_writeln_str(pU08 str)
{
  usart_write_str(str);
  usart_write_char(USART_CHAR_CR);
  usart_write_char(USART_CHAR_LF);
}
//-----------------------------------------------------------------------------

void usart_write_U08(U08 value,U08 digits)
{
  usart_write_str(nc_U08_to_str(value,digits));
}
//-----------------------------------------------------------------------------

void usart_write_S08(S08 value,U08 digits)
{
  usart_write_str(nc_S08_to_str(value,digits));
}
//-----------------------------------------------------------------------------

void usart_write_U08_hex(U08 value)
{
  usart_write_str(nc_U08_to_hex(value));
}
//-----------------------------------------------------------------------------

void usart_write_U08_bin(U08 value)
{
  usart_write_str(nc_U08_to_bin(value));
}
//-----------------------------------------------------------------------------

void usart_write_U16(U16 value,U08 digits)
{
  usart_write_str(nc_U16_to_str(value,digits));
}
//-----------------------------------------------------------------------------

void usart_write_S16(S16 value,U08 digits)
{
  usart_write_str(nc_S16_to_str(value,digits));
}
//-----------------------------------------------------------------------------

void usart_write_U16_hex(U16 value)
{
  usart_write_str(nc_U16_to_hex(value));
}
//-----------------------------------------------------------------------------

void usart_write_U32(U32 value,U08 digits)
{
  usart_write_str(nc_U32_to_str(value,digits));
}
//-----------------------------------------------------------------------------

void usart_write_S32(S32 value,U08 digits)
{
  usart_write_str(nc_S32_to_str(value,digits));
}
//-----------------------------------------------------------------------------

void usart_write_U32_hex(U32 value)
{
  usart_write_str(nc_U32_to_hex(value));
}
//-----------------------------------------------------------------------------

void usart_write_float(float value,U08 decimals,U08 digits)
{
  usart_write_str(nc_float_to_str(value,decimals,digits));
}
//-----------------------------------------------------------------------------

#ifdef USART_USE_RX_IRQ

ISR(SIG_USART_RECV)
{
        usart_receive_char = UDR;

  if (usart_rx_ready) // Exit if ready flag is still set 
  {
    return;
  }

  // If CR received, then set ready flag
  if (usart_receive_char == USART_CHAR_CR)
  {
    usart_rx_buffer[usart_rx_buffer_index] = 0; // Terminate input string
    usart_received_chars = usart_rx_buffer_index;
    usart_rx_buffer_index = 0;
    usart_receive_suspended = false;
    usart_rx_ready = TRUE;
    return;
  }

  // Ignore all characters till next CR
  if (usart_receive_suspended)
  {
    return;
  }

  // Check for underscore or comment
  if (usart_receive_char == '_' || usart_receive_char == ';')
  {
    usart_receive_suspended = true;

    return;
  }

  // If Backspace received, then delete last character
  if (usart_receive_char == USART_CHAR_BS && usart_rx_buffer_index)
  {
    usart_rx_buffer_index--;

    return;
  }

  // Ignore invalid characters
  if (usart_receive_char < USART_CHAR_SPC)
  {
    return;
  }

#ifdef USART_USE_UPPERCASE
  if (usart_receive_char >= 'a' && usart_receive_char <= 'z')
  {
    usart_receive_char -= 32;
  }
#endif

  if (usart_rx_buffer_index < USART_RX_BUFFER_SIZE - 1) // Store character
  {
    usart_rx_buffer[usart_rx_buffer_index++] = usart_receive_char;
    //usart_writeln_str(usart_rx_buffer);
  }

  //usart_write_char(usart_rx_buffer[usart_rx_buffer_index]);
 //usart_writeln_str(usart_rx_buffer);
 //usart_write_char(usart_rx_buffer[1,2]);
 //usart_write_char(usart_rx_buffer[usart_rx_buffer_index]);
 //usart_writeln_flash_str(*usart_rx_buffer);
 //usart_write_char(usart_rx_buffer);
}  
#endif 


#ifdef USART_USE_TX_IRQ

ISR(TRALA_vect)
{

        // if it is necessary to write something via USART ... then send
        // if not ... disable this interrupt.
        if (usart_write_start_index < usart_write_stop_index) // some bytes in the usart_tx_buffer should be send away.
        {
                UDR = usart_tx_buffer[usart_write_start_index%USART_TX_BUFFER_SIZE];
        }
        else
        {
                // disable this interrupt source
                UCSRB &= ~(1<<UDRIE);
        }
}  
#endif