Dirty little bugs - a pin/macro approach

Program testing can be used to show the presence of bugs, but never to show their absence!

Edsger W. Dijkstra

/-

Measuring and observing usually (if not always) change what one is measuring. I've never seen Schrödinger's cat, at least not when leading with embedded systems nor in my garden, but the former implication causes many problems when trying to debug time-critical functions/operations in embedded software and hardware.

Usually a printf-like UART output works but that would slow down or even hang code which can't wait for the UART to stream its data out. Even though with a substantial buffer it will come a time where it will get stuck.

There is a nice, well known techinque, that uses output pins to reflect some state, such as which function or interrupt handler the microcontroller is doing at the time. Since setting the output value requires only a few instructions, this approach suits better the time-critical scenarios. This technique is helpful in many ways: one may measure from interrupt latency and cpu usage to interrupt or thread deadlock.

That's how the following code came up to mind, here is a simple header file which is based on the macros I posted some time ago here.

#ifndef _dbgpin_h_
#define _dbgpin_h_

#include "portutil.h"

/* Enables or disables debugging */
#if    DBGPIN_ENABLED 1

/* Debug pins */
#define DBGPIN_01    0,2
#define DBGPIN_02    0,3
//---- etc

/* Initialization */
#define DBGPIN_INIT( pin )    do { FPIN_AS_OUTPUT(pin); FPIN_CLR(pin);  } while(0);

/**
* Beware of returns, exclude them!
*/
#if    DBGPIN_ENABLED
#define DBGPIN_BLOCK( pin, block ) \
           FPIN_SET_( pin ); \
           do { \
               block \
           } while(0); \
           FPIN_CLR_( pin );
#else
#define    DBGPIN_BLOCK( pin, block ) block
#endif

#endif /* _dbgpin_h_ */

Here is an example:

DBGPIN_BLOCK( DBGPIN_01,
a = b;
callSomething();
);

There is a small drawback: the do-while structure won't let any variable declared inside 'block' to be visible outside. That can be solved by removing the do-while, if you need it that way just go ahead and delete those two lines.

Also notice that a return in 'block' won't allow the macro to clear the corresponding pin, so applying the macro to a function with many return points is messy. The alternative is to change the original function's name and call it through a sort of wrapper which does it inside a DBGPIN_BLOCK macro. It's not pure beauty but it works nice, and once you've done the debugging it can be disabled by changing DBGPIN_ENABLED to 0.

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.

Embedded C++ constructs - Part 1

There has been a big explosion about using C++ within embedded systems. Recently David sent me some interesting papers and info about Embedded C++ so here I present what I've been doing so far (or at least a small portion of it).

Templates

First I have to say that templates are not a code bloat if they're managed with care. In fact the C++ compiler is supposed to optimize them at compile time.

Here are some base templates I've coded to ease pin mapping on the LPC23xx ARM family.

#include "lpc24xx.h"        /* LPC23/24xx register definitions */
#include "static_assert.h"  /* static assert for non-C++0x compilers */

namespace HW
{
  /**
  * Output Pin Abstraction
  */
  template<unsigned int port, unsigned int pin>
  class OutPin
  {
      STATIC_ASSERT(pin <= 31, PinMustBeLessThan32);

  public:
      OutPin() {
          *(&FIO0DIR + 8*port) |= (1<<pin); //configure pin as output
      }
      void Set(void) { *(&FIO0SET + 8*port) = (1<<pin);}
      void Clr(void) { *(&FIO0CLR + 8*port) = (1<<pin);}
  };

  /**
  * Input Pin Abstraction
  */
  template<unsigned int port, unsigned int pin>
  class InPin
  {
      STATIC_ASSERT(pin <= 31, PinMustBeLessThan32);
 
   public:
      InPin() {
          *(&FIO0DIR + 8*port) &= ~(1<<pin); //configure pin as input
      }

      operator bool () {
          if ( (*(&FIO0PIN + 8*port)) & (1<<pin) )
              return true;
          else
              return false;
      }
  };
};

This may look a like waste of code at first glance. However these classes avoid many mistakes and provide a hardware independent interface to pin outputs and inputs, it's just a question of redefining this templates to fit the platform.

Also note that the compiler will throw an error if pin's value is not within the allowed range. This is also a protection and won't waste any processor instructions or any other memory. It would be useful to limit the port range too. The above templates use the static assert method described earlier in this post.

The constructors will manage to configure the port pin as output or input. If the pin is defined globally then the constructor will be called before entering the main function, configuring the pin as it should. If it is defined inside a function or by using the new operator (which I would try to avoid)  then the constructor will be called when it is instantiated.

Here is an example:

// Pin 0.25
HW::OutPin< 0,25 > myLed;
// Pin 1.20
HW::InPin< 1,20 >  mySwitch;

void invert(void)
{
   if ( mySwitch )
       myLed.Clr();
   else
       myLed.Set();
}

Beautiful, isn't it? The generated code (arm-elf-gcc 4.2.x) is exactly the same as if it is done manually by writing/reading the corresponding registers. There is no loss in performance compared to the equivalent C code.

In the next post I will discuss a UART implementation by using similar code constructions.

What I do not like about C++

C++ lacks many useful C99 characteristics and g++ doesn't implement them either. I could live without most of them but what really hurts me is to avoid using Designated Initializers, specially on structs. It won't be a big problem if struct's data is on RAM but it's disappointing when structs are on ROM (const).

If we want a struct to be in ROM while using C++ it has to be declared const, but in addition constructors can't be used or the const-declared struct will be placed in RAM (cRazY). It is an understandable limitation but that means that the only way to initialize a struct is by passing each element one by one and in the exact order as they're defined in the struct. That is error prone, particularly when a new element is added in the middle of the struct. So when we try to switch to C++ to avoid errors we become prone to issues that were solved with C99.

