AVRFreaks.net

// SendWithInterrupt - main.c
//
// by Sage Radachowsky, Feb-Mar 2008 ("sager" at "mit" dot "edu")
//
//
// Program to test sending data to the serial output (UART / RS232) using interrupts
// instead of actively polling to check if the last byte was written.
//
// This has two advantages -- the CPU is using its built-in hardware signals rather than
// burning CPU instructions so it consumes less power, and (2) the CPU is freed
// to do other things rather than wait for some 9600 baud output or even 57k baud output,
// which is a heck of a long time in a multi-MHz world.
//
// This is written for the AT90CAN128 microcontroller, which has 2 UART lines. To rewrite
// it for any Atmel AVR micro that has just one serial line, you would have to change the
// names of all the UART registers to remove the "0".
//
// Note that interrupts must be globally enabled for this stuff to work - of course!
//
// This code sets up the interrupts to interface with stdout, so that "printf()" sends
// by interrupt! Easy and Sweet!
//
// NOTE: Be sure to change your CPU speed if it's not 1.8432 MHz !
//




//**********************************************
//                DEFINITIONS
//**********************************************



// CPU frequency
#define F_CPU 1843200L   // 1.8432 MHz

// UART baud rate
#define UART_BAUD  9600

// UART buffer size
#define UART_BUFFER_SIZE 256


//**********************************************
//               HEADER FILES
//**********************************************


#include <ctype.h>
#include <string.h>
#include <stdint.h>
#include <stdio.h>

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>

#include <util/delay.h>




//**********************************************
//            FUNCTION DECLARATIONS
//**********************************************

void         USART0_Init(void);
static int   UART0_Putchar(char c, FILE *stream);
void         DelayAwhile(void);


//**********************************************
//               GLOBAL VARIABLES
//**********************************************

char UartBuffer[UART_BUFFER_SIZE]; // this is a wrap-around buffer
int  UartBufferNextByteToSend; // position of next byte to be sent
int  UartBufferNextFree; // position of next free byte of buffer
int  UartSendingInProgress; // 1 = sending is in progress


/* This is the pointer to the serial interface */
/* Defines the stream interface for write only */

FILE uart_str = FDEV_SETUP_STREAM (UART0_Putchar, NULL, _FDEV_SETUP_WRITE);




// ################## here we GO! ####################

int main()

{

   // initialize the UART and enable interrupts
   USART0_Init(); sei();

   printf ("Hello from SendWithInterrupt.\n");
   DelayAwhile();


   // loop forever
   while (1)
   {

      printf ("This is test output. How's the weather?\n");
      DelayAwhile();

   }


}


//===============================================================================
  void DelayAwhile()

//
// Delays a while, to slow down to a human level.
//


{
   _delay_ms(200);
   _delay_ms(200);
   _delay_ms(200);
}





//****************************************************
//                 UART functions
//****************************************************




//===============================================================================
  void USART0_Init()

// This routine initializes the UART0 port of the AT90CAN128 and clears the
// write buffer.
//
// This routine does NOT enable the transmit-complete interrupt (TXCIE0).
// That is left up to the UART0_PutChar() routine, after it puts something in
// the buffer for the first time.
//
// This routine also does NOT enable general interrupts. That is left to the
// main() initializing code, and it MUST be done for this stuff to work.
//
// Also sets standard out to the uart interface, so printf() works sweetly.
//

{

   // init buffer data structures
   UartBuffer[0] = '\0'; // clear the first byte of buffer
   UartBufferNextByteToSend = 0; // set "next byte to send" to beginning
   UartBufferNextFree = 0; // next free byte is also beginning of buffer
   UartSendingInProgress = 0; // clear "sending in progress" flag

   // set baud rate
   UBRR0H = (unsigned char) (((F_CPU/(16L*UART_BAUD))-1) >> 8);
   UBRR0L = (unsigned char) ((F_CPU/(16L*UART_BAUD))-1);

   // Set frame format: 8data, no parity & 1 stop bits
   UCSR0C = (0<<UMSEL0) | (0<<UPM0) | (0<<USBS0) | (3<<UCSZ00);


   // Enable transmit
   UCSR0B = (1<<TXEN0); //Enable the transmitter only

    // set standard output stream to our UART interface
   stdout = &uart_str;

}


//===============================================================================
  static int UART0_Putchar(char c, FILE *stream)

// If transmit is in progress, adds a character to the UART output buffer.
// If transmit is not in progress, kicks off a transmit.
//
// The send buffer is a wrap-around buffer.
//
// If the buffer is full, then this routine returns EOF.
// A successful completion returns 0.
//
// This routine disables the UART Tx interrupt temporarily, because
// things would get funky if the interrupt signal routine were called during
// execution of this routione.
//
// If the buffer was empty to start with, then this routine "primes the pump"
// sending the character directly to the UART.
//
// This routine also adds carriage returns to newlines.
//

{
   register int ReturnStatus = 0; // return 0 for success
   register int UartBufferNextFree_last; // space to save last UartBufferNextFree

   // if character is a "newline" then add a "carriage return" before it.
   if (c == '\n')
      UART0_Putchar('\r', stream);


   // if no send is already in progress, then "prime the pump" by sending directly to UART
   if (UartSendingInProgress == 0)
   {
      // set "sending in progress" flag
      UartSendingInProgress = 1;
      // send the first byte!
      UDR0 = c;
   }
   else
   {
      // disable the Tx Complete interrupt
      UCSR0B &= ~( 1 << TXCIE0 );

      UartBuffer[UartBufferNextFree] = c;

      // increment the next free byte index, while saving last value
      UartBufferNextFree_last = UartBufferNextFree++;

       // check for wrap-around
      if (UartBufferNextFree == UART_BUFFER_SIZE) // if we reached the end of the buffer -
           UartBufferNextFree = 0; // start back at the beginning

      if (UartBufferNextFree == UartBufferNextByteToSend) // if buffer is full -
      {
         // bump back the index so transmit routine doesn't think buffer's empty
         UartBufferNextFree = UartBufferNextFree_last;
         // return with error code   
         ReturnStatus = EOF;
      }
      
      // enable the Tx Complete interrupt
      UCSR0B |= ( 1 << TXCIE0 );
   }


   // return with status code
   return ReturnStatus;
}









//********************************
//       INTERRUPT HANDLERS
//********************************


//===============================================================================
   ISR (USART0_TX_vect)


// This interrupt service routine is called when a byte has been sent through the
// UART0 port, and it's ready to receive the next byte for transmission.
//
// If there are more bytes to send, then send the next one and increment the index.
// If the index reached the end of the buffer, then wrap around to the beginning.
//
// If there is not another byte to write, then clear the "UartSendingInProgress"
// flag, otherwise set it if a byte has just been sent.
//

{
   if (UartBufferNextByteToSend == UartBufferNextFree)  // if nothing to send -
   {
        UartSendingInProgress = 0;   // clear "sending in progress" flag
       return; // then we have nothing to do, so return
   }

   // set "sending in progress" flag
   UartSendingInProgress = 1;

   // send the next byte on UART0 port
   UDR0 = UartBuffer[UartBufferNextByteToSend];

   // increment index and check for wrap-around
   UartBufferNextByteToSend++;
   if (UartBufferNextByteToSend == UART_BUFFER_SIZE) // if we reached the end of the buffer -
      UartBufferNextByteToSend = 0; // then start back at the beginning

}