7 Day Office Thermostat

This is for someone who works from home usually four days a week. Every now and then the days get shifted around, so it needs to be easy to say “I’d normally be here today and away tomorrow, but I’m leaving now and I won’t be here tomorrow”.

Also, this unit is for a small outbuilding that can get very cold overnight, so it has to two temperature settings. One for “I’m going to be here today so start warming up to XX degrees an hour before my usual start” and one for “Even if I’m not here, turn the heater on if it gets below YY degrees.

Design decisions:

• Get the basic functionality working with an Arduino based approach, then later add an ESP32 based WiFi capability.
• Separate out all the 240V circuitry from the Arduino and human interface bits, with two separate boxes.
• Use 3D printing to keep parts aligned and vaguely tidy.

Power switching box:

My first version of this was a decidedly “chunky” unit built of CNC cut MDF and acrylic. The circuitry worked but it lacked aesthetic appeal.

There’s nothing much inside this box, just small power supply and a 20A SSR (Solid State Relay).

I decided to redo the unit, and this time I drew up a detailed Fusion 360 CAD, even to including some of the wires.

With this CAD, I could print out small plastic parts to help align things on a lasercut mdf base. The laser also marked placement outlines to help assemble it. Printed PLA parts glue really well to MDF with wood glue. When I revised the base I just levered them off (taking some mdf with them), then soaked the mdf off to reuse them.

I found a cheap extension cord and chopped it in half to supply the power in and power out cords. A 3m section of CAT5 ethernet cable connects the two boxes, with GX16-6 connectors (I didn’t want to use normal ethernet connectors in case someone plugged one end into a computer).

The controller box:

I decided to use one of these cheap “LED&KEY” boards that comes with 8 x 7-segment displays, 8 LEDs, and 8 push button switches. All they require is +5V, GND, and 3 pins on the Arduino. (I saw these used on a Clough42 video and immediately bought a bunch).

The remainder of the parts were an Arduino Nano (clone), DHT11 temperature/humidity sensor, a DS3231 real time clock with battery, and a couple of TTP223 based capacitive touch sensors.

Note: I later tested the Omron SSR and realised it only drew 11mA, so got rid of the transistor buffer.

This time I drew up a 3D printed case, which incorporated mountings for the various parts, and had holes for the display LEDs to poke out.

I also 3D printed some little “pushers” to poke through the holes and press on the push buttons.

This all looked very good.

One problem is that the thin (2mm) PLA allows the other LEDs (on the Nano, RTC, and LED&KEY board) to show through. It’s not really much of a problem and I could always put some tape over them.

I needed to add some printed labels to the buttons and I decided to go with a new technique. I exported the layout as a DXF from Fusion 360 into Inkscape and drew up a pattern, including the lines to cut out. I passed this to my vinyl cutter (“Silver Bullet” brand) and used its SureCutsALot software to print the pattern with registration marks, then align the cutter to those registration marks and precisely cut out the holes. This worked extremely well and is a technique I’ll certainly use again.

On the final version, I printed/cut the cover in 210gsm card, then put it on some baking paper and sprayed heavily with clear gloss polyurethane. This made it look and feel much more like plastic.

The final result looks quite nice.

Except when you look at wiring on the back.

Here I’ve used the reverse of my usual technique and glued small MDF islands down to the PLA. These are 6mm thick with holes tapped for M3 screws which hold small terminal strips for soldering. It works, and makes the soldering easier, but it’s not pretty.

The software:

The program running on here is pretty simple (about 700 lines) with by far the bulk of it to do with using the buttons to edit the settings. The actual code to measure the temperature and control the heater is only a few lines.

  // CONTROL //
  unsigned long newControlTime = millis();
  if (newControlTime - oldControlTime > controlInterval) {
    oldControlTime = newControlTime;
    if (isValidTime && isValidTemp) {
      if (HereButtonPressed || (!beforeStart && !afterFinish && (settings[setTHISWEEK + DayOfWeekOffset].value == 1))){
        //HERE mode
        float target = settings[setTEMPHERE].value;
        heaterOn = (lastTemperature < target);
      } else {
        //AWAY mode
        float target = settings[setTEMPAWAY].value;
        heaterOn = (lastTemperature < target);
      }
    }else {
      heaterOn = false;
      Serial.println("Control: not valid.");
    }
    //write to digital output for SSR
    digitalWrite(SSRDATAPIN, heaterOn);
  }

