Took a photo of this today, as I liked what it said on the side of the lorry:

The 3D printer that I originally bought around 2014 was a Prusa i3 MK2. I chose the self build, as I wanted to know how the printer was constructed, and the instruction provided by Prusa are superb. The MK2 was upgraded to a MK2.5 and then a MK2.5S. However, it recently began throwing up all sorts of errors, including MINTEMPs and thermal runaways. I figured that it could be a number of sensor errors, but when inspecting it, and moving it to the workbench, I managed to break some of the plastic parts. This was probably due to the age of the machine (though could have be partially down to my clumsy handling).

As I have had it for about 10 years, and still need to do quite a bit of 3D printing at home, I decided to buy a new MK4S so that I could continue with my 3D printed projects (and also reprint the plastic parts for the MK2.5S). The MK4S is a huge upgrade from the MK2.5S and has some extremely nice facilities, including network capability.

With the MK4S up and running, I thought it would be nice to overhaul the MK2S and get it back to a serviceable condition (more print time). So, I stripped it down and cleaned the frame and hardware. I also printed new plastic parts for it using the MK4S. Here it is in its current state:

The plastic parts printed really well, but I’m not happy with the bearings (which are the old ones after I upgraded to a MK2.5). So I have ordered a new set this week and will replace all of them.

I’m about 1/2 way through the rebuild now, and it is coming along well, and everything appears to be fitting together as it should. The frame structure is now together, with new bearings for the Y-axis. There were some issues getting the frame square and level, and it required a lot of adjustment before it allowed the carriage to move smoothly:

The Z axis has also been installed with the bars for the X carriage, and now it just needs mounting on the base. Once this is completed, then the extruder and wiring can be installed:

My MKIIS was finished just before Christmas 2024, after re-printing all the plastic parts (on my MK4S) replacing the bearings and belts, bed sensor, PINDA, hot end sensor and print plate. When it was first (re)assembled, the self-diagnostic reported that the frame was spot on – it has never done that before (it was always just slightly out of alignment). It runs smoother than before, but still has a slight issue with stringing the filament, which I am working on. I even upgraded the filament support to a MK3/4 version – sp much easier to use, and includes a filament guide.

(The bass on the left is my vintage Kramer DMZ4001 which I have had from new, having bought it in 1982. It has been modified, replacing the pickups with schaller split neck pickup and adding a schaller bridge pickup. It weighs a ton.)

A recent commission was for a garden lighthouse. It had to be tall, and light up automatically when dark. This is the result, it is made from (mostly) 3mm ply which I hand sawed and assembled in my shed. It was first designed using a 3D modelling application, and then each piece converted to a 2D design so that some of the smaller parts could be laser cut (e.g. the windows and door). The roof is made from 3mm ply and then covered in copper foil. With time it should age nicely and turn green. The whole thing stands at just over 1m tall.

The lighthouse contains a very simple circuit to control the light (a single led inside the top part), a photoresistor and a solar cell to recharge the three AA batteries inside. The solar cell and photoresistor can be seen below, and on the far right you can just about see the little circuit board:

The whole thing took about 3 days to construct, then another few days to paint. I used exterior gloss for the white bits (after having first primed the wood) and then I sprayed the red with acrylic enamel.

If you would like one (similar or new design), then please contact me for details. Keep in mind they take a while to construct!

Last week we added the ‘smell machine’ to the cow. This device is custom made for the cow, and circulates a single smell placed in a container inside the machine. The smell machine was 3D printed in parts and then assembled, rather like a model kit. You can see the container for the smell in the main image below – it’s the square orange thing sticking out of the side. When you remove it completely it opens up so that you can place a smell inside. It was designed so that a standard sized cotton wool pad could be soaked in a smell and placed in it.

The smell is circulated by a large computer fan (the big black thing), chosen for its fairly compact size but high air volume. When we tested it, the fan would move across the table by itself when on full power. There are also to servos on the smell machine which open and close a pair of butterfly valves. These are intended to keep the smell inside the machine when the fan is not blowing. Otherwise the smell will just come out by itself …

