# (trying to) Measure temperature

In a while I’ll need to characterize an oven and perhaps build a new one.
Just to start I have to apply a power step and measure how the internal temperature evolves.

In order to save time I searched my local distributors and bought a K type thermocouple with amplifier and cold junction compensation. It is not the most accurate but it is more than enough for now. There are a couple of ics available that give a direct digital output but the work needed to breadboard them and have a meaningful reading is beyond the scope at this stage.

This is what I bought:

Appears on many places as a “Grove High Temperature Sensor”. It sports an OPA333 precision opamp and a CJ432 adjusted to provide a 1.5V reference. The rest of the circuit is nothing special, except that the manufacturer called the thermistor “light”. It can be consulted here.

### First ligths

While I have more capable hardware at hand I grabbed an Arduino Nano and the official library from https://github.com/Seeed-Studio/Grove_HighTemp_Sensor and lo and behold I had it streaming temperature to my terminal.

### Let’s get graphical

I cooked a simple gui on python using Qt and Qwt while listening to Olivia Newton.
It is pretty barebones, only has facilities to export into csv, a couple of tracking cursors and gracefully handles device disconnections (say, I yank the cable). I expect to post process the data using QtiPlot or Kst.

### Tweaking

One of the first things I noted was that the measured temperature jumped in big steps of about 2°C.
Using the default setup with a 5V “reference” and considering the amplifier gain every adc bit amounts to:

$Vbit = \frac{5000mV}{1023*54.16} = 0.09024 mV$

Looking at the polynomial coefficients used by the library (ITS90) and taking a first order approximation one bit corresponds to a 2.26°C step and it grows bigger with the measured temperature as other terms start to influence the result. Even tough the output is low pass filtered at about 1.6KHz and it is averaged over 32 points there’s still noise.

Changing the reference to use the regulated 3.3V makes it about 1.5°C but even if it is more than enough for what I need it can be better.

With a couple of bits more I can achieve better resolution. Instead of using an external adc I took advantage of the inherent noise on the reference and output and chose to apply a 16 times oversample in order to have 12 bits out of the 10 bit adc. Application note AVR121 explains that nicely. Now I am limited (in theory…) to 0.37°C steps and I can average on top of that to further reduce variations.

The last source of error (besides not knowing for sure the “real” value of the references) is that the library assumes a fixed 350mV output, the circuit ideally floats the amplified thermocouple voltage around that. In order to measure it I added a small relay from my stash (TQ2SA-5V) to short the input. It is not meant to be used as a dry relay but does fine so far.
Upon startup it reads 348 mV; while a 2mV difference may not seem that big it turns out to be at least 185m°C. Anyway the main sources of error now are the thermocouple and adc reference.

# How to make an awesome Android dashboard for your embedded widget

– Use a standard protocol. We chose Firmata.

– Play with nice things. We used Ionic, Apache Cordoba and the wonderful BluetoothSerial plugin.

– Remember to either modify the Firmata firmware to use the default 9600 bps speed of our HC06 adapter or change it to work at 57600.

Browserify a Node implementation of the protocol and make a port-like object so it talks over Bluetooth.

– The bluetooth plugin doesn’t like to work with binary data so we improve it.

After writing some glue code you end up with a nice and working control panel. I only got the working part but there are a ton of cool reusable widgets out there (like NexusUI or KievII)

# New life for an old tv tuner.

A long long time ago I bought a cheap pci tuner card to listen to the radio. I was able to watch tv with it out of the box but the radio didn’t work. So I patched the driver and it made it into mainline.

Fast forward today, I don’t have a machine with a pci slot anymore but still wanted to listen to airwaves again as my other stereo broke. So I took out the tuner (a tnf 9835) and cooked a simple pygtk app to control it. I looks just like what you can expect from being born from such a quick hack. After trying for a while to make the hardware i2c interface work I settled for a pure software implementation. (also, pull-ups are not optional) I got all the bit masking ops right the first time (but on the other hand that was just copy pasted from drivers/media/tuners with some small edits). It is basically a nice interface around the SN761677.

Compared with my phone the sensitivity is rather poor as it needs quite a bit of an aerial but the sound quality feels better. Alas, the latter is totally subjective.

# Wizard

Within the last month I’ve worked on a series of projects involving Drupal, Node.js, Android (both pure Java and hybrid apps), Ionic and an embedded ip stack ( uIP ). That was fun.

# Back to basics.

For a course I’m taking at the uni I spent the last weeks programming entirely in assembler for a not very small micro.

Last time I did that for real work was about 12 years ago, dinosaurs roamed the Earth and the 16F84A was popular among my friends here.

It felt quite refreshing but the compiler sometimes behaved like a real jerk.

For instance this was flagged as invalid:

label   db $BA,$DC, $0E But trimming the spaces made it happy: label db$BA,$DC,$0E

