The Foundry: Blowing Smoke

In the last post, we saw a fire actually burning in the foundry. The concrete has set, and doesn’t fall apart while being used. After researching other designs, and using some logic, we figured we need to force more air into the system. As we designed previously, there is a large 30mm hole on the side of the forge to allow air into the fire. Unfortunately, this doesn’t seem to provide the amount of air we need to get the desired heat. We have tried a number of ways to force air into the hole, with varying success. First we literally blew into it, like you would a campfire, and it works well, but soon you start to really hyperventilate, and it’s not good. The next idea was to take a chopping board (but any board will do) and flapped it, forcing air towards the hole. This worked much better than simply blowing. Lots of air fuels the fire, and it burns really hot. The big downside is that it wastes most of the air produced, and creates some interesting smoke patterns that seem to be inefficient. Either way, it is a good cheap way to improve the forge performance.

First Tests
The foundry during its first fire, not particularly hot.

The method we eventually used to force air into the system was in the form of a fan. Before I start this section, it comes with a warning, you need to wear goggles if you try this, as will be explained. You have been warned. The initial fan was in the form of an old hairdryer, bought from a charity shop for £3. Putting it right up to the hole forced hot air directly into the hole, with very little waste air escaping. It worked very well, and the fire started to burn much hotter. It also meant we could control the amount of airflow by using the switches on the hairdryer, or simply moving it further away.

Forcing air into the forge
Forcing air into the forge using a hairdryer, the fire is visibly hotter.

Two issues came up while using this method of airflow. The first big problem is the mass of air being forced into the hole needs to go somewhere. The only place it can go is straight up, and as we don’t have a lid it just fires ash into the air. This is dangerous if gloves and goggles aren’t being worn. This ash can be hot and can take some of that fuel and heat away from the forge. A lid will fix this, and that will be covered in the next post. For this test we kept it at a low fan speed, and found a nice point where we weren’t firing ash into the air, but still giving lots of air to the fire. The second problem was that the hairdryer started getting really hot, and the plastic began to melt. Essentially this means it was too close to the fire, but if you move the fan away then the air just misses. To fix this we found a 30mm diameter iron pipe, and attached the hairdryer to it. This allowed the air to be funneled in with the fan unit being further away from the forge.

The fire burning
The fire burning with a steel tin on top to stop the ash flying out.

So what have we learnt from this fire? We need a lid. This will be a topic of further posts, but for now we know we can produce a hot fire, and the air going into the fire can be controlled. Thanks for reading, and hope to come with another update soon.

Four Bit Carry Adder/Subtractor Circuit

After creating my 1 bit full adder design found in a previous post, I decided to go for something a little more complicated. I wanted to prove to myself that the ripple carry system worked, so the obvious choice is to make a multi bit device. 4 bits seemed like a good amount, it’s a value used in some early ALU’s so it can be used in a future project. To make it more interesting I added in the ability to make the device a Subtractor at the same time. When you look at the schematic, it only requires one more device per adder, so it’s not even an expensive thing to implement, but adds lots of functionality. As with the 1 bit adder, I have attempted to build this adder using only single logic chips.

4 bit adder-subtractor circuit

The first stage is to know the logic circuit, its widely known and can be found pretty easily all over the web. I’m not going to explain how it’s created (I can always make a separate post on that) but I can describe how to use it. The aim is for the device to take two 4 bit inputs (0 – 15), along with a carry from another adder. So the adder needs to be able to output a value between 0 and 31. In binary this can be shown as 5 bits, so we have 2 outputs. This the S output is a 4 bit bus, and the Co output bumps this up to the 5 bits we need to make 31. A truth table can be made for this but it would be 32 lines long, so too much for this post. You could regard it as a personal challenge if you want to attempt it on your own.

So I got onto Altium and made a schematic of this circuit using some of the low voltage 7400 LVC series individual logic gates that I used on the previous adder I made. They come in SOT23-5 packages which are leaded a nice size to solder. Plus they are a size where it’s possible to probe the pins fairly easily. Luckily Altium shows the components as their logic symbols. Below I have shown the first two adders, the third and fourth are basically the same as the second one, which is the idea of the ripple carry adder.

