A Modular 1GHz Spectrum Analyzer

May 14, 2014 by Brian Benchoff 17 Comments

[MrCircuitMatt] has been doing a lot of radio repair recently, quickly realized having a spectrum analyzer would be a useful thing to have. Why buy one when you can build one, he thought, and he quickly began brushing up on his RF and planning out the design of a 1000 MHz spectrum analyzer

The project is based on Scotty’s Spectrum Analyzer, a sweep-mode, modular 1GHz spectrum analyzer that is, unfortunately, designed entirely in ExpressPCB. [Matt] didn’t like this proprietary design software tied to a single board house. The basic building blocks of [Scotty]’s spectrum analyzer were transferred over to KiCAD, the boards sent off to a normal, Chinese board house.

In the second video, [Matt] goes over the design of the control board, a small module that connects the spectrum analyzer to the parallel port of a PC. There’s a lot of well thought out design in this small board, a good thing, too, since he’s powering his VCO with a switched mode supply. The control board has a 32-bit I/O, so how’s he doing that with a parallel port, what is ultimately an 8-bit port? A quartet of 74ACT573, a quad buffer with latch enable. Using the eight data lines on the parallel port allows him to toggle some pins while the ancient pins on the parallel bus – Strobe, Select Printer, and Line Feed control the latches on each of the buffers. This gives him the ability to write to 32 different pins in his spectrum analyzer with a parallel port.

Right now, [Matt] is wrapping up the construction of his control board, with the rest of the modules following shortly. He thinks the completed analyzer might even be cheaper than a professional, commercial offering, and we can’t wait to see another update video.

Continue reading “A Modular 1GHz Spectrum Analyzer” →

Retrotechtacular: Forging Of Chain By Smiths

May 13, 2014 by Brian Benchoff 36 Comments

Ah, the days when men were men and people died of asbestos related illnesses in their 30s. Let this video take you back to the ancient times when chains were forged by hand, destructively tested using wooden capstans, and sent off to furnish the ships of the line, way back in the year 1940.

The video is something of an advertisement for the Netherton iron works, located in the English midlands. Founded sometime in the mid 19th century, it appears the tooling and machinery didn’t change much the hundred years before this was filmed.

The chain begins as a gigantic mass of wrought iron bars brought in from a forge. These bars are stockpiled, then sent through chain shears that cut them into manageable lengths a foot or so long. The next scene would probably look the same in 1940 as 1840, with gangs of men taking one of the bars, heating it in a forge, beating it on an anvil, and threading it through the last link in the chain they worked on. This isn’t the satisfying machinations of industrial automata you’d see on How It’s Made. No, this is hard manual labor.

Whether through simple quality control or an edict from the crown, the completed chains are tested, or more specifically, proofed. Yard long samples are tested to their failure point, and entire chains are proofed to their carrying capacity in 15 fathom ( 90 feet) long lengths. These chains are then examined link by link, stamped and certified, and sent off to mines, factories, tramp steamers, and battleships.

Although the Netherton iron works no longer exists, it did boast a few claims to fame in its day. It manufactured the anchors and chain for both the Titanic and Lusitania. Of course, such a large-scale production of wrought chain in such an archaic method would be impossible today; today, every wrought iron foundry has been shuttered for decades. If you’ve ever wondered how such massive things were made with a minimal amount of machinery, though, there you go.

Continue reading “Retrotechtacular: Forging Of Chain By Smiths” →

Injection Molding With Hot Glue

May 12, 2014 by Brian Benchoff 24 Comments

Injection molding is simply forcing a melted thermoplastic into a mold of some sort, letting it cool, and then prying the mold apart to get to the finished piece. Hot glue guns are basically handheld thermoplastic extruders, so when [scorch] dug up some old injection molds he had sitting around, it didn’t take long to put two and two together.

Injection molds aren’t something any normal person has sitting around, but a few years ago [scorch] found two books published by Gingery, the same people who have published instructions on how to build a metalshop from scrap. [scorch] created his molds on a small CNC mill – a Sieg X3 – and his initial experiments with injection molded plastic were fairly successful, even if the molds were made from self-cast billets.

After molding a few hot glue LEGO parts with his equipment, [scorch] had a look around the Internet and noticed this was nothing new. One company even sells a hot glue gun-based injection molding kit using polyethylene glue sticks. Their demo video (seen below) seems much more complicated than [scorch]’s efforts, so we’ll say he came out ahead on this one.

Continue reading “Injection Molding With Hot Glue” →

Hackaday Links: May 11, 2014

May 11, 2014 by Brian Benchoff 11 Comments

North Korean drones! Yes, your local hobby shop has the same aerial reconnaissance abilities as North Korea. Props to Pyongyang for getting v-tail mixing down.

