So we spent some money on some kit and in the next few weeks will be busy making as much content as we can manage…

Only the head, clutch and gearbox were salvaged from the old engine, all the rest is new including a nice kent500 cam.

Pulled away from a junction and the engine suddenly turn into a bag of spanners, luckily I was only a couple of hundred yards from home so managed to coast pretty much all the way.

I’ve taken the head off and theres bits of aluminium stuck to the tops of the pistons and some holes around the edges, not good.

Did buy a nice new set of lamps, halogen of course! Might be able to see where I’m going.

On the DCC front, lets just say I wasn’t impressed. The items on sale were under featured, many had user interfaces much like an early 80s pocket calculator, not good at all. There was a couple that had nice interfaces but they were up around the £400 mark, ouch.

On to the booster, the cheapest was around £150 for a 4A unit, way too much, there was an 8A for £250 too. Considering the modern N gauge locos draw somewhere around 50mA-100mA theres no way i was pay that much, just to help development.

In the end I spotted a Hornby Select for £60 which has a built in booster capable or just under 1A, with a bit of modding (15v -> 12v and bring out the logic level DCC rails) it’s woking a treat! yay.

I’ll also be adding a video of some of the layouts to this post at some point.

Went to Halfords armed with measurements and suggestion from various forums and came out with a HB075, which was about 2mm wider than the hole in the boot floor. However, the 075 seemed to be the battery of choice so I gave it a go.

What can I say, perfect fit, once in, a bit of a shove and it’s just snug against the sides!
Lower profile, higher capacity and a much higher current handling, getting on for double the old battery.

Anyway, if you have a mini with a dead battery and need one in a hurry get one of the Halfords 075, if your not in a hurry get one from somewhere else with the same measurements.

The Wot series of planes from Chris Foss are well known among RC pilots, especially the British ones. The Wot4 being one of the best flying models ever created, the first version over 25 years ago.
The foamie version sharing the same looks as the larger original, but still maintaining the great flying characteristics.

www.youtube.com/watch?v=JEhhBPI5GEM

Instead I use commonly available, fairly cheap aluminium and brass tube from B&Q, and M3 studding which is available from most model engineering suppliers.

I’ll assume you can work out the length yourself and go straight into making the links.

Step 1:
Cut the brass and aluminium tube to equal lengths, I like to use a small pipe cutter as it gaurantees a straight cut.

Step 2:
Press the brass into the aluminium tube, since the tollarances on the cheap aluminium tubes aren’t great the brass could be a very tight fit, to make it easier put the brass in the fridge for 10 mins, then gently heat up the aluminium, you only heed to heat it a little, just to the point you can’t touch it.

Step 3:
Cut the M3 studding to length, for the Axial ball ends on the SCX10 6mm of thread is needed, to cut the studding 12mm longer than the tubes.

Step 4:
Fit the ball ends and attach the finished links to your truck.

So there you go, they look the part, are super strong and you can make a set in under an hour, what more could you want?..

The font in 5×7 pixels making the it 470 bytes including a smiley.

Ideally it wants a way of programming it without rewriting the whole program, perhaps a low speed soft serial on one of the Port2 pins, not sure yet.

The source file can be found here main.c

or here in this text box:

#include  <msp430x20x3.h>

#define FONTWIDTH 5					// Number of bytes wide
#define FONTOFFSET 32				// Offset of font array to ascii
#define SCANDELAY 50				// Scan speed, smaller is faster

// ***********************
// *  Message to display *
// ***********************
const unsigned char message[] = {"The quick brown fox jumps over the lazy dog"};