Conclusion:

It works!

I can think of lots of improvements, but it works and I learned a lot of new techniques.

Alas, the recipient really wants WiFi connectivity so she can change the settings (particularly whether she is here/away today) without going out (in the cold) to the shed. So the next part of this project will be hooking up an ESP32 which will send and receive information from the Arduino (via serial), and present the settings as a web server on the home network.

A Simple Stepper-Based Turntable

Last week I happened across a youtube video in which someone had built a self-aiming airsoft turret. The interesting thing was that he’d mounted the whole unit using just the bearings of the stepper motor. This intrigued me enough that I decided to spend a day (hah!) and knock together a small stepper motor based turntable using cheap and salvaged parts.

I found a suitable stepper and got it working with a general purpose stepper driver circuit I’d put together some time ago. I decided on a 150mm disk and a 150x150x50 lasercut box. I managed the tricky task of reverse engineering the pinion on the stepper to print a matching socket, then set about gathering the parts to make it (Arduino nano and a cheap L298 motor driver board).

The problems of fitting in:

Alas, when I started considering how to fit the parts into the box I’d designed, I realised it would be much harder than I expected. The stepper was a large one, and the L298 board is too large to mount vertically on the side (44mm square pcb will only just fit into 50mm high – 3mm_MDF_top – 2mm_MDF_base, but that leaves no room for connections).

I had three choices (a) go to a bigger box, (b) swap out the stepper for a smaller one or replace the L298 with an A4988 controller, or (c) use Fusion 360 to engineer the exact placement of parts so it could all fit together. I went with option (c) and I’ve spent much of the last five days refining my design.

While this might sound like a lot of work for little gain, I’ve learned a huge amount about working with much more complex assemblies in Fusion, developed a bunch of tricks to improve my projects, and also created my own cad models of devices such as the Arduino Nano, SPDT toggle switches, and pots.

The Fusion 360 model:

It doesn’t look too bad laid out like this, but some of the clearances are tight!

The first prototype:

I got to the stage of laser cutting the box and mounting the first few components before I realised how tight it would be. Here you can see the box (open at the bottom) with the stepper motor, the base (with L298 driver, arduino nano, and a strip of solder terminals), and the disk for the top with the first iteration of printed joiner (the blue six legged thing) to push onto the pinion gear of the stepper motor. On the left is a general purpose stepper driver which I use for testing salvaged steppers.

To make it more challenging, I’d decided that the base piece would sit a bit above the bottom of the box, so that the mounting screws and nuts wouldn’t stick out the bottom of the box, requiring rubber feet. That stole another 6mm of vertical height and made things even tighter.

Assembly begins:

In order to see where I could run wires, I needed to mark the outline of the stepper onto the base. If I was going to do that, I might as well have an “Engrave” sketch with part placement and extra information. Not really needed here but good practice.

The little solder tag section at the bottom is a laser cut piece of 6mm MDF, with a row of holes tapped for M3. The two at the end fasten it down, the other four have a M3x5 screw holding a solderable tag. I find this works well for me, as MDF stands up well to the heat of soldering.

I made up a 6-way DuPont connector cable (my first!) to link the Arduino to the L298 board. To keep the wires from floating around, I printed a small set of troughs to press them into and glued it down.

connecting the Arduino to the L298

It fits:

box (upside down) and base which fits inside it

It’s still a tight fit. I had to cut a hole in the base to let the boss at the bottom of the stepper protrude and tidying the wires away while fitting it together was a bit messy. But it does fit.

I probably could have fitted it together without drawing up a CAD model, but it wouldn’t have been easy.

