I was in an vintage collectables store and saw a beaten up old ‘Robie the Robot’ forgotten at the back of a shelf. It’s dome was cracked and it’s remote missing. Robot collectors are quite voracious in Canberra with most robots snapped up within days. However, it seems nobody relished this rough robotic remnant, so I got it cheap.

This robot was also known as: Tandy Robie, Radio Shack Robie, Robie the Robot, Talking Robie, RS 4061, Robocom 1000, Robie Parlant, Robocom Robot (Super). There is a good write up about the robot on theoldrobots.

Tear Down

Disassembling Robie I discovered a typical 80’s remote control toy. RC circuitry oozing with leaking capacitor electrolyte and decayed protective lacquer. Apparently the built in speaker could talk, but looking at the circuitry, my guess is it functioned as a wally talky, playing a voice signal from the remote. I didn’t have the remote so I can’t confirm.

The motors were the “old style”; power hungry and weak. The Achilles heel that made all 80’s moving toys kinda nerfed.

The front screen was fake, the heads and arms were not designed to move. I will need to fix all this.

A New Brain.

Decided to throw a pi in there, with a monitor that fits the front screen and a camera because that would be cool.

For the display, a generic five dollar 2.2″ SPI TFT LCD that sells for arduino projects works well (fits just behind the front monitor panel). The stock plastic used for Robies display is way to dark for the screen to be visible, so I used a Fresnel lens instead (you can get them from the two dollar shop, sold a book magnifiers).