const unsigned char System5x7[] = {							// The font
	0x00, 0x00, 0x00, 0x00, 0x00,// (space)
	0x00, 0x00, 0x5F, 0x00, 0x00,// !
	0x00, 0x07, 0x00, 0x07, 0x00,// "
	0x14, 0x7F, 0x14, 0x7F, 0x14,// #
	0x24, 0x2A, 0x7F, 0x2A, 0x12,// $
	0x23, 0x13, 0x08, 0x64, 0x62,// %
	0x36, 0x49, 0x55, 0x22, 0x50,// &
	0x00, 0x05, 0x03, 0x00, 0x00,// '
	0x00, 0x1C, 0x22, 0x41, 0x00,// (
	0x00, 0x41, 0x22, 0x1C, 0x00,// )
	0x08, 0x2A, 0x1C, 0x2A, 0x08,// *
	0x08, 0x08, 0x3E, 0x08, 0x08,// +
	0x00, 0x50, 0x30, 0x00, 0x00,// ,
	0x08, 0x08, 0x08, 0x08, 0x08,// -
	0x00, 0x60, 0x60, 0x00, 0x00,// .
	0x20, 0x10, 0x08, 0x04, 0x02,// /
	0x3E, 0x51, 0x49, 0x45, 0x3E,// 0
	0x00, 0x42, 0x7F, 0x40, 0x00,// 1
	0x42, 0x61, 0x51, 0x49, 0x46,// 2
	0x21, 0x41, 0x45, 0x4B, 0x31,// 3
	0x18, 0x14, 0x12, 0x7F, 0x10,// 4
	0x27, 0x45, 0x45, 0x45, 0x39,// 5
	0x3C, 0x4A, 0x49, 0x49, 0x30,// 6
	0x01, 0x71, 0x09, 0x05, 0x03,// 7
	0x36, 0x49, 0x49, 0x49, 0x36,// 8
	0x06, 0x49, 0x49, 0x29, 0x1E,// 9
	0x00, 0x36, 0x36, 0x00, 0x00,// :
	0x00, 0x56, 0x36, 0x00, 0x00,// ;
	0x00, 0x08, 0x14, 0x22, 0x41,// <
	0x14, 0x14, 0x14, 0x14, 0x14,// =
	0x41, 0x22, 0x14, 0x08, 0x00,// >
	0x02, 0x01, 0x51, 0x09, 0x06,// ?
	0x32, 0x49, 0x79, 0x41, 0x3E,// @
	0x7E, 0x11, 0x11, 0x11, 0x7E,// A
	0x7F, 0x49, 0x49, 0x49, 0x36,// B
	0x3E, 0x41, 0x41, 0x41, 0x22,// C
	0x7F, 0x41, 0x41, 0x22, 0x1C,// D
	0x7F, 0x49, 0x49, 0x49, 0x41,// E
	0x7F, 0x09, 0x09, 0x01, 0x01,// F
	0x3E, 0x41, 0x41, 0x51, 0x32,// G
	0x7F, 0x08, 0x08, 0x08, 0x7F,// H
	0x00, 0x41, 0x7F, 0x41, 0x00,// I
	0x20, 0x40, 0x41, 0x3F, 0x01,// J
	0x7F, 0x08, 0x14, 0x22, 0x41,// K
	0x7F, 0x40, 0x40, 0x40, 0x40,// L
	0x7F, 0x02, 0x04, 0x02, 0x7F,// M
	0x7F, 0x04, 0x08, 0x10, 0x7F,// N
	0x3E, 0x41, 0x41, 0x41, 0x3E,// O
	0x7F, 0x09, 0x09, 0x09, 0x06,// P
	0x3E, 0x41, 0x51, 0x21, 0x5E,// Q
	0x7F, 0x09, 0x19, 0x29, 0x46,// R
	0x46, 0x49, 0x49, 0x49, 0x31,// S
	0x01, 0x01, 0x7F, 0x01, 0x01,// T
	0x3F, 0x40, 0x40, 0x40, 0x3F,// U
	0x1F, 0x20, 0x40, 0x20, 0x1F,// V
	0x7F, 0x20, 0x18, 0x20, 0x7F,// W
	0x63, 0x14, 0x08, 0x14, 0x63,// X
	0x03, 0x04, 0x78, 0x04, 0x03,// Y
	0x61, 0x51, 0x49, 0x45, 0x43,// Z
	0x00, 0x00, 0x7F, 0x41, 0x41,// [
	0x02, 0x04, 0x08, 0x10, 0x20,// "\"
	0x41, 0x41, 0x7F, 0x00, 0x00,// ]
	0x04, 0x02, 0x01, 0x02, 0x04,// ^
	0x40, 0x40, 0x40, 0x40, 0x40,// _
	0x00, 0x01, 0x02, 0x04, 0x00,// `
	0x20, 0x54, 0x54, 0x54, 0x78,// a
	0x7F, 0x48, 0x44, 0x44, 0x38,// b
	0x38, 0x44, 0x44, 0x44, 0x20,// c
	0x38, 0x44, 0x44, 0x48, 0x7F,// d
	0x38, 0x54, 0x54, 0x54, 0x18,// e
	0x08, 0x7E, 0x09, 0x01, 0x02,// f
	0x08, 0x14, 0x54, 0x54, 0x3C,// g
	0x7F, 0x08, 0x04, 0x04, 0x78,// h
	0x00, 0x44, 0x7D, 0x40, 0x00,// i
	0x20, 0x40, 0x44, 0x3D, 0x00,// j
	0x00, 0x7F, 0x10, 0x28, 0x44,// k
	0x00, 0x41, 0x7F, 0x40, 0x00,// l
	0x7C, 0x04, 0x18, 0x04, 0x78,// m
	0x7C, 0x08, 0x04, 0x04, 0x78,// n
	0x38, 0x44, 0x44, 0x44, 0x38,// o
	0x7C, 0x14, 0x14, 0x14, 0x08,// p
	0x08, 0x14, 0x14, 0x18, 0x7C,// q
	0x7C, 0x08, 0x04, 0x04, 0x08,// r
	0x48, 0x54, 0x54, 0x54, 0x20,// s
	0x04, 0x3F, 0x44, 0x40, 0x20,// t
	0x3C, 0x40, 0x40, 0x20, 0x7C,// u
	0x1C, 0x20, 0x40, 0x20, 0x1C,// v
	0x3C, 0x40, 0x30, 0x40, 0x3C,// w
	0x44, 0x28, 0x10, 0x28, 0x44,// x
	0x0C, 0x50, 0x50, 0x50, 0x3C,// y
	0x44, 0x64, 0x54, 0x4C, 0x44,// z
	0x00, 0x08, 0x36, 0x41, 0x00,// {
	0x00, 0x00, 0x7F, 0x00, 0x00,// |
	0x00, 0x41, 0x36, 0x08, 0x00,// }
	0x10, 0x22, 0x28, 0x22, 0x10, // :)
};