To control the smell machine, there is a small wooden control box containing a Pololu Micro maestro servo controller and a small circuit board with a MOSFET to switch the fan motor on and off. The Micro Maestro was chosen because it can be programmed to respond to input – it runs a simple script which waits for the button press, monitors the control for the number of seconds, controls the servos and sends the signal to the MOSFET. I can highly recommend them, and the scripting language is easy (a bit like FORTH, if you have ever used that).

On the front panel there is a power-on light, a green push button and a rotary control to select the number of seconds for the fan to blow. The operation is simple: select number of second for fan, and then press the button. The valves in the smell machine will open, the fan will blow for the set number of seconds, and then the valves will close.

Whilst the cow was resting on the sofa (see below) we added the smell machine underneath (not shown here) and also tied up all the loose wires, for which there are many. The next job is to add a power connector for the mains and also an on/off switch.

Next week we will be trying out the cow with a group of students from Reading college, so I hope all goes well.

A project I have been working on lately is motorising a ‘route roller’, which is a device which allows you to carry and view an A4 route sheet when on your classic motorcycle. Here is the image of the version sold by the VMCC:

I found the device a little clumsy to use, because you often have to let go of the handlebar and direct your attention to twiddling the knob at the side to scroll the map. I figured that there had to be a better way which would be quicker and would be less distracting, so decided to motorise one.

The idea was to build an extension to the existing route roller so that you could just add the motor unit with little modification. This first version uses two laser cut brackets from 3mm acrylic, two 3D printed plugs that fit into the end of the rollers and hold the two axles, three 3D printed spur gears, and a 3D printed cover. The unit is driven by a cheap stepper motor controlled by an ATTiny microcontroller and a ULN2003 darlington array.

Here are some photos of the unit:

Here’s a (pretty crappy) video of the unit working:

I’ll make the plans and circuit available on this blog when I have perfected the device a bit more and given it a good road test. But if you are interested in making one for yourself and trying it out, then email me and I can send you the necessary details.

Here is the Fritzing circuit for the motorized route map:

I used an ATTiny 85 microcontroller to send the signals from the switches to the ULN2003A (Darlington array) not because it was easier than creating a simple transistor circuit (it wasn’t) but because I have a box full of them, and they need using! Anyway, it’s kinda nice to use an ATTiny, as it opens up possibilities for mods later on (e.g. tap/hold the buttons to change speed).

The components needed for this crude (but simple design) are:

2 x 12mm push buttons

1 x ATTiny85 Microcontroller

2 x 10uF caps (for power supply – a bit overkill)

1 x 5V voltage regulator (to power the ATTiny)

2 x 10K resistors, 1/4 W

1 x ULN2003A Darlington array

12V stepper motor

Wire of various colours.

Stripboard

Note: the stripboard shown in the Fritzing circuit is just for illustrating the circuit, I actually used less than half of the full 9 x 25 board so that it would fit in the small space available.

The stepper motor I originally used was a cheapo 5V (and the one that you can see working in the video) but it was very underpowered and would regularly jam and stop working. So I upgraded it to a cheapo 12V, which was slightly better, but not perfect. See below:

The ATTiny was programmed using an Arduino Uno as a programmer. The Arduino code for the ATTiny is here:

/*
* 
* IN1 = pin 2
* IN2 = pin 3
* IN3 = pin 4
* IN4 = pin 5
* 
*/


#include <Stepper.h>

/*-----( Declare Constants, Pin Numbers )-----*/
//---( Number of steps per revolution of INTERNAL motor in 4-step mode )---
#define STEPS_PER_MOTOR_REVOLUTION 32

//---( Steps per OUTPUT SHAFT of gear reduction )---
#define STEPS_PER_OUTPUT_REVOLUTION 32 * 128 //2048

// Button for scrolling up and down
#define UPBTN 1
#define DOWNBTN 5

//The pin connections need to be 4 pins connected
// to Motor Driver In1, In2, In3, In4 and then the pins entered
// here in the sequence 1-3-2-4 for proper sequencing
Stepper small_stepper(STEPS_PER_MOTOR_REVOLUTION, 2, 3, 4, 0);

