Hot bed

Making a heated bed to combat warping has been on my "to do" list for a long time. In fact I ordered the materials more than a year ago. My plan was to use an aluminium plate with many small power resistors screwed on the back.

The plate is 8" square to match my table and 6mm thick. A friend with a CNC machine shop kindly machined it for me. It saved me a lot of hard work with a hacksaw and file and looks a lot better as well.



I estimated that it would need about 50W to raise the temperature to 100°C, so I aimed for 100W to give a reasonable margin for control. I used 9 10W 12Ω resistors wired in parallel. Driven from 12V this would take 9A giving a power of 108W.

The holes in the resistors are only big enough for M2 screws. I drilled blind holes and tapped them with a plug tap, actually a broken tapered tap that I ground to a flat end.



Tapping small holes in aluminium is tricky, that was how the tap came to be broken in the first place. The correct size hole for M2 is 1.6mm but I drilled it 1.7mm to make it easier to tap. In fact aluminium is so ductile that the peaks of the thread are still the correct diameter. I.e. the 1.7mm drill would not fit the hole after tapping and the thread was a good tight fit on the bolts. I used paraffin for lubrication.

Soldering the resistors was fun.



I used stout wire to handle 9A and high temperature solder because I fancied using it as a hot plate for soldering. My 50W iron did not have enough power to melt the solder when the resistors were mounted with two thick copper wires leading from them. To get round that I placed it on a silicone matt and powered it up to raise the temperature to 100°C and then soldered it while hot and live, not something I would recommend. As the iron bit is grounded I had to solder all the 0V connections first and then swap the polarity.

The original plan was to power it from a 12V PC power supply and switch it with a big MOSFET. Initial tests with a bench power supply showed it took about 15 minutes to warm up to 80°C. When calculating the power I had forgotten take into account the specific heat capacity of the thick sheet of aluminium. I didn't want to add 15 minutes to the build time, so I decided to double the power. I have abused these resistors before and got away with it. I changed the wiring slightly to make a series parallel combination with a total resistance of 12Ω and fed it from 48V AC giving 192W.

I used a big 350W transformer and controlled the mains to it with a solid state relay. Since the temperature is controlled there is no real point in using a regulated DC supply. It is much more efficient to use AC and avoid the losses associated with rectification and smoothing. It also allows me to use the same control hardware and firmware that I used for the SMT oven.

I made some PEEK insulating stand-offs to mount it on my XY table with a gap of about 6mm below the resistors: -



I wrapped the feed points around two of these to make the transition to a lower temperature with PTFE sleeving before using normal flex to handle the movement of the table.



I also added some foam board to insulate the top of my X-Y table.



This just fills some of the air gap under the plate to prevent air circulating and convecting heat downwards.

I made some PTFE washers to go under the nuts that hold it down by slicing up a failed extruder insulator: -



These deformed considerably when I heated the table to 230°C, highlighting why PTFE insulators fail when used in an extruder.

Here is the final result mounted on the machine: -



I added Kapton tape around the edge as I thought it would stop hot air escaping from underneath, but it didn't seem to make a lot of difference.

Here is the open loop response at full power: -



Although it can reach the required temperature, it is much too slow for SMT soldering. It needs to be able to rise at about 1°C / second for that. So I will stick to using the oven for soldering for now. I was hoping to be able to paste boards, place components and then solder with the board still on the table, but it obviously needs a lot more power.

Here is the response using bang-bang control from the host at one second intervals.



Some analysis: the initial rise rate is about 20°C in 75 seconds. The specific heat capacity of aluminium is 0.9 J /gK and the total weight of the bed plus resistors is 700g. So with 192W the time taken to rise 20°C should be 0.9 × 700 × 20 / 192 = 66 seconds, reasonable agreement as we ignored any heat loss.

The initial fall rate is 5°C in 85 seconds while at a temperature of ~80°C above ambient. So the rate of heat loss is 0.9 * 700 * 5 / 85 = 37W. Looking at the steady state the power is on for about 1 in 6, which would be 32W, so again reasonable agreement.