void delayMS(unsigned int ms )							// MS delay function
{
    unsigned int i;
    for (i = 0; i<= ms; i++)
       __delay_cycles(500);
}

void displayChar(unsigned char inChar){					// Function to display a character
	int i;
	for(i=0;i<FONTWIDTH;i++){
		P1OUT = System5x7[(inChar-FONTOFFSET)*5+i];		// Set the LEDs to the character part
		delayMS(SCANDELAY);								// Delay so the LEDs are visable
		P1OUT = 0x00;									// Turn off the LEDs
		delayMS(SCANDELAY/10);							// Delay so you can see the character
	}													// parts

	delayMS(SCANDELAY);									// Bit of a gap between characters
}

//*******************
//*  main function  *
//*******************
void main(void){
	WDTCTL = WDTPW + WDTHOLD;				// Stop watchdog

	P1DIR |= 0xff;							// Set port 1 to output
	P1OUT = 0x00;							// Make sure port 1 is LOW

	int arraySize = sizeof(message);		// Get the message length

	int i;
	for(i=0;i<arraySize;i++){				// Send message one charicter at time
		displayChar(message[i]);			// too the led array
	}

	P1OUT = 0x00;							// Make sure all the LEDs are off

	while(1){								// Make sure the processor doesn't
											// do something silly by putting it
	}										// in a loop
}