The first two adders of the four found on the board

I also added a few LEDs to show what parts are on and off. This means the user can see the inputs and outputs. These LEDs run off the 5V input voltage, and have 220Ω current limiting resistors in series with them. Also, I have put in some 0.1 inch header pins so it can be attached into a breadboard and maybe even a micro.

The LEDs for the carry bits and outputs
The LEDs for the input bits

As a base of my circuit, I have decided on a double sided 100mm x 100mm board. This is quite big as you can see for the circuit I have made, but gives plenty of space for a soldering iron to get access. As well as this, it gives a nice amount of space for multimeter probes. I also tried to keep the individual logic chips in a similar arrangement as the schematic. This is meant to be used as a learning device, so it’s useful for the chips to line up with the diagram. The header pins for the inputs and outputs are placed on opposite sides of the board to make it more obvious for the user to see it. And the pins have designators written on the board so the user can see what each pin does. The input and output busses are placed in fairly logical places, and grouped together. There is no point having all the A inputs intertwined with the B inputs. The pins for the power and ground are on opposite sides with their own headers, only one needs to be connected for it to work. The LEDs that are directly attached to the pins are placed closer to the logic circuitry, but labeled clearly on the silkscreen. Most of the routing to the LEDs is on the underside of the board, else the top could get confusing. All the designators for components have been made half the normal size due to the small amount of parts used in the project. The below images show the PCB layout I created with the top copper being red, bottom copper being blue, and the silkscreen shown in yellow.

Top Copper

As you might be able to see, I have tried to keep all the power on the bottom side of the board. This leaves lots of space for the logic signals on the top, where the user is more likely to see. As you can see, most of the inputs and outputs of the circuit are also on the bottom side. This is because the way the busses work and input into the adder needs lots of crossing over and would add confusion into the design. This is why labels were used instead.

Bottom Copper

To make it easier to see, I made a larger image of the first and last adder in the series. As you can see, the only real difference in them is that the first has the add/subtract input shown by an LED, whereas the last shows the carry from the previous adder (C0). This is because the A/D bit is attached to all the adders, but the first bit doesn’t have a carry bit input. The carry on that adder is the input for the A/S. It serves the function of inverting the first bit, so that it works like 2’s complement when in subtract mode.

The layout of the first adder in the series
The layout of the last adder in the series

As noted above I used 7400 LVC series logic gates. The SOT23-5 package chips have the suffix of “BVD”. See the datasheets for each of the devices for more information. I have written a simple bill of materials below:

12x SN74LVC1G86DBVT – XOR gate
8x SN74LVC1G08DBVT – AND gate
4x SN74LVC1G32DBVT – OR gate
17x DO-214 LED’s
17x 0805 220Ω resistors
6x 5-pin 0.1″ header pins

The main downside to this type of adder is that is is very slow. Especially when you get to high bit amounts that you are trying to add. This adder will take at least 4 times as long as a single adder to add the two numbers together because the signal has to propage through 4 full adders. This problem is known as propagation delay, each logic chip will take a very short time to compute the output. Although this time is not perceivable by the human eye, if there are 100’s of logic gates in a row, then the delays start to add up and be a problem. If this circuit is to be used in a computer, it could need to make calculations thousands, or maybe millions of times a second, and a carry bit adder is not generally good at that. There are other, faster adders that I will show in a future post.

The Foundry: The First Fire

Now it’s time to test the foundry, or at least the first version of it. This also has a benefit to it. Some others who have made this style of foundry have found this process helps the concrete to fully cure, and dry any leftover water still in the mixture. This process is pretty simple, most suggest using charcoal as the main fuel. We went down the local hardware store and they had a sale on charcoal briquettes. These are small and there are plenty of them, and fit nicely in the foundry. Light the fire in any way you are used to, we used fire lighters and some cheap kindling, also from the hardware store. If you don’t know how to light fires safely, find somebody who does.

First Tests
The foundry having its first fire, drying it out and seeing whether it can survive.

