Author Archives: Elliot Williams

E-ink Display Driven DIY

via hardware – Hackaday

E-ink displays are awesome. Humans spent centuries reading non-backlit devices, and frankly it’s a lot easier on the eyes. But have you looked into driving one of these critters yourself? It’s a nightmare. So chapeau! to [Julien] for his FPGA-based implementation that not only uses our favorite open-source FPGA toolchain, and serves as an open reference implementation for anyone else who’s interested.

Getting just black and white on an E-ink display is relatively easy — just hit the ink pixels with the same signal over and over until they give up. Greyscale is made by applying much more nuanced voltages because the pixels are somewhat state-dependent. If the desired endpoint is a 50% grey, for instance, you’d hit it with a different pulse train if the pixel were now white versus if it were now black. (Ever notice that your e-book screen periodically does a white-black flash? It’s resetting all the pixels to a known state.) And that’s not even taking into account the hassles with the various crazy voltages that E-ink displays require, which [Julien] wisely handed off to a dedicated chip.

In the end, the device has to make 20-50 passes through the screen for one user-visible refresh. [Julien] found that the usual microcontrollers just weren’t capable of the speed that he wanted, hence the FPGA and custom waveform tables. We’ve seen E-ink hacks before, and [Julien] is standing on the shoulders of giants, most notably those of [Petteri Aimonen] and [Sprite_tm]. [Julien]’s hack has the fastest updates we’ve ever seen.

We still can’t wait for the day that there is a general-purpose E-ink driver chip out there for pennies, because nearly every project we make with a backlit display would look better, and chew through the batteries slower, with E-ink. In the meantime, [Julien]’s FPGA implementation is pretty close, and it’s fully open.


Filed under: FPGA, hardware

Hackaday Trims Its Own Resistors

via hardware – Hackaday

There are times when you might want an odd-value resistor. Rather than run out to the store to buy a 3,140 Ω resistor, you can get there with a good ohmmeter and a willingness to solder things in series and parallel. But when you want a precise resistor value, and you want many of them, Frankensteining many resistors together over and over is a poor solution.

Something like an 8-bit R-2R resistor-ladder DAC, for instance, requires seventeen resistors of two values in better than 0.4% precision. That’s just not something I have on hand, and the series/parallel approach will get tiresome fast.

Ages ago, I had read about trimming resistors by hand, but had assumed that it was the domain of the madman. On the other hand, this is Hackaday; I had some time and a file. Could I trim and match resistors to within half a percent? Read on to find out.

Metal-Film, Through-Hole Resistors

All in the name of science

Your run-of-the-mill through-hole resistor is a metal-film resistor, made by depositing a thin layer of metal onto a non-conductive ceramic cylinder. The metal film is cut into a helix, and the length, width, and thickness of the resulting metal coil determine the resistance. Since the deposited metal is so thin, between 50 nm and 250 nm, you might think that trimming this down by hand is going to be a bit finicky.

Jumping straight to the punchline, when I was trying to change the resistance by small amounts, maybe less than 5% or so, it was trivially easy to land spot on the exact desired value. I had bags of 1 kΩ and 2 kΩ 1% resistors, and I figured I would make a whole bunch of mistakes while learning.

The reality is that I went over the target once out of seventeen attempts, and that only by one ohm. The rest of the resistors are trimmed as well as I can measure — down to the single ohm. (My meter and probes have a 0.3 Ω offset, but there’s nothing I can do about that.) I pitched the “bad” one, made one more, and had a perfect set in short order.

Here’s the whole procedure. I put the resistor into some insulated clamps, and clipped my ohmmeter to either end. I used a small round file, and just went at it. The first few strokes get you through the relatively thick coating, but once you see metal, or notice a blip on the ohmmeter, a very light touch with the file is the rule. Maybe blow some of the metal dust off between strokes when you’re getting close, but I didn’t notice that it made much difference. Seven or eight light strokes with the tiny little file brought the resistors to a ten-point landing.

