Behavior – Device Abstraction

March 28th, 2009 § Comments Off on Behavior – Device Abstraction § permalink

You’ve coded your project with your x-axis step pin on GPIO11. But my device has it on GPIO3. Or even worse, I use a a servo and counter, which doesn’t have a concept of a step. How do we resolve this?

If instead of considering the device itself when coding the logic, what if we were to abstract the meaning of the device from its behavior? That’s the basic idea behind Behavior-Device abstraction.

Navigation sample of the idea

Say I’m building a Unmanned Aerial Vehicle (UAV). I have a navigation behavior which needs realtime orientation data. A typical orientation circuit requires a Gyro and accelerometer for accuracy and drift compensation. If the navigation system had to deal with those calculations, that code becomes unwieldy. However, if it were coded to a single OrientationDevice, then the implementation of that device could be two sub devices – the GyroDevice and AccelerometerDevice, and can build a homogenized notification of orientation changes. What if a manufacturer were to build a single chip that handles both and provides a single interface to it? All one would need to do is replace out the Orientation device without rewriting the Navigation behavior.

The example above described a composition – Each component has a singular responsibility. These are aggregated into a composite or logical device, which then can be actioned upon or notified from independent of the internal implementation.

GCode behavior – Cartesian bot/Extruder

RepRap has 1 main behavior – The GCode interpreter. It receives commands from the host machine, and drives two logical components – the extruder and the Cartesian bot. The Cartesian bot is composed of 3 linear actuators. The Extruder has a temperature sensor, heater and feed device.

The RepRap project uses Stepper motors for linear actuation, with end stops for collision avoidance and homing. It could be implemented using a servo motor or linear stepper driver. Since driving the linear actuator is now abstracted from the behavior, changes to the driving mechanism becomes much less complicated.

In other words, the behavior tells the bot where to go, the bot figures out how to get there, and the linear actuators figure out how to do it.

The Cartesian Bot

class CartesianDevice : public Device, 
                         public Observable,
                         public Observer
     LinearActuator& _x;
     LinearActuator& _y;
     LinearActuator& _z;
     bool _xInMotion;
     bool _yInMotion;
     bool _zInMotion;
     CartesianDevice(LinearActuator& x, LinearActuator& y, LinearActuator& z);

     void moveTo(float newX, float newY, float newZ);
     void moveHome();
     inline bool axesInMotion() { return _xInMotion || _yInMotion || _zInMotion; }
     virtual void notify(uint32_t eventId, void* context);

Linear Actuator

class LinearActuator : public Device, public Observable, public Observer { float _currentPos; float _revPerMM; StepperDevice& _stepper; OpticalInterrupt& _nearInterrupter; OpticalInterrupt& _farInterrupter; public: LinearActuator(float _revPerMM, StepperDevice& stepper, OpticalInterrupt& far, OpticalInterrupt& near); inline float currentPosition() { return _currentPos; } inline void setTempRate(float rate) { _stepper.setTempRate(rate); } void moveTo(float newPosMM); void moveHome(); virtual void notify(uint32_t eventId, void* context); };

Stepper Device

class StepperDevice : public EventLoopTimer, 
                      public Device, 
                      public Observable
    int8_t _stepPin;
    int8_t _dirPin;
    bool _forward;
    int _currentTick;
    int _targetTick;
    int _ticksPerRev;
    milliclock_t _maxRate;
    StepperDevice(int8_t stepPin, int8_t dirPin, int ticksPerRev, milliclock_t rate);
    void goForward();
    void goBackward();
    void turn(float numberOfRevolutions = 0.0f);
    void start();
    void stop();
    void setTempRate(float rate);
    virtual void fire();


class OpticalInterrupt : public Device, 
                         public Observable, 
                         public PeriodicCallback
    int _inputPin;
    OpticalInterrupt(int pin);
    virtual void service();

Event Loop for the Arduino

March 27th, 2009 § Comments Off on Event Loop for the Arduino § permalink

Making an LED blink or driving a single stepper using the Arduino is very easy – pulse a pin in the Arduino loop handler is all you need. However, as builds become more complex, there is often the need to manage multiple devices.

The RepRap firmware is such a project. The firmware has numerous steppers, motors, heaters, fans and sensors – it is chalk full of features. The developers have literally performed magic with the tiny little Arduino. However, I believe they will admit that the code base is becoming a little unwieldy and difficult to modify.

As an operating systems developer, my job is to identify patterns in application development, build abstractions which simplify these common cases and generate boiler plate or error prone code. In my post on the RepRap firmware refactor, I described several design patterns which are applicable to not just RepRap, but many other complex embedded projects. The best place to start is with the root of all evil – the event loop.