So, that's the only thing I don't like about C++, the solution? Use C for cont struct initializers and C++ for the rest? Don't know.

Writing portable Embedded code - Pin portability

EDIT: I've posted a C++ alternative using templates here.

Portability can be hard on embedded systems. The fact that we can code in C most of the time doesn't mean code is portable. Even worse, it means that you may have to rewrite many functions/macros in order to get the 'same' code to work on another platform/chip.

A nice approach is to write a simple yet powerful HAL (Hardware Abstraction Layer), sometimes called a driver. There are many protocols and peripherals whose functions are nearly the same between different vendors and chips, such as I2C, SPI, UART,MCI controllers. For SPI we would code at least three functions: SPI_init(), SPI_tx() and SPI_rx(). Actually SPI_tx() and SPI_rx() might be the same due to SPI's full duplex capability. There might be other functions or macros to control the chip select line. This approach works nice for standard peripherals, but we may need to access port pins individually to perform some task or communicate to a device by bit-banging.

Most LCD character displays work the same way and use the same protocol and control lines. A 'universal' C module for character LCD control sounds great, but pin compatibility should be addressed first, it's not attractive if we need to change tens of lines to port it.

We'll first define some useful string-concatenating macros:

#define    _CAT3(a,b,c)  a## b ##c

#define    CAT3(a,b,c)   _CAT3(a,b,c)

#define    _CAT2(a,b)    a## b

#define    CAT2(a,b)    _CAT2(a,b)

The macros are called twice to ensure tokens are preprocessed as we want them. Kernighan and Ritchie's wonderful C book has good information about how that works. These macros can be defined in a global header file so they can be included whenever they're needed.

Basic operations on port pins include setting a pin as output or input, clearing a bit, setting a bit and reading it's value when configured as input. Given that I defined another header file which looks like this, specially made for the Philips LPC23xx family (ARM7):

/* Set bit */
#define FPIN_SET(port,bit)  CAT3(FIO,port,SET) = (1<<(bit))
#define FPIN_SET_(port_bit) FPIN_SET(port_bit)


/* Clear bit */
#define FPIN_CLR(port,bit)  CAT3(FIO,port,CLR) = (1<<(bit))
#define FPIN_CLR_(port_bit) FPIN_CLR(port_bit)


/* Set as input */
#define FPIN_AS_INPUT(port,bit)  CAT3(FIO,port,DIR) &=~(1<<(bit))
#define FPIN_AS_INPUT_(port_bit) FPIN_AS_INPUT(port_bit)

/* Set as output */
#define FPIN_AS_OUTPUT(port,bit)  CAT3(FIO,port,DIR) |= (1<<(bit))
#define FPIN_AS_OUTPUT_(port_bit) FPIN_AS_OUTPUT(port_bit)


/* when used as input */
#define FPIN_ISHIGH(port,bit)  ( CAT3(FIO,port,PIN) &  (1<<(bit)) )
#define FPIN_ISHIGH_(port_bit) FPIN_ISHIGH(port_bit)

/* returns !=0 if pin is LOW */
#define FPIN_ISLOW(port,bit)  (!( CAT3(FIO,port,PIN)& (1<<(bit)) ))
#define FPIN_ISLOW_(port_bit) FPIN_ISLOW(port_bit)

Done this we can set bit 2.1 by ussuing FPIN_SET(2,1), or clear it by doing FPIN_CLR(2,1). The functions ending with an underscore are meant to be used when pin position is given as a #define macro, such as:

#define LEDA 2,1
#define LEDB 2,1

FPIN_AS_OUTPUT_( LEDA );
FPIN_SET_( LEDA );
FPIN_CLR_( LEDB );

I agree this may sound complicated, but by defining all these functions it's possible to manipulate all port pins easily and in a portable way. If we want to change the pin or port LEDA is using we only need to change it once, the macros will take care of it.

If we were to do the same on an AVR it's a question of changing the macros as shown below. Don't forget ports are named with letters (A,B,C,D...) rather than numbers.

/* Set bit */
#define FPIN_SET(port,bit)  CAT2(PORT,port) |= (1<<(bit))
#define FPIN_SET_(port_bit) FPIN_SET(port_bit)


/* Clear bit */
#define FPIN_CLR(port,bit)  CAT2(PORT,port) &=~(1<<(bit))
#define FPIN_CLR_(port_bit) FPIN_CLR(port_bit)


/* Set as input */
#define FPIN_AS_INPUT(port,bit)  CAT2(DDR,port) &= ~(1<<(bit))
#define FPIN_AS_INPUT_(port_bit) FPIN_AS_INPUT (port_bit)

/* Set as output */
#define FPIN_AS_OUTPUT(port,bit)  CAT2(DDR,port) |= (1<<(bit))
#define FPIN_AS_OUTPUT_(port_bit) FPIN_AS_OUTPUT(port_bit)


/* when used as input */
#define FPIN_ISHIGH(port,bit)  CAT2(PIN,port) & (1<<(bit)))
#define FPIN_ISHIGH_(port_bit) PIN_ISHIGH(port_bit)


/* returns !=0 if LOW */
#define FPIN_ISLOW(port,bit)  (!( CAT2(PIN,port) & (1<<(bit))) )
#define FPIN_ISLOW_(port_bit) FPIN_ISLOW(port_bit)

Now the LCD routines are really portable. Minor changes might be needed if there are other pin registers to modify, but the basic pin functionality is covered by the macros defined above.