Indeed, because it’s easy to go too far at first, I found that ideal candidate resistors to file were the 1,990 Ω ones. Many of my 1 kΩ resistors came in at 999 Ω, which makes it hard to get through the casing without overshooting the mark. I probably could have just left them. The good news is that most 1% resistors will be off by more than a few ohms in either direction, otherwise they’d be sold as 0.1% resistors. And of course, you need to pick source resistors with a lower resistance than the target — you’re not adding metal with the file.

So you only need to have one value of resistor in your kit, right? Absolutely not. Creating a 1.2 kΩ resistor from a 1 kΩ original is asking for trouble. I got it to work a few times, again down to the single ohm, by restarting the filing process in a different place rather than simply going deeper in one hole, but I don’t recommend it, and I can’t think of when you’d need to. Just add a 200 Ω resistor in series and trim that. Remember that you’re thinning down a metal spiral that’s only 100 nm thick to begin with. Easy does it.

Surface-Mount?

Filing down through-hole resistors to exact values was so much easier than I had anticipated that I decided to take on something harder. I tacked a 1206 2.1 kΩ resistor onto some stripboard. Wouldn’t you know it, it read out exactly 2,100 Ω, so 2,105 Ω became the target. That didn’t go well at all; I ended up with a 2,722 Ω resistor faster than I had expected.

Didn’t end well.

The second 1206 started out at 2,103 Ω, and I just went at it without a goal in mind. By going very carefully, I got it’s resistance down to 2,009 Ω before it jumped to 2,600 Ω and beyond. Lowering the resistance doesn’t make sense at all. Maybe I was dragging some solder into the gap and effectively thickening the metal layer? I went looking for information, but didn’t get any further into the construction than Vishay’s datasheet: “metal glaze on high-quality ceramic” which doesn’t enlighten much.

After two more attempts, I couldn’t get the SMT resistors in trim at all; the layer of deposited metal is just too thin. And anyway, I’m not sure how useful it would be — the thought of soldering and de-soldering seventeen of these isn’t very appealing.

Conclusion

Trimming through-hole resistors is awesome. I made a complete set of matched better-than-0.05% (!) resistors for an 8-bit DAC in half an hour with nothing more than a file and an ohmmeter. And on my first try. You could easily make a 10-bit DAC this way. The result was an order of magnitude better than I had hoped, and it wasn’t hard at all. Amazing. And nothing says cool like a hand-made, artisanal DAC. (For odd values of cool.)

My attempt at trimming surface-mount resistors, on the other hand, was a complete failure. Anyone out there care to guess why? Is it just the tweakiness of trimming a super-thin film? Anyone with a precise laser cutter want to have a go and write us about it?


Filed under: Engineering, Hackaday Columns, hardware

New Fonts for gEDA PCB Tool

via hardware – Hackaday

In the open-source world, there are two main choices for PCB design: KiCad and gEDA. But if you’re tired of the boring Hershey fonts telling you which resistor is which, or if you need to comply with ISO 3098, there’s one clear choice: PCB-RND, the improved fork of gEDA’s PCB tool. Why?

Because PCB-RND now supports osifont, which supports a ridiculous number of languages. In addition to the usual suspects, like Azerbaijani through Vietnamese, support has also been added for legacy users, including those of Middle Earth, who build PCBs that can only be read when the thrush knocks by the setting sun of the last light on Durin’s Day.

And they haven’t stopped there. Looking forward to the Treaty of Organia in 2267, you can now create PCBs that are fully plqaD-HaSta compliant.

We’re glad to see these important steps made toward reaching out to underserved PCB-constructing communities. However, we’re appalled at the continuing lack of support for Rihannsu. This will have to be rectified by anyone who wants to push their projects in the Beta Quadrant.


Filed under: hardware

Arduino into NAND Reader

via hardware – Hackaday