Connecting to the stepper motor:

This was a salvaged motor and it had a pinion gear attached. I could have removed it, but then I’d just have had to make a solid attachment to the shaft, which would probably require adding a flat, etc.

Instead I decided to leave the pinion attached and print a matching socket. This required me to work out the dimensions of the gear with the help of calipers and Fusion 360’s “spur gear” generator. It turned out to be a 15 tooth, 0.6mm module, 25° pressure angle gear.

My first version just pressed on to the gear (I printed it with a 0.2mm clearance gap). This worked but was hard to install, worked loose, and rattled.

I replaced this with a more complex joiner which worked very well.

And it even works:

You can’t tell, but the battery is spinning smoothly and quietly. The device is crude, but usable for some purposes.

The software:

This was a very simple bit of code.

There are three inputs; ON/OFF (pull-up by internal resistor, short to ground to activate), direction CW/CCW (ditto), and speed (analog input from wiper of 10K pot connected to +5v and GND). To make the wiring easier, I ran all three into analog input pins. In the process, I committed the noob error of forgetting that A6 and A7 on a nano don’t have internal pull-up resistors.

There are 6 digital outputs; the four stepper control signals, and two PWM outputs to the L298 enable lines. This let me reduce the power of the motor when turning at low speeds, making it smoother.

The hardest bit of the code was that I specifically wanted a soft start/stop sequence. If you turn the ON/OFF switch or adjust the speed control, the program will ramp the speed up/down slowly. This makes it much less likely that what’s sitting on the turntable will be thrown off. If you change the CW/CCW switch while the unit is running, it will ramp down to zero, then ramp back up in the opposite direction.

I got the device rotating using the standard Stepper library, but switched to the AccelStepper library as it had ‘set speed’ and ‘max acceleration’ functions. Then I wasted quite a while before I realised that the SetSpeed() function ignores the acceleration settings, and had to configure the ramp manually.

#include <AccelStepper.h>

#define SpeedPin A3 //green
#define CwCcwPin A4 //black
#define OnOffPin A5 //yellow

#define Enable1Pin 5 //black
#define Enable2Pin 10 //white

unsigned long oldTimeStatus = 0;  
const long statusInterval = 50;

int motorSpeed = 0;
int maxDelta = 2;

AccelStepper stepper(AccelStepper::HALF4WIRE, 6, 7, 8, 9); 

void setup()
{  
  //Serial.begin(9600);
  Serial.begin(115200);
  delay(100);
  Serial.println("Turntable");

  pinMode(Enable1Pin, OUTPUT);
  pinMode(Enable2Pin, OUTPUT);
  digitalWrite(Enable1Pin, HIGH);
  digitalWrite(Enable2Pin, HIGH);
  pinMode(SpeedPin, INPUT);
  pinMode(CwCcwPin, INPUT_PULLUP);
  pinMode(OnOffPin, INPUT_PULLUP);
  
   stepper.setMaxSpeed(300);
   stepper.setSpeed(motorSpeed);	
   stepper.setAcceleration(0.1); //ignored by .setSpeed
}

void loop()
{  

  unsigned long newTimeStatus = millis();
  if (newTimeStatus - oldTimeStatus > statusInterval) {
    char workStr[30];

    int sensorReading = analogRead(SpeedPin);
    // map it to a range from 0 to 100:
    motorSpeed = map(sensorReading, 0, 1023, 0, 280);

    int currentSpeed = stepper.speed();


    // read enable
    bool isON = (digitalRead(OnOffPin) == LOW);

    // read direction
    bool isCCW = (digitalRead(CwCcwPin) == LOW);

    if (isON) {

      if (isCCW) {
        motorSpeed = -motorSpeed; //map to backwards
      }
    } else {
      motorSpeed = 0;
    }

      

      int delta = motorSpeed - currentSpeed;
      delta = constrain(delta, -maxDelta, maxDelta);
      int safeSpeed = currentSpeed + delta;

      sprintf(workStr, "S %03d R %03d C %03d -> S %03d", sensorReading, motorSpeed, currentSpeed, safeSpeed);
      Serial.println(workStr);

      stepper.setSpeed(safeSpeed);

      if (abs(safeSpeed) < 60) {
        if (safeSpeed == 0) {
          digitalWrite(Enable1Pin, LOW);
          digitalWrite(Enable2Pin, LOW);
        } else {
        analogWrite(Enable1Pin, 80); //PWM = 1/4 power
        analogWrite(Enable2Pin, 80); //PWM = 1/4 power
        }
      } else {
        digitalWrite(Enable1Pin, HIGH); //PWM = full power
        digitalWrite(Enable2Pin, HIGH); //PWM = full power
      }
      
      oldTimeStatus = newTimeStatus;
  }
  
   stepper.runSpeed();
}

Was it worth it?

If I wanted a quick and usable device, this wasn’t the way to go about it.

However, I learned a lot.

My notes file for this mini-project has over 50 notes I marked as “Problems” (yes, I made a lot of mistakes), and at least 30 marked as “Possible improvements”, some of which I implemented, some I may use in future projects.

A tumble drier for seeds

This year we had a good crop of Spaghetti Squash, grown from the seeds we saved from one squash last year. Since that had been so successful, we decided to save all the seeds this year. Lots of seeds. This is just some of them.

One of the problems with squash seeds is that they are wet and slippery, and if you leave them to dry in a clump, they all stick together. The previous batch we just spread out by hand on paper towels, which worked fine. With many more seeds this time, I decided to automate the process. Needless to say, the effort involved in building the device was considerably more than doing it by hand would be, but it was a fun exercise and I was able to try out a bunch of techniques.

The first version:

This was mostly thrown together from stuff I had lying around. The main mechanism is a small worm drive motor connected to some M8 threaded rod supported with a 608 (roller skate) bearing. I lasercut some 50mm wheels out of 6mm MDF with lots of little “V” cuts around the edges like a gear, to get some friction. There’s a second set of rollers, freely rotating, on the other side.

I was going to throw an Arduino into the mix when I realised that all I needed was to have the container rotated for about 30 seconds every half hour, something that a simple relay timer board could do easily.

Problems:

There were a number of problems with this version. The most obvious was that there was nothing to stop the seeds from falling out the open container, but also the friction wasn’t enough. It would all turn when unloaded, but not with a load of wet seeds contributing their reluctance to move.

A quick 3d printed cap solved the first problem (the hexagonal pattern is just infill, with zero top and bottom solid layers). I fluked the dimensions on the first try and it fitted tightly and never came off.

The friction was a bigger problem. I wrapped some fabric tape around the plastic container, which helped, but in the end I had to make a really crude fix. I rigged up a ball bearing on a spring that pressed down from the top to ensure rotation. It worked, but was rather ugly.

Drying wasn’t as fast as I’d like either. I pointed a fan into the open end, which helped.

Time for a rebuild:

While the basic mechanism was the same, this time around I made a special effort to try for a tidier setup. This wasn’t just for prettiness sake. I want to get back into some robotics and wiring layout and connection issues can be major issues in that field, so some practice wouldn’t go amiss.

I used a bigger mounting board this time, and included an 80mm PC fan. There’s a small buck converter providing a reduced voltage (6.7V) to keep the fan blowing, but quietly.

All the wires going to screw terminals got crimp ferrules on them which really improved the reliability. I think it also makes it look tidier.

I was very pleased with the little power distribution blocks (visible at the top of the board). These were 3d printed (in different colours, of course) and took a block of 4 terminals off a row of connectors (what’s known as “chocolate block” connectors in many places). Surprisingly, they’re not glued or screwed in place, just a friction fit that takes considerable force to push in and won’t pull out without the use of a pair of pliers. I used the same technique on the voltage reducer board and there’s another connector just for the fan.

