Embedded C++ constructs - Part 2

As mentioned in part 1, I'll now get into an UART example, providing the basic functionality through a class. This example works with the LPC ARM7 family from NXP Semiconductors (Philips).

Register abstraction

First here is how I abstract a hardware register. It's nothing special but a simple template class:

namespace HW
{
  /**
   * Individual HW register
   */
  template < unsigned long int BASE, unsigned long int OFF >
  class Reg
  {
  public:
      void operator = (const unsigned long int & val) {
          *((volatile unsigned long int *)(BASE + 4*OFF)) = val;
      }

      unsigned long int & operator = ( const Reg & reg ) {
          return *((volatile unsigned long int *)(BASE + 4*OFF));
      }

      operator unsigned long int () {
          return *((volatile unsigned long int *)(BASE + 4*OFF));
      }
  };

};

(I used C-like casts here but it would be better to use reinterpret_cast<> instead)

Three operators are implemented. It's essential to be able to cast the class to an unsigned int so we can use it transparently.

The template parameters let us provide a base and offset address which will be useful when a peripheral is abstracted through a template class.

UART peripheral abstraction

The UART peripheral in the LPC2xxx family consists of a collection of registers, starting from a base address. There are some interesting bits lying around on the microcontroller too that control peripheral power, the peripheral's clock and associated interrupts. Here all of them are encapsulated in a single class, except for the interrupts (to do).

namespace HW
{
  /**
   * UART Module Abstraction
   */
  template<unsigned int BASE, unsigned int PCON_BIT, unsigned int PCLK_SEL>
  class RegUART
  {
  public:
      void powerOn() {
          PCONP |= (1<<PCON_BIT);
      }

      void setClkDiv( unsigned int divv ) {
          PCLOCK_SELECT( PCLK_SEL, divv );
      }

      HW::Reg<BASE, 0> RBR;
      HW::Reg<BASE, 0> THR;
      HW::Reg<BASE, 0> DLL;
      HW::Reg<BASE, 1>   DLM;
      HW::Reg<BASE, 1>   IER;
      HW::Reg<BASE, 2>   IIR;
      HW::Reg<BASE, 2>   FCR;
      HW::Reg<BASE, 3>   LCR;
      HW::Reg<BASE, 5>   LSR;
      HW::Reg<BASE, 7>   SCR;
      HW::Reg<BASE, 8>   ACR;
      HW::Reg<BASE, 9>  ICR;
      HW::Reg<BASE, 10>  FDR;
      HW::Reg<BASE, 12>  TER;
  };
};

#define HWUART0 HW::RegUART< UART0_BASE_ADDR, PCLK_UART0, PCLK_UART0 >
#define HWUART1 HW::RegUART< UART1_BASE_ADDR, PCLK_UART1, PCLK_UART1 >
#define HWUART2 HW::RegUART< UART2_BASE_ADDR, PCLK_UART2, PCLK_UART2 >
#define HWUART3 HW::RegUART< UART3_BASE_ADDR, PCLK_UART3, PCLK_UART3 >

PCONP and PCLOCK_SELECT() are macros defined in another file, nothing special.

HWUARTx are macros that help when specifying certain port. It will be used in the next piece of code.

#include <string.h>

namespace Drivers
{
   /**
   * LPC2xxx UART Peripheral
   * Polled.
   *
   * @param T Hw::RegUART
   *   Use HWUART0, HWUART1...
   */
   template< class T >
   class PolledUart
   {
   private:
   T UART;

   public:

       /**
        * Init UART
        *
        * @param brate  desired baudrate
        */
       void init(unsigned int brate) {

       UART.setClkDiv( PCLK_DIV_1 );
       UART.powerOn();

       UART.LCR = 0x80;  //DLAB = 1

       UART.DLL = (Fpclk/16)/brate & 0xFF;
       UART.DLM = (((Fpclk/16)/brate) >> 8) & 0xFF;

       UART.LCR = 3 | //8 bit char length
        (0<<2) | // 1 stop bit
        (0<<3) | //no parity
        (0<<4) | //partity type
        (0<<6) | //disable break transmission
        (0<<0) ; //enable access to divisor latches

       UART.FCR = (0x07); //FIFO ENABLE, Rx & Tx
   }

       /**
        * Transmit a single byte
        *
        * @param c
        */
       void tx( unsigned char c ) {
           while ( !( UART.LSR &  (1<<5) ) )
               ;
           UART.THR = c;
       }

       /**
        * Transmit several bytes
        *
        * @param data   data to transmit
        * @param length  length of 'data'
        */
       void tx( const unsigned char *data, unsigned int length ) {
           while( length-- > 0 )
               tx( *(data++) );
       }

       /**
        * Transmit a C string
        *
        * @param str
        */
       void tx( const char *str ) {
           tx( (const unsigned char *) str, strlen(str) );
       }

       /**
        * Byte receive
           * BLOCKING
        *
        * @return unsigned char  received char
        */
       unsigned char rx(void)
       {
           while ( !( UART.LSR & (1<<0) ) )
               ;

           return UART.RBR;
       }

       /**
        * Returns if there is data to be read in the FIFO
        *
        * @return bool  true if there is data available
        */
       bool isDataAvailable(void)
       {
           if ( UART.LSR & (1<<0) )
               return true;
           else
               return false;
       }
   };
};

PolledUart implements UART basic functionality. No constructor is used to avoid undesired code creation, so init() must be called before using any other function.

Even though this class contains a RegUART class as a private member it won't take any extra memory since the compiler (at least gcc-elf-arm here) will optimize the template. I did some tests and there is no difference in code size with a simple C function doing the same statements directly.

Finally, to see how it works, if we wanted to use UART0 through this class we could instantiate it like this:

Drivers::PolledUart< HWUART0 > Uart0;

void testUart0()
{
   Uart0.init(115200);  //init @ 115200 bps

   Uart0.tx("Hello there!\n");
}

If the class is to be used by many C++ files one should consider declaring it extern inside a header file and implementing it in a single cpp one. That would save code by avoiding function inlining each time it's used.

Improvements

This is just a basic version to demonstrate how easy and clean code can get. Here are some modifications that will make the class more useful:

• If there is an RTOS it would be useful to protect this class from concurrent access by using semaphores. It's not a difficult task, a mutex should be declared and initialized (maybe inside a constructor).

• An interrupt-based uart is nice too, even better if RTOS' messages queues are used. This shouldn't be a problem either.