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.
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;
public:
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();
};
OpticalInterrupt
class OpticalInterrupt : public Device,
public Observable,
public PeriodicCallback
{
int _inputPin;
public:
OpticalInterrupt(int pin);
virtual void service();
};
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)
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.
Grid Beam is a building technique developed in the 70’s. It is a simple technique which uses perforated square beams, connected by normal furniture bolts. I first learned about the technique from the book How to build with Grid Beam by new society publishers:
While the book is more of an history of grid beam, it does have some techniques and discussion on design. I think the technique has huge potential as a reusable building method
In need of a Dirty workbench, I decided to build a ‘stick’ making jig and attempt to build a bench. I was surprised by a few things:
Beam stability is a function of the species, not the holes
Hole accuracy is important, but not a deal breaker – the bolts pull the beams together nicely
It takes about 20 minutes to drill a 6 foot beam – not including finishing touches like chamfer
Our home is expensive to heat. Not only is that, but it feels drafty. We were convinced that our main heating problems were the Windows in our family room (where the thermostat is) – all were replaced without any effect.
Annoyed, we needed to find a way to pinpoint our homes problems. We turned to Thermal Imaging by Northwest Infrared to help us understand the problems. I am very impressed and highly recommend their service. I believe this is the single best thing that can be done to your home. It is inexpensive and pinpoints phantom energy loss. Northwest Infrared only does energy evaluation – you’ll get brutally honest information without the sales pitch.
Thermal analysis is a two step process:
Depressurize the home taking accurate barometric measurements to determine how much leakage there is.
Use a thermal imager to see where cold air is leaking into the home.
Common Problems
Attic access not sealed well:
Pipe cutouts are huge openings to the crawl space:
Downdraft vent in the cooktop isn’t sealed or baffled:
Return air vent uses the floor joists instead of being ducted – drawing lots of air from the ‘area between floors’
– And in our case those floor joists are open to the outside!
Check out this ghostly image:
Our Unique Problems
Our new windows weren’t sealed correctly (you can bet we’ll be bringing that up with Anderson Renewable):
Our vents aren’t sealed correctly:
Our worst offender is our heating room which is open to the crawl space. This room is essentially outside, but not insulated like it is an inside closet:
February 11th, 2009 § Comments Off on avr-libc realloc ‘fix’ § permalink
I’ve been working on patterns for Arduino, which relies on a dynamic array for managing event loops, observables, and device abstraction. However, I was blocked by a critical failure in realloc. While I could have worked around it using malloc/free, but wanted to understand what was going on in libc.
One thing that struck me about realloc was the naming conventions; What was the difference between fp1, fp2, cp1, cp2? Some referred to a free block, some referred to a free pointer. I gave up and renamed the variables to something more readable.
The fatal flaw has to do with mixing sizeof(__freelist) and sizeof(size_t). In many cases, the difference results in indexing into the middle of a free list entry, thus corrupting memory.
void* realloc(void *ptr, size_t newLength)
{
struct __freelist *currentBlock, *nextBlock,
*currentFreeBlock, *previousFreeBlock;
char *currentPointer, *nextPointer;
void *memp;
size_t largestBlockSize, sizeIncrease;
/* Trivial case, required by C standard. */
if (ptr == 0)
return Malloc(newLength);
currentPointer = (char *)ptr;
currentBlock = (struct __freelist *)
(currentPointer - sizeof(size_t));
nextPointer = (char *)ptr + newLength; /* new next pointer */
if (nextPointer < currentPointer)
{
/* Pointer wrapped across top of RAM, fail. */
return 0;
}
nextBlock = (struct __freelist *)(nextPointer - sizeof(size_t));
/*
* See whether we are growing or shrinking. When shrinking,
* we split off a chunk for the released portion, and call
* free() on it. Therefore, we can only shrink if the new
* size is at least sizeof(struct __freelist) smaller than the
* previous size.
*/
if (newLength <= currentBlock->sz)
{
/* The first test catches a possible unsigned int
* rollover condition. */
if (currentBlock->sz <= sizeof(struct __freelist) ||
newLength > currentBlock->sz - sizeof(struct __freelist))
{
return ptr;
}
nextBlock->sz = currentBlock->sz - newLength - sizeof(size_t);
currentBlock->sz = newLength;
Free(&(nextBlock->nx));
return ptr;
}
/*
* If we get here, we are growing. First, see whether there
* is space in the free list on top of our current chunk.
*/
sizeIncrease = newLength - currentBlock->sz;
currentPointer = (char *)ptr + currentBlock->sz;
for (largestBlockSize = 0, previousFreeBlock = 0,
currentFreeBlock = __flp; currentFreeBlock;
previousFreeBlock = currentFreeBlock,
currentFreeBlock = currentFreeBlock->nx)
{
if (currentFreeBlock == nextBlock &&
currentFreeBlock->sz >= sizeIncrease)
{
/* found something that fits */
if (sizeIncrease <= currentFreeBlock->sz + sizeof(size_t))
{
/* it just fits, so use it entirely */
currentBlock->sz +=
currentFreeBlock->sz + sizeof(size_t);
if (previousFreeBlock)
previousFreeBlock->nx = currentFreeBlock->nx;
else
__flp = currentFreeBlock->nx;
return ptr;
}
/* split off a new freelist entry */
currentPointer = (char *)ptr + newLength;
nextBlock = (struct __freelist *)
(currentPointer - sizeof(size_t));
nextBlock->nx = currentFreeBlock->nx;
nextBlock->sz = currentFreeBlock->sz -
sizeIncrease - sizeof(size_t);
if (previousFreeBlock)
previousFreeBlock->nx = nextBlock;
else
__flp = nextBlock;
currentBlock->sz = newLength;
return ptr;
}
/*
* Find the largest chunk on the freelist while
* walking it.
*/
if (currentFreeBlock->sz > largestBlockSize)
{
largestBlockSize = currentFreeBlock->sz;
}
}
/*
* If we are the topmost chunk in memory, and there was no
* large enough chunk on the freelist that could be re-used
* (by a call to malloc() below), quickly extend the
* allocation area if possible, without need to copy the old
* data.
*/
if (__brkval == (char *)ptr + currentBlock->sz && newLength > largestBlockSize)
{
nextPointer = __malloc_heap_end;
currentPointer = (char *)ptr + newLength;
if (nextPointer == 0)
{
nextPointer = STACK_POINTER() - __malloc_margin;
}
if (currentPointer < nextPointer)
{
__brkval = currentPointer;
currentBlock->sz = newLength;
return ptr;
}
/* If that failed, we are out of luck. */
return 0;
}
/*
* Call malloc() for a new chunk, then copy over the data, and
* release the old region.
*/
if ((memp = Malloc(newLength)) == 0)
return 0;
memcpy(memp, ptr, currentBlock->sz);
Free(ptr);
return memp;
}
January 30th, 2009 § Comments Off on avr-libc – Realloc bug § permalink
A few months ago I proposed a refactor for the Arduino RepRap firmware. I was quick to code it up and build test cases on the desktop, then ported to the Arduino… Where it failed miserably. There the code languished as I spent time on it here and there. I attempted getting SimulAVR working, but it doesn’t support the Arduino chipsets (thought about adding support). I tried AVR Studio in a bootcamp’d windows install, but it kept hanging when debugging this problem. As a last resort, I ported the avr-libc memory apis to the initial desktop refactor, and was able to see the problem clear as day. I spent some time reducing the repro to the smallest form:
There is a bug in the free list manager in Realloc, specifically when growing a buffer into the next free entry. I was convinced I had a bug in a fairly large codebase, and whittled it down to this reproduction. I’m now playing with a couple of fixes, but need to figure out how to get a ‘blessed’ fix into lib-avr.
Stepping through the malloc into the free results in: