19 April 2018
The final piece I made for the Vipers LRP event last month was this monument. I've made a similar display case
before so we were trying to improve upon that one. This time the monument could only be opened once all the corresponding rune keys were in place. As the keys were scattered around we thought it would be cool to make them glow when they were inserted into the monument. Some simple LED and microswitch arrangement, side lit the perspex runes. The runes were supposed to be easy to insert and hard to remove. The body was made with ply but painted with a stone effect. I don't believe it fared particularly well in the weather and could have done with a coat of sealant but I shall learn for next time. I even managed to pick up an action shot of this item too.
by email@example.com (Martin Raynsford) at 19 April 2018 09:10 PM
18 April 2018
A quick tray puzzle I was asked to make for a LARP event. I assume once all the events were placed in order some kind of secret was revealed. The arrows ensure that the pieces are put in the right way round and show which direction time travels, the events were jumbled before cutting so that the grain didn't give any clues.
by firstname.lastname@example.org (Martin Raynsford) at 18 April 2018 08:07 PM
16 April 2018
I've come to the conclusion that I just don't need 3 laser cutters and I don't have space or time for them all anyway so I'm going to have to let this one go. It's barely been used, we bought it with Just Add Sharks and then never used it. I haven't used it for 6 months.
It comes with RD works and should be compatible with Lightburn
which is what all the cool kids are raving about. It's also got a really lightweight head so it's super fast. I wish I had more time to play with it.
If you're interested, it's up on ebay, try to snag a bargain.https://www.ebay.co.uk/itm/Kent-Laser-Solo-40W-C02-laser-cutter-600x310mm-RD-Works/282927236074
by email@example.com (Martin Raynsford) at 16 April 2018 11:44 AM
04 April 2018
Over the laser few weeks I had the joy of making some props for a LARP event. The first was 4 large wells/portals which specific inscriptions upon them. This was largely a woodworking project made from an old pallet, the inscription stones were engraved upon the laser and each stone was weathered using a hot air gun to give it a burnt looked. Some plastic sheet and lighting gave it the effect of being filled with water but it also made them waterproof so that actual water could be put inside them.
As the event has now happened I even spotted some photos of the items in action.
by firstname.lastname@example.org (Martin Raynsford) at 04 April 2018 09:41 PM
21 March 2018
Now that I've really got to grips with the ESP8266
I can start to use it in various projects. This one has been on the cards for a very long time and there are already lots of projects doing something similar here's my effort. For anyone still not sure what it is, Stranger Things
(season 1) is a tv series about a missing boy, who at one point, communicates with his mum through the medium of fairy lights. This is just a fun way to spell out messages for people but it's wifi controlled so any old phone can set up the messages to display.
These displays are now available in my store as kits or working items, should you want to build one for yourself or read on for further details.
The project is based around some 12mm WS2811 RGB led's. The 12mm lights have a lot of diffusion are easy to mount in holes and don't have to be spaced evenly apart making them ideal for quick installation in a back board like this. The board is 3mm birch ply with a mixture of engraving and line artwork to still give the appearance of fairy lights. (svg here
The controller is the Wemos D1
, I have run a capacitor between the 3V3 and Gnd to filter out any power supply noise to the ESP8266 (much more important when driving motors). The LEDs connect directly to pin D1 on the device and are driven using the FastLed
library. The whole thing is powered from the USB connection, if you intend to crank the LED's up to full brightness you probably want to consider an appropriate external PSU that can handle the required current ~1.5A. In this demo the lights are set to <1% brightness and they're still perfectly visible.
The HTML input for this project is so simple I decided not to serve a whole web page from SPIFFS
. It's actually just a few lines that can easily be served from a string. Below you can see that it's just a text box and a submit button. The text box is restricted to 49 characters so as not to overload the input buffer on the ESP but this limitation could be easily removed by keeping the data as a string.
The ESP code is also fairly straight forward, the device is configured to start it's own wifi network
with a given SSID and password. It then sets up a webserver
to supply the browser with the input page. Finally it responds to an incoming message
by saving the data and replying back to the browser with the new message
Most of the interesting things happen in the main loop, firstly we use the fastled library function "EVERY_N_MILLISECONDS" to process our code once every 350 milliseconds, this is a non blocking function and leaves the controller free to deal with the webserver and dns for the rest of the time. Every 350 milliseconds we rebuild a string of colours to display to the lights. Firstly we decide if this is an even or an odd loop, the coloured lights should be on all the time but the displayed letter should flash on and off. I've used a simple list of 4 different colours, LED 1, 5, 9 etc will always be red and because the middle row of lights is reversed the pattern isn't blindingly obvious. Every other loop we simple increase the brightness of the letter we're trying to display. This leads to the first problem though, because the middle row of LED's is reversed it's not as simple as saying A=1, B=2.
The solution is to map letters to LED's, the code currently has 2 sets of mapping functions in 2 different methods. The first is to map the letters A,B,C to the numbers 1,2,3. In the ASCII standard
A=65 so it's a simple subtraction but it allows us to map the lower case characters to the same place since a=97. After this first mapping process we end up with the numbers in a standard we're used to. The second is to map those numbers to specific LED's, we could do it with simple subtraction again (because it's only one row that is reversed) but this time I opted to create an array of 27 characters and assign each letter individually. This offers greater flexibility with wiring, with this method I could go up and down with the lights or any random order I chose.
Full Source code here
Improvements could definitely be made in the colouring of the lights, the main loop itself doesn't need to know what colour each pixel is so the colours could all be chosen in the setup function and each loop through the main code simply increasing the brightness of a pixel or decreasing it to turn them 'on/off'.
by email@example.com (Martin Raynsford) at 21 March 2018 02:41 PM
17 March 2018
Everyday Electronics magazine is something I have fond memories of from my childhood. Much of the practical knowledge I have of electronics originated from things I read there or stuff I tried to make (some of it DID work). For many years my parents kept-up a subscription for me until sometime in the late-80s when I outgrew it.
There is quite a lot of info online about EE’s sister publication Practical Electronics (which it would eventually merge with to create Everyday Practical Electronics) but I can’t find a lot written about EE. Recently I saw an edition of EE that recognised as one I originally owned in a second hand shop. At 20p it was an easy decision to take home.
EE always put a bit of effort in to the cover which is one thing that makes them memorable. This one with the dodgy looking vicar and his assistant is perhaps memorable for the wrong reasons. The projects are typical of what I remember – endless variations on simple circuits with oscillators, discreet transistors, 4000-series CMOS and op-amps. Even the cover project isn’t that exciting, though if you were in the market for an electronic wheel of fortune I guess it would do the job. They might have been basic and (whisper) not terribly useful but building them was still a great way to learn practical skills.
The features are quite interesting and remarkably well considered in terms of content. Magazines like EE were the main source of information in the pre-Internet era and you can almost see how the different features mirror popular Internet content today. In “For Your Entertainment” Barry Fox makes some interesting comments on the current state of flat-screen displays before getting side-tracked in to a discussion of Sinclair’s doomed flat CRT project. The government didn’t half invest in some rubbish projects in those days. Some of the features do hint towards the tide of consumer electronics that would spell doom for much of the old hobbyist world. Another glimpse of the future is the side-bar on direct broadcasting by satellite in “Radio World”. The introduction of DBS as a platform for Sky TV was a huge step towards today’s media landscape.
As a child, my favourite regular feature became “Counter Intelligence” by Paul Young. I liked his witty, caustic and grumpy musings on life in the kind of corner electronics shop that was already finding times tough. I remember that dad used to take me to a shop in Leicester staffed by blokes in beige lab-coats stocked with thousands of components in tiny draws. They hardly ever had exactly what you wanted but could usually produce something that would do the job.
The adverts are a real blast from the past. Many of them seemed to run unmodified for years and years. The spiv zapping his light and the odd boy with his crystal set were almost permanent features. I imagine J Bull (Electrical) always doing deals on vast lots of unwanted items and then finding enticing descriptions to sell them off to the unsuspecting.
So, for anyone who, like me, wants to wallow in nostalgia, or just see what the old days were like here is Everyday Electronics August 1981.
by Iain at 17 March 2018 06:21 PM
12 March 2018
During the wifi configuration tutorial I described a method to provide a firmware reset in the case that you forget the user name and password using an additional button (or wire loop). I also lamented the problems of the Wemos D1 board not being able to distinguish between a power cycle and a button reset. Today I'm going to discuss another way to achieve a firmware reset of the device without the requirement for any additional hardware. The method itself is quite simple and we have already used all required parts for the wifi configuration program.
The first thing the device should do when it starts up, is set a flag in the non volatile memory and after a given period of time it should clear this flag again. Now if the device is reset before it has the chance to clear the flag we can tell that the reset button has been pushed twice in quick succession and use that as an indicator that we want to perform a firmware reset.
There are a few items to declare at the start of the program, we'll be using the EEPROM library to write the flag to a memory location that is remembered between boots. The flag is stored as a 4 byte value and should have two different states, these should not be zero because that is the default value for EEPROM, I have chosen 0x55 and 0xAA as they are alternating bit patterns but the actual values are fairly arbitrary. Finally we should declare a memory location to store the value and a length of time to check the value.
There are two helper functions used to access the EEPROM. CheckFlag looks at the memory location for the flag and returns true if the flag is set. WriteFlag puts a new value in the memory location, don't forget to call EEPROM.commit() which is specific to the ESP devices, this is the function that actually writes the data to the memory locations.
In this example we're going to be using the Serial port and built in LED to indicate the state of the device so those should both be set up immediately. For the EEPROM library to work you need to tell it how many bytes of data it is going to be using. This EEPROM.begin step is something I miss all the time with infuriating results. Next comes the actual checking of the flag, if the flag is still set from the previous boot cycle then we know that we need to perform a firmware reset, in this example we note the state by turning on the LED. If we perform a firmware reset we should clear the flag now so as to avoid a double reset situation. If the flag is not set then we should turn it on now.
Finally there is a little delay loop which waits the given time before clearing the flag, I've added this as a blocking delay at the end of setup because I don't like the idea of my main loop performing a redundant check for the rest of it's execution. It could easily be implemented as a non blocking check
in the main loop though.
Now when you download and run the program, if you click the reset button twice within a 3 second period you should see the LED turn on indicating a firmware reset state. As usual the full code is at the bottom.
by firstname.lastname@example.org (Martin Raynsford) at 12 March 2018 12:10 PM
06 March 2018
This is a set of wooden templates and tokens for the game 'Grasslands'
. The game itself looks like a lot of fun and I like the idea you can get started with any old die cast toys. I loved the new mad max
film and this looks like it fits right into that genre.
by email@example.com (Martin Raynsford) at 06 March 2018 09:26 PM
05 March 2018
I had a request about 3 months ago for a set of tak
. The design isn't very complicated so when I actually remember and finally got round to making it this evening I thought I could at least make it look like it took a while to build. I rotated the grain for each tile on the board so it has a slightly different shade for odd/even tiles. The diamonds were cut separately, painted and then inserted on the diagonal. The tak stones themselves were made from 9mm ply which allows them to stand up and a quick capstone was made by stacking 6mm ply. (svg here
by firstname.lastname@example.org (Martin Raynsford) at 05 March 2018 11:51 PM
01 March 2018
I made this hourglass prop for world book day for a Discworld death costume. It's mostly made from 6mm ply but the 'glass' sections are made from 2l fizzy bottles and the 'sand' is rice died blue. It's a little bit sticky because the centre hole is a little bit small but that's actually quite good that someones entire 'life' doesn't pass from the top section to the bottom section instantly.
Hazel decided to go to school dressed as Little Lou and the Woolly Mammoth. All I had to do was make a sew a pocket onto her dress, my wife had the clever inspiration to make the Woolly Mammoth from a knitted poncho and a dozen elastic bands.
by email@example.com (Martin Raynsford) at 01 March 2018 02:04 PM
28 February 2018
In Part 1 of the Wifi configuration tutorial
we learned how to set up the device to read/write from non volatile areas of memory so that we can recall a new wifi ssid and password between reboots. In Part 2 we're going to provide an interface that allows you to set the new values from a web page. This tutorial is a combination of all the previous parts so I'll include links to the relevant parts rather than run through it all again.
The one part we missed from the last tutorial was actually creating a wifi network. We need to include the ESP8266Wifi library and open up a new access point.
Do this after loading the new wifi values to ensure the network has the correct name.
The next step is to set up a webserver
to provide pages to the user. We're going to create a default index page that's just simple text. For the tutorial this will serve to point the user in the right direction for the admin functions but in a full program this would be whichever page you like. We're also going to set up a static handler to serve the page 'admin.html' from SPIFFS
and finally declare a handler to deal with incoming arguments from the admin page
With those parts implemented we're now ready to actually create the user interface. We're going to take a departure from the Arduino IDE at this point, all of the interface can be written in html
to perform some basic data validation before it gets sent to the ESP device. There are lots of online editors to aid development of html pages but I found JSFiddle
to be very useful. (although you'll have to manually switch to the results tab on the following script to see the output)
Once the form is successfully filled out it will POST
a series of arguments to the ESP device. The form only needs to contain new ssid or new password information, and it is only input data with a name attribute that gets sent so we should be seeing upto 3 arguments, 'oldpassword', 'newssid' and 'newpassword'. Our handleAdmin() function will be sent the incoming data and it's ready for us to process, lets take a look at that function.
The first thing we do is look at all the arguments and pass them out to the serial port, a handy way to make sure that we're sending the values we think we're sending. The web server library has more specific functions that allow us to check and see if a specific arguments exists before we try to process the data. We can pass the argument name to the web server using the 'hasArgs()' function and check to see if the old password has been supplied. The first test is to make sure that the password matches the one we're currently using, if these don't match we should ignore all the rest of the data.
If the password matches we then need to copy the values from the newssid and newpassword arguments into our own variable. We can check at this point that the arguments are also the right length (and if they're not greater than zero they don't exist at all). We copy the new values over to our config variables and store them to EEPROM, it's as simple as that. It's polite to let the user know if there was success or failure at this point so we construct a short html response string with the pass or fail result, being html we can also add in a browser redirect back to the main page. I have looked at performing an automatic reboot at this point to start using the new values but the Wemos D1 doesn't appear to restart correctly, this is probably something to do with the USB serial device and the arduino programming.
Here is the whole program, the next step would be to roll all of this access point configuration into a single library that could be easily imported into any project.
by firstname.lastname@example.org (Martin Raynsford) at 28 February 2018 08:31 PM
26 February 2018
By request I made a stencil as large as possible. This 600x900 sheet of mylar filled my entire bed and took a whole 2 hours to cut the fine detail out of. I believe it's going to be used to apply a pattern to fabric for a cosplay outfit.
by email@example.com (Martin Raynsford) at 26 February 2018 11:07 PM
25 February 2018
So far with the ESP8266
modules we've been using the same network name and password, these values have been hard coded into the program for ease of use. Now imagine that we had a dozen devices all running at the same time, all trying to set up the same wifi network (and yes I realise by using the mac address as part of our SSID
we have avoided this problem). The solution, that we're going to talk about today, is to allow the user to configure the network name and password. This is simply good practice as anyone who has logged into a device using 'admin' and 'password' should realise.
The first step is to find a way to store the new values in a way that they will be remembered while the device is turned off, and then be able to load that information when the device turns back on again. On a standard Arduino we'd use the EEPROM
which would allow us to write data to a specific type of memory that requires special electrical conditions to be programmed and that retains the information between boots. On the ESP8266 we use exactly the same EEPROM library but it only emulates EEPROM and it actually writes to the flash memory instead (the same place we store the program data to).
The EEPROM libraries
do all the hard work of writing to the correct registers within the device but older versions of the library would only read/write single bytes of data to/from the EEPROM. This led someone to create the EEPROMWriteAnything library
, this library allows you to define a single data structure
that contains all the information you want to store and write it in a single operation. That seems like a lot of preamble but hopefully it'll start to make sense once we put it all together.
The first thing to do is declare a data structure to hold our information we also create an instance of the structure at the same time called 'config'. The structure has two strings of data, one to hold the name of the network and the other to hold the password. Both the password and name can be up to 16 characters long but each string needs to have a null ('0') character at the end so we make byte arrays that are 17 bytes long. We can also give this information default values at the point of decleration.
This now gives us a way to store our information in volatile ram, meaning it will be forgotten at reboot. When the program starts, we want to load this information from the EEPROM overwriting the default values but this puts us in a bit of a catch 22 situation. At some point we need to write this information to the EEPROM before we read it. My solution also doubles up as a firmware reset should you ever forget the wifi password.
As part of the setup function we can initialise one of the input pins to be a reset indicator ('D1'). By pulling the GPIO pin low we can rewrite the password and network name upon program start, this should be done the first time the device is started but it can also be done any time the user requires it. This is akin to holding down a reset button on any electronic gadget while it boots. If the device detects the reset pin it writes the default values to the EEPROM, in both cases the device then reads the values back from the EEPROM before creating a new wifi network. The values are output to the serial port which is not particularly secure but if you already have a physical USB connection there are worse things you could do with the device.
My test setup just has a wire link connecting between D1 and GND, and D1 is configured to use the pullup resistor to provide the high voltage 'on' signal. I spent quite some time on a detour trying to use the built in reset button on the wemos board to provide the same function. It is possible to distinguish between a 'button push' reset and a 'power on' reset but the USB->Serial device (CH340C
) is tied into the reset pin to enable the arduino bootloader to reprogram the ESP device so pushing the reset button makes it appear like a power on reset. My detour only identified the problem and I haven't found a solution for it yet.
So that's part 1 of wifi config, we initialise some memory and store some default values to non volatile memory, recalling them at program start and a method for restoring the default values should the password be forgotten. The next part will be to provide a method for a user to actually change the values in eeprom.
by firstname.lastname@example.org (Martin Raynsford) at 25 February 2018 07:51 PM
19 February 2018
This was a new, clean honeycomb first thing this morning, now at the end of the day it's as dirty as ever. Wood is inevitably messy but it's also a little warped so you need the steel honeycomb so you can hold the wood down with magnets
by email@example.com (Martin Raynsford) at 19 February 2018 10:06 PM
18 February 2018
I tried the same style again
but this time I used an outline to show me where to paint the colours and I ended up with a slightly nicer colour wash. The grain of the tree is also 90 degrees out from the grain of the backboard which is a nice effect.
by firstname.lastname@example.org (Martin Raynsford) at 18 February 2018 02:19 PM
16 February 2018
I saw a discussion about how to make these kind of tree cutouts with multiple leaves, it inspired me to give it a try. I've included the process in photos below. People seem to use this style for wedding gifts and family trees. I tried to add some graded paint effects, I think I used a bit too much paint to start with before I started watering it down and spreading it to the edges. The next one will be better.
Start by cutting out the blanks for painting, I also cut out the tree trunk because it's going to be a different colour.
Paint the blank and the tree trunk, I tried for a colour wash effect so that there is some colour gradient across the piece.
Put the painted blank back into the laser cutter and cut the shapes from it, you can see I have already switch the red tree trunk for the brown painted one.
Tape the cut shapes back into the board so that they can all be lifted out of the laser as a single piece.
Glue the back of the cut shapes being careful not to get any glue on the frame.
Finally secure the glued,cut parts onto the back board and carefully remove the frame to reveal the finished item.
by email@example.com (Martin Raynsford) at 16 February 2018 01:24 PM
13 February 2018
I've been wanting to make an interesting clock variant for some time now and I thought it would be cool to have each digit represented by an analogue gauge, so here is my design for an alternate clock. The top two dials represent the hour (in a 24 hour format) and the bottom 2 dials represent the minutes. The whole system is run by an Arduino
connected to an I2C Real Time Clock module
and an I2C PWM Servo Driver
. Having both the RTC and the Servo Driver on I2C
, is definitely a bit of overkill for this simple project but it does leave a lot of IO free for future expansion and the servo control is exceptionally steady (no jitter)
The dials are made from a combination of laser cut wood (stained dark) and perspex. Each dial has a white perspex backing which has been engraved and infilled with acrylic paint to achieve a high contrast on the numbers. There is a second piece of clear perspex over the front of each dial to enclose the pointer and stop small fingers from touching the moving parts. The dials are mounted on a 6mm plate which is tilted backwards about 10 degrees which makes the whole unit fairly sturdy. The electronics are mounted onto the back of the board using small self taping screws on the appropriate mounting points for each module (svg here
The software to drive the whole thing is rather simple, Adafruit supplies lots of lovely sample code for both the RTC
and the PWM
driver so it was just a matter of tying those together. The simple plan was to be able to set a number between 0 and 9999 onto all 4 dials by working out the minimum and maximum range for a dial and subdividing by 10. That didn't quite work out and I had a little detour into the realms of PROGMEM
to map new values into the servos in a way that didn't consume any additional RAM (again thinking about the expansion possibilities). I found the PGMWrap library
was a very useful tool which allowed me to store my static map of values into the flash memory instead of in RAM. Full Source code is here
and included below.
I'm using fairly generic 9g micro servos
to drive the pointer on each dial. Although all 4 servos came in the same batch there appear to be two different types with differing time ranges. All 4 servos were sufficiently different in accuracy that I ended up having to map the exact positions of each of the dial numbers onto corresponding PWM values for the servo driver. This again had the added bonus of being very exact when moving to each position although it was a little time consuming to set up. The pointer was glued onto a modified servo horn and screwed into place before the clear perspex was added. It's a bit glue heavy and not particularly repairable so hopefully it won't break any time soon.
I left the setServoPosition function in the code so that I could easily use the dials for a hit counter or other number display. I never did find out how to declare and use a 2 dimensional array from the PROGMEM so if anyone figures out how to do that I would love to know please, it would simplify the mapping just a little bit more and much more streamlined code because the PWM servo driver is technically capable of handling 4 of these displays at once.
by firstname.lastname@example.org (Martin Raynsford) at 13 February 2018 11:57 PM
I made a prototype dial for another project and it all came together well. It's mostly Birch ply, stained dark brown. The pointer is 1.5mm ply painted black and attached to a cut down servo arm. The backing is 3mm white acrylic, infill painted with black acrylic paint. The whole thing has another layer of 3mm clear acrylic over the front to act as a protective layer. It's a standard 9g servo behind it and connected to an arduino to make it easy to drive.
by email@example.com (Martin Raynsford) at 13 February 2018 08:28 AM
12 February 2018
I made this gauge with white acrylic and a black paint infill to bring out the numbers, although I engraved through the protective layer and used it as a mask I think it's probably easier to just engrave the material without the mask because the paint wipes off the plastic pretty easily, now that I'm using airbrush paints.
by firstname.lastname@example.org (Martin Raynsford) at 12 February 2018 11:05 PM
08 February 2018
I've also been working on a bunch of these rotating rings, they can be used in all sorts of cakes. Most turntables are solid but because these have a hole in the middle you can build cake right through them. I've made 4, 5 and 8 inch versions but failed to take any 8" photos. Useful for cakes like this
by email@example.com (Martin Raynsford) at 08 February 2018 10:20 PM
DNS is essentially a naming system
for computers and services connected to a network. It's a way of mapping an IP address to a name and keeping that connection even if the IP Address Changes. You could visit google by going to http://18.104.22.168/
but it's much easier to remember and type http://google.com/
into your browser instead. So far we've been accessing our ESP device by typing http://192.168.4.1/ as a URL but there is a way to set up a local DNS server on the device so that it too can have it's own named URL.
For this tutorial we're going to go right back to the basic access point
code. This code creates a local access point with a simple user name and password and responds to the browser with a simple piece of text. Being the wonderful arduino environment there is already a library written to enable you to do this with just two lines of text, the first to include the library and the second to tell it which URL you want.
Voila, now when you go to the browser and visit http://esp.local/ it takes you to your device.
All is good, in theory. It can't be that simple though other wise I wouldn't be having such a dilemma about DNS. The trouble is this only appears to work from my iPhone. When I go to my android phone or my laptop I can't access the device in the same way. This is also part of the problem with arduino, we're only using the libraries we don't really understand how they work. There's usually some workaround though and in this case there is a second DNS library readily available which appears to do the same thing so lets look at that.
The DNSServer library is a bit more involved (but still not a lot). The header file has to be included, an instance of the dns server declared, the server needs to be set up with the domain name (and DNS port) and finally it needs to be called in the main loop to ensure the requests are processed.
This has the rather disappointing effect that it doesn't appear to work on either iPhone or Android so it seems like a funny thing to include it here. Well the DNSServer library does have one interesting feature that actually proves to be quite useful. If you do not specify a domain name and instead use a wildcard, '*', it is supposed to be able to capture all requests and direct them to the correct URL. This is know as a captive portal and public wifi spots use them to direct your browser to their own login pages. The captive portal functionality finally allows us to connect to http://esp.local/ on the android (and laptop) device. In fact we can connect to anything we want it all goes to the same location.
The trouble is it doesn't work on the iPhone, and here is the dilemma. With the two obvious DNS libraries neither of them actually does a complete job. The world is not ending though, it is possible to use both libraries at the same time and between them they seem to cover all bases. So that's the little work around for now (full code here
Arduino being open source, it is actually possible to delve deep inside these libraries and figure out how they work, what they're doing or not doing in the specific iPhone/Android cases and it should be perfectly possible to fix one of these libraries to work with both systems, that all takes time though, I guess I know what I'll be doing next week.
by firstname.lastname@example.org (Martin Raynsford) at 08 February 2018 06:46 PM
07 February 2018
I have learnt something new, the collective nouns for Owls is a "Parliament".
I have made a whole box full of owl heads for a course Dawn is running in Amsterdam
this weekend, and also the reason for all the cars
I made last week.
by email@example.com (Martin Raynsford) at 07 February 2018 09:59 PM
03 February 2018
While I still try to get my head around the two different DNS servers I thought it was about time to write another tutorial. In this tutorial I'm going to discuss the use of the Serial Peripheral Interface Flash File System
(SPIFFS). This handy library lets you store files on the flash memory of the device. So instead of having to construct a HTML string as a response to a request we can serve up a standard web page.
To use SPIFFS you need to include the file "fs.h" at the top of the program and in the setup function you need to start the SPIFFS library using the 'begin' function. This initialises the library and allows you to access any files that are contained within the flash memory. For the purpose of debugging I tend to loop through the file system to list all the files contained on the device. The following lines of code retrieve a reference to the directory structure and then outputs all the files names to the serial port.
Finally we need to put this file system to use. The web server library is able to serve web pages directly from the file system rather than having to construct a new response each time. In this case we instruct the web server to respond to a root request with the index.html page directly from SPIFFS. Using this method you can write a web page in sensible editor, test it in your browser all without ever having to connect to the ESP device.
Here the complete code for a simple web page server, the next issue is how to get the files onto the device in the first place. ESP8266FS
is a tool that can be used to create file system images and upload them to the ESP device. It integrates with the Arduino IDE so it's easy to use. To install the tool you simply create a folder called 'Tools' in your arduino sketchbook directory, and unpack the zipped file
Now when you open the Arduino IDE there should be an additional option in the 'Tools' menu system. ESP8266 Sketch Data Upload. If you create a folder called 'Data' next to your arduino sketch, then the tool will convert any files in that folder, into an image and send them to the file system on the device.
by firstname.lastname@example.org (Martin Raynsford) at 03 February 2018 11:27 PM
02 February 2018
I put the vacuum former
to some serious work this week. I had a good run of making car body shells and owl heads, a little bit of practice and I could turn round each new sheet pretty quickly. Obviously making the owl heads and cars themselves has taken up a little bit longer and it has delayed the next ESP8266 tutorial while I try to figure out DNS. In other news I managed to turn my kitchen into a parking lot.
by email@example.com (Martin Raynsford) at 02 February 2018 06:24 PM
31 January 2018
Eli had to make a stone age scene for his homework, he opted to make a model A frame hut similar to the one recently built on Primitive Technology
. We laser cut a base to hold it all together and make it easy to line the sticks up and we laser cut all the palm fronds from crepe paper to go over the top of it. It took all day but he really enjoyed it.
by firstname.lastname@example.org (Martin Raynsford) at 31 January 2018 10:21 PM
28 January 2018
The next incredibly useful feature for the ESP8266 is the ability to program it directly over the Wifi. This would allow you to build devices that didn't even need a usb serial connection and you can easily update any devices that have been sent out to people already (would have been very handy for me this week).
The HTTP web updater
is actually part of the standard arduino core and it's incredibly simple to set up. We're going to build upon the web server tutorial
but this functionality can be included in all future programs.
Include the ESP8266HTTPUpdateServer.h and declare a new instance of the class for use in the program. The only other thing required to make this work is to tell the update server which web server it should be working with. This is done just before you start the local web server.
The arduino environment is able to prepare a new image to upload to the device. In the menu system you can go to "Sketch->Export Compiled Binary", this will be all the information about your program contained in a single file.
Now when you connect to the device via wifi you should be able to navigate the browser to "192.168.4.1/update", this will load a page that allows you to select a new image to upload to the device. Select the binary image from your sketch folder and click the update button, you should see the status of the upload displayed at the bottom of the page.
If the device has successfully updated, you will receive an message informing you of it's completion. It says the device is rebooting but the wemos D1 needs to be manually restarted using the reset button.
Once the device has actually rebooted you should be able to connect again to the wifi and load the root page to see that your changes have taken effect. For this demo I used the update to change the basic text response from 'Hello World' to 'Wifi Updated'
Here is the complete example code,
by email@example.com (Martin Raynsford) at 28 January 2018 03:24 PM
25 January 2018
In the previous tutorial
we set up a simple web server and responded to incoming HTTP requests with a static web page, this time we're going to have some interaction between the web page and the device. We'll set up a simple web page with a button and when you click that button we'll toggle the LED on the ESP8266.
In the setup function we're going to add some additional handlers for incoming URIs.
Instead of serving up a simple 'Hello World' text response, this time we're pointing the root URI towards the servePage function, in which we'll create a more detailed HTML response.
We've added a second handler for the /args URI and pointed it towards the handleArgs function, this will be used to process the incoming data.
Finally we've added an onNotFound handler, this should respond to all other URIs and direct the browser back towards the root homepage.
The servePage function still only creates a simple response for the client, but this time is is written in HTML. The sample creates a button and wraps it with a link to change the location of the browser when the user clicks the button. The new URI contains some arguments that tell the ESP8266 what is required. In this case we would like the LED to be toggled. This additional data will be sent from the browser to the web server on our device and the web server can interpret it accordingly.
The handleArgs function looks a bit more involved but the actual core is still pretty simple. The first four lines are just included to aid debugging, they create a string of data that lists all of the incoming arguments to the web server and they send that string to the serial port. This makes it very easy to see what was actually sent by the browser.
The middle of the function contains a for loop which iterates through all of the incoming arguments. There may be multiple arguments coming from the browser and they could be in any order so we loop through them all comparing the argument name against the value we're looking for, in this case 'led'. Once we have identified the argument we look at the value of the argument to decide what to do with it, in our case the value is 'toggle' but it could easily be 'on' or 'off'. If both the argument and it's value match then we toggle the state of the built in LED (don't forget to set up the LED pin as an output at the beginning of the program).
Upload the code and connect to the wifi network created by the device, point the browser towards http://192.168.4.1/ and you should see a simple page with a single button load. When you click that button the LED on the ESP8266 should toggle between the on and off state.
by firstname.lastname@example.org (Martin Raynsford) at 25 January 2018 11:39 AM
24 January 2018
I've clearly started something now and I was asked to make some TNT blocks
, these blocks are predominantly red which leaves some issues for laser cutting. I could have used a red wood but the engraved areas would be a darker red, not the white colour required for the label. The solution was to mask a sheet of poplar and then paint key areas of it red, I used an airbrush to ensure that the colour didn't bleed under the masking. This gives me 3-4 different colours to use, all of the detailing was done with line artwork so that it stood out as a strong black.
by email@example.com (Martin Raynsford) at 24 January 2018 05:40 PM
23 January 2018
The previous tutorial
showed how to create a wifi access point but the ESP8266 didn't do anything once a station was connected. In this tutorial, we build upon the previous access point to serve a simple HTML web page in response to a request from a connected station.
The ESP8266 Webserver library
implements a basic web server that allows the ESP to respond to incoming HTTP requests without needing to worry about the low level details of the response. Include the library at the top of the sketch with the line
Next we need to declare a new Web Server object using the HTTP port number, 80. This is the default port that a browser will use.
The ESP web server needs to be continually polled to see if anything is trying to connect to the device. This is done with a single call, placed inside the main loop code for the device
Now we have set up a web server to respond to HTTP requests we need to tell it what to respond with. These last few lines create a function that replies to a root ("/") request with a simple text response "Hello World!". It is possible to add other URI responses to the webserver, to serve different pages depending on what is requested.
Putting it all together gives us this sample code.
Compile the sample code and upload it to the device, you should be able to connect to the wifi network created by the ESP chip. The default IP address for the device is 192.168.4.1 so open a browser and navigate to "http://192.168.4.1/", a page should load showing this response
by firstname.lastname@example.org (Martin Raynsford) at 23 January 2018 09:28 PM
While I was in a minecrafty mood
, I thought I'd take a look at some of the other blocks to see what could work on the laser. These oak blocks came out ok, I let the grain of the wood do the hard work as the detailing. It amuses me somewhat that they're made from illomba faced poplar ply instead of real oak. The lettering is done with negative engraving and the font could be a little thicker to make it stand out more.
by email@example.com (Martin Raynsford) at 23 January 2018 09:27 AM
22 January 2018
In the previous tutorial
we covered the very basic function of most micro controllers, blinking an LED, but the whole reason we're interested in the ESP devices is their ability to establish a WiFi connection. There is a library for this and it's very easy to set up.
The ESP8266 WiFi library
has the ability to operate in a range of modes. It can act as a station where it would connect to an existing Wifi network, it can become an access point where it creates it's own wifi network and it lets devices connect directly to it. Finally it can operate in a mixture of both modes which is useful for forming mesh networks
The internet of things is a brave new world where people are putting all kinds of things online
, even simple things like lightbulbs
can be hacked and turned against the owner, because of this I've written all of my software in access point mode. I'm sure simple common sense could secure these devices on your local network but it's one less thing for me to worry about this way round.
I've written a very basic sample to initialise an access point with a predefined ssid and password.
The sample initialises the serial port functions before starting the wifi, the serial port is useful for debugging the application. In this instance the serial port sends details of the exact ssid and password being used to create the wifi network. The network name is created by combining a fixed string with the unique Chip ID, that way if I have more than one device turned on at the same time they'll both generate different network names.
In reality the sample boils down to two lines of code,
"WiFi.mode(WIFI_AP);" which sets up the device to operate as an access point.
"WiFi.softAP(ssid, pass);" which sets up the wifi with a given name and password.
It's worth noting that the ssid should be at least 8 characters long and less than 64 characters. If you want to set up a wifi network without a password just leave the password field blank.
Now when you open up a list of wifi devices from your laptop or mobile phone you should see the wifi network available to access.
by firstname.lastname@example.org (Martin Raynsford) at 22 January 2018 11:46 PM
21 January 2018
These little tokens are made to look like the chests from Minecraft. I made a whole batch for someone as part of an incentive system, each token collected allows 5 minutes of play on Minecraft.
by email@example.com (Martin Raynsford) at 21 January 2018 06:18 PM
19 January 2018
With my wooden mould complete
I was able to use the vacuum former to create a plastic shell that matches the shape of the owl heads. I'm going to cast that shell with a silicone compound to make an exact replica of the wooden mould and I'll be able to make two shells from a single sheet of material.
I used a large block of foam to fill some of the void in the middle of the cast, this reduces the amount of silicon I have to use. Last time I tried this though I forgot that the foam would float in the silicon. This time I laser cut a base board for the mould, once filled the foam will float up against this and be held in place. I put some pour holes in it so that I can fill it from the reverse, but due to a combination of the foam obscuring the holes, the holes being in the wrong place and me being generally rubbish at pouring I ended up making quite a mess of the board. It was all good fun though, you can see that the silicon copy came out well and has been already pressed into service (cornflour makes an excellent mould release)
by firstname.lastname@example.org (Martin Raynsford) at 19 January 2018 10:08 PM
17 January 2018
I needed a new vacuum forming mould for the owl heads, as there are a few workshops coming up over the next month it makes sense to do it properly.
The basic shape was made up with a mix of 6mm and 3mm ply, there is a sacrificial layer in between the two which will be replaced with a larger disk to create the lip in the middle.
3 bolts were placed through the middle of the mould to help them stay together. The larger bolt in the middle was used to hold the mould in the pillar drill. This allowed me to sand all the layers down and make it nicely rounded. The laser cut edges are really useful here, basically anywhere still displaying a burnt edge hasn't been sanded smooth yet.
by email@example.com (Martin Raynsford) at 17 January 2018 10:34 PM
I already mentioned that I would be using Arduino
to program these boards, Arduino is an open source hardware and software project that speeds up development on a range of Arduino compatible devices. Most of the hard work has been done already and provided in a wide range of libraries making this kind of embedded electronics accessible to almost anyone.
Download the integrated development environment (IDE) from the the Arduino website
and install it on your machine. This package comes with information about a wide range of devices but we will need to add the ESP8266 specifically before we can create a project for these devices.
Once installed, open the program and go to File->Preferences.
Add the following URL in the Additional Boards Manager text box, this will tell the Arduino IDE how to find the files it needs to run the ESP devices. Click the OK button to accept the changes. http://arduino.esp8266.com/package_esp8266com_index.json
Now we need to add ESP devices to the list of available boards, go to Tools->Board:Arduino->Boards Manager. It'll be the top entry at the list of devices.
Use the search bar at the top to find the ESP library, as you type it'll narrow the selection down. Once you have selected ESP8266 a box will appear that allows you to install a version of the library. Select the most recent version and click "install". A progress bar will update while the libraries are installing.
Now when you go back into the board selection (Tools->Board:...) you will see a new section and several new entries for ESP8266 devices.
Select "WeMos D1 R2 & mini" from the list, this will set up the compiler to target the board you're going to be using.
Connect the device to your computer using a USB cable and allow the PC to establish a serial connection with the device.
Go to Tools->Ports to select the newly established Com port from the list of available com ports.
Now your ready to test the device.
Here is some simple Blink code, you can see that in the setup function the device sets up the LED pin to be an output and in the main loop it toggles the value between high and low once a second to make the LED flash.
Click the Upload button (arrow pointing right) to send the code to the device, if all is successful you should now have a flashing LED on the device.
by firstname.lastname@example.org (Martin Raynsford) at 17 January 2018 09:42 PM
16 January 2018
It is my intention to launch some new products in the near future and redo some existing ones so I'm taking the opportunity to tweak my logo. While it's functionally the same the whole text is now done with a single line font and the cat is also a single outline with whiskers. The redesign will undoubtedly save me seconds each time it is cut so I'm sure it'll pay for itself in just a matter of years.
The logo can also be engraved to a similar effect simply by converting the stroke to paths and filling in the gap, useful for when I want to make larger logos.
I also spent some time playing with the kitty to produce some interesting effects,
by email@example.com (Martin Raynsford) at 16 January 2018 11:03 PM
I've spent a lot of time recently working on various cakes for Dinkydoodle designs
working on a range of moving cakes
that are headed for mass production. The Cars
, Droid heads
and Owl head
, are all essentially the same thing, a controller and a few servos. Like most projects I work on now I started to look at the arduino range to for a controller and software, there are lots of compatible devices to suit every budget and a lot of the libraries are well established for all the basic functionality. The car needs some wireless control though which ultimately led me to the ESP8266 chips
. Given my lack of recent laser cutting blogging I thought it would be sensible to share some information about this work in the hope that it might help someone else.
The ESP8266 is a low-cost Wi-Fi microchip with full TCP/IP stack and microcontroller capability produced by Shanghai-based Chinese manufacturer, Espressif Systems. Which is to say, they're capable of creating a wifi data link to your phone/laptop/other device, they can serve html web pages and a whole range of other useful things and are currently available from as low as £1.20 each. I jumped straight in and purchased a few ESP-01 devices (pictured) and waited for them to arrive. Obviously I should have done a bit more research before starting because I bought the wrong thing.
The first lesson I learnt is that there are a lot of different types of ESP chips, they've had a fair bit of development over the years and some significant improvements. There is nothing wrong with the ESP-01 device, it's the cheapest of the bunch and it's fully capable and functional but you will need a programmer for it. If like me you have a few old arduinos floating around, it's possible to wire one of those up to reprogram the device
. I followed this route to stop me waiting on more parts to arrive but the two rows of pins make it a pain to put on a breadboard. If you want to use these devices I would really recommend buying a programmer
especially as they only cost £0.65. But read on before doing either of those things.
The ESP-01 is an older device, it has some quirks and most notably only 4 usable GPIO pins. The ESP12 is the much more recent device and has 9 GPIO pins, it's also available for the same price per module. As you'll notice from the image though it's not particularly breadboard friendly. If you're incorporating it into your own pcb you can treat it like any other smt device but for quick start you're probably better off buying it already built into a development module. I ended up going with the Wemos D1 Mini
which you can get for <£2.00 a time and it has the Serial device built into it. The whole thing can be powered off USB and it's relatively easy to attach your own things to it.
The ESP12 also comes in a range of different boards, the wemos typically comes with ESP12f but Espressif seem to be up to ESP12n, from my view point I've not seen a notable difference between them but newer is probably better right? This website
offers a fairly comprehensive review of all the different modules, modes and boards that you can get the ESP devices in. Next up, I'll talk about getting started and the infamous blink led sketch.
by firstname.lastname@example.org (Martin Raynsford) at 16 January 2018 11:09 AM
03 January 2018
I picked up a cheap tablet stand from Ikea today, being bamboo I knew it could be personalised and my wife loves anything Pusheen. I ran some tests on poplar to dial in some settings and test the style (the lines are wide and out of focus), obviously I should have been testing on bamboo. As soon as I started the first engrave pass I realised that the engraving turned the wood white and my colours would be out of whack. I quickly swapped the files and layers around to engrave the laptop and not the Pusheen.
by email@example.com (Martin Raynsford) at 03 January 2018 09:27 PM
22 December 2017
I found some time today to make a full version of the new advent calendar. I assembled it with all the doors in order but they can be put in any order you want. I view this as a base for a real calendar, a little flourish across the top or a winter scene and it would make a nice product. You could also change the door knobs easily and size for extra customisation. This version is just large enough for quality street chocolates, obviously I have 22 days worth of chocolate to eat tonight :) (svg here
by firstname.lastname@example.org (Martin Raynsford) at 22 December 2017 05:02 PM
20 December 2017
I made an advent calendar
5 years ago and despite requests to start selling them, I could never get them into a sensible time frame or budget. This year the discussion of advent calendars came up again and I decided to take another shot, this is how I would make a calendar now. The handles are made using wooden push pins (they need trimming), the doors are hinged by the wall sections and they rest upon the verticals to stop them being pushed in too far. There is enough friction in the hinge to keep them open during use. Obviously I've missed most of December now but I'll draw up the full 24 door version so I'll be well ahead for next year.
by email@example.com (Martin Raynsford) at 20 December 2017 10:42 PM
15 December 2017
I have a couple of LED strips that I use as Christmas lights
. This year I mounted one above the other and I needed some connectors to space them equally across the length. These little hangups were made from 5mm acrylic and allow the strips to slide in and out and clip into place (by squashing the silicon sleeve slightly)
by firstname.lastname@example.org (Martin Raynsford) at 15 December 2017 11:19 AM
14 December 2017
I made a mistake while cutting the last set of Carcassonne tiles
, I had a magnet
too close to the tiles and it didn't cut cleanly. Unfortunately the files for Carcassonne have all the tiles split into two sets and all the tiles smushed together, there is no easy way to recut a single tile. This means it's time to redo the whole set and correct all the other things that have been niggling me. The original files were drawn in 2013 and over the last 4 years I've learned a lot more about inkscape so can do things better.
The new file will use layers to allow me to easily turn parts on and off, and more colours which can be set up as operations in Lasercut.
Several people have asked for tile sets without the grass, these tiles are generally used as guest books at weddings, no grass leaves more areas to write on.
Roads and buildings never quite touched the edges of the tiles. It was close enough not to worry about but I knew it wasn't 'perfect'.
Lasercut takes a long time to convert vector lines into an engrave, to speed up the process I used inkscape to create a bitmap of all the engraved areas.
During laser cutting materials have a tendency to shift with heat and wood warp. The original tiles pushed up against each other and cut along the middle but this leaves little defects as the material shifts. The new tiles will all be cut individually. It will take 20-30 seconds longer but I can live with that on a 2 hour cut.
It's a slow process and I still have other work to do but slow and steady and I'll get there.
by email@example.com (Martin Raynsford) at 14 December 2017 10:54 AM
10 December 2017
Craft time for the whole family, we're all at home so decided to make some wrapping papers. We started with simple brown paper and carved some potatoes to make printing stamps. For a second sheet we drew a single black line across a page and then finger painted a string of lights onto it, these should provide enough wrapping for a good handful of presents.
by firstname.lastname@example.org (Martin Raynsford) at 10 December 2017 04:29 PM
09 December 2017
If we were making a Jurassic world cake
and we already make cake cars
we'd be a bit foolish not to make a Jurassic world Jeep. The jeep had a custom version of the car base to lift the vehicle a bit higher up but the mechanics are all essentially the same, meaning the car base can actually be quite versatile. Dawn covered the platform with cake and icing and did all the difficult decorating parts that actually make it look like a car, it's a very impressive job that I believe was completed at stupid o'clock the morning before the event.
There's even video of the car driving through the gates (the car determined the size of the gates). I'd like to point out that I wasn't there though because friend don't let friends take vertical video.
by email@example.com (Martin Raynsford) at 09 December 2017 05:21 PM
It's been a busy week getting these cars into production and after a late night last night I finally finished a batch of 8 cars ready for workshops this weekend. I delivered them to Nottingham first thing this morning and as far as I know it's all going well which means I get to sit back and work on some other projects this weekend (Like catching up on some blogging). In the meantime here are some pics of the completed cars.
by firstname.lastname@example.org (Martin Raynsford) at 09 December 2017 04:19 PM
08 December 2017
The remote car cakes
have a layer of plastic between the cake and the electronics. This needs to be shaped to fit the wheels and provide enough space for actual cake to go onto the car. The vacuum former
is the perfect tool for this. I started by taking a mould of an actual toy car about the right size, this ended up being a one shot deal as the toy car melted on the second pull.
At this point I had a sheet of plastic in roughly the right shape and a strong desire not to mess up a second time so I scrabbled around the garage to see what my options were. I found a bag of plaster of paris and decide that casting the mould was a sensible way forward.
The plaster of paris was cast, the kitchen was turned upside down, nearly every available surface turned into useful space full of junk, at least I had a few hours to tidy things up again. It was all a bit impromptu but good fun. The plaster of paris former was cut into separate parts for the cake. The middle section will become a mould for the cake part of the car, the nose and bonnet will house the electronics.
The plaster of paris parts were shaped, padded and mounted upon a base to hold them in the right places. The wheel arches were built up to allow ample room for the wheels. This new mould served well for the first half dozen cars, it was a bit of a struggle to remove the mould after it was formed and it started to show signs of wear which led to a mould rethink but that's for another day.
by email@example.com (Martin Raynsford) at 08 December 2017 01:14 PM
07 December 2017
The remote control car cake
design was refined to a point where we could run workshops on it, allowing other people to make them. This means small production runs of parts, last night I sat and assembled 32 wheels, each one made from 5 layers of material and then I squeezed rubber tyres onto them. It's mindless work but it needs to be done and at least I get to watch TV at the same time.
by firstname.lastname@example.org (Martin Raynsford) at 07 December 2017 11:56 AM
04 December 2017
I cut some more wound point counters tonight, but this time I used air brush paints to fill the lettering. It's thinner than normal acrylic paint, offers great coverage and dries quicker. I definitely recommend it for infill effects.
by email@example.com (Martin Raynsford) at 04 December 2017 11:26 PM
03 December 2017
I had the pleasure of attending a Dinkydoodle Designs
cake making course today, it was great to go along and learn how to make the cake that goes around the droid heads
I've been making for the last 2 years. Because BB9 has a flat top I had to rebuild the whole mechanism to make it fit into the available space, I took the opportunity to make some needed improvements, such as vacuum formed heads and bearings for the moving parts. I also decided to add an ESP8266 into the mix so that the whole thing could be controlled from my phone. I had a great day and would really recommend it for anyone who is looking for something different to do.
by firstname.lastname@example.org (Martin Raynsford) at 03 December 2017 07:58 PM
02 December 2017
Eli drew a picture of a small present he wanted to make for Santa. He measured the size of the bag to find the right scale and he drew the design out on inkscape with a little bit of help. I set up the laser to cut on a small piece of illomba faced poplar ply that he picked from the scrap pile and 45 seconds later we had the item made.
by email@example.com (Martin Raynsford) at 02 December 2017 04:05 PM
30 November 2017
The control box
I made the other day was destined to be connected to this set of Jurassic World Gates. The gates are modelled after those in the film, the LED lights flicker like real torches, the gates open and close (and stop at the limits of their travel) and the whole thing can play the Jurassic World theme tune. This framework will head off Dinkydoodle Designs
to be covered in cake and icing.
by firstname.lastname@example.org (Martin Raynsford) at 30 November 2017 11:06 PM
27 November 2017
I've been working on a cake this weekend, bit of a rush and I'll be able to reveal the whole thing before the end of the week. For now I put together a quick electronics box to give it a polished feeling. The most recent version of inkscape comes with a lot more choice of Hershey text so I opted for a rather nice font on the switches to denote the functions.
by email@example.com (Martin Raynsford) at 27 November 2017 08:44 PM
24 November 2017
The school asked me to cut a selection of santa keys for their Christmas fair. It was a simple drawing and cutting keys from my mdf scraps. (svg here
by firstname.lastname@example.org (Martin Raynsford) at 24 November 2017 04:26 PM
23 November 2017
The basic car framework
needs a food safe covering to go between the cake and the electronics. Thankfully when I bought my vacuum former
this project was already on the cards so it's a perfect excuse to use it. I laser cut a basic mould from ply and assembled it as a mould to form over. The cake needed to clear the wheels and provide turning clearance for the steering. These covers came out pretty well, the trouble is that vacuum forming works best with a 3 degree angle on the edges and the laser cutter cuts perfectly vertical so it was a bit of a struggle to get the mould out. This was when I introduced an air pump to the vacuum former. Applying a bit of positive pressure after forming releases the mould a little and made it easier to remove.
by email@example.com (Martin Raynsford) at 23 November 2017 09:19 AM
22 November 2017
As well as making my own cake
for cake international, I've been rather heavily involved in making these remote control car cakes. Once you add sugar paste icing and a large chunk of cake these things start to weigh quite a lot so moving them round becomes quite a tricky challenge. This car has been through a few iterations before it will go into product development, this is the first version.
I decided to use the ESP8266 wifi chip to function as a controller on these devices. They're able to act as a webserver and deliver HTML pages directly to your own device without the need for any kind of app. As most of the people in the cake world seem to use iPhones and I have android seemed the easiest solution.
I wanted the car to keep the traditional Ackermann steering mechanism, so I used a servo to directly drive a linkage mechanism. The little 9g servo just about coped with the turning forces but it needed to be enlarged once all the cake was put on top of it
Two motors controlled the rear wheels, these were directly attached to the drive wheels. Wheels and motors were bought as a single and designed to be connected together. The motors were driven by an L298N dual H-bridge chip.
This iteration was functional as you can see in the video but it all needed beefing up a bit to provide any kind of longevity. I'll discuss more of the design in the next post and try to keep you all a bit more involved while I'm stuck in development mode.
by firstname.lastname@example.org (Martin Raynsford) at 22 November 2017 09:28 PM
18 November 2017
I bought some cheap LED clock kits
a few years ago, they were good fun to assemble and left me with a perfectly serviceable clock for the kids rooms. I opted not to buy the (nasty plastic) case because it was laser cut and I could make my own, move forward a few years and today seemed like a good time to actually do that.
It's a simple wooden box really with holes in the correct places, the clock module slides in loosely from the front and wedges in place with some foam. The plastic panel slides into some grooves along the front of the box. It's transparent grey plastic
so the LED's can shine through it. The grooves on the front mean that the burnt side is out on the top of the clock, I should have masked it to reduce those marks. Being wooden I can easily glue it to the underside of my shelves next to my hooky hooks
by email@example.com (Martin Raynsford) at 18 November 2017 04:44 PM
16 November 2017
This is one of those little projects that didn’t need to be done, or could have been done very simply. Despite a lot of feature creep, everything just came together at the right time, and I’m really pleased with the results.
Firstly, a bit of background. My mum celebrated her birthday a couple of months ago, and the present my sister bought her was a geode that she picked up on a recent holiday to the United States. Not just a regular geode, though, but one that had a hole drilled out and a light attachment that went inside so it glowed nicely. Well, it would have glowed nicely, except that the US bulb was rated for 110v, not our full strength 220v electricity. So the millisecond it glowed nicely for was followed by a loud bang and the bulb turning black.
As I was there to see this, I figured I could easily get a light fitting and bulb from Ikea and we’re all good. Then I wondered if LED lights might be a better idea. At the same time, I was starting a project for the RC2014 involving a ESP8266 wifi enabled micro controller. Coincidentally, I’d just bought a couple of WS2812 based Zip Sticks. So, you can guess where I’m going with this, right? Yup, use the ESP8266 to set all the LEDs to a nice shade of blue, and job done!
Well, that would have been within my programming abilities. However, I wondered if anybody else had controlled WS2812 LEDs from an ESP8266. Would you believe they had? And not only that, but I found McLighting from Toblum on GitHub which enables wifi control from your phone or computer to not only set the colour, but a whole stack of pretty effects.
Time to fire up KiCad and get a PCB designed. I’d taken the rough measurement of the hole in the geode, and had a 40mm diameter round PCB to fit everything on. With a mixture of through-hole and surface mount components, and using both sides of the board, everything went on well. Because I only needed a very small run, OSHPark was the obvious choice. And at only $11.25, it was a real bargain!
A few days later and 3 lovely purple PCBs arrived. It wasn’t long before I got the soldering iron out and started to assemble them. I assumed that my selection of every single value of surface mount capacitor would have contained what I needed, but sadly it didn’t even get close, so I had to resort to bodging in a couple of through-hole electrolytic caps. I also noticed that I hadn’t indicated the +ve or -ve power terminals. A rookie mistake, but not the end of the world. Once it was all together, though, it worked just great!
A quick test, and a run through of the settings and things were looking really good. But would it fit the geode? Time for a trip down to my parents house and try it out.
The PCB went in to the geode with no problem at all. If anything it was slightly undersized, but I’d prefer it to be a little bit too small than too big. A plastic ring that was a snug fit held it securely in place.
In the daylight, it looks absolutely awesome!
By night it looks even better… although getting a good photograph isn’t so easy!
by Spencer at 16 November 2017 12:29 PM
12 November 2017
As is their right, the blood and oil guys decided to go with acrylic for their counters
. The acrylic is a bit trickier to glue together and all of the lettering has to be done with infill techniques
. I decided to opt out of the assembly process for these and instead supply bags full of parts :)
by firstname.lastname@example.org (Martin Raynsford) at 12 November 2017 10:19 AM
11 November 2017
I made this simple, magnet free version of a score tracker for Blood and Oil
. I used 0.8mm birch
for the front and back panels and 3mm poplar for the middle layer. The lettering was done with Hershey text to make it as fast as possible and the emblem is a combination of engraving and outlining. The idea was to make these as quick as possible for a batch order but I also liked the super skinny style.
by email@example.com (Martin Raynsford) at 11 November 2017 10:12 AM
07 November 2017
A family of large meeples from 12mm plywood, coloured before cutting. I really should mask the reverse or clean my honeycomb to make them look better after cutting.
A customised start tile for Carcassonne. Somebody wants to use a set as a guest book for their weddings, having the guests write messages on the rest of the tiles.
A quick stencil for painting some fabric. It's for a cosplay costume, possibly one of the super hero suits?
Finally here is the days orders, a mixture of marble machines, kits and other custom parts (like the meeples)
by firstname.lastname@example.org (Martin Raynsford) at 07 November 2017 06:36 PM