So I quickly made up these labels to stick on female header, they include extra GND and VCC labels.

If you have trouble with the GIF I’ve also made a PDF, which can be downloaded from this link
http://www.beigematchbox.co.uk/blog/wp-content/uploads/2010/09/ti_launchpad_header_labels.pdf

www.youtube.com/watch?v=nFJbpV_LppQ

Just a quick video demonstrating the skeleton program for controlling lights on an RC truck (Axial Honcho) from the transmitter with only a 2 position switch (Ch3) to control normal/mode selection, and the steering to choose the mode.

The box can currently handle 8 LED channels, such as brake/tail, headlight, left indicators etc.
It gets it’s channel information from the 3 servo connectors on the receiver.

I’m also considering ways to monitor the motor speed, with that and the throttle position it will be possible to work out when your driving in reverse, so turning on a reversing light.

And yes, thats an Arduino, a Pro mini at 8MHz on 3.3v.

So, without further ado…
http://www.itunes.com/apps/whatsmympg

Click, download and have a play
Don’t forget it’s 100% free, runs on anything with iPhone OS 3 or later, including iOS4 and the iPad

Anyway, I’ve been wanting to make an audio visualiser for a while, looked at many ways of going about driving lots of LEDs with brightness control almost all using various chips to generate a separate PWM for each LED, to me this sounds all to easy… So I set about doing it with just an Arduino with an ATMEGA168.

The layout is basically the same as a normal common anode LED matrix, except the anodes are PWN driven.

The software is all done through the main loop, no interrupts. This makes things a little more interesting, having to keep the loop nice and short, basically as long as it’s under around 800us it wont interfere with running the LEDs.

Plan is to connect up a pair of these giving 10 leds per audio channel using serial to keep things in sync, such as the mode, buffer size etc.

Once I can find some nice small 4 pin polarised connectors for the LEDs I can hook them up, which should show off the effect nicely.

www.youtube.com/watch?v=nBDrcngNGDM

Oh and the matrix scans at 100Hz, which beats a little with my 50Hz camera, to the human eye the effect is smooth.

/*
BeigeMatchbox.co.uk 8/8/2010
If you use any of my code please pop a credit in your source
*/

// Pin asignments
#define OPTIONPOT 2
#define MODEBUTTON 15
#define REDBUTTON 17
#define GREENBUTTON 18
#define BLUEBUTTON 19
const char pots[] = {3, 4, 5};
const char led[] = {9, 10, 11};
const char anode[] = {2, 3, 4, 5, 6, 7, 8, 12, 13, 14};

// ADC Values
byte audioSamples[4] = {0, 0, 0};
byte optionPot = 0;

// Audio Smoothing Buffers
byte sampleBufferOne[192];  // due to overhead the sample buffers are split
byte sampleBufferTwo[192];
byte sampleBufferThree[192];
byte samplePointers[3];

// Current lit LED
char clockCount = 0;

// Mode selection
char modeNumber = 0;
const char maxMode = 4;

// Misc vars for demos
byte refByte = 0;
byte refByteTwo = 0;
boolean getBrighter = true;
unsigned long dimmerMicros = 0;
long millisOne = 0;
long millisTwo = 0;
long millisThree = 0;
long millisFour = 0;

// var for scan freq
unsigned long scanMicros = 0;

// Full frame buffer R, G, B
//   0 == off, 255 == on
byte frame[11][4] = {
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0},
  {0, 0, 0}
};

// ************************
// * Hardware Setup       *
// ************************