We didn’t use much to start with, this is meant to be a calm fire to help cure the concrete, and test it can deal with at least some hot temperatures. It was also to see how well it burnt with the air hole we put in. Main problems we found were that the air hole did not provide enough oxygen into the system, so the fire was slightly stinted. We tried blowing into the hole a few times, and the fire definitely got bigger, but it also sprayed ash into the air, so be very careful of that. We also noticed something most blogs talk about, lots of heat escapes from the top. With the foundry having such a big opening, very little of the heat is retained, and the fire has to work harder to keep the heat at a set level. A lid is often the best way to battle this.

The aftermath
The foundry after its first test and the ash was scraped out of it.

So what have we learnt from our first fire? We need a lid, and some way to force air into the hole. This will be a topic of further posts, but for now we know our concrete foundry can withstand the heat of a fire, and is now a little bit darker from all the ash. Thanks for reading, and hope to come with another update soon.

One Bit Adder Project

One thing that has always been interesting to me is using logic circuitry in electronics. It’s easy to implement something on a microcontroller in just a few lines of code, but the real challenge comes from making a boolean project using real logic gates. It’s something we all learn about if you have taken a basic computer science class, or even digital electronics. One of the first circuits you ever learn about is the adder. It’s pretty simple, teaches you how to cancel down boolean equations, and only has a few inputs and outputs. I have decided to try and make the circuit using real components, and see if I can get it to work.

full adder layout

The first stage is to know the logic circuit, its widely known and can be found pretty easily all over the web. I’m not going to explain how it’s created (I can always make a separate post on that) but I can describe how to use it. The aim is for the device to take two 1 bit inputs, along with a carry from another adder. So the adder needs to be able to output a value between 0 and 3. In binary this can be shown as 2 bits, so we have 2 outputs. The S output represents bit 1, and the Co output represents bit 2. Below is the truth table I used, if you want a little challenge, try and get the above circuit using boolean algebra.

A B Ci Co S
0 0 0 0 0
0 0 1 0 1
0 1 0 0 1
0 1 1 1 0
1 0 0 0 1
1 0 1 1 0
1 1 0 1 0
1 1 1 1 1

So I got onto Altium and made a schematic of this circuit using some of the low voltage 7400 LVC series individual logic gates. They come in SOT23-5 packages which are leaded and a nice size to solder. Plus they are a size where it’s possible to probe the pins fairly easily. Luckily Altium shows the components as their logic symbols.

1 bit adder 1 schematic

I also added a few LEDs to show what parts are on and off. This means the user can see the inputs and outputs. These LEDs run off the 5V input voltage, and have 220Ω current limiting resistors in series with them. Also, I have put in some 0.1 inch header pins so it can be attached into a breadboard and maybe even a micro.

1 bit adder 1 schematic

As a base of my circuit, I have decided on a double sided 50mm x 50mm board. This is quite big as you can see for the circuit I have made, but gives plenty of space for a soldering iron to get access. As well as this, it gives a nice amount of space for multimeter probes. I also tried to keep the individual logic chips in the same arrangement as the schematic. This is meant to be used as a learning device, so it’s useful for the chips to line up with the diagram. The header pins for the inputs and outputs are placed on opposite sides of the board to make it more obvious for the user to see it. The pins for the power and ground are on the same side on both headers. The LEDs that are directly attached to the pins are kept close to them, and the track is fairly obvious to show where the signal is from. The silkscreen labels which LED designates which input/output. All the designators have been made half the normal size due to the small amount of parts used in the project. The below images show the PCB layout I created with the top copper being red, bottom copper being blue, and the silkscreen shown in yellow.

1 bit adder 1 PCB top

As you might be able to see, I have tried to keep all the power on the bottom side of the board. This leaves lots of space for the logic signals on the top, where the user is more likely to see. As you can see, not all signals are on the top side due to circuit constraints, but signals that do swap over are generally short jump, and straight lines, This makes it more obvious where the tracks go without having to flip the board.

1 bit adder 1 PCB bottom

As noted above I used 7400 LVC series logic gates. The SOT23-5 package chips have the suffix of “BVD”. See the datasheets for each of the devices for more information. I have written a simple bill of materials below:

