USB Temperature Logger With Some Extra Tricks

Many of us electronics hacker types tend to have at least the same common equipment on our benches, namely a multimeter, an oscilloscope, some sort of adjustable power supply, and maybe a logic analyzer. These are great tools covering many bases, but dealing with temperature measurements is often neglected. A sudden need for such often results in just buying a either dedicated measurement unit, or some cheap eBay thermocouple board and just rolling with a few hacks. [Jana Marie Hemsing] had a need for measuring the thermal side of things, and got fed up with hacking with piles of boards, and designed herself a proper instrument for the task.

The result is a very tidy four-channel thermocouple frontend, feeding the data into the host computer via USB. Each of the four channels can either be a K-type input or a NTC thermistor input, decided at board assembly time, but you could just build two units with four channels of each and cover all bases. The K-type thermocouple input is based around the MAX31855 series device. While the ‘KASA’ suffixed device is probably most common, if you need to dedicate some channels to handling one of the other six or so other common thermocouple types, that just needs the appropriate MAX31855 variant dropping in, and you’re good to go.

For the controller, [Jana] has chosen the common STM32F0x microcontroller, which handles all the USB protocol side of things. The extra functionality added allows direct driving of a heater controller via the DRV8837 H-Bridge, with a extra few open collector outputs for other things you might want to drive. This allows the logger to function as a kind-of thermal IO device. Firmware is written in good old fashioned STM32 HAL, using the standard STM32CubeMX and the GCC toolchain. It looks like the Makefile came via the STM32 Project Generator route. The firmware has a neat trick up its sleeve too; with a flick of the switch on the back, the firmware can switch between outputting CSV data over a standard USB CDC link (a virtual serial port), or it can present a SCPI terminal interface, enabling integration into existing SCPI-based test flows. Nice work!

We’ve seen a few logging projects on these fair pages, like this battery powered ESP32 logger device. If IoT logging is more your thing, here you go.

Open Source LXI Tools Free Us From Vendor Bloat

LXI, or LAN eXtensions for Instrumentation is a modern control standard for connecting electronics instrumentation which supports ethernet. It replaces the older GPIB standard, giving much better performance and lower cost of implementation. This is a good thing.  [Martin Lund] has created the open source lxi-tools project which enables us to detach ourselves from the often bloated vendor tools usually required for talking LXI to your bench equipment. This is a partial rewrite of an earlier version of the tool, and now sports some rather nice features such as mDNS for instrument discovery, support for screen grabbing, and a LUA-based scripting backend. (API Link)

SCPI or Standard Commands for Programmable Instruments is the text-based language spoken by many instruments, allowing control and querying of an instrument. Just to be clear, SCPI is not at all a new thing, and older instruments that have GPIB or RS232 connectors, still could talk SCPI. lxi-tools is not for those. Some instruments can also be very picky about the formatting of commands, especially if they’re buggy, so the ability to interactively debug commands is very desirable. It is quite possible to make poor use of SCPI commands in your test script and end up with tests that just take far longer to execute that they need to. lxi-tools has a benchmarking tool too, which helps you to dig in and find out where all the time is going and make suitable adjustments.

We’ve not seen much about LXI on Hackaday, but we did cover using PyVISA for dealing with SCPI-over-GPIB in python.¬† If you have an older instrument¬† with GPIB and you don’t want to sell a internal organ to pay for a USB adaptor, here’s one you can make yourself.

Hackaday Podcast 146: Dueling Trackballs, Next Level BEAM Robot, Take Control Of Your Bench, And Green Programming

Postpone your holiday shopping and spend some quality time with editors Mike Szczys and Elliot Williams as they sift through the week in Hackaday. Which programming language is the greenest? How many trackballs can a mouse possibly have? And can a Bluetooth dongle run DOOM? Join us to find out!

 

Take a look at the links below if you want to follow along, and as always, tell us what you think about this episode in the comments!

Direct download (52 MB)

Continue reading “Hackaday Podcast 146: Dueling Trackballs, Next Level BEAM Robot, Take Control Of Your Bench, And Green Programming”

Back of Rigol DS1104Z oscilloscope with the Ethernet and USB ports visible.

SCPI: On Teaching Your Devices The Lingua Franca Of Laboratories

