PCB Laminator Is Its Own Project

February 29, 2016 by Al Williams 21 Comments

One of the easiest ways to make PC boards at home is to use the toner transfer method. The idea is simple: print the artwork using a laser printer and then use a clothes iron to transfer the toner from the paper to a clean copper clad board. The toner is essentially plastic, so it will melt and stick to the board, and it will also resist etchant.

There are several things you can do to make things easier. The first is the choice of paper. However, the other highly variable part of the process is the clothes iron. You have to arrange for the right amount of heat and pressure. If you don’t do a lot of boards, you’ll probably have to make several passes at getting this right, scrubbing the reject boards with acetone and scouring pads to clean them again.

[Igor] had enough of the clothes iron and knew that other people have used lamination machines to get the toner off the paper and on the blank board. He started with a commercial laminator but hacked it for PID control of the temperature and made other improvements.

Continue reading “PCB Laminator Is Its Own Project” →

Icestudio: An Open Source Graphical FPGA Tool

February 23, 2016 by Eric Evenchick 38 Comments

If you’ve ever worked with FPGAs, you’ve dealt with the massive IDEs provided by the vendors. Xilinx’s ISE takes about 6 gigabytes, and Altera’s Quartus clocks in at over 10 gigs. That’s a lot of downloading proprietary software just to make an LED blink.

[Jesús Arroyo]’s Icestudio is a new, graphical tool that lets you generate Verilog code from block diagrams and run it on the Lattice Semi iCEstick development board. A drag and drop interface lets you connect IOs, logic gates, dividers, and other elements. Once your block diagram is ready, a single button press downloads the code to the iCEstick.

Under the hood, Icestudio uses IceStorm, which we’ve discussed on HaD in the past, including this great talk by [Clifford], Icestorm’s lead. For the GUI, Icestudio uses nw.js, which spits out JSON based on the block diagram. This JSON is converted into a Verilog file and a PCF file. The Verilog is used to create the logic on the FPGA, and the PCF is used to define the pin configuration for the device. Clicking on selected modules reveals the generated Verilog if you want to know what’s actually going on.

It’s experimental, but this looks like a neat way to get started on FPGAs without learning a new language or downloading many gigs of toolchains. We’re hoping Icestudio continues to grow into a useful tool for education and FPGA development. A demo follows after the break.

[Thanks to Nils for the tip!]

Continue reading “Icestudio: An Open Source Graphical FPGA Tool” →

Clearly The Best Way To Organize SMD Parts

February 11, 2016 by Voja Antonic 36 Comments

Have some plexiglas (acrylic) leftovers lying around? Well, they could be put to good use in making this SMD organizer. It comes in handy if you deal with a lot of SMD components in your work. No longer will you waste your time trying to find a 15K 1206 resistor, or that BAS85 diode… or any other component you can think of soldering on the PCB. The basic idea is fairly straightforword, which helped keep this short.

SMD resistors are packed in thick paper tapes that don’t bend easily, and thus need larger containers than other components, which are packed mainly in flexible PE tapes. The first version of this organizer was built with a 96mm diameter space for resistors and 63mm diameter for other components, but it seems that there is no need for such large compartments. If I were to make it again, I would probably scale everything down to about 80% of it’s current size.

The best way to join all plexiglass parts is to use four M4 threaded rods. There is also a 1.5mm steel rod which holds SMD tape ends in place and helps to un-stick the transparent tape which covers the components. At the top of the organizer there is a notch for paper, used for components labels. Most SMD components are packed in 8mm wide tapes, making the optimal compartment width 10mm. It is not easy to cut the 10mm thick acrylic and get a neat edge – instead, you could use more layers of thin sheets to make the spacers. Using 5mm acrylic you can combine more layers for any width of tape, which contains wider components, like SMD integrated circuits. The only thing that you have to be careful about, is to keep the distance between the thin steel rod and acrylic, which is marked as “2-4mm” on the drawing. It is good if this space is just a few tenths of a millimeter wider than the thickness of SMD tapes.

The CorelDraw file that can be used for laser cutting the acrylic parts, is available for download. If you scale the profiles, don’t forget to readjust the hole diameters and some other dimensions which have to remain intact. If you have 5mm acrylic pieces, you should probably use two layers of acrylic for every tape (red parts on the drawing). The barrier layers would be made of thin acrylic — for instance 2mm (the blue parts). Edge layers (green) are once again 5mm thick, and there are also the end pieces (yellow), glued to the previous borders and used to “round up” the whole construction and to protect your hands from the threaded rods and nuts.

While you’re building this for your bench, make a vacuum picking tool for SMDs out of a dispensing syringe with a thick needle. It’s a common trick for hackers to use an aquarium air pump, just turn the compressor unit by 180°, so that it creates vacuum instead of blowing the air outside. This process is described by R&TPreppers in the video below.

Continue reading “Clearly The Best Way To Organize SMD Parts” →

Local Hacker Discovers Card Edge Connectors

February 8, 2016 by Brian Benchoff 56 Comments