The plate is ~ 200mm square so its area is 0.04m² so it looks like we need about 1kw / m² to reach the sort of temperatures needed for HDPE and probably twice that to have reasonable warm-up time and control. Mendel's build area is also 200mm square, so would require a similar power.

You might have noticed the thermocouple is covered with a piece of ceramic cloth in the photo above. This is what happens if it is just stuck down with Kapton tape:-



You can see that as the temperature rises you get increasing thermal noise. Even with the ceramic cover in place you can see similar noise on the open loop test when the temperature was much higher. I think the reason for this is the convective air currents causing chaotic air turbulence. If you think about it you have hot air rising but, away from the edges, the only way cold air can replace it is by falling through the rising air.

A better place to put the thermocouple would be under the bed to avoid the convection currents, but I wanted to try controlling the surface temperature when it was covered by a bed material. Here is what happens with the thermocouple on top of a 3mm thick sheet of smoked acrylic: -



The set point is 95°C in this case. Clearly a case where bang-bang does not work too well, with 5°C overshoot and 3°C undershoot.

The acrylic loses about 15°C between the bottom and the top surface. That makes it curl upwards, so it would need a frame around the edge to hold it down. Fortunately I have one made from HDPE laminated with aluminium so it should stand the heat. It also adds a significant time lag.

Another problem is that acrylic has a glass transition at about 114°C. When the control was of the top surface temperature, the bottom surface exceeded that during the overshoots and went soft.

So I will need to implement PID for top surface control, but I had a suspicion that a transformer was not going to like PWM into its primary much. Anyhow I put the thermistor back onto the plate and moved the bang-bang control from the PC to the firmware in preparation for building something. Bang-bang was an apt name for what happened next. When the temperature crossed the set point it started dithering the mains on and off. The transformer sounded like it wanted to jump off the desk and then blew its 3A anti-surge mains fuse.

The solid state relay turns the power on at the zero point crossing of the mains, and off when the current is zero. Current builds up slowly through an inductor so what could possibly be wrong? I had noticed big transformers thump when you connect them to the mains, but I had always assumed it was because the secondary usually has a big smoothing capacitor to charge up. However, this was a purely resistive load, and even with no load attached the transformer thumps on start-up, so some reading up on transformer theory was required!

It turns out that transformers take a big surge current and turning on at the zero crossing point is actually the worst point to turn them on. The reason is that when a transformer is running, being an inductor, the current lags behind the voltage by 90°. So normally when the voltage is crossing zero, the current is at its maximum reverse polarity and over the next half cycle of voltage it goes though zero and then to its maximum positive value: -

If the current starts at zero then over the first half cycle it will rise to twice its normal value: -

That would not be too bad except for the fact that transformers usually run with their core close to magnetic saturation for efficiency reasons. That means the core saturates during start-up. The inductance disappears and then the only thing limiting the current is the DC resistance of the primary, about 3.3Ω in my case, so the current can be enormous. Counter intuitively, the best time to turn a transformer on is when the mains is at its peak voltage.

So I learned something I didn't know about transformers. The fix was simple, I added a solid state relay to the secondary circuit and plugged the transformer into the mains. Bang-bang control then was able to pulse it very quickly due to the dithering caused by noise, which ends up with some proportional control, that reduces the temperature swings to a fraction of a degree.



So I can add PID control firmware and it can be shared with my oven control but I have an extra solid state relay and a big transformer. A better solution would be to pick the resistor values to give the correct wattage when wired in series across the mains. Of course mains on a moving table is not the safest design. I would use a heavy three core flex with an earth lead to the plate and a second independent earth strap for safety.

It turns out the first use for my heated bed was not to combat warping, but actually something more essential, details coming soon ...

Cooking with HydraRaptor

I needed to assemble some PCBs recently, so I set about making a temperature controller for my SMT oven.



First I had to replace the solid state relay on HydraRaptor.