int Steps2Take;

void setup() {
  pinMode(UPBTN, INPUT);
  pinMode(DOWNBTN, INPUT);
  small_stepper.setSpeed(700);
}

void loop() {

  // Get thevalue form the up button
  int up = digitalRead(UPBTN);
  int down = digitalRead(DOWNBTN);

  if (up == 1 && down == 0) {
    small_stepper.step(STEPS_PER_MOTOR_REVOLUTION);
  }

  if (down == 1 && up == 0){
    small_stepper.step(-STEPS_PER_MOTOR_REVOLUTION);
  }

}

I will have a look around for the mechanical drawings. I have done many different designs, using lots of different stepper motors and plain electric motors, so will take a bit of time to locate the one above. I upgraded the design later on to use a plain geared 12V electric motor, as it was more powerful and simpler to design.

The latest project I am working on with Kate is the interactive cow for MERL. As part of their rehang, they commissioned the building of an interactive cow which can be used by visitors. The cow will be capable of recording and playing back sounds, produces smells on demand and also will have removable textured ‘skins’ that can be attached to it.

The full-sized friesian cow arrived about 3 weeks ago, but we have yet to name her:

Perhaps we should hold a competition for a name?

Last week we started construction by cutting out part of the base that the cow will stand on, and also had to make a small hole in the belly to insert the magnets to hold the removable textures, and also to fit the electronics in when they are ready. We started by lying her on the sofa – perfect for minor operations:

Using a Dremel and a small cutting wheel, we cut out a small section – just large enough to get one’s arm inside! When the cow is upright you cannot see the hole.

The next job to do is to finish the base by adding braces, wheels and the sides, covering with faux grass and bolting on the cow. Once we have her rolling, then we’ll add some electronics.

This example shows how to control a mains lamp using a 240V relay board and an Arduino Uno. The idea is to randomly flicker the light on and off, similar to an old strip light when it becomes a bit old, or the starter is failing.

WARNING: Don’t mess with mains electricity, unless you are very confident about what you are doing. Mains supply can kill. If in doubt, get a qualified electrician/engineer to assist you.

Controller Board

The controller board is a cheap off-the-shelf 4-port 240V, 10A relay module. For this example I have just used an Arduino UNO to control it, though I will eventually replace this with an ATTiny85 as I need only 4 ports. The relay module is similar to this:

Originally, I powered the relay module through the Arduino using the 5V output, but this affected the operation of the relays, and led to erratic behaviour – the input lights for the relay would flash on and off, but the relay would not change state. So instead, the relay board is powered using a separate power supply, and is connected to the Arduino using only the inputs and a GND connection.

Arduino Sketch

The C code for controlling the is simple: generate a random integer between 8 and 11 (those are the port numbers on the Arduino that I have used) and use that generated number to toggle the state of a associated port. Do this over and over …

[code language=”css”]
#define INTERVAL 50

#define RELAY1 8 // Relay 1 is on pin 8, etc.
#define RELAY2 9
#define RELAY3 10
#define RELAY4 11

int switchState[4] = {0, 0, 0, 0};
int randomNumber = 0;

void lightSwitch(int state, int lampNumber);