When [turingbirds] was looking around for the absolute minimum connector for a JTAG adapter, he wanted something small, that didn’t require expensive adapters, and that could easily and reliably connect a few JTAG pins to a programmer. This, unsurprisingly, is a problem that’s been solved many times over, but that doesn’t mean there isn’t room for improvement. [turingbirds] found his better solution by looking at some old card edge connectors.

Instead of 0.1″ pitch pin headers, weirder and more expensive connectors, the Tag Connect, or even pogo pins, [turingbirds] came up with a JTAG adapter that required no additional parts, had a small footprint, and could be constructed out of trash usually found behind any busy hackerspace or garage. The connector is based on the venerable PCI connector, chopped up with a Dremel and soldered to a JTAG or ISP programmer.

This is simply a card edge connector, something the younglings seem to have forgotten. Back in the day, card edge connectors were a great way to connect peripherals, ports, and anything else to the outside world. They were keyed, and you could only put them in one way. They were relatively cheap, and with a big coil of ribbon cable, you could make custom adapters easily. For low-speed connections that will only be used a few times, it’s very hard to beat a card edge connector.

Of course the connector itself is only half of the actual build. To turn a chopped up PCI connector into a JTAG adapter, [turingbirds] made footprint and part files for his favorite PCB design tool. In this case it’s Eagle, and the libraries that will plop one of these connectors down are available on GitHub.

Is this the latest and greatest way to plug a programmer into a board? No, because this has been around for 30 or 40 years. It does, however, put a programming port on a PCB with zero dollars in components, a minimum of board footprint, and uses parts that can be salvaged from any pile of old computers.

Build Yourself An Awesome Modular Power Supply

February 6, 2016 by Elliot Williams 34 Comments

You may think you’ve built a power supply for your bench. Heck, we all do. But until you check out [Denis]’s bench power supply build, you may not even know what you’re missing.

[Denis]’s design is nearly entirely modular and targeted to the intermediate builder. It’s built on easily available parts and through-hole components. It’s got an Arduino running as the brains, so you’re going to be able to hack on the code when you feel like tweaking it. But easy doesn’t mean light on features. Let’s walk through the build together.

It starts off with a pre-regulator: a switching MOSFET that gets the voltage down to just a couple volts above the target value. Then it’s off to the post-regulator that includes all of the fine adjustments, the DAC and ADC interfacing to the microcontroller, and some fancy features like a “down-programmer” that turns the output off extra quickly.

On the user end of things, [Denis] made a very sleek board that incorporates a TFT touchscreen for the controls, Arduino connections, and the obligatory banana plug outputs. There’s opto-isolation on the SPI bus, a real-time clock, and a bunch more goodies on board. He’s in his third revision of this module, and that level of refinement shows. It’s even SCPI compliant, meaning you can control remotely using an industry-standard protocol.

So what would you do with a ridiculously fancy power supply under microcontroller control? Test out battery charging algorithms? Program test routines to see how your devices will work as their batteries drain out? We have no idea, but we know we want one!

Pimp My Scope: Touchscreen Edition

February 4, 2016 by Elliot Williams 11 Comments

Do you have a touch-screen oscilloscope? Neither do we. But how cool would that be to pan left and right or expand either axis just like you do on your cellphone screen? [Igor] did just that, and the results (in the video below the break) look fantastic.

We’ve covered [Igor]’s previous round of hacking on his Siglent scope, where he bricked it by flashing the wrong firmware, and then fixed it by Frankensteining the screen into the box that the firmware wanted. But once he’d gotten the scope-hacking bug, he couldn’t quit.

A brief overview: an Arduino Nano reads the touchscreen and sends the commands to the scope to act accordingly. [Igor] initially wanted to simply use the COM port on the back to control, but his previous mis-flashing of the firmware had rendered that moot. Instead, he went after the data bus that interfaces with the keyboard unit, reverse engineered its protocol, and spoofed keypresses with custom code in the AVR.

As a side effect of all this, [Igor] could also write a script that controls the scope from his computer, and he ended up re-housing it all in the nice wooden front panel that you see now. It’s more than a step up from the previous covered-in-electrical-tape look, and the new functionality is very very cool. Kudos.

Continue reading “Pimp My Scope: Touchscreen Edition” →

A Better Way To Plug A CPLD Into A Breadboard

February 4, 2016 by Bil Herd 62 Comments

If you read my first post about a simple CPLD do-it-yourself project you may remember that I seriously wiffed when I made the footprint 1” wide, which was a bit too wide for common solderless breadboards. Since then I started over, having fixed the width problem, and ended up with a module that looks decidedly… cuter.

To back up a little bit, a Complex Programmable Logic Device (CPLD) is a cool piece of hardware to have in your repertoire and it can be used to learn logic or a high level design language or replace obsolete functions or chips. But a CPLD needs a little bit of support infrastructure to become usable, and that’s what I’ll be walking you through here. So if you’re interested in learning CPLDs, or just designing boards for them, read on!