Event Loop

Event driven programing is a staple of modern application development. In my experience, event driven patterns are not as prevalent in embedded development – it’s a shame, because it is very useful. The main conceptual leap requires the developer to give up control to the power of the loop – a leap that is often very difficult as they are used to complete control. I’ve completed an implementation, which in its current state is more of a timer loop, but will grow to enable queued events (both on and off board).

This code is currently checked into the RepRap source forge repository. It is only dependent on the Dynamic Array implementation checked into the tree as well.

There are several features of this event loop:

  • Periodic (or cycle) events
  • Timed events, with support for wrapping (since the milliclock quickly overflows)
  • Reentrant – You can add or remove events while processing an event
  • Support for nested, independent Eventloops (for those special cases)

(NOTE: It is not interrupt safe at the moment)

Sample Use

void StepperDevice::turn(float numberOfRevolutions)
    if (_currentTick)
    _targetTick = (int)(numberOfRevolutions / _ticksPerRev);

    notifyObservers(StepperEvent_Start, this);

void StepperDevice::fire()
    digitalWrite(_stepPin, HIGH);
    digitalWrite(_stepPin, LOW);

    if (_targetTick && (_currentTick == _targetTick))
        notifyObservers(StepperEvent_Complete, this);

The Event Loop Header

#ifndef EventLoop_h
#define EventLoop_h

typedef unsigned long milliclock_t;
extern const unsigned long MILLICLOCK_MAX;

// Periodic Event Callback
//  Derive from this class to implement a periodic servicing
class PeriodicCallback
  // NOTE: This is a harmless warning: 
  //  alignment of 'PeriodicCallback::_ZTV16PeriodicCallback' 
  // is greater than maximum object file alignment.
  // Bug in avr-g++. 
  // See
    virtual ~PeriodicCallback();
    virtual void service() = 0;

// Timer
//  Derive from this class to implement a periodic timer.
//  This class also contains information needed for 
//  maintianing a timer, designed to be memory efficient.
class EventLoopTimer
    milliclock_t _lastTimeout;
    milliclock_t _period;
    inline void setPeriod(milliclock_t period) 
        { _period = period; }
    EventLoopTimer(unsigned long period);
    virtual ~EventLoopTimer();
    virtual void fire() = 0;
    inline milliclock_t period() const 
    { return _period; }
    inline milliclock_t lastTimeout() const 
        { return _lastTimeout; }
    milliclock_t nextTimeout() const;
    inline void setLastTimeout(milliclock_t nextTimeout) 
        { _lastTimeout = nextTimeout; }

// Event Loop
//  This class implements the main loop. 
//  It allows clients to register for periodic 
//      servicing, or timed servicing.
class EventLoop
    DArray _periodicEvents;
    DArray _timers;
    milliclock_t _lastTimeout;
    bool _running;
    void sortTimers();
    DArray* findFiringTimers();
    void addPeriodicCallback(PeriodicCallback* callback);
    void removePeriodicCallback(PeriodicCallback* callback);
    int periodicCallbacks() { return _periodicEvents.count(); }

    void addTimer(EventLoopTimer* timer);
    void removeTimer(EventLoopTimer* timer);
    int timers() { return _timers.count(); }
    bool running() { return _running; }
    void exit() { _running = false; }

    void run();
    static EventLoop* current();


Updated Arduino plugin

March 24th, 2009 § Comments Off on Updated Arduino plugin § permalink

I updated the Arduino plugin with the following features:

  • ATMega328 support
  • Arduino programming model (setup/loop instead of main)
  • Support for pde files (which are just C++ source files)

Download link

Let me know if you have any issues. (or send a quick note to say you use it)

Retrofitting an EasyDriver

March 5th, 2009 § Comments Off on Retrofitting an EasyDriver § permalink

Brian Schmalz’s easy driver, offered by SparkFun is a nice little stepper driver. There are two major deficiencies however: It is hard wired to eighth step mode, and the ground pin is opposite the signal pins. I decided to fix these as I reassemble the extruder.

The step mode on the A3967 is selected by pin 12 & pin 13. By bringing these pins low, we can select full step. This is achieved by clipping the pins from the pads and soldering a wire to ground – the same ground I wanted to route over to the signal pins. In order to seat the polarized header, I filed a pin slot and soldered the ground jumper.
Rev EasyDriver

Where am I?

You are currently viewing the archives for March, 2009 at OoeyGUI.