(and I spent my weekly cursing budget chasing it)

Fortunately it runs fine under Wine, can be called from a makefile and the debugger/simulator works.

# From busted magnetron to incense holder.

It’s been a while since I made something nice.

A couple of weeks ago I spotted a neighbour taking a microwave to the curb and brought it home with me, as they are always full of useful bits. This one was not very old but of a very simple construction. It has a mechanical timer that makes a lovely ‘ding’ when finished. It also went through a bit of hard love.

Cavity magnetrons are very cool devices. Besides providing a couple of strong magnets and aluminum plates they are made of a very pure copper allow with interesting shapes.

From time to time I like to burn some lignum vitae and upon opening this one I knew what to make of it. I chucked it on the drill press, gave it several passes of wet sandpaper and then a cloth with polishing compound. It took quite a good shine but the handling with greasy hands is giving it a light patina. The holes are filled with glow in the dark paint. I haven’t managed yet to capture the effect but they look quite good at night (and also with uv light).

I left the rest without a final polish, partly as a testament of its origins and also because probably I’ll make a cherry wood stand for it.

# Adventures in smps carnage I.

A while ago while cleaning the trash pile I thought that it’d be nice to mod one of the many computer supplies to have a variable output. So I picked up the less crappy, replaced the transformer with a one with better turns ratio to achieve a higher voltage output and put a pot on the feedback loop.

At first it kind of worked but with a lot of unstable points and weird modes. Then I realized that I fed the feedback from about 50K when the nominal was near 10K (and also there is considerable input current there). A simple emitter follower took care of that, now there only remains plain oscillations.

The operating point moves a lot considering that I want the output to be adjustable between 5V and 50V and without a fixed load. The original compensation scheme was a plain integrator plus a zero, I can make things a little better slowing it down a lot but what’s the fun on that.