2x SN74LVC1G86DBVT – XOR gate
2x SN74LVC1G08DBVT – AND gate
1x SN74LVC1G32DBVT – OR gate
5x DO-214 LED’s
5x 0805 220Ω resistors
2x 5-pin 0.1″ header pins

How a Voltage Regulator Works: LM7805

Voltage regulators are one of the first electronic components you get introduced to as a hobbyist. Really useful when starting out, it simply takes a voltage that is too high, and reduces it down to a set voltage that you want, usually defined by the component. Solves the problem of having batteries or power supplies being a different voltage to the thing you are powering (such as your Arduino), and at as little as 50p from ebay they are easily acquired. Sounds like a great solution, but there is an issue, they are terribly inefficient. They are known to get very hot when used at high currents, and often need hefty heatsinks to stop the magic smoke from being released. To demonstrate why they get so hot we need to think about what happens during use. Remembering Kirchoff, the current going into a system is the same as the current going out of the system. If we use a simplified version of the regulator, the only thing this device changes is the voltage of the output. Due to the minimal current lost powering the circuit we assume the vast majority of power lost is in heat. Using the basic equation of:

Power (W) = Voltage (V) x Current (I)

So if we use an example of the LM7805 made by On Semiconductor (previously Fairchild) that can regulate 5V at 1A. It’s a pretty standard component, and is very typical of a voltage regulator.

If we use a 9V input the power going in is 9V x 1A = 9W.

The output power is 5V x 1A = 5W.

This means that there is 4W of power being dissipated from the regulator as wasted heat. This is a large amount when considering the size of the packages available. When thinking about problems excessive heat can cause in a circuit, it can quite easily damage itself and other components around it when not designed properly. It is why there are often big chunks of aluminium attached to the back of the components to act as a heat sink.

7805
7805 chip in a TO-220 package. Notice the heat sink on the rear with a screw mount.

This post isnt meant to dissuade you from using regulators, they have their place in electronic circuits, and are a great starting point. All electronic engineers need to have a broad understanding of the advantages and disadvantages of linear voltage regulators to be able to handle them properly.

How it Works

LM78xx schematic 2 coloured
Schematic of the silicon inside an LM78xx device, coloured relating to the function of each area.

The above schematic can be found on the datasheet, but it’s been coloured in to show the different sections of the circuit.

The most important component in the above schematic is Q16 (Red), it controls the current between the input and output, therefore the voltage. It is placed in a darlington pair configuration with Q15 (Orange). In this configuration Q16 is amplifying the current amplified by Q15. This means that Q15 can be used to introduce error feedback. The Blue section contains a voltage divider that scales the output voltage so that it can be used by the bandgap circuit. This bandgap circuit is found in the yellow section (Q1 and Q6). This bandgap reference produces an error signal that is fed into Q7 (orange). A bandgap is used because it can provide a stable output even when the temperature of the device changes.

The orange section takes this error and amplifies it through Q15 and the darlington configuration described earlier. The purple section has overheating protection (Q13) and excessive output current protection (Q14). Occasionally on these schematics you also find excessive input voltage protection marked as Q19 in this section. These shutdown the regulator in fault conditions like overcurrent or getting too hot. The Green section is known as the “start up” circuit, because it provides the initial current needed to power the bandgap circuitry. This gives a jumpstart to the circuit when it needs it.

I chose the LM7805 because 5V is a common value to be used, but the LM78xx series has many different preset voltage versions. The bandgap circuit is trying to get its input to 1.25V, this is from the voltage divider found in the blue section. As R20 is a variable resistor, the voltage divider can be calibrated during manufacture to output exactly 1.25V at any chosen output voltage. This is great for a manufacturer because they make lots of the same chip, and it can be made to suit any voltage output they want. This is also similar to the way some adjustable voltage regulators work, such as the LM317. In adjustable chips, the voltage divider is made by the designer externally, meaning it can be applied to any situation with a simple change of resistors.

Basic Configuration