[James Tate] is starting up a project to make a “Super Reverse-Engineering Tool”. First on his list? A simple NAND flash reader, for exactly the same reason that Willie Sutton robbed banks: because that’s where the binaries are.

As it stands, [James]’s first version of this tool is probably not what you want to use if you’re dumping a lot of NAND flash modules. His Arduino code reads the NAND using the notoriously slow digital_read() and digital_write() commands and then dumps it over the serial port at 115,200 baud. We’re not sure which is the binding constraint, but neither of these methods are built for speed.

Instead, the code is built for hackability. It’s pretty modular, and if you’ve got a NAND flash that needs other low-level bit twiddling to give up its data, you should be able to get something up and working quickly, start it running, and then go have a coffee for a few days. When you come back, the data will be dumped and you will have only invested a few minutes of human time in the project.

With TSOP breakout boards selling for cheap, all that prevents you from reading out the sweet memory contents of a random device is a few bucks and some patience. If you haven’t ever done so, pull something out of your junk bin and give it a shot! If you’re feeling DIY, or need to read a flash in place, check out this crazy solder-on hack. Or if you can spring for an FTDI FT2233H breakout board, you can read a NAND flash fast using essentially the same techniques as those presented here.


Filed under: Arduino Hacks, hardware

Humidity Sensor Shootout

via hardware – Hackaday

If you want to measure humidity (and temperature, and maybe even barometric pressure) in a device that you’re building, have a look at this comprehensive test of seven different options. We’re going to summarize the results here, but you’ll really want to read up on the testing methodology — it’s great science hacking. Did you know about using saturated salt solutions to produce constant humidity levels for calibration? We didn’t.

The so-called DHT22 module doesn’t fare all that well, with one of six that [Robert] tested being basically horrible, and three of them breaking within two years of use. The one that works well, however, is pretty good. Feeling lucky?

The Bosch BME280 looks great. It costs a bit more as a bare part, and a few times more than mounted on a friendly module, but it seems to be very reliable. And you get a barometer thrown in for the extra work. Indeed, it performed so well that Hackaday contributor [Nava Whiteford] put the part under a scanning electron microscope to figure out what’s going on.

The other sensors were fine, with the HTU21D and SHT71 being standouts for their ultra-fast response. For the full details, go click on that link at the top. Having just installed a sextet of DHT22s in our house last year, we’re left with that sinking feeling that we may have gotten what we paid for, which wasn’t much. At least they’re all still running.

Thanks to [Dodutils] and [mac012345] via comments in another thread.


Filed under: hardware, home hacks

SKiDL: Script Your Circuits in Python

via hardware – Hackaday

SKiDL is very, very cool. It’s a bit of Python code that outputs a circuit netlist for KiCAD.

Why is this cool? If you design a PCB in KiCAD, you go through three steps: draw the schematic, assign footprints to the symbolic parts, and then place them. The netlist ties all of these phases together: it’s a list of which parts are connected to which, the output of schematic capture and the input for layout. The ability to generate this programmatically should be useful.

For instance, you could write a filter circuit generator that would take the order, cutoff, and type of filter as inputs, and give you a spec’ed netlist as output. Bam! In your next design, when you need a different filter, you just change a couple of variables. Writing your circuits as code would make arranging the little sub-circuits modular and flexible, like functions in code.

At the very least, it’s an interesting alternative to the mouse, click, drag, click paradigm that currently dominates the schematic capture phase. Just as some of you like OpenSCAD for 3D modelling, some of you will like SKiDL for circuit design.

We’ve become so accustomed to the circuit diagram as the means of thinking about circuits that we’re not sure that we can ever give up the visual representation entirely. Maybe designing with SKiDL will be like sketching out block diagrams, where each block is a bit of Python code that generates a circuit module? Who knows? All we know is that it sounds potentially interesting, and that it’ll certainly be mind-expanding to give it a try.

Give it a shot and leave feedback down in the comments!


Filed under: hardware