Speaking of the fan, the printed shroud was an interesting design task in Fusion 360. My first attempt, using vase mode printing, failed dismally. However this version worked well.

In the view above you can see the corrugated disks which were tapped and then threaded onto the M8 rod. I was short of M8 nuts so they’re actually held in place by laser cut (and manually threaded) MDF nuts. This was very cheap and worked well (except when I didn’t tap them quite vertical), and I’ll use the technique in the future.

I replaced the container as well. I found a chunk of alkathene pipe (83mm diameter) and chopped of a short section. I printed ventilated caps for both ends so the air could flow through. To solve the friction problem, I glued a section of the high-friction rubber matting sold for lining kitchen drawers, etc, around it. Note – I used PVA glue and just laid down a few stripes along the pipe, waited for them to dry, then rotated the pipe and did more stripes. This worked very well and I had no more friction problems.

The Verdict:

This was an interesting exercise, and it did the job I needed. Running for about 12 hours it turned a wet sludge of seeds into a convenient batch of dry seeds. Since it only rotated for 30 seconds every half hour, the seeds didn’t get thrashed around.

Now I can dismantle it back to parts until next year.

M6 Version of MakerBeam

A small experiment in 3d printing something like “MakerBeam”, an aluminium extrusion based construction technique, itself derived from 80/20 extrusion (which, by the way, is silly expensive here in New Zealand).

I have lots of sizes of M6 hex head bolts so I scaled it up a bit to fit the heads of those bolts, rather than special headed bolts or special nuts. There’s an M6 thread down the hole in the centre.

The four diagonal slits in the design are an attempt to be tricky. They’re only 0.1mm wide so they should get melted together when printed. However, they trigger the slicer software to add a full set of perimeters around them, greatly strengthening the weakest point of the shape. Not sure how well it will work, but worth a try. I could achieve the same effect by fiddling with the slicer and defining extra volumes to print with higher infill or solid, but I’d rather define it in the model, not the slicer.

In the slicer (I use “Slic3r”) preview window, you can see how diagonal slits have added a lot of extra strength.

Cosplay Experiment (3D Print + Cloth Mache) Spiral Horn

Papier mache (and the related “cloth mache”) techniques has some excellent features. It’s extremely cheap, and can make strong and light weight objects. However – at least when I do it – it can end up rather lumpy and irregular.

I love 3D printing, but making large structures with a normal printer gets expensive fast, and also takes a long time. The longest print I’ve done took 16 hours, but some people routinely print 50 to 100 hour prints. The shapes should be exactly what you planned (except when something goes wrong) but laying down all those layers takes time.

I’m not the first person to think of combining these two techniques. I got the idea from 3d-print-and-papier-mache and I’m sure others have done it as well.

I was playing around with “vase mode” on my printer the other day. This is a special way of 3d printing where, rather than laying down a series of layers, the printer lays down molten filament in one continuous SPIRAL layer. The resulting object has to be hollow, with thin walls only one layer thick. However, since the extruder doesn’t stop and start but just keeps looping around while slowly rising, the results tend to be very smooth and are surprisingly strong for their weight. It’s also much faster as only the outside skin is being printed

I drew up this horn shape in Fusion 360. (For those interested, it’s a loft between two circles, with a coil edge as the guide rail).

Here it is printing. It came out very nicely, with lovely smooth curves that felt very nice to the touch.

My first attempt wasn’t so good. In vase mode, each line of filament must partially overlap the one below, since there’s no interior. If it moves too far horizontally from the previous layer, it ends up splodging in mid-air. I need to do some more experimenting to find the shallowest angles I can print.

I cut some strips of cloth from the rag pile, and wrapped my 3d printed “horn”. I worked in a spiral pattern from the bottom, dipping the cloth in heavily diluted white pva glue (probably 50/50 water to glue). It took a couple of tries but was surprisingly easy.

The very wet mix took a long time to dry. I left it sitting for a couple of days. Since the armature was 3d printed, I didn’t need to worry about it getting damaged or mouldy.