Looking at the datasheet, there are many applications for the device. but the simplest one is just an input and an output. All that’s needed is a couple of decoupling capacitors to smooth out AC signals and random noise. Voltage regulators work best with clean, smooth power. There is also the need, due to the voltage drop across the transistors, for the input voltage to be at least 2V above the required output. This is always a good rule of thumb to go by when it comes to regulators.

LM78xx basic configuration
LM78xx basic configuration

I would recommend people read the datasheet and have a play with different voltage inputs and current outputs, see how easy it is for it to get hot. In that datasheet there are some other good applications using the device, you can turn it into an adjustable voltage output, constant current supply and high current supply. These are also good projects for learning more about transistors and op amps. Equally, there are other types and brands of regulator out there, some cheap, and some quite expensive, it is worth shopping around for  the ones that suit you.

The Foundry: Drilling an Air Hole

At this point we had a cast foundry base, made out of sand and plaster of paris. To see how that was made, see the tutorial here.  Before we first test it though, we had to make one modification, and that was to drill a 30mm diameter hole in the side of it.

The hole from the outside
The hole from the outside

The idea of the hole is to allow air to come in and fuel the fire. The theory goes that the air comes in the side, and the resultant fumes (like smoke) leave via the opening at the top. It makes sense because heat rises, and takes all those hot resultant gasses up with it. Note that we don’t really care about the fumes coming off the fire at this point, we just want as much oxygen as possible to get to the coals. If hot exhaust fumes are leaving via the same hole as the oxygen, but going the opposite direction, they will interact with each other, slow each other down, and make the furnace much more inefficient.

Also notice the hole is angled down into the base of the furnace. This isn’t by accident, we want that hole to do two things, pump air into the base of the fire, and not let anything go back up the hole. This hole in the future may contain a fan, to pump more air in. We don’t want the embers flying back up the pipe and breaking the fan during use.

To drill the hole we used a hammer drill bought from Aldi, and a 30mm masonry drill bit, these parts can be pretty cheap if you search around, and the hole doesn’t have to be this exact size. Use what you can find, and make sure you get help when doing the drilling. As always, safety is important, and safety glasses and gloves would be a good idea. if one person steadies the foundry, while the other drills, it is much easier. Go slow, so that the plaster on the inside doesn’t break too much. It is easy to be too eager and create large cracks and chips, which could mean an entire restart.

The hole from the inside
The hole from the inside, notice the dust, and broken parts around the hole.

Although this was a shorter post, the next one will be about the first tests! As always, thanks for reading, and I hope to be along with another update soon. If you guys have any tips, questions, or want to show your foundry, please post in the comments below.

Interfacing a PIC and a 16×2 LCD

So in a recent project I had to implement a 16×2 LCD  on a PIC16F1827, but the system will work on most PIC microcontrollers, with slight changes to the code. For this project I am using MPLAB X v3.40, a free development environment, and a PICKIT 3, which can be bought at a number of stores online.

Setting up the MPLAB project

  1. Start off by loading up MPLAB X, if you don’t have it already, install it from the Microchip website microchip.com/mplab/mplab-x-ide.
  2. Start a new project, by going to File->New Project… or by pressing Ctrl+Shift+Nnew project
  3. The project we want is a standalone project, it should be chosen by default. Next choose the device we want, write in the box PIC16F1827 there should only be one. We want to use the PicKit 3 for the programmer. I am using XC8 as the compiler, this is available from the Microchip to9 stawebsite. Finally choose the name of the project, and where you want to keep it. Then click finish.
  4. It wont look like mush at the moment, but under Projects on the right, there should now be your newly created project, with a drop down, and a set of folders. Something like this: 
  5. To start the project, we need a main.c. So right click on Source Files, go to New->C Main File… then in the Dialog, change the name to main. After pressing okay, it should look like this: 

Connecting the LCD

LCDs have what is known as a parallel connection. This means that we send data 8 bits at a time, rather than serial where it is one at a time. The datasheet for the PIC is found on the microchip website here. The pinout is found on page 4.

PIC pinout

Register Select (RS) pin, this decides which of the two registers that is getting written to. Either the instruction register (what the screen does) or the data register (what is shown on the screen). This is connected to A4 on the PIC.