void setup(){
  // Set dividers on timer 1 and 2 to 1
  TCCR1B = TCCR1B & 0b11111000 | 0x01;
  TCCR2B = TCCR2B & 0b11111000 | 0x01;

  Serial.begin(19200);

  pinMode(MODEBUTTON, INPUT);
  pinMode(REDBUTTON, INPUT);
  pinMode(GREENBUTTON, INPUT);
  pinMode(BLUEBUTTON, INPUT);

  for (char i=0; i <= 2; i++){
    pinMode(led[i], OUTPUT);
    analogWrite(led[i], 255);
  }

  for (char i=0; i <= 9; i++){
    pinMode(anode[i], OUTPUT);
    digitalWrite(anode[i], HIGH);
  }

  digitalWrite(MODEBUTTON, HIGH);
  digitalWrite(REDBUTTON, HIGH);
  digitalWrite(GREENBUTTON, HIGH);
  digitalWrite(BLUEBUTTON, HIGH);

}

// ************************
// * Main Loop            *
// ************************

void loop(){

 doScan();
 doButton();
 doMode();
 doOptionPot();

}

// ************************
// * Mode Loops           *
// ************************

void doMode(){
  switch (modeNumber) {
    case 0:
      blinkerMode();
      break;
    case 1:
      knightMode();
      break;
    case 2:
      randomMode();
      break;
    case 3:
      snakeMode();
      break;
    case 4:
      sampleMode();
      break;
    default:
      break;
  }
}

// ************************
// * Mode Button          *
// ************************

void doButton(){
  if(digitalRead(MODEBUTTON) == LOW){
    clearFrame();
    clearLeds();
    modeNumber ++;
    if(modeNumber > maxMode){
      modeNumber = 0;
    }

    waitForButtons();

    dimmerMicros = micros();
    millisOne = millis();
    millisTwo = millis();
    millisThree = millis();
    getBrighter = true;
    refByte = 0;
    refByteTwo = 0;

  }
}

// ************************
// * Option Pot                *
// ************************

void doOptionPot(){
  if (millis() - millisFour > 10) {
    millisFour = millis();
    if(modeNumber == 4){
      optionPot = map(analogRead(OPTIONPOT), 0, 1023, 1, 192);
    }
    else{
      optionPot = map(analogRead(OPTIONPOT), 0, 1023, 0, 255);
    }
  }

}

// ************************
// * Blinker Mode         *
// ************************

void blinkerMode(){
  if (millis() - dimmerMicros > 1){
    dimmerMicros = millis();
    for (char i=0; i <= 9; i++){
      for (char j=0; j <= 2; j++){
        frame[i][j] = refByte;
      }
    }

  if(getBrighter == true){
    refByte ++;
    if(refByte == 255){
      getBrighter = false;
    }
  }
  else{
    refByte --;
    if(refByte == 0){
      getBrighter = true;
    }
  }
  }
}

// ************************
// * Knight Mode          *
// ************************

void knightMode(){
  dimLeds(1250);

  if (millis() - millisOne > -(optionPot-255)) {
    millisOne = millis(); 

    if(getBrighter == true){
        refByte ++;
        for (char j=0; j <= 2; j++){
          frame[refByte-1][j] = 255;
        }
      if(refByte == 10){
        getBrighter = false;
      }
    }
    else{
      refByte --;
      for (char j=0; j <= 2; j++){
        frame[refByte-1][j] = 255;
      }
      if(refByte == 1){
        getBrighter = true;
      }
    }
  }
}

// ************************
// * snakeMode            *
// ************************

void snakeMode(){
  dimLeds(7500);

  if (millis() - millisOne > -(optionPot-255)) {
    millisOne = millis();

    frame[refByte][refByteTwo] = 255;

    if(getBrighter == true){
      if(refByteTwo >= 2){
        getBrighter = false;
        refByte ++;
        if(refByte > 9){
          refByte = 0;
        }
      }
      else{
        refByteTwo ++;
      }
    }
    else{
      if(refByteTwo <= 0){
        getBrighter = true;
        refByte ++;
        if(refByte > 9){
          refByte = 0;
        }
      }
      else{
        refByteTwo --;
      }
    }
  }
}

