temperature controller

[Jason] learned a lot by successfully automating this meat smoker. This is just the first step in [Jason’s] smoker project. He decided to begin by hacking a cheaper charcoal-fed unit first, before setting his sights on building his own automatic pellet-fed smoker. With a charcoal smoker it’s all about managing the airflow to that hot bed of coals.

Custom mount for servo was actually one of the more challenging things to get just right.

[Jason] started by making sure the bottom was sealed off from stray airflow, then he cut a hole into the charcoal pan and attached a length of steel pipe. The opposite end of the pipe has a fan. Inside the pipe there is a baffle separating the fan from the charcoal pan. The servo motor shown here controls that valve.

The pipe is how air is introduced into the smoker, with the fan and valve to control the flow rate. The more air, the higher the temperature. The hunk of pipe was left uncut and works fine but is much longer than needed; [Jason says] the pipe is perfectly cool to the touch only a foot and a half away from the smoker.

With the actuators in place he needed a feedback loop. A thermocouple installed into the lid of the smoker is monitored by an Arduino running a PID control loop. This predicts the temperature change and adjusts the baffle and fan to avoid overshooting the target temp. The last piece of hardware is a temperature probe inside the meat itself. With the regulation of the smoker’s temperature taken care of and the meat’s internal temperature being monitored, the learning (and cooking) process is well underway.

There are many, many smoker automation projects out there. Some smokers are home-made electric ones using flower pots, and some focus more on modifying off the shelf units. In a way, every PID controlled smoker is the same, yet they end up with different problems to solve during their creation. There is no better way to learn PID than putting it into practice, and this way to you get a tasty treat for your efforts.

[ZL2PD] needed to replace an old Weller soldering station and decided not to go with one of the cheap soldering stations you can find all over the Internet. He has a long story about why he had to design his own controller, but you never have to explain that to us. He kept detailed notes of his journey and in the end, he built three different controllers before settling on one.

He started with a Hakko hand piece that uses a thermistor for temperature measurements. The first iteration of the controller had analog controls. He wasn’t happy with the number of parts in the design and the simple LED display. That led him to replace the controller with an ATTiny CPU and a use a serial LCD.

Weller, the German soldering tools manufacturer, has a nice range of micro soldering irons (pencils) designated as the WMRP series. These are 12V, 40 W or 55W units with a 3 second heat up time, and allow quick tip exchange without needing any tools. [FlyGlas] built a neat soldering station / controller for the WMRP series based around an ATMega microcontroller running Arduino.

cold junction compensation using the PTC (KTY82-210) included in the WMRP soldering pencil

input voltage measurement

soldering pencil current measurement

recognizing if the soldering pencil rests in the stand (–> standby)

3 buttons to save and recall temperature values

rotary encoder to set soldering temperature

illuminated 16×2 character LCD module

USB for debugging and firmware update

4mm safety socket for +12V power input and a protective earth socket for connection to ESD protection

A PWM signal from the microcontroller controls the load current using a MOSFET. Load current is measured using a Hall Effect-Based Linear Current Sensor – ACS712. The corresponding linear output voltage is buffered and slightly amplified using AD8552 zero drift, single supply, RRIO Dual Op Amp before being sent to the microcontroller ADC input. To ensure ADC measurements are accurate and stable, a low noise precision voltage reference – ADR392 is used. Another precision resistive voltage divider allows input voltage measurement. The supply input has over-current and reverse voltage protection. A set of buttons and a rotary encoder are connected to the microcontroller to allow settings and adjustments. An analog section measures the thermocouple voltage from the soldering pencil as well as the stand-by switch status. The handle has an embedded reed switch that is activated by a magnet in the support stand which puts it into stand-by mode. Another analog section performs cold junction compensation using the PTC sensor within the soldering pencil.

The Git repo contains the initial Arduino code which is still a work in progress. While the hardware source files are not available, the repo does have the pdf’s, gerbers and BOM list, if you want to take a shot at building it. Check a demo video after the break. Thanks [Martin] for sending in the tip.