void setup() {
// Relays are on pins 8 – 11
pinMode(RELAY1, OUTPUT);
pinMode(RELAY2, OUTPUT);
pinMode(RELAY3, OUTPUT);
pinMode(RELAY4, OUTPUT);

// The relays are active low, so pull them low to close the switch
digitalWrite(RELAY1, LOW);
digitalWrite(RELAY2, LOW);
digitalWrite(RELAY3, LOW);
digitalWrite(RELAY4, LOW);

void loop() {
// Randonly switch on and off a set of 4 lights

// On this cycle generate a lamp number
int randomNumber = random(20);

// Now toggle that lamp
if (randomNumber >= 8 && randomNumber <= 11) {
toggleSwitch(randomNumber);
}

//Serial.println(randomNumber);
delay(INTERVAL);
}

void toggleSwitch(int switchNumber) {

if (switchState[switchNumber – 8] = ~switchState[switchNumber – 8]) {
digitalWrite(switchNumber, HIGH);
} else {
digitalWrite(switchNumber, LOW);
}

}
[/code]
Here’s a video of the lamp controller:

You can hear all four relays switching on and off, which adds to the effect.

To Do

1. Test this on the strip lights.
2. Make board with ATTiny85 and voltage regulator.
3. Place relay module and controller into an enclosure.
4. Find cheap 240V – 12V power supply to power the relay module and ATTiny.

The other project for this weekend was a really simple ATTiny85 programmer ‘shield’ for an Arduino Uno. This board fits on top of the Uno and effectively turns the Uno into a programmer for the ATTiny chip. The programmer takes about 20 minutes to assemble, and requires nothing more than a piece of stripboard, a dip socket and a 10μF capacitor. I have also added an LED (+ 220Ω resistor) to the board so that I can test the ATTiny by uploading a blink sketch.

Stripboard View

I have used a 9 x 25 stripboard (a standard size you can by cheap off ebay), as it was what I had to hand. Of course, you could use a dedicated Arduino proto shield, which would look a lot neater and fit better.

Side views:

Fritzing View

Below are the Fritzing diagram for the programmer. On the left is the topside to show the placement of the components (note that the top of the stripboard has no strips on it – they are shown here for guidance only). The right view shows the reverse of the board, where the strips have been cut. I have a little tool for doing this, but a 4mm drill bit would work just as well.

Components

9 x 25 single-sided stripboard
8 pin DIL socket to fit the ATTiny
1 x 10μF capacitor
1 x 220Ω resistor
1 x 3mm LED
single core wire
1 x 9 pin male header, 1 x 7 pin male header
1 x ATTiny85 to program

Assembly

Start by soldering the resistor to the board, followed by the jumper wires. Then add the DIL socket.

Before soldering the headers, place the headers into the stripboard , and then onto the socket on the Arduino and push them into place. Using a flat metal object (such as the side of a pair of tweezers) press on top of the headers to push the pins down so that they are flush with the plastic body. This helps to extend the pins, so they fit better into the sockets on the Uno. Now go ahead and solder the headers onto the stripboard.

Add the LED – don’t forget to get this the right way round : the longer leg (anode) goes next to the resistor.  Finally add the capacitor.

When you have finished soldering the stripboard, fit it on top of the Uno, making sure that the right hand side pin of the 7 pin header fits into the right hand GND socket on the Uno, and the  right hand side pin of the 9 pin header fits into socket 8 of the Uno. See image above.

Below is an image of the programmer with teh ATTiny in place. Note the location of the dot. I have coloured this in white to highlight it, bt on the chip itself it will be black.

Using the programmer

1. Before you can program the ATTiny with the Arduino IDE, you will need to add ATTiny hardware profile to the Arduino IDE. With version 1.6.4 you can use the tools > boards > boards manager to add the ATTiny. With older version you will need to manually download and install the profile. I would suggest you go here, as this is a good explanation of how to set it up.
2. Place the programmer onto the Uno as described above. Plug the Uno into your computer using the USB cable.
3. Open the Arduino programming IDE and open the sketch Examples > ArduinoISP. Compile and upload this sketch to the Uno. This temporarily converts the Uno into a programmer for the ATTiny.
4. Make sure your ATTiny85 is in the socket on the programmer, and that it is the right way around. See image above for correct orientation.
5. Open the standard blink sketch and change it to the following:

[code language=”cpp”]

void setup() {
// put your setup code here, to run once:
pinMode(3, OUTPUT);
}

void loop() {
// put your main code here, to run repeatedly:
digitalWrite(3, HIGH);
delay(100);
digitalWrite(3, LOW);
delay(100);
}

[/code]

6. Change the board type in the Arduino IDE to ATTiny85 (how to do this will depend upon which version IDE you have) and select 8MHz internal clock. The COM port will be the one that the Uno is connected to.
7. Compile and then upload the ATTiny sketch. You should see the LED blinking.