There’s nothing quite as satisfying as the look of a well laid out resistor array, and the folks at Boldport have taken this to a new level. It’s an art piece, yes, but these would make fabulous drink coasters.

Here’s something even more artistic. [cpurola] found a bunch of cerdip EPROMs and bent the pins in a weird chainmaille-esque way. The end result is an EPROM bracelet, just in time for mother’s day. It’s a better use for these chips than tearing them apart and plundering them for the few cents worth of gold in each.

[John] still uses his original Xbox for xmbc, but he’d like to use the controllers with his computer. He never uses the third and fourth controller ports, so he stuck those in his computer. It’s as simple as soldering the controller port module to a connector and plugging it into an internal USB port. Ubuntu worked great, but Windows required XBCD.

[Kerry] has modified an FT232 USB/UART thingy as an Arduino programmer before. The CP2102 USB/UART is almost as popular on eBay, a little less expensive, and equally suited for ‘duino programming. It requires desoldering a resistor and soldering a jumper on a leadless package, but with a fine solder tip, it’s not too bad.

Phenox: Wherein Quadcopters Get FPGAs

May 11, 2014 by Brian Benchoff 23 Comments

quad

The computing power inside a quadcopter is enough to read a few gyros and accelerometers, do some math, and figure out how much power to send to the motors. What if a quadcopter had immensely more computing power, and enough peripherals to do something cool? That’s what Phenox has done with a micro quad that is able to run Linux.

Phenox looks like any other micro quad, but under the hood things get a lot more interesting. Instead of the usual microcontroller-based control system, the Phenox features a ZINQ-7000 System on Chip, featuring an ARM core with an FPGA and a little bit of DDR3 memory. This allows the quad to run Linux, made even more interesting by the addition of two cameras (one forward facing, one down facing), a microphone, an IMU, and a range sensor. Basically, if you want a robotic pet that can hover, you wouldn’t do bad by starting with a Phenox.

The folks behind Phenox are putting up a Kickstarter tomorrow. No word on how much a base Phenox will run you, but it’ll probably be a little bit more than the cheap quads you can pick up from the usual Chinese retailers.

Videos below.

Continue reading “Phenox: Wherein Quadcopters Get FPGAs” →

Unbricking The Da Vinci And Installing Custom Firmware

May 11, 2014 by Brian Benchoff 67 Comments

We’ve seen a lot of projects based around the Da Vinci 3D printer, all deserved, because the Da Vinci is honestly a terrible 3D printer; it has chipped and DRM filament cartridges, a terrible software interface, and completely closed firmware. The first two shortcomings have already been taken care of, and now the door is open for open source firmware on the Da Vinci printer.

[Jason] bricked his Da Vinci when upgrading the firmware, and like any enterprising tinkerer opened up the enclosure and took a look at the electronics board. He found an ATSAM3X8E, a very capable ARM Cortex-M3 microcontroller. This is the same processor in the Arduino Due, making it possible to write code for the Due and upload it to the Da Vinci controller.

After installing Atmel Studio 6, he noticed the printer controller showed up in the device manager, making it a snap to upload updated firmware, unbricking his printer.

With the ability to upload firmware, the problem quickly becomes writing new open source firmware, or at least porting existing firmwares; there are a few people across the internet trying to reverse engineer the board schematic from the PCB. Once that’s done, it should be a trivial matter to make the Da Vinci an open device, and teaching a lesson to every company that thinks they can sell a closed device in what is ultimately an open ecosystem.

The Phidgets Solar Powered Weather Station

May 11, 2014 by Brian Benchoff 14 Comments

weather

Yes, it’s a weather station, one of those things that records data from a suite of sensors for a compact and robust way of logging atmospheric conditions. We’ve seen a few of these built around Raspberry Pis and Arduinos, but not one built with a Phidget SBC, and rarely one that has this much thought put in to a weather logging station.

This weather station is designed to be autonomous, logging data for a week or so until the USB thumb drive containing all the data is taken back to the lab and replaced with a new one. It’s designed to operate in the middle of nowhere, and that means no power. Solar it is, but how big of a solar panel do you need?

That question must be answered by carefully calculating the power budget of the entire station and the battery, the size of the battery, and the worst case scenario for clouds and low light conditions. An amorphous solar cell was chosen for its ability to generate power from low and indirect light sources. This is connected to a 12 Volt, 110 amp hour battery. Heavy and expensive, but overkill is better than being unable to do the job.

Sensors, including temperature, humidity, and an IR temperature sensor were wired up to a Phidgets SBC3 and the coding began. The data are recorded onto a USB thumb drive plugged into the Phidgets board, and the station was visited once a week to retrieve data. This is a far, far simpler solution than figuring out a wireless networking solution, and much better on the power budget.

Via embedded lab