DIY Arduino Soldering Iron Hits Version 2.0

September 22, 2018 by Tom Nardi 11 Comments

A few months ago we brought word that [Electronoobs] was working on his own open source alternative to pocket-sized temperature controlled soldering irons like the TS100. Powered by the ATMega328p microcontroller and utilizing a 3D printed enclosure, his version could be built for as little as $15 USD depending on where you sourced your parts from. But by his own admission, the design was held back by the quality of the $5 replacement soldering iron tips he designed it around. As the saying goes, you get what you pay for.

But [Electronoobs] is back with the second version of his DIY portable soldering iron, and this time it’s using the vastly superior HAKKO T12 style tip. As this tip has the thermocouple and heating element in series it involved a fairly extensive redesign of the entire project, but in the end it’s worth it. After all, a soldering iron is really only as good as its tip to begin with.

This version of the iron deletes the MAX6675 used in V1, and replaces it with a LM358 operational amplifier to read the thermocouple in the T12 tip. [Electronoobs] then used an external thermocouple to compare the LM358’s output to the actual temperature at the tip. With this data he created a function which will return tip temperature from the analog voltage.

While the physical and electrical elements of the tip changed substantially, a lot of the design is still the same from the first version. In addition to the ATMega328p microcontroller, version 2.0 of the iron still uses the same 128×32 I2C OLED display, MOSFET, and 5V buck converter from the original iron. That said, [Electronoobs] is already considering a third revision that will make the iron even smaller by replacing the MOSFET and buck converter. It might be best to consider this an intermediate step before the DIY iron takes on its final form, which we’re very interested in seeing.

The first version of the DIY Arduino soldering iron garnered quite a bit of attention, so it seems there’s a decent number of you out there who aren’t content with just plunking down the cash for the TS100.

Continue reading “DIY Arduino Soldering Iron Hits Version 2.0” →

Building A Pocket Sized Arduino Oscilloscope

September 21, 2018 by Tom Nardi 10 Comments

There’s little question that an oscilloscope is pretty much a must-have piece of equipment for the electronics hacker. It’s a critical piece of gear for reverse engineering devices and protocols, and luckily for us they’re as cheap as they’ve ever been. Even a fairly feature rich four channel scope such as the Rigol DS1054Z only costs about as much as a mid-range smartphone. But if that’s still a little too rich for your taste, and you’re willing to skimp on the features a bit, you can get a functional digital oscilloscope for little more than pocket change.

While there are a number of very cheap pocket digital storage oscilloscopes (DSOs) on the market, [Peter Balch] decided he’d rather spin up his own version using off-the-shelf components. Not only was it an excuse to deep dive on some interesting engineering challenges, but it ended up bringing the price even lower than turn-key models. Consisting of little more than an Arduino Nano and a OLED display, the cost comes out to less than $10 USD for a decent DSO that’s about the size of a matchbox.

But not a great one. [Peter] is very upfront about the limitations of this DIY pocket scope: it can’t hit very high sample rates, and the display isn’t really big enough to convey anything more than the basics. But if you’re doing some quick and dirty diagnostics in the field, that might be all you need. Especially since there’s a good chance you can build the thing out of parts from the junk bin.

Even if you’re not looking to build your own version of the Arduino-powered scope [Peter] describes, his write-up is still full of fascinating details and theory. He explains how his software approach is to disable all interrupts, and put the microcontroller into a tight polling loop to read data from the ADC as quickly as possible. It took some experimentation to find the proper prescaler value for the Atmega’s 16MHz clock, but in the end found he could get a usable (if somewhat noisy) output with a 1uS sample rate.

Unfortunately, the Arduino’s ADC leaves something to be desired in terms of input range. But with the addition of an LM358 dual op-amp, the Arduino scope gains some amplification so it can pick up signals down into the mV range. For completion’s sake, [Peter] included some useful features in the device’s firmware, such as a frequency counter, square wave signal source, and even a voltmeter. With the addition of a 3D printed case, this little gadget could be very handy to have in your mobile tool kit.