Read/Write (RW) pin, this decides whether you are writing to or reading from the LCD. This is connected to pin A3.

Enable (E) pin, is to tell the LCD when data needs to be transferred. Pulsing this pin will write or read to the registers the data on the data pins. This is connected to pin  A2.

These pins are defined at the top of the code, to make life easier for us later on.

#define LCD_RS LATAbits.LATA4   //LCD Command/Data Control
#define LCD_RW LATAbits.LATA3   //LCD Read/Write Select
#define LCD_E LATAbits.LATA2    //LCD Enable Line

Data Pins (D0-D7), are the pins that transfer the information between the LCD and the PIC. These are connected to pins B0-B7. So B0 is connected to D0, and so on until B7 is connected to D7.

Vdd and Vss are connected to 5v and GND respectively.

Contrast (Vo) is connected to a 10k pot between the 5v  and  GND.

If the LCD you are using has connections for a backlight, follow the datasheet for instructions, on mine I connect it t0 5v and GND.

The Code

Below is the function I create to send data to the LCD.

#define LCD_CMD 0
#define LCD_TXT 1 

void LCD_DATA (unsigned char data, int type)
{
    __delay_ms(100);   // short delay

    LATB = 0x00;       // reset the register to 0
    LATB = data;       // set B output to the data we want to send
    __delay_ms(1);     // short delay for data to set

    if (type == LCD_CMD)
    {
        LCD_RS = 0;    // command mode
    }
    else
    {
        LCD_RS = 1;    // character/data mode
    }

    LCD_RW = 0;        // start the pulse
    __delay_ms(1);     // small delay
    LCD_E = 1;         // enable LCD data line
    __delay_ms(1);     // small delay
    LCD_E = 0;         // disable LCD data line
    __delay_ms(5);
}

Calling this function in the main, like follows will send data to the LCD. Notice the #define at the top, these are declaring LCD_CMD and LCD_TXT. Basically, when the type is LCD_CMD the LCD is sent into command mode, by setting the RS pin. Equally, sending LCD_TXT will clear the RS pin, putting the LCD in character mode.

The information on the data pins will then get written to the LCD, by clearing RW. To actually tell the LCD that it needs to be sent new instructions the enable pin needs to be pulsed. Once this happens, the screen should be updated with the new information.

#include <stdio.h>
#include <stdlib.h>
#include <xc.h>

#define _XTAL_FREQ 500000

#define LCD_RS LATAbits.LATA4   //LCD Command/Data Control
#define LCD_RW LATAbits.LATA3   //LCD Read/Write Select
#define LCD_E LATAbits.LATA2    //LCD Enable Line

#define LCD_CMD 0
#define LCD_TXT 1 

void LCD_DATA (unsigned char data, int type)
{
    __delay_ms(100);   // short delay

    LATB = 0x00;       // reset the register to 0
    LATB = data;       // set B output to the data we want to send
    __delay_ms(1);     // short delay for data to set

    if (type == LCD_CMD)
    {
        LCD_RS = 0;    // command mode
    }
    else
    {
        LCD_RS = 1;    // character/data mode
    }

    LCD_RW = 0;        // start the pulse
    __delay_ms(1);     // small delay
    LCD_E = 1;         // enable LCD data line
    __delay_ms(1);     // small delay
    LCD_E = 0;         // disable LCD data line
    __delay_ms(5);
}


int main(int argc, char** argv) {
 
    // write "hello world!" on the first line
    LCD_DATA('h', LCD_TXT);
    LCD_DATA('e', LCD_TXT);
    LCD_DATA('l', LCD_TXT);
    LCD_DATA('l', LCD_TXT);
    LCD_DATA('o', LCD_TXT);
    LCD_DATA(' ', LCD_TXT);
    LCD_DATA('w', LCD_TXT);
    LCD_DATA('o', LCD_TXT);
    LCD_DATA('r', LCD_TXT);
    LCD_DATA('l', LCD_TXT);
    LCD_DATA('d', LCD_TXT);
    LCD_DATA('!', LCD_TXT);
 
    while (1)
    {
 
    }
 
 return (EXIT_SUCCESS);
}