Solid state relays are triacs with an optically coupled input, zero crossing switching and built in snubbers. I used it for controlling a vacuum cleaner when milling. It was massively overrated but for some reason it failed some time ago. I replaced it with a cheaper one and added a varistor across the mains input to kill any transients, as that is the only explanation I can think of for the old one's demise.





The next task was to write a simple graphing program in Python. I tested it by plotting the response of my extruder heater.



With bang-bang control it swings +/- 2°C with a cycle time of about ten seconds.

Here is the code for the graph: -

from Tkinter import *

class Axis:
  def __init__(self, min, max, minor, major, scale):
      self.scale = scale
      self.min = min
      self.max = max
      self.minor = minor
      self.major = major

class Graph:
  def __init__(self, xAxis, yAxis):
      self.xAxis = xAxis
      self.yAxis = yAxis
      self.root = Tk()
      self.root.title("HydraRaptor")
      self.last_x = None
      frame = Frame(self.root)
      frame.pack()
      xmin = xAxis.min * xAxis.scale
      xmax = xAxis.max * xAxis.scale
      ymin = yAxis.min * yAxis.scale
      ymax = yAxis.max * yAxis.scale
      width  = (xmax - xmin) + 30
      height = (ymax - ymin) + 20
      #
      # X axis
      #
      self.canvas = Canvas(frame, width = width, height = height, background = "white")
      for x in range(xmin, xmax + 1, xAxis.minor * xAxis.scale):
          self.canvas.create_line(x, ymin, x, ymax, fill = "grey")
      for x in range(xmin, xmax + 1, xAxis.major * xAxis.scale):
          self.canvas.create_line(x, ymin, x, ymax, fill = "black")
          if x == xmin:
              anchor = "nw"
          else:
              anchor = "n"
          self.canvas.create_text((x, ymax), text = x / xAxis.scale, anchor = anchor)
      #
      # Y axis
      #
      for y in range(ymin, ymax + 1, yAxis.minor * yAxis.scale):
          self.canvas.create_line(xmin, y, xmax, y, fill = "grey")
      for y in range(ymin, ymax + 1, yAxis.major * yAxis.scale):
          self.canvas.create_line(xmin, y, xmax, y, fill = "black")
          if y == ymin:
              anchor = "se"
          else:
              anchor = "e"
          self.canvas.create_text((xmin, ymax + ymin - y), text = y / yAxis.scale, anchor = anchor)
      self.canvas.pack()
      self.canvas.config(scrollregion=self.canvas.bbox(ALL))
      self.root.update()

  def scaleX(self,x):
      return x * self.xAxis.scale

  def scaleY(self,y):
      axis = self.yAxis;
      return (axis.max + axis.min - y) * axis.scale

  def plot(self, line, colour = "blue"):
      for i in range(len(line) - 1):
          self.canvas.create_line(self.scaleX(line[i][0]),
                                  self.scaleY(line[i][1]),
                                  self.scaleX(line[i+1][0]),
                                  self.scaleY(line[i+1][1]), fill = colour)
      self.root.update()


  def addPoint(self,p, colour="red"):
      x = self.scaleX(p[0])
      y = self.scaleY(p[1])
      if self.last_x != None:
          self.canvas.create_line(self.last_x, self.last_y, x, y, fill = colour)
      self.last_x = x
      self.last_y = y
      self.root.update()

  def __del__(self):
      self.root.mainloop()

The third task was to interface a thermocouple to HydraRaptor. I had a spare analogue input, so I attached one of Zach's thermocouple sensor boards to it. I tested it by attaching the thermocouple to a light bulb with Kapton tape. I then ran a program that turned the bulb on and then off and graphed the temperature response.



As you can see there is a ridiculous amount of noise on the readings. I tracked this down to switching noise on HydraRaptor's 5V rail, which is generated by a simple buck converter from a 24V rail. The AD595 datasheet claims that it has a power supply sensitivity of only 10mV/V so the error should have been a small fraction of a °C. All I can assume is that its rejection of high frequency noise is far less than its DC supply rejection. In fact, pretty much all the supply noise appears on the output.