So instead of blindingly doing things I set out to measure the loop response using Middlebrook’s method. I cobbled up a quick python program with Gtk and GStreamer to generate the test signals with a computer soundcard. Initially I expected to just sweep the frequency and measure some points manually on the scope but there is a lot of 50Hz induced interference that together with switching residuals make that task impossible, I really need to perform a synchronous detection in order to get a meaningful result. That means I’ll have to make room for some more quality time coding to get the scope samples in an automated fashion. The usb protocol is documented here ( http://elinux.org/Das_Oszi_Protocol#0x02_Read_sample_data ).

The setup is a far cry from the ones depicted in the famous AN70 by Jim Williams. I used an H-Field probe to rule out magnetics as an interference source. I expected the output filters and the transformer to be troublesome but their effects on the point of injection are negligible. On the other hand, long wires on the feedback path (even twisted) and the snap recovery diodes aren’t a good match.

# Isolated trigger output

So I finally added an isolated trigger output to that pulse generator. It is just a gdt from a no brand computer supply driven from another gate so it does not disturb that much the main output. The 100ohm on the secondary it’s there so I don’t forget which are the right leads and that capacitor in parallel with the 1k on the primary is not really needed but it made things nicer with the first transformer I used.

It works as expected:

The ratio is 5V / 0.8V = 0.16 , so that 1k I’ve put on the primary appears as 1k * (0.16^2) = 25.6 Ohm on the other side and matching to 50Ohm is as easy as putting a series resistor.

I already knew that the level shifter has a turn off delay of about 1.3uS compared to the output from the 4093 (look at that, it is 23 years old!). The main contributor to that is the last transistor (a PNP), as I just slapped a 1k resistor from base to emitter and called it a day. On the range of voltages I am interested even if the output latches the dissipation involved is way inside a safe zone, but the cost of that simplicity is that I am not able to bring it into cutoff just as fast. Replacing that with a 220 ohm improves things a bit but it is not the ultimate solution. Anyway, I like it as it is.

# Bypassing.

This happens when you forget to add a ‘lytic after the regulator, although the datasheet only shows a 100nF on the output. Not that it really matters on this case. On the pulse generator the logic gates are fed from a regulated supply, mostly so I can forget and use the same as the output stage. Without load and having only a 100nF ceramic halfway between the 7805 and the 4093 (less than a cm…) the rail bounces about 300mVp-p, but it becomes negligible when using a small 10uF in parallel.

Just for kicks I removed the ceramic cap, leaving the output without bypassing at all. The result was a set of narrower 800mVp-p spikes that settled quite fast.

# Driver strength.

Last time I made a pulse generator to drive, among other things, some mosfets. When loaded with a gate its rise time increases to about 200ns, trying out some capacitors I get the same result with 5nF. While it is not quite right to approximate the gate with a simple capacitor it helps to ballpark the driver needs.

The output swings 10 volts on 200ns (10%-90% of 12.5 volts) on a 5nF cap. I = C*dV/dt , so 250mA are flowing. If I want a faster driver I’ll need to add another stage, as the BC548 won’t give me much more current. LTSpice kind of agrees with these numbers, but I need to put 15nF to match the rise time (and the current increases accordingly).

# Inductor saturation tester

“You have a quite novel approach to high current circuits”

(This is one in a series of posts, not in chronological order.)
Lately I’ve been playing again with switched supplies. The last time I worked mostly blind, not having a scope I sampled the available inductors around my needed values and settled with the ones that didn’t catch fire for the first test run.

Now I wanted to try more topologies, and having a lot of unknown cores, I needed to characterize them. I started with the traditional BH measurement using a small ac source and an integrator. I haven’t got round to finish the writeup on that one but it gave me some useful data to start.

Still, I needed to measure with more precision their inductance and how they behave when handling high currents. I lashed up a pulse generator with variable on period using  a couple of schmit trigger gates and a level shifter. When loaded by the gate the risetime goes from about 20ns to 200ns, there’s room for improvement considering it was made from parts I had lying around and without too much thought. I can also lower the drive voltage, above 6 volts the gate charge increases. Meanwhile, I’ll need to add an isolated trigger output.

The power section is comprised of an irf540, a medium value shunt, flyback diode, some local decoupling and a snubber. I’m using high side sensing as it lets me monitor the current and voltage on the dut easily without resorting to differential probes. Also the fet’s source won’t rise above ground when using the same supply for both the driver and power stage, sparing me from a whole lot of problems. The shunt is made with two 0.22 ohm resistors of dubious quality in parallel. While I have a couple of 50 mohm ones made just for that for most of the time the resulting voltage will be too low to work comfortably. It doesn’t look good but gets the job done (the power section was made with parts from another test fixture, so there are some leftovers).

Shorting the test leads I get this:

Plugging in all the constants the fixture has a stray inductance of about 2.1 uH. ( V/L = dI / dT , all that can be read off the cursors ). On the linear part, the average current is 25 amps, so the resistance turns out to be close to 0.4 ohms. Looking at the power input it dips around 2 volts (not that bad being it a cheap pc supply) and then overshoots by 6 volts. However, looking at the connectors on the far end it is not that bad:

So, most of the voltage drop and artefacts are due to poor local decoupling, long leads and connector resistance. That funny ringing on the drive signal is because the scope ground is just at the supply terminals and it bounces a lot given that there are about 30cm of leads in between.

After tidying things a bit and putting the snubber and flyback where they are supposed to be it works like a charm:

Redid some of the shots, so their dates don’t match anymore.

# The root of all evil.

I just love when I forget to add ‘volatile’ and the compiler happily optimizes away a chunk of code.

After staring for a while at the screen trying to figure out why it doesn’t work as expected I went for a quick nap. When I got back I noticed several warnings about it that were invisible to my eyes before.

# Using WebKitGTK as the UI for GStreamer applications.

Lately I’ve been thinking a lot about how can I make nice and easily customizable interfaces for video applications. My idea of ‘nice’ is kind of orthogonal to what most of my expected user base will want, and by ‘easily customizable’ I don’t mean ‘go edit this glade file / json stage / etc’.

Clutter and MX are great to make good looking interfaces and like Gtk have something that resembles css to style stuff and can load an ui from an xml or json file. However, they will need sooner or later a mix developer and a designer. And unless you do something up front, the interface is tied to the backend process that does the heavy video work.

So, seeing all the good stuff we are doing with Caspa, the VideoEditor, WebVfx and our new magical synchronization framework I questioned:

Why instead of using Gtk, can’t I make my ui with html and all the fancy things that are already made?

And while we are at it I want process isolation, so if the ui crashes (or I want to launch more than one to see side by side different ui styles) the video processing does not stop. Of course, should I want more tightly coupling I can embed WebKit on my application and make a javascript bridge to avoid having to use something like websockets to interact.

One can always dream…

Then my muse appeared and commanded me to type. Thankfully, mine is not like the poor soul on “Blank Page” had.

So I type, and I type, and I type.

‘Till I made this: two GStreamer pipelines, outputting to auto audio and video sinks and also to a webkit process. Buffers travel thru shared memory, still they are copied more than I’d like to but that makes things a bit easier and helps decoupling the processes, so if one stalls the others don’t care (and anyway for most of the things I want to do I’ll need to make a few copies). Lucky me I can throw beefier hardware and play with more interesting things.

I expect to release this in a couple of weeks when it’s more stable and usable, as of today it tends to crash if you stare at it a bit harder.

###### “It’s an act of faith, baby”

Using WebKit to display video from a GStreamer application.
Something free to whoever knows who the singer is without using image search.

# Stability analysis of an active load.

A more formal analysis about why the previous compensation scheme worked.

On this first part I will cover the loop around the opamp ignoring for a while the output transistor and parasitic capacitances; they will come later.

Some math after the jump. Continue reading