The Foundry: Part 1 – The First Casting

So we had our aim, and a basic design based off we saw in the videos we had watched. Now we needed to start the process of making it. We made a list of materials we might need, and had a basic look around on the internet, and off we went to the shops. During our travels we visited Screwfix, Wickes, B&Q, Hobbycraft and even Homebase. There were some pretty simple things we needed. Listed below:

  • Sand
  • Plaster of Paris
  • Drill (and drill bits)
  • Steel bucket
  • Safety Goggles
  • Safety Gloves
  • smaller plastic bucket
  • cheap measuring jug

Some of these items you might already own, (and we did) but it was listed as things we needed to complete this stage of the project.

Safety Notice (don’t ignore)

At this point I am going to stress a couple of those boring safety points. We have worked with some materials that could be considered quite dangerous if improperly used. So use safety gloves wherever possible (these can be as cheap as £1.50 in some stores, so there is no excuse!) and goggles and masks are a good idea, especially with dust, and when drilling. If you don’t understand why these are needed, maybe you should stop reading at this point.

Location

We would recommend thinking about where you do this project, there is the potential for spillage of plaster of paris, and that can ruin surfaces; so kitchens are probably out of the question. We recommend outside on a nice sunny day. Its always a good idea to be in a nice open area with plenty of ventilation, even when not working with toxic chemicals, it’s just good practice. We chose out outbuilding, its airy, already has paint stains, and contains all the tools we need as it doubles up as a basic workshop.

The Making

So let’s get on to the bit you care about how we made the foundry. The method starts with mixing together a mixture of 3.5 parts plaster of paris, 3.5 parts sand, and 2.5 parts water. This can be scaled up or down depending on how much you need to make to fill your bucket. We used a standard 14 litre bucket, and a standard liquid measuring jug to mix parts.

14 litre bucket
a 14 litre steel bucket found at most hardware stores
measuring jug
standard measuring jug

A few good tips to add in at this point. You should probably get some friends for this project, a few extra hands can be really useful. while we were making ours, we had one person stirring the mix, and another adding in the parts. Notice below, how many hands are in the images. The other point is to add the sand and plaster of paris before the water. As soon as the water is added, the mix will start the process of setting and you need to get that stuff mixed as fast as possible before it gets too hard. The last point is to mix this a lot, you want it to be thoroughly mixed together, else it could separate in the drying process.

Also, it would be a good idea to wear gloves at this point in the making, plaster of paris can cause burns if it gets in contact with the skin. Read the packaging first, and be careful when handling the powder and the mix.

mixing it together
Mixing it all together

While the mix is almost at its fully ready state, somebody needs to get the smaller plastic bucket, and fill it mostly with water. The amount of water used will depend on your buckets and mix. The water makes it much easier to hold the smaller bucket in place while the main mixture sets. If you get it right, it should not need much force to keep it in place until sufficiently hard.

placing the inner bucket
Placing the inner bucket

Once it is held in place for around 5 minutes it should be hard enough to let go of. if not, it may need to be held longer. You could always put heavy items on top to keep it in place. After a while it should look like the one below. Able to be left without touching, slowly drying.

still drying
Waiting for the mix to dry, but it still hold the inner bucket

Remember that at this stage, it still needs to be left for a long time before we actually take the bucket out, preferably for 24 hours, but it will depend on the mix you made, your climate, the temperature, all manner of things. We recommend leaving it overnight. When you touch the top of the mix, if it is moving then it isn’t ready yet.

The next stage is very fragile though. First empty all the water out of the inner bucket. Then we used a pair of pliers to slowly move the sides of the bucket away from the newly set mix. The bucket was slightly damaged, but with patience it is possible to remove the inner bucket to leave your new fire hole. If it doesn’t collapse in on itself it’s considered a success!

finished
The finished article, ready for fire

Thanks for reading this post, I hope to be posting some more updates about our foundry in the coming weeks, so watch this space. Also, if you have been making your own foundry, leave a comment below. We would love to hear from you.