Beer lovers rejoice! [Mats] has reverse engineered a temperature controller and written new open source firmware for it. This effectively gives all us homebrewers a low cost, open source software driven controller. The STC-1000 is a cheap (under $20 USD) temperature controller mass-produced in the far east. The controllers do work, but have several limitations. The programming options are somewhat limited to basic set points for heat and cool. The controller also is only programmed for temperature display in Celsius, which is a bit of an annoyance for those of us who think in Fahrenheit. Under the hood, the STC-1000 utilizes a Microchip PIC16F1828 microcontroller. Unfortunately the PIC’s protection bits were set, so the original code would have been extremely difficult to extract. Not a problem, as [Mats] reverse engineered the hardware and wrote his own firmware. A 10k NTC thermister acts as the temperature probe. The probe is read by the PIC’s ADC. These probes are not very linear, so a look up table is used to convert from volts to degrees Celsius or Fahrenheit.

[Mats] new firmware allows for up to 6 profiles. Each profile has up to 10 set points and a time duration to hold each of the set points. Hysteresis and temperature offset values are also programmable via the front panel. PIC software is often written in C using Microchip’s MPLAB tool chain, and programmed with the PICkit 3 In Circuit Serial Programming (ICSP) tool. [Mats] decided to buck the system and wrote his C code using Small Device C Compiler. To keep things simple for homebrewers who may not have Microchip tools, [Mats] used an Arduino Uno for flashing duties. Thankfully the unholy matrimony of a PIC and an AVR has not yet caused a rift in time and space. The firmware is still very much in the beta stage, so if you want to help out, join the discussion on the homebrew talk forum. If you see [Mats] tell him we owe him a Haduino which he can use to almost open his beer.

Once [Brian] got under the hood, he found that it actually has four separate heatsinks: one for the bridge rectifiers and one for each power transistor on the three output channels. The heatsinks are electrically and thermally isolated from each other and change temperature based on the channel being used.

[Brian] and his associates had several Microchip MCP9803 temperature sensors kicking around the lab from previous projects, so they put one on each heatsink. The great thing about these is their address selection pins which let all four of them sit together on the I²C bus to Arduinoville. Each sensor is insulated and clamped to its heatsink with a piece of meccano and a dab of thermal paste.

[Brian] used an Arduino Mini and built the circuit on stripboard. The fan runs at 24V, so he’s sharing that with the Arduino through a 7805. He controls the speed of the fan with PWM from the Arduino fed through a MOSFET. The Arduino reads from each sensor and determines which one is hottest. [Brian] wanted the fan to run at all times, so he set a base speed of 20%. When the heatsinks reach 30°C/86°F, the fan speed is increased to 40%. After that, the speed increases at 5°C/9°F intervals until it reaches max speed at 65°C/149°F.

Hackaday Alum [Nick Schulze] decided to help out a friend who needed a controller to hold water at a precise temperature. Coffee guzzling hackers of the world should rejoice, as [Nick] targeted a coffee urn as the vessel for the project. What he came up with was a couple of custom boards and a roll-your-own temperature probe which does a fantastic job of regulating the temperature of the liquid.

Needing to switch the mains going to the heating element he immediately thought of an AC chopper circuit based on a Triac. What didn’t come to mind immediately was the need to detect the zero crossing. In the image above you can see nearest the urn his high voltage board. Below that is the zero crossing detector circuit. For feedback he created his own temperature probe using a TC1047 temperature sensor. After soldering on a filtering cap and the leads he dipped it in JB Weld to make it water tight. If you’re using this for coffee may we recommend seeking out a food safe probe.

After successful testing he added a user interface and buttoned it up in the enclosure seen in the video below.

[Benjamin Havey] and [Michael Abed] built the controller as their final project in his microprocessor class. The idea is to monitor and control the mini-refrigerator so that the strain of Saccharomyces Cerevisiae yeast produce as much ethanol as possible. An MSP430 microcontroller was used. It monitors a thermister with its analog to digital converter and drives a solid state relay to switch mains power to the fridge. At 41 degrees Fahrenheit this is down below what most lager yeasts want (which is usually in the low fifties). But the nice thing about using a microcontroller is you can set a schedule with different stages if you find a program that gives the yeast the best environment but requires more than one temperature level.

Who knew all that beer making was getting you ready to produce alternative fuels?