I need to do a bit of trimming and sculpting at the ends, where the cloth ended, but only minor stuff.

Here it is on the turntable, ready for painting. My turntable is built from a car wheel bearing, with a cordless drill motor for rotation. Using spray paint, this gives me a much more even coating.

This is after a very quick paint job. I just grabbed the first couple of cans that came to hand (which happened to be blue and gold). However, it does look a lot nicer than the plain white.

It looks, and is, pretty rough. I’m sure I’ll do more experimenting with this, though. One big advantage of this technique is that I can simply mirror image the model, and hence the 3d print. Compared to trying to make two parts look the same by hand, that should be a big improvement.

Storage for Boot (Trunk) of Toyota Caldina

The boot of our family car is usually full of ‘stuff’. Jackets and blankets in case of a breakdown, tow rope, leather gloves, etc. These tend to get shoved to and fro to make room but flop around and spread out. This annoyed me more than usual the other day, when I had to clear everything out to get access to the floor.

I didn’t take a photo of the mess in the boot, but this is the sort of junk that was in there, hurled over into the back seat.

Looking at the boot, there’s an area just behind the back seat where things could be stored vertically if there was a suitable container.

I took some measurements and used Fusion 360 to work out the angles. I could have drawn up a cad diagram of the unit but it was just as easy to lay it out on paper.

This is what I came up with. It’s a simple box with two partitions. One side is angled to match the slope of the back of the back seat. The other is dropped down a bit to make access easier. Cardboard was the material of choice for this. (The rendering above was done after the fact, while experimenting with Fusion 360’s new sheet metal workspace, which can also be used for cardboard boxes).

I found a suitable chunk of cardboard from our huge collection in the shed and we marked out the main shape and cut it out. Folded up and held with clamps, it looked pretty reasonable, and fitted firmly into the space I’d planned.

When I put it down on the floor, it was immediately inspected.

The weak point will probably be the back (front as you look at it) wall. It’s already got two layers of cardboard over much of it, so I filled in the gap, then covered it with another complete layer. Probably overkill, but cardboard is cheap and light. We slathered it with pva glue and weighted the sandwich of layers down with exercise weights and wood.

I flipped it the next morning, and glued the angled face. The partitions were added with more pva and some tricky clamping. I added a rim of clear tape just for looks

This is what it looks like in place for a test fit. I mucked up the measurements slightly and had to cut a notch for the handle which releases the sunshade fitting. A lot easier to change in cardboard than something harder.

And this is what it looks like full of stuff. It absorbs a heap of bits and pieces and still leaves most of the boot clear.

 

Christmas Lights Obelisk/Pyramid

Barbara wanted some pretty Christmas lights. It was a bit late for Christmas (i.e. it was January). So?

We started with some 100×25 Oregon, ripped in down to 50×25. Here I’ve chopped four 1600mm lengths to form the sides of the pyramid/obelisk. We found a nice looking christmas tree on Google Images then used a graphics package to measure the angle – turns out that 80°  from horizontal was the angle we thought looked good.

Some simple trigonometry gave us the size of the base (close enough to 500mm), to get the angle we wanted. Some more 50×25 oregon and various offcuts from the mitre saw gave us a base.

We braced it up for strength, since I planned on placing one or two concrete blocks onto the base to weight it down. (We get strong winds around our place).

Some 7mm holes and M6 bolts attached the ‘legs’ to the base. Forgot to allow for the 25mm offset from the ends of the pieces of wood, so our angle won’t be quite correct.

A very sophisticated (not) mechanism fastened the top together. One zip-tie.

Here’s the result so far, with a human for size comparison.

Chicken wire! Messy stuff to work with, but a compressed air stapler made it easy to pin it down. We only put wire over three sides, leaving the fourth side open to allow placing concrete blocks (for weight) and christmas tree lights (for pretty).

We put it up on an earth bank overnight, to check it wouldn’t blow down.

Barbara fitted the lights through the chicken mesh. Took quite a while. Here we ran a quick test in a darkened room. Looking good!