// ************************
// * random Mode          *
// ************************

void randomMode(){
  dimLeds(2500);

  if (millis() - millisOne > -(optionPot-255)) {
    millisOne = millis();
    frame[random(0, 10)][random(0, 3)] = 255;
  }
}

// ************************
// * Audio Sample Mode    *
// ************************

void sampleMode(){

  if (millis() - millisThree > 3) {
    millisThree = millis();

    unsigned int smoothed = 0;

    audioSamples[refByte] = -analogRead(pots[refByte])/4-255;

      switch (refByte) {
       case 0:
        sampleBufferOne[samplePointers[refByte]] = audioSamples[refByte];
        break;
       case 1:
        sampleBufferTwo[samplePointers[refByte]] = audioSamples[refByte];
        break;
       case 2:
        sampleBufferThree[samplePointers[refByte]] = audioSamples[refByte];
        break;
       default:
        break;
       }

    for (byte j=0; j <= optionPot-1; j++){
      switch (refByte) {
       case 0:
        smoothed += sampleBufferOne[j];
        break;
       case 1:
        smoothed += sampleBufferTwo[j];
        break;
       case 2:
        smoothed += sampleBufferThree[j];
        break;
       default:
        break;
       }
    //  smoothed += sampleBuffer[refByte][j];
    }
    smoothed /= optionPot;
    if(samplePointers[refByte] <= optionPot-2){
      samplePointers[refByte] ++;
    }
    else{
      samplePointers[refByte] = 0;
    }

    frame[0][refByte] = smoothed;

    if(refByte < 2){
      refByte++;
    }
    else{
      refByte = 0;
    }

  }

  if (millis() - millisTwo > 50) {
    millisTwo = millis();
    for (char i=9; i >= 1; i--){
        for (char j=0; j <= 2; j++){
          frame[i][j] = frame[i-1][j];
        }
      }
    }

}

// ************************
// * Scan Led array and   *
// * dim any lit LEDs     *
// ************************

void dimLeds(int dimSpeed){

  if (micros() - dimmerMicros > dimSpeed) {
    dimmerMicros = micros(); 

    for (char i=0; i <= 9; i++){
      for (char j=0; j <= 2; j++){
        if (frame[i][j] > 0){
          frame[i][j] -= 1;
        }
      }
    }
  }

}

// ************************
// * Scan the matrix      *
// ************************

void doScan(){
  if (micros() - scanMicros > 1000) {
    scanMicros = micros();

    clearLeds();

    digitalWrite(anode[clockCount], HIGH);
    delayMicroseconds(25); //Without this delay there is a flicker

    if(clockCount < 9){
      clockCount ++;
    }
    else{
      clockCount = 0;
    }

    digitalWrite(anode[clockCount], LOW);

    setLeds();
  }
}

void setLeds(){
  for (char i=0; i <= 2; i++){
    analogWrite(led[i], frame[clockCount][i]);
  }
}

void clearLeds(){

    analogWrite(led[0], 0);
    analogWrite(led[1], 0);
    analogWrite(led[2], 0);

}

void clearFrame(){
  for (char i=0; i <= 9; i++){
      for (char j=0; j <= 2; j++){
        frame[i][j] = 0;
      }
  }
}

// ************************
// * Wait for any buttons *
// ************************

void waitForButtons(){

 while(digitalRead(MODEBUTTON) == LOW){
      //wait for button up
    }
}

www.youtube.com/watch?v=czVTEGMq4Ok

The programming was done by me, BeigeMatchbox, the graphics and the conversion formulas were worked out by eagleworks.co.uk

Also, don’t forget to have a look at whatsmympg.co.uk

And a quick video, no plot, just some random clips.

www.youtube.com/watch?v=yozUWe-f6bc