A front assembly was 3d printed to hold the pi, monitor and camera (such that everything lined up, and the camera could see out of the hole previously used for the frontal on/off switch.

Motorising the Head

A turntable system was created in OpenSCAD, using the awesome parametric gear library by Dr Jörg Janssen. I didn’t have a 3d printer, so I printed via the ANU Makerspace.

The turntable is driven by a 28byj-48 stepper motor, with a ULN2003 Darlington transistor array driver.

I discovered the original broken dome was most likely not a custom mould, but a security camera dome. I had some difficulty justifying a proper replacement as Australian retailers wanted over $50 for a replacement security camera dome (just the one piece of plastic). So I just replaced the head with a plastic dome from a toy shop.

The result is not quite as fast as I would like, but it was unexpectedly charming.

Getting the arms to move.

A bracket was designed to get some cheap tower-pro servos to fit aligned with the arms. The brackets neatly affixes to old circuit mounting points in the plastic. A custom servo horn will friction fitted the arms to the servo. The existing arm bearing was sanded a bit to get it to slide freely. The result is a much more expressive robot.

Whats next.

I have made files for the progress thus far available via github, encase anyone has a Robie of their own and wants to try this. https://github.com/busyDuckman/robbie

Next up I will work on:

• Drive system so Robie can move around.
• Microphone array so voice interaction is possible.
• Control software.
• Personality and human interaction.

You can download it via: https://www.thingiverse.com/thing:4300602

Background

Some manufactures put the VESA mount at the bottom of the screen, others in the middle. This can cause an issue for many situations, especially if monitors need to be used on a shared mount or in portrait mode.

Lets compare the pro’s cons of the mounting styles:

The result for a shared mount was quite noticeable.

The plate which pokes out, should connect to the monitor. The other to the VESA mount (See below).

Customisation

The mount can be customised in OpenSCAD, or via the Thingverse customiser: https://www.thingiverse.com/apps/customizer/run?thing_id=4300602.

The following parameters should be altered to suit your need.

Recently I have been building a train set, I will blog the progress, in six parts, highlighting how I get certain things done.

• Part 1 – Design and Woodwork
• Part 2 – Electrical design.
• Part 3 – Mechanical servicing
• Part 4 – Construction
• Part 5 – Painting of buildings and natural elements.
• Part 6 – Embedded computing and setup of DCC controllers.

Base Setup

Firstly I am designing a track that is movable from a storage hook on a garage, to a pool table in my living. This requires a baseboard, which I constructed with three cross breams, an MDF sheet and Tasmanian oak edging.

Designing the layout.

I used  the Simple Computer Aided Railway Modeller (SCARM) to plan my layout.  A read over an old German railway construction guide gave me a lot of practical hints as to what made a good layout.

Layout as viewed from the front.

layout as viewed from the rear.

Setting up the levels for hills and track.

The frame work is wood and MDF. Before getting into some neat tricks, lets look at a time lapse.

Steps:

• The track plan is printed 1:1 on a standard printer using 40 pieces of paper, there is a trick to doing this in SCARM.
• The layout is placed on the board and a toy train is run over it, just to get a feel for what it will be like to interact with.
• Spacers are cut on a table saw, so that the MDF can be set to the correct height for the track.
• Contours are cut from MDF using a jigsaw and the track carver up and placed on top of the MDF.
• Everything is assembled, a brad gun and wood glue is a quick way to get this done. I screw down the MDF, without glue, so I can  run wires later.

Train storage Cabinet.

I built a cabinet to hold the trains and keep them dust free.

• It is build like a picture frame, but I used the table saw to create a ‘grove cut’ on the frame.
• The grove allows two pieces of acrylic to slide like doors in the frame.
• If your not 100% on table saws, this video is terrific. (10:20 explains grove cuts).
• Using acrylic instead of glass lets me insert the doors after assembly (acrylic bends)
• The wood is Tasmanian oak (to match the table) and the finish is Linseed oil followed by a glossy furniture polish.
  • Frame Cutting  in Tasmanian oak is fraught with random peril. If you cut the long edges first, you can reuse failed cuts for the short edges, saving timber.

Bias Lighting is a light around your display that helps you perceive contrast and reduces eye stress. It also just looks just plain cool, and create a kind of relaxed vibe.

There is a lot of theory on optimising bias lighting, but really any light will help quite a bit. So why not see if we can do anything inventive with the bias lighting colour.

The Idea

Lets use a bias lighting that changes colour, and experiment with:

• Altering the colour to  correspond with the time of a day
• Blink light to warn you that you have a meeting soon
• Having the colour change match the movement of the sun
• Changing the colour to green (or whatever) when its your “bed time”
• Using a colour change scheme set to work with your circadian rhythm

Materials

What you will need:

• Some WS2811 LED strips (approx 30cm per monitor)
• An arduino
• Some 3 core wire
• About an hour free time
• Electrical tape

Results

WS2811 RGB Strips

WS2811 strips can be acquired via Ali Express at a reasonable price, they are a strip of RGB LED’s that are individually addressable (set any LED to any colour).

Pros’

• Each chip has an active data repeater that forwards the data signal. Provided the 5v power to the strip is strong, the data signal is propagated to as many chips as you like.
• Very good value
• Strong bright lights
• Fast data channel
• Only requires one GPIO pin.

Cons’

• PWM control used for arbitrary colours is not super fast. Use of 7 colours that involve any LED being either full on or gull off produces results that work better for moving items / camera.
• Poor build quality occasionally causes minor issues
• Some visual artefacts from “fast moving pixels”.  (that can look very cool if used correctly).

The strips look like what you see below. They can be cut to length, and have a soldered connection every 30cm or so.  The arrows indicate the direction the data signal is propagated in, your controller (eg an arduino) must be connected to the left most (first) arrow. However the voltage to run the strip can be applied anywhere.

A close up look shows a chip (black part on the left) and three LED’s, the middle one being red.

Arduino Setup

For effective bias lighting, stick an adhesive LED strip to the back of your monitor, about 5cm from the top. The arduino can be mounted with stick on velcro to what have you. If necessary, connect up multiple sections of LED strips (one for each monitor) using a good 3 core wire.

The LED strip’s data line is connected to a single arduino GPIO pin configured as an output.  Its important to note the strip has an arrow on it, this arrow shows the direction the data will travel. Your data cable must be connected to the first  LED in the strip (not the last).

For my three monitors I was able to power the strip directly from my arduino, using only USB power. Though your mileage may vary.

Setup via USB Power

If you can get away with it wire up the strips shown in the top diagram. Be aware that your PC or USB hub will be responsible for providing power to a large set of lights.

Consider some issues with this:

• There will remain a significant current draw on the PC even while its in sleep mode (or running of batteries).  Be aware not all PC power supplies sleep well , they may turn their fans off even though you are drawing enough current to necessitate a low amount of active cooling.
• Your arduinos regulator will may get hot.
• Your USB port may well not be up to task.

For these reasons I would advise:

• Connection via a powered USB hub. 
• Use of a USB Doctor Device to check your current draw is sensible (eg 350mA or below, the 500mA max in the USB spec does not always pan out well)
• Configuring the brightness of the LED output (programmatically) to reduce current draw.
• Don’t connect the Arduous power jack to a DC wall adapter (see note on ground loops later in this article).

If your Arduino fails to start, or the strip displays a gaudy set of flashing bright colours, you will need to use external power to run the strip. The cutt-off regarding how long your strip can be, before problems appear varies greatly between different production runs (of the RGB strip, not the arduino).

Setup via External 5V power supply

To use an external power supply  to power the strip is not difficult (see image below). But it leaves us with the annoying issue of ground loops (see ground loop section later in this article).

To use external 5V power:

• Connect the 5V ground to both the arduinos ground and the LED strips ground.
• Set-up a 7V(ish) power for the arduinos DC Jack, and use a cheap buck DC-DC power supply (eg LM2596 module) to drop that voltage down to 5V, which is connected to the LED strips power supply.
• Resist the urge to just get a 5V power supply and connect it to both the arduous 5V pin and the LED strip, unless you have a good regulated 5V supply.

A little more safety to this circuit

The soldering of wiring to the LED strip is often problematic, and the area is often moved / stressed / bent.  This can cause the electrical connection to come loose, short or form an intermittent contact.

We may want to protect the first LED package in the strip from damage caused by too much current passing though the data line (I suggest using a 330 ohm resistor).  It’s also not a bad idea to provide a 1000uF decoupling capacitor (use an electrolytic capacitor and watch the polarity). Without this you risk a wiring issue, or power connection issue, damaging the first LED unit on the strip.

In practice, you may never have a problem without these extra components, and the damage is often repaired easily by removing the first pixel and re-soldering. So the decision is yours, a ‘best practice’ version of the above circuits is shown below.

Watchout for ground loops

If you need more power than just the USB connection you will have to give some thought to protecting your computer from ground loops.

The possibility of a ground loop exists when your arduino is connected to the PC via a USB cable and both the arduino (or connected circuitry) and the PC are mains connected in some way (even via a plug pack).

Possible solutions include:

• USB isolator (eg: this one)
• Powering the PC from battery (eg laptop)
• Powering the arduino from battery (eg 6v SLA)
• Powering the arduino and circuitry from a plug-pack and using a wireless connection to communicate to the arduino
• Don’t connect the usb cable
  • Use a network enabled board (the network ports are very well isolated). The etherten is great for this.
  • Use wifi via a $5 esp8266 (for example this one)
  • Use an infra red serial connection (2400 baud)
• Just live with a potential ground loop
  • Plug everything into the same wall socket and keep your fingers crossed.

Basic arduino code to test out the LED Strip

Now we have to check our electrical project functions as predicted. For this article, and part 2, I will be using the FastSPI_LED2 library from  fastled.io.

This demo code will create the effect shown in the video at the top of this article. If all you wanted was cool looking bias lighting, your’e done!

#include "FastSPI_LED2.h"

//----------------------------------------------------------------------------------------
//
// LED stip driver for smooth HUE trnsitions radiating from the middle of the LED strip.
//
//----------------------------------------------------------------------------------------

//Alter this to suit your setup
#define NUM_LEDS 91
#define PIN_LED 4

//This is where the individual pixel for ever LED is stored.
//use LEDS.show(); to sync the strip with the data in this array.
struct CRGB leds[NUM_LEDS];

void setup() 
{
	  // sanity check delay - allows reprogramming if accidently blowing power w/leds
   	delay(2000);

   	//to prevent too high  a power draw use 25% brightness
   	LEDS.setBrightness(64);

    //setup the LED controller
    LEDS.addLeds<WS2811, PIN_LED, RGB>(leds, NUM_LEDS);
}


void loop()
{ 
  byte hueMiddle=0;
  byte hueEdge=0;
  byte hueStep = 48;
  int maxHue = 255; //NB: hue may not be in the range 0-255, if we use a differnt hsv2rgb function.
  bool sync = false;
  
  while(true)
  {
    //pause a second
    delay(1000);

    //push the hue of the middle part of the bias light forward
    for(int s=0; s< hueStep; s++)
    {
        hueMiddle++;
        if(hueMiddle >= maxHue)
        {
          sync = true;
          break;
        }
        updateStrip(hueMiddle, hueEdge);
    }

    //have the edge of the bias light catch up to the hue in the middle
    for(int s=0; s< hueStep; s++)
    {
        hueEdge++;
        if(hueEdge >= maxHue)
        {
          sync = true;
          break;
        }
       updateStrip(hueMiddle, hueEdge);
    }

    // Reached the end of the hue cycle, wrap to the begining.
    // We do it this way because if the hueMiddle wraps around, but the
    // hueEdge remains before the end, then a full rainbow is creted
    // when updateStrip smooths the pixels over the strip
    if(sync)
    {
       hueMiddle = 0;
       hueEdge = 0;
       sync = false;
    } 
  }
}


// This method creates a smooth transition of pixels, from one hue in the middle
// to another hue at the edge.
//
//note: Could be faster with symetry away from middle.
//note: Could be faster with integer math.
//note: Because of the long delay, this does not need to be fast.
void updateStrip(byte hueMiddle, byte hueEdge)
{
    float mid = NUM_LEDS/2;
    int hueDiff =  hueEdge - hueMiddle;
    for(int i = 0; i < NUM_LEDS; i++) 
    {
        //get the hue for the pixel
        CRGB pixel;
        float h = abs(i-mid)/mid; //0 at mid, 1 at edge
        h *= hueDiff; //0 at mid, hueDiff at edge
        h += hueMiddle; //hueMiddle at mid, hueEdge at edge

        //set the pixel
        hsv2rgb_spectrum(CHSV((byte)round(h), 255, 255), pixel);
        leds[i] = pixel;
    }
    delay(150);
    LEDS.show();
}

What’s next?

In a follow-up article (part-2) we will cover syncing your arduino to the computers clock, choosing good colours for different times of the day and using your location to calculate where the sun is (in case you want to tune your your lighting to the time of the day).

This cabinet cooling hack is based around the Artic F12 TC series fans because this fan has a built in temperature sensor. It’s not a hardware hack at all. but a ‘cabinet hack’; so don’t be afraid to give it a go if your not into electronics.

These fans are awesome for cabinets (cooling your amp. game console, etc) because they:

• have their own temperature sensor and speed up accordingly;
• are basically silent until needed;
• use a fluid dynamic bearings (much longer lasting than regular fans)
• know when to speed up (temperature profile is pretty good);
• are long lasting;, with a 6 year warranty;
• less irritating and deeper than normal fans (sounds like a fridge) when going full ball.
• are not expensive.
• The specs say it can run on 5v so USB power may be an option.
  • Edit: I just tried one out on my bench-top power supply. It did not move until about 6.5v.

Links:

• ARCTIC F12 TC
• ARCTIC F12 PRO TC

For this project I am using my DIY honey-comb fan guard (details here) to protect the fan and install it into a cabinet.

Step 1: Plan it out.

Some things you need to do first,

• Figure out which way you are going to position the fan.
  • Many people have the fan blow into the cabinet so that dust is not drawn in through every crack
  • You can then protect the from sucking dust in with a screen
  • Note: You don’t want the fan working against another devices fan, which it sits behind
• Route 12v power to the fan pins and check it spins and works before installing.
  • Don’t worry about an off switch, it will idle silent when your devices don’t need cooling.
  • You can use a 12v wall wart.
• Look into dust catching foam
• By my testing, this neat little fan in question draws 30mA on idle and about 100mA when going full throttle.
  • So look for a 12v wall-wart in the 150mA to 200mA range.
  • Also Red is positive, black is negative, and don’t do anything with the yellow.

Step 2: Cut your cabinet.

Take care, with this.

• Use a 120mm hole saw and a stencil (I have one here).
• Drill from the outside in
• Unplug everything in your cabinet, don’t dill through into your favourite electronic toy.
• Do the hole-saw first, then the other four holes.
  • Then, if your hole saw moves of target, you can reposition your stencil.

Stencil (on right, print at 300 dpi. The big circle should be 120mm in diameter and the screw holes 105mm centre to centre.

Step 3: Assemble and Enjoy.

•  You may need a guard on both sides, to prevent errant wires entering the fan.
• Be careful the temperature sensor is not damaged (its breakable, and the fan stops if you smash it)
  • Generally tuck the sensor out of harms reach.
  • Place your temperature sensor on the device if you need more aggressive cooling.

Introduction:

I needed some fan guards for my arcade machine and for a neat little entertainment centre hack.

Playing around I made a fish-eye honey-comb screen that looked pretty good. The pattern has larger holes near the centre of the fan and smaller holes where it counts.

How to make your own (with plans):

Making this is pretty easy if you have a laser cutter. If you don’t grab the .dxf  file and head of to your local laser/acrylic cutting business or makerspace.

The .dxf file is downloadable here.
A printable .png (good for the template) is downloadable here.

Q: I’m too lazy, can you sell me one?

Not any more (sorry).

I originally designed this as a two shelf unit, but trivially built it as a three shelf unit. The indents in the shelf place McCormick brand spices (Australian jar) at a pleasing interval, and seat them snugly. The rail is at the right height to keep the label viable and support the jar, without making removal difficult.

Machining was done on the artifactory‘s  CNC-router.

Final Result

Blue Prints

Image (click for larger)

Download

DXF (cad file)  here

Construction Notes

NB: I could not quite let go of my old school woodworking tendencies, so I made all tabs fit the slots exactly… This meant that after the router made its cut, the wood would expand a little and not fit in the slot. This is just what I wanted, preferring a bit of sanding at the end, so all would fit very snug. Nowadays I would wind back the slots 0.3 of a millimetre and let the glue do the rest.

The spices escutcheons I ended up 3d – printing and painting.  Nowadays there are plenty of 3d printing services should could offer a much better finish.

The stain I used was Wattyl Wood Gel – Honey Oak. I like how easy and fool proof these stains are. The results not bad either.

Photos of actual parts.