One could be excused for thinking sometimes that the concept of connecting devices with other devices for automation purposes is a fairly recent invention. Yet for all the (relatively) recent hype of the Internet of Things and the ‘smart home’, laboratories have been wiring up their gear to run complicated measurement and test sequences for many decades now, along with factories doing much the same for automating production processes.

Much like the chaotic universe of IoT devices, lab equipment from different manufacturers feature a wide number of incompatible protocol and interface standards. Ultimately these would coalesce into IEEE-488.1 (GPIB) as the physical layer and by 1990 the first Standard Commands for Programmable Instruments (SCPI) standard was released that built on top of IEEE-488.

SCPI defines (as the name suggests) standard commands to interact with instruments. It has over the past decades gone on to provide remote interaction capabilities to everything from oscilloscopes and power supplies to exotic scientific equipment. Many off the shelf devices a hobbyist can buy today feature an SCPI interface via its Ethernet, USB or RS-232C port(s) that combined with software can be used to automate one’s home lab.

Even better is that it’s relatively straightforward to add SCPI functionality to one’s own devices as well, so long as it has at least an MCU and some way to communicate with the outside world.

Continue reading “SCPI: On Teaching Your Devices The Lingua Franca Of Laboratories”

DIY Source Measurement Unit

DIY Source Measurement Unit Shows All The Details

An SMU or Source Measurement Unit works a bit like a power supply, in that it can source current into a load and a bit like an electronic load, in that it can sink current from a power source. It includes a crossover circuit, so that it cleanly and predictably swaps between sink and source modes automatically. This makes it terribly useful for testing all manner of power circuits, charging and characterizing batteries or just saving bench space by replacing two separate boxes.

This DIY-SMU from analog electronics guru [Dave Erikson] is a full four-quadrant design, meaning that it can operate with both positive and negative voltages. The design shows excellent performance, comparable to commercial instruments that cost serious money, which is testament to [Dave]’s skill and experience.

Source: Wikipedia

The quadrants can be understood if you imagine a graph with voltage on the horizontal axis, and current on the vertical. Both axes can swing to both polarities, with quadrants I & III indicating power delivered into a load and quadrants II & IV power absorbed from a source.

The very detailed project logs show every gory detail, every problem found and the work to solve it. Its a long read, which for those interested in such devices, will be time well spent in this scribe’s humble opinion.

The DIY-SMU is mostly analog in nature, with the control portion courtesy of a Teensy 3.2, with a Nextion TFT display with touch for the user interface. The firmware even supports SCPI over USB to allow remote control and data gathering, so its ready to drop right into your test and measurement stack. For more reading goodness, checkout JSMU, a related project, taking inspiration from the DIY-SMU. Details can be found on this project GitHub repo.

Many power supply projects have graced these pages over the years, like this 2015 Hackaday Prize Entry but this is one of the few four-quadrant designs to be found, so hats off!

Continue reading “DIY Source Measurement Unit Shows All The Details”

No More Floppy Drives For This Agilent Scope

When [kiwih] picked up an Agilent 54621A scope, he was amused that it had a floppy disk. At one time, it was high-tech to use a disk to transfer scope data to your computer. Today, not so much. However, on the back was a serial port. Surely it was possible to read data from there. It is, and what results is a nice walkthrough of finding the port’s info and interfacing with it using Python.

Normally, you’d use the included BenchLinkXL software to grab data from the port, but that software is so old it would not run under Windows 10 or Wine. Searching didn’t turn up much on the serial port, but it did locate a manual for a similar Agilent scope. That manual wasn’t too helpful since it assumed you were connecting via a LAN or USB. However, it did make reference to an older model that was also similar and that was the key to finding a manual that did explain the serial port protocol.

The command set looks suspiciously like SCPI — Standard Commands for Programmable Instruments — which is a layer on top of the GPIB protocol. Many scopes speak that language, so that’s not surprising. That also means if you are in the mood to communicate with an SCPI scope, you might find the code useful, even if you don’t use a serial port or have this exact Agilent model.

SCPI has a lot of uses. For example, try talking to your scope. The cheap Rigol and similar scopes usually have SCPI and you can control and read them using the same kind of techniques.