Come nightfall, it was very pretty.

Avoiding electrocution while testing 240v circuits

I needed to measure the output voltages on a bunch of unmarked transformers I’d accumulated. (No, I’m not a hoarder. I can stop any time I want to. Perhaps.)

I’ve done this before, with just a bunch of alligator clips, a mains cord, and a multi-meter. It’s very simple, but it’s *dangerous*. Reaching over live 240v wires to take measurements isn’t a good idea. Worse is that a bunch of wires in mid-air have a tendency to move around, generally shorting something wires together.

I recently made up a number of little test boards to hold test circuits in place without having to worry about wires getting loose. Here, for example, is a test with an arduino (on a solderless breadboard), an L298 motor driver, and a worm geared motor. The boards are 85mm long, with two rows of M4 holes 10mm apart. The rows are 75mm apart. They’re mounted to a laser cut piece of 6mm mdf, with two long rows of M4 tapped holes. (MDF taps quite well with a tap in a cordless drill).

I really don’t know, yet, whether these ‘boards mounted on boards’ are a good idea or not. However, they’re cheap and worth trying. In particular, they hold wires securely for testing which was exactly what I wanted for testing my transformers.

Here’s a test victim hooked up to a test setup. I grabbed a spare chunk of 12mm MDF (I didn’t even bother cutting it square). I marked a grid of cross marks at 10mm x 25mm spacing using the laser cutter, then drilled and tapped just the few holes I wanted to hold things down. Chocolate blocks, hot melt glued down, gave me a secure but adjustable fixing for wires.

Note that I used a female EAN mains plug rather than a standard power cord to supply power. I physically unplugged it every time I changed the circuit, which I probably wouldn’t have done if it was a plug into a wall socket.

This particular transformer made me glad I’d gone to the trouble, as it was very easy to power it off when I plugged it in and it started to hiss and smoke. Looks like I picked up a 110V primary transformer somewhere along the line and it *really* didn’t like running on 240V.

Even when I ended up using crocodile clips, they were much more secure when clipped into the immobile terminal blocks.

A quick test of a crude opto-coupled triac circuit felt a lot safer when wired up like this as well. I wouldn’t trust a solderless breadboard at 240V.

Laser cut numbered pegs for workmen

We had a tradesman coming out to do some “stump munching” of some of our (large) supply of stumps. We only want a few done, and some of them are in the deep grass. So, laser cutter to the rescue.

Here’s the laser cutter chopping out some mdf numbers – about 80mm wide x 140mm high. Mdf is 3mm thick, but I should have used 6mm.

For a quick job, they came out ok. The bright yellow plastic would be really good for this but it’s PVC. Cutting pvc on the laser will rot your lungs from the hydrochloric acid vapour. Worse, it damages the optics of the laser!

A very quick spray paint with flourescent pink from a rattle can.

Some cheap bits of wood. Once again, a box of kindling from the supermarket.

Bits of wood pointed on the mitre saw, and pink numbers stapled on with the air nailer.

These did the job. You can see them from some distance. Next time I’ll use thicker material as the staples pulled right through on a couple when I hammered the stake into the ground.

 

 

Quick laser-cut carpentry clamp storage

There’s a saying in carpentry “You can never have too many clamps.” This is true until you need to store them. I’ve got a bunch of these cheap “F” clamps which make a messy pile. I knocked this holder together out of 3mm mdf. The slots are 5mm wide and go back 70mm.

 

As usual, I used the very handy “BoxMaker” extension for Inkscape, though I drew the slots in DesignSpark Mechanical. Note that the top layer (with slots) is doubled up with an extra layer to make it stronger. It might have been OK like that but I later added some simple braces. After that it was plenty strong enough.

 

Here it is attached to the wall. (It’s actually attached with a French Cleat so I can move it around if I want to).

And here it is fully populated. I screwed another piece of wood to the bottom of the back, a bit thicker than the cleat at the top, so the top now slopes towards the back by a few degrees.

Very quick. Very cheap.