If you’d rather go the commercial route, Hackaday’s very own [Jenny List] has been reviewing a number of very affordable models such as the DSO Nano 3 and the JYE Tech DSO150 build-it-yourself kit.

[Thanks to BaldPower for the tip.]

Advanced Techniques For Using Git With KiCAD

September 19, 2018 by Kerry Scharfglass 4 Comments

For most developers “distributed version control” probably means git. But by itself git doesn’t work very well with binary files such as images, zip files and the like because git doesn’t know how to make sense of the structure of an arbitrary blobs of bytes. So when trying to figure out how to track changes in design files created by most EDA tools git doesn’t get the nod and designers can be trapped in SVN hell. It turns out though KiCAD’s design files may not have obvious extensions like .txt, they are fundamentally text files (you might know that if you’ve ever tried to work around some of KiCAD’s limitations). And with a few tweaks from [jean-noël]’s guide you’ll be diffing and merging your .pro’s and .sch’s with aplomb.

There are a couple sections to the document (which is really meant as an on boarding to another tool, which we’ve gotten to in another post). The first chunk describes which files should be tracked by the repo and which the .gitignore can be configured to avoid. If that didn’t make any sense it’s worth the time learning how to keep a clean repo with the magic .gitignore file, which git will look for to see if there are any file types or paths it should avoid staging.

The second section describes how you can use two nifty git features, cleaning and smudging, to dynamically modify files as they are checked in and out of the repo. [jean-noël]’s observation is that certain files get touched by KiCAD even if there are no user facing changes, which can clutter patch sets with irrelevant changes. His suggested filters prevent this by stripping those changes out as files get checked in. Pretty slick.

Visual Schematic Diffs In KiCAD Help Find Changes

September 19, 2018 by Kerry Scharfglass 11 Comments

When writing software a key part of the development workflow is looking at changes between files. With version control systems this process can get pretty advanced, letting you see changes between arbitrary files and slices in time. Tooling exists to do this visually in the world of EDA tools but it hasn’t really trickled all the way down to the free hobbyist level yet. But thanks to open and well understood file formats [jean-noël] has written plotgitsch to do it for KiCAD.

In the high(er)-end world of EDA tools like OrCAD and Altium there is a tight integration between the version control system and the design tools, with the VCS is sold as a product to improve the design workflow. But KiCAD doesn’t try to force a version control system on the user so it doesn’t really make sense to bake VCS related tools in directly. You can manage changes in KiCAD projects with git but as [jean-noël] notes reading Git’s textual description of changed X/Y coordinates and paths to library files is much more useful for a computer than for a human. It basically sucks to use. What you really need is a diff tool that can show the user what changed between two versions instead of describe it. And that’s what plotgitsch provides.

plotgitsch’s core function is to generate images of a KiCAD project at arbitrary Git revisions. After that there are two ways to view the output. One is to generate images of each version which can be fed into a generic visual diff tool (UNIX philosophy anyone?). The documentation has an example script to help facilitate setting this up. The other way generates a color coded image in plotgitsch itself and opens it in the user’s viewer of choice. It may not be integrated into the EDA but we’ll take one click visual diffs any day!

Soldering Like It’s 205 BC

September 18, 2018 by Dan Maloney 43 Comments

Did you ever stop to think how unlikely the discovery of soldering is? It’s hard to imagine what sequence of events led to it; after all, metals heated to just the right temperature while applying an alloy of lead and tin in the right proportions in the presence of a proper fluxing agent doesn’t seem like something that would happen by accident.

Luckily, [Chris] at Clickspring is currently in the business of recreating the tools and technologies that would have been used in ancient times, and he’s made a wonderful video on precision soft soldering the old-fashioned way. The video below is part of a side series he’s been working on while he builds a replica of the Antikythera mechanism, that curious analog astronomical computer of antiquity. Many parts in the mechanism were soldered, and [Chris] explores plausible methods using tools and materials known to have been available at the time the mechanism was constructed (reported by different historians as any time between 205 BC and 70 BC or so). His irons are forged copper blocks, his heat source is a charcoal fire, and his solder is a 60:40 mix of lead and tin, just as we use today. He vividly demonstrates how important both surface prep and flux are, and shows both active and passive fluxes. He settled on rosin for the final joints, which turned out silky smooth and perfect; we suspect it took quite a bit of practice to get the technique down, but as always, [Chris] makes it look easy.