I fixed it by filtering the supply with a simple RC filter consisting of a 1K series resistor and a 22uF capacitor. I fitted these to the thermocouple board in the unused holes intended for an alarm LED and its series resistor. The power is fed in via the anode connection for the LED. It feeds to the supply rail via the 1K fitted in the R1 position. The positive lead of the capacitor goes into the original +5v connection to the board. The negative lead goes to the GND connection together with the ground lead. This mod will be required whenever the 5V rail comes from a switch mode supply rather than a linear regulator.



Here is the much improved graph with the filter fitted: -



The next thing I tried was bang-bang control of the oven to a fixed temperature with the thermocouple attached to a scrap PCB. No great surprise that there is massive overshoot due to the thermal lag caused by the loose coupling of the PCB to the heating elements via air.



It is obvious some form of proportional control is required, so I implemented PWM control of the mains supply to the oven. As triacs don't turn off until the end of the mains cycle there is no point in varying the pulse width in less than 10ms increments (in the UK). So I implemented a simple firmware scheme where I can specify how many 10ms units to be on for out of a total period, also specified in 10ms units. Setting the period to 1 second allows the heating power to be expressed in 1% units.

My original plan was to implement a PID controller, but after examining the required soldering profile I decided a much simpler scheme would probably perform better.


The is a profile for tin-lead solder that I got from an Altera application note. I mainly use leaded solder at home because the lower melt point gives a much bigger margin for error, it wets and flows a lot better, the fumes are less toxic and it doesn't grow tin whiskers.

Looking at the profile you can see the times are not too critical, but the temperatures are. I reasoned I could simply apply fixed powers to get the right temperature gradient until each target temperature was reached. To get round the overshoot problem I simply measured the overshoot and subtracted it from the target temps.

After a little experimenting I got this profile, which looks pretty good to me: -



The blue line is the target profile, red is actual and the green lines show the time at which each target was reached.

The preheat slope and re-flow slope are simply full power until the temperature is equal to the target minus the overshoot. During the first half of the soak period I had to ramp the power from 0 to 50% to get it to turn the first corner without overshoot. When the reflow peak minus the overshoot is reached I simply turn the oven off. When it gets to the cool section I open the oven door.

Here is the code: -

from Hydra import *
from Graph import *

profile = [(10,20), (120,150), (210,180), (250,210), (330, 180), (420, 20)]

slope = 140.0 / 100
overshoot = 15.0
pre_overshoot = 25

preheat_temp = 150.0
soak_temp    = 180.0
soak_time    = 90.0
reflow_temp  = 210.0
melt_temp    = 183.0

preheat_slope = (soak_temp - preheat_temp) / soak_time

s_preheat = 1
s_soak = 2
s_reflow = 3
s_cool = 4

def interp(profile, x):
  i = 0
  while i < len(profile) - 1 and profile[i + 1][0] < x:
      i += 1
  if i == len(profile) - 1:
      return 0
  p0 = profile[i]
  p1 = profile[i+1]
  return p0[1] + (p1[1]-p0[1]) * (x - p0[0]) / (p1[0] - p0[0])


def oven_cook(profile):
  hydra = Hydra(True)
  try:
      xAxis = Axis(min = 0,  max = 500, minor = 5,  major = 25, scale = 2)
      yAxis = Axis(min = 10, max = 250, minor = 5,  major = 20, scale = 2)
      graph = Graph(xAxis, yAxis)
      graph.plot(profile)

      t = 0
      state = s_preheat
      m_state = s_preheat
      hydra.set_mains(100,100)
      while t < xAxis.max:
          sleep(1)
          temp = hydra.get_temperature()
          print temp
          graph.addPoint((t, temp))
          #
          # Control the power
          #
          if state == s_preheat:
              if temp >= preheat_temp - pre_overshoot:
                  hydra.set_mains( 0, 100)
                  t_soak = t
                  state = s_soak
          elif state == s_soak:
              power = (t - t_soak) * 100.0 / soak_time
              if power > 50:
                  power = 50
              hydra.set_mains(int(power), 100)
              if temp >= soak_temp - overshoot * preheat_slope / slope:
                  hydra.set_mains(100,100)
                  state = s_reflow
          elif state == s_reflow:
              if temp >= reflow_temp - overshoot:
                  hydra.set_mains(0,100)
                  state = s_cool
          #
          # Draw the time lines
          #
          if m_state == s_preheat:
              if temp >= preheat_temp:
                  graph.plot([(t,10), (t,temp)], "green")
                  m_state = s_soak
          elif m_state == s_soak:
              if temp >= melt_temp:
                  graph.plot([(t,10), (t,temp)], "green")
                  m_state = s_reflow
          elif m_state == s_reflow:
              if temp < melt_temp:
                  graph.plot([(t,10), (t,temp)], "green")
                  m_state = s_cool

          t += 1
      hydra.init()

  except:
      hydra.init()
      raise