If you’d like to dig a bit deeper into modern techniques, we’ve covered the physics of solder and fluxes in some depth. And if you need more of those sweet, sweet Clickspring videos, we’ve got you covered there as well.

Continue reading “Soldering Like It’s 205 BC” →

DIY Rubber Ducky Is As Cheap As Its Namesake

September 17, 2018 by Tom Nardi 26 Comments

The “Rubber Ducky” by Hak5 is a very powerful tool that lets the user perform rapid keystroke injection attacks, which is basically a fancy way of saying the device can type fast. Capable of entering text at over 1000 WPM, Mavis Beacon’s got nothing on this $45 gadget. Within just a few seconds of plugging it in, a properly programmed script can do all sorts of damage. Just think of all the havoc that can be caused by an attacker typing in commands on the local machine, and now image they are also the Flash.

But unless you’re a professional pentester, $45 might be a bit more than you’re looking to spend. Luckily for the budget conscious hackers out there, [Tomas C] has posted a guide on using open source software to create a DIY version of Hak5’s tool for $3 a pop. At that cost, you don’t even have to bother recovering the things when you deploy them; just hold on tight to your balaclava and make a run for it.

The hardware side of this hack is the Attiny85-based Digispark, clones of which can be had for as low as $1.50 USD depending on how long your willing to wait on the shipping from China. Even the official ones are only $8, though as of the time of this writing are not currently available. Encapsulating the thing in black shrink tubing prevents it from shorting out, and as an added bonus, gives it that legit hacker look. Of course, it wouldn’t be much of a hack if you could just buy one of these little guys and install the Rubber Ducky firmware on it.

In an effort to make it easier to use, the official Rubber Ducky runs scripts written in a BASIC-like scripting language. [Tomas C] used a tool called duck2spark by [Marcus Mengs], which lets you take a Rubber Ducky script (which have been released by Hak5 as open source) and compile it into a binary for flashing to the Digispark.

Not quite as convenient as just copying the script to the original Ducky’s microSD card, but what do you want for less than 1/10th the original’s price? Like we’ve seen in previous DIY builds inspired by Hak5 products, the trade-off is often cost for ease of use.

[Thanks to Javier for the tip.]

Behold A DIY, Kid-Friendly Table Saw

September 14, 2018 by Donald Papp 26 Comments

The “table saw” swaps the saw for a nibbler; here it is cutting corrugated cardboard in a manner much like the saw it replaces.

“Kid-friendly table saw” seems like either a contradiction, a fool’s errand, or a lawsuit waiting to happen; but this wooden table saw for kids actually fits the bill and shows off some incredible workmanship and attention to detail as well. The project works by using not a saw blade, but a nibbler attached to a power drill embedded inside.

Unsurprisingly, the key to making a “table saw” more kid-friendly was to remove the saw part. The nibbler will cut just about any material thinner than 3 mm, and it’s impossible for a child’s finger to fit inside it. The tool is still intended for supervised use, of course, but the best defense is defense in depth.

The workmanship on the child-sized “table saw” is beautiful, with even the cutting fence and power switch replicated. It may not contain a saw, but it works in a manner much like the real thing. The cutting action itself is done by an economical nibbler attachment, which is a small tool with a slot into which material is inserted. Inside the slot, a notched bar moves up and down, taking a small bite of any material with every stroke. Embedding this into the table allows for saw-like cutting of materials such as cardboard and thin wood.

The image gallery is embedded below and shows plenty of details about the build process and design, along with some super happy looking kids.

Continue reading “Behold A DIY, Kid-Friendly Table Saw” →