oven_cook(profile)

This is the first board I soldered with it: -



All the joints were good. I had a few solder balls and some bridging but that was due to not getting the right amount of paste on each pad. I will be working on a solder paste dispenser soon!

I need to do some more testing to see if the arbitrary algorithm will work with large and small boards and with inner planes, etc. It relies on the overshoot being fairly constant, although with leaded solder you have some leeway.

I also want to play with PID to see if I can get a more general solution. The problem I see is that PID does not look into the future, so will always overshoot somewhat, which is exactly what you don't want. I think rather than using the angular profile, that is impossible for the oven to follow, I would have to put in a rounded curve, such as the one the oven actually follows now, as the control input.

Reliable extruder at last?

... well only time will tell but I have now fixed all the teething problems on my "no compromise" extruder.

The first problem was it was leaking plastic. I simply tightened the thread about another quarter turn while hot. The problem started when I had to dismantle it to replace the first resistor that I damaged. When I put it back together I didn't get it tight enough as it is difficult to judge when full of plastic and hot. The seal relies on the fact that the relatively sharp edge of the stainless steel tube can bite into the softer aluminium. It seems to work when tightened enough.

The other problem was that the motor would skip steps in the middle of a build for no apparent reason. It seems the amount of force required to extrude varies wildly for which I have no explanation, but I did find some mechanical issues that were reducing the torque available.

I noticed the gear would always be in the same position when the motor skipped. I found that the grub screw was catching on the bearing housing. You would expect it just to grind the PLA away, but PLA is very hard, so it would take a very long time to do so. I increased the clearance around the wheel hub and also around the moving part of the ball bearings.

Another issue was that both the worm and the gear were slightly off centre on their shafts, so when the two high points coincided they would bind. The hole in the Meccano gear is slightly bigger than the 4mm shaft it is on, not sure why. The hole I drilled in the worm is 5mm but the MakerBot motors have imperial shafts about 4.75mm, so that was even more eccentric. Added to that was the fact that the motor bracket has a slight warp to it angling the shaft down a little. All these things conspired to make it stiff to turn once per revolution. I fixed it by tightening the bottom motor screw tight and slackening the top two a little. That was enough to reliably extrude PLA. Making the motor holes into slots would make things less critical.

Although the extruder was working reliably for PLA I wanted more torque in reserve, so I switched to a higher torque motor more suited to my driver chip. The Lin motor I was using was rated at 0.3Nm holding torque for 2.5A, but my controller can only manage about 1.5A without some better heatsinking. I switched to the Motion Control FL42STH47-1684A-01 which gives 0.43Nm at 1.7A. So at 1.5A I have gone from 0.18Nm to 0.4Nm, i.e. doubled the torque and also got the right shaft diameter to fit the hole I drilled in the worm.



The only downside is that it is bigger and heavier, not really an issue on HydraRaptor.

To give it a thorough test I printed off a couple of Mendel frame vertices.



These take about 2 hours each with 0.4mm filament, 25% fill, double outline at 16mm/s, infill at 32mm/s. Six are needed in total.

I still have to test it with HDPE and PCL., I know it works with ABS.