Hackaday

Syndicate content Hackaday
Fresh hacks every day
ถูกปรับปรุง 2 hours 17 min ก่อน

Dumbing Down a Smart Switch

พฤ, 07/07/2016 - 15:00

Internet of Everything is the way to go for home automation these days. ITEAD makes an ESP-8266 switch that IoT-ifies your appliances. If you still have an ancient, 433 MHz style radio switch system, they even make one that does WiFi and 433 MHz. But if you’re too cheap to shell out for the dual-mode version, you can always add a $1 433 MHz radio yourself. Or at least, that’s what [Tinkerman] did.

Aside from the teardown and reverse-engineering of the WiFi-enabled switch, [Tinkerman] also flashed custom firmware into the switch’s ESP-8266, and worked it all into his existing home Node-RED framework. Now he’s got more possible ways to turn on his living-room lights than any person could possibly hope for!

If you want to get into this whole WiFi-based home automation game, you could do worse than to have a look at the series we ran on MQTT just a little while ago. Seeing [Tinkerman]’s Node-RED demo makes us think that we’ll have to give that a look for our home system as well.


Filed under: home hacks, wireless hacks

Hackaday Prize Entry: Open Source FFT Spectrum Analyzer

พฤ, 07/07/2016 - 12:00

Every machine has its own way of communicating with its operator. Some send status emails, some illuminate, but most of them vibrate and make noise. If it hums happily, that’s usually a good sign, but if it complains loudly, maintenance is overdue. [Ariel Quezada] wants to make sense of machine vibrations and draw conclusions about their overall mechanical condition from them. With his project, a 3-axis Open Source FFT Spectrum Analyzer he is not only entering the Hackaday Prize 2016 but also the highly contested field of acoustic defect recognition.

For the hardware side of the spectrum analyzer, [Ariel] equipped an Arduino Nano with an ADXL335 accelerometer, which is able to pick up vibrations within a frequency range of 0 to 1600 Hz on the X and Y axis. A film container, equipped with a strong magnet for easy installation, serves as an enclosure for the sensor. The firmware [Ariel] wrote is an efficient piece of code that samples the analog signals from the accelerometer in a free running loop at about 5000 Hz. It streams the digitized waveforms to a host computer over the serial port, where they are captured and stored by a Python script for further processing.

From there, another Python script filters the captured waveform, applies a window function, calculates the Fourier transform and plots the spectrum into a graph. With the analyzer up and running, [Ariel] went on testing the device on a large bearing of an arbitrary rotating machine he had access to. A series of tests that involved adding eccentric weights to the rotating shaft shows that the analyzer already makes it possible to discriminate between different grades of imbalance.

The HackadayPrize2016 is Sponsored by:








Filed under: The Hackaday Prize

Making A Networked 32X32 LED Panel Case

พฤ, 07/07/2016 - 09:00

[Adam Haile] of [Maniacal Labs] is at it again, whipping up some LED weirdness. This project is smaller than most of his work, though: he has made a nice case that holds a 32X32 LED matrix screen, the controller, and a Raspberry Pi. Check out the build and a brief demo in the video below.

This nice 3D printable design, called the Jumbo1K, would be a good starting point if you are looking to make something with one of these screens, as it provides easy access to all of the ports on the Pi for programming, debugging and networking the device without ruining the look. It does this with a neat trick, using the keystone jacks that you put in your wall when you are rewiring your house.

[Adam] usually works on a larger scale than this, creating displays with thousands of LEDs.


Filed under: led hacks

Cheap and Effective Dune Buggy Wheel Chair

พฤ, 07/07/2016 - 06:00

[masterfoo]’s mother-in-law suffers from a bad hip which would have sidelined her participation in the Fourth of July festivities. As a testament to the power of family and ingenuity, [masterfoo] built her a beach-capable wheel chair to give her some off-roading capability.

The frame is built out of 1.5″ PVC piping and the tires are 20×8-8″ inner tubes for ride-on lawnmowers. The lawnmower  wheel inner tubes were cost-effective and fit the purpose, saving the need for the more expensive purpose-built-for-the-beach Wheeleez tires. They also have a fluid inside that plugs small punctures which will come in handy against he beach’s small cacti and other flora. This video was their guide for the foam insulation and plywood wheel assembly, also employing the handy man’s secret weapon to protect the tube from the rim’s plywood edge. Check it out in action!

The canvas was secured to the PVC with E6000 multi-surface, fabric-and-plastic super glue and some needlework in a double-layered, reclined setup for comfort and redundancy. The final touches were a platform for a small cooler, a beach umbrella to keep the sun off, and cup holders for both passenger and pusher.

All in all a wonderful build from the heart, and it only cost $140! If you’re on the lookout for other low-cost beach vehicles, why not a motorized hammock?

[via /r/DIY]


Filed under: misc hacks

Paper Tape Drive for a Live Performance Music Box

พฤ, 07/07/2016 - 03:00

Music is a mystery to some of us. Sure, we know what we like when we hear it, but the idea of actually being able to make it baffles us. And the idea of being able to build new instruments to create it, like this paper-tape programmable music box (YouTube, embedded below), is beyond impressive.

You’ll no doubt remember [Martin Molin] of the group “Wintergatan” and his astounding marble madness music machine. This instrument is on a much more modest scale and is centered around an off-the-shelf paper tape music box. But the cheap plastic drive gears kept failing under performance conditions, so [Martin] headed to what appears to be his cave-based workshop and started grinding. He prototyped a new paper drive from Lego Technics, and while it worked, it needed help to pull the paper. What followed was an iterative design process that culminated in a hybrid of plastic and metal Technic parts that drive the paper reliably, and a musical instrument that’s much more than just a tinny wind-up music box. Hear it in action below with another new instrument, the Modulin, which sounds a little like a Theremin but looks like – ah, just watch the video.

The build video hints at more details to come, and we’re hoping for a complete series like that for the marble machine. We’d also love to see details on the Modulin too – if there ever was a hacked musical instrument, that’s it.


Filed under: musical hacks

LuaRadio Brings More Options to SDR

พฤ, 07/07/2016 - 01:31

GNURadio is the swiss-army-knife of software-defined radio suites: it does everything and anything. It has a great GUI overlayer that makes creating radio flows fairly simple. There are only two areas where we could quibble with the whole system — it’s a gigantic suite of software, and it’s a lot harder to code up in Python than it is to use the GUI.

[Vanya Sergeev] started up his LuaRadio project to deal with these shortcomings. If you’re looking for the full-GUI experience, you’re barking up the wrong tree here. LuaRadio is aimed at keeping things easy to code and keeping the codebase small and tidy.

That doesn’t mean that it departs entirely from GNURadio’s very successful flow-graph programming paradigm, however, and if you’re comfortable with the procedure of hooking up a signal source to a filter block to an output, you’ll be doing fine here as well. Check out the obligatory FM radio demo — the “hello world” of SDR — and you’ll see how it works: instantiate the various blocks in code, and then issue “connect” commands to link them together.

LuaRadio’s main selling points are its size and the ease of programming it by hand. It’s got great documentation to boot. It’s written as a library that’s embeddable in your C code, so that you can write standalone programs that make use of its functionality.

LuaRadio is a new project and it doesn’t have a GUI either. It may not be the ideal introduction to SDR if you’re afraid of typing. (If you are new to SDR, start here.) But if you want to code up your SDR by coding, or run your radio on smaller devices, it’s probably worth a look. It’s at v0.1.1, so we’re looking forward to hearing more from LuaRadio in the future. Any of you out there use it? We’d love to hear in the comments.


Filed under: radio hacks

A Pi Robot Without a Hat

พฤ, 07/07/2016 - 00:01

Daughter boards for microcontroller systems, whether they are shields, hats, feathers, capes, or whatever, are a convenient way to add sensors and controllers. Well, most of the time they are until challenges arise trying to stack multiple boards. Then you find the board you want to be mid-stack doesn’t have stackable headers, the top LCD board blocks the RF from a lower board, and extra headers are needed to provide clearance for the cabling to the servos, motors, and inputs. Then you find some boards try to use the pins for different purposes. Software gets into the act when support libraries want to use the same timer or other resources for different purposes. It can become a mess.

The alternative is to unstack the stack and use external boards. I took this approach in 2013 for a robotics competition. The computer on the robots was an ITX system which precluded using daughter boards, and USB ports were my interface of choice. I used a servo controller and two motor controllers from Pololu. They are still available and I’m using them on a rebuild, this time using the Raspberry Pi as the brain. USB isn’t the only option, though. A quick search found boards at Adafruit, Robotshop, and Sparkfun that use I2C.

This approach has challenges and benefits. A stack of daughter boards makes a neat package, where external boards makes a tangle of wires. Random sizes can make mounting a challenge. Providing power can also be a hassle because of the random placement of power pins. You can’t rely on USB power, especially from a Raspberry Pi whose USB is power limited.

On the other hand, external boards can offload processing from your main processor. Once a command is sent, these boards handle all the details including refresh requirements. They are likely to provide capabilities beyond the microcontroller software libraries since their processors are dedicated to the task.

I am using an 18-channel board from the Pololu Maestro Servo Controller family of boards that control from 6 to 24 servos using a single board. You might find the Adafruit 16 channel I2C board a useful alternative. For motor control I turned to the Pololu Simple Motor Controller family using one that will handle 18 amps. Others will handle from 7 to 25 amps. Or consider the Sparkfun Serial Controlled Motor Driver. Another source for USB controllers is Phidgets. I experimented with one of their spatial devices for the original robot. I should have used it to measure the tilt since one of my robots rolled over on a hill. Ooops!

Servo Control

The board currently installed on my robot is the Mini Maestro 18. The Maestro provides control over the servo speed, acceleration and movement limits. A home position can be set for startup or when errors occur. You can even do scripting or set movement sequences to play on command.

On the hardware side, the Maestro also allows channels to be used for digital input or output, and some channels for analog input. On some there is one channel for pulse width modulation output. An onboard regulator converts the servo power input to the voltage needed by the processor, simplifying part of the power distribution challenge.

My previous robot used the Maestro to control pan and tilt servos for camera positioning, a servo to lift samples from the ground, and a safety LED. Two analog inputs from current sensors on the motors helped avoid burnout during stalls, and four inputs from a simple RF key fob transmitter provided control. The latter came in handy for testing. I’d program a test sequence such as starting a 360° camera scan for landmarks or drive onto the starting platform and drop the sample. A button press on the key fob would initiate the activity. One button was always set up as an emergency halt to stop a rampaging robot. The rebuild is following this pattern with some additions.

Motor Controller

The two Simple Motor Controllers (SMC) each handled the three motors on either side of the Wild Thumper chassis. The SMC does more than just control the motor speed and direction. You can set acceleration, braking, and whether forward and reverse operate at the same or different speeds. The board monitors a number of error conditions for safety. These stop the motor and prohibit movement until cleared. Such blocking errors include lost communications, low input voltage, or drivers overheating.

An additional capability I found extremely helpful is the ability to read signals from a radio control (RC) receiver. These signals can be used to control the motor and, with some cross wiring between two controllers, provide differential drive control. This is useful for driving the robot to a new location using an RC transmitter. I didn’t use the RC inputs directly. Instead I read the RC inputs and issued the control commands from my program. This let me monitor the speed in my program logs for correlation with the other logged data. I also used an input to command the robot into autonomous or RC control operations. There are also two analog inputs that can be used to directly control the motor and can be read through commands.

Serial Communications

USB ports were my choice for communications but there is also a TTL level serial port with the standard RX and TX pins. This port can be used by the Raspberry Pi, Arduino, or any other microcontroller that has a TTL serial port.

The Maestro boards using USB appear as two serial ports. One is the command port that communications with the Maestro processor. The other is a TTL port. This port can serve as simply a USB to TTL serial port converter to allow communications with other boards, even from another vendor. Another use of the TTL port is to daisy chain Pololu boards. I could attach the SMC boards in this manner and save two USB ports for other devices. These boards support this by having a TXIN pin that ANDs the TX signal from the connected board with the TX on the board.

Both of these controllers support a few different communications protocols. I use the one Pololu created and is available on some of their other products. The command details are different between the boards, but the basic command structure is the same. They call it their binary protocol, and the basic format follows:

0xAA, <device address>, <command>, <optional data>, <crc>

All the fields are single bytes except for the data field which is frequently 2 bytes to transmit 16-bit data. The returned data is only one or two bytes with no additional formatting. Note they provide for detecting errors in the message by using a CRC (cyclical redundancy check). This is probably not critical over USB but a TTL line might receive noise from motors, servos, and other devices. A CRC error sets a bit in the error register that can be read if the command is critical.

I wrote my own code, C++ of course, for the PC and converted it just now to the Raspberry Pi. The main change is the different serial port code needed by Linux and Windows. Pololu now provides Arduino source for the protocol making it easy to use these boards with that family of controller boards.

Wrap Up

The chassis, Pi, and these boards are now installed on the Wild Thumper chassis along with a pan and tilt controlled by servos. A safety LED is on when power is applied and flashes when the robot is actively controlling the system. A LiPo battery powers all but the Pi because I need to configure a battery eliminator circuit to provide five volts. I’m powering it temporarily using a USB battery pack.

A test program, cross compiled from my desktop, moves the robot forward, pivots left than right, and then reverses. The pan / tilt moves and the LED flashes. I originally used a web camera for vision processing but will switch to the Pi camera since it is better. The Neato lidar discussed in a previous article will soon find a place onboard, along with an accelerometer to detect possible rollovers.

I’m sure I could have done this using Pi daughter boards despite the challenges I mentioned earlier. There are trade-offs to both approaches that need to be considered when working on a project. But there is one final advantage to the external boards: they have a lot of twinkly LEDs.

Product photos from Pololu.


Filed under: Arduino Hacks, Featured, Raspberry Pi, robots hacks

42,300 Transistor Megaprocessor Is Complete

พุธ, 07/06/2016 - 22:31

As it turns out, the answer is not 42, it’s 42.3 — thousand. That’s how many discrete transistors spread across the 30 m2 room housing this massive computation machine. [James Newman’s] Megaprocessor, a seriously enlarged version of a microprocessor, is a project we’ve been following with awe as it took shape over the last couple of years.

[James] documented his work in great detail, and by doing so, took us on a journey through the inner workings of microprocessors. His monumental machine is now finished, and it’s the ultimate answer to how a processor – and pretty much everything that contains a processor – works.

8 bytes of Megaprocessor RAM (ca. 200 x 200 mm)

Everyone of the ~42,400 transistors were hand-soldered to one of the massive PCBs, which look more like interactive circuit diagrams than actual circuit boards. This incredible amount of discrete transistors makes up the thousands of logic gates that eventually form the Megaprocessor’s registers, its arithmetic logic unit, its sequence control and also: its 256 bytes of RAM. Each logic gate displays the current IO state through LEDs, which also turns the RAM into a gigantic LED wall on which you can play Tetris.

Despite its complexity, the Megaprocessor is pretty much self-documenting. [James] mounted all PCBs on large frames, which add up to a 10m long and 2m tall “computation display”. Detailed diagrams show the information flow between the functional blocks – and through the room. At full throttle, it runs at about 8 kHz clock frequency, but to follow the execution of a single instruction you can just turn it down to 1 Hz, or even stop the processor to study its state.

[James] wasn’t always sure how many transistors the build would eventually require since it was hard to predict how many 8 Byte RAM cells – which consist of 766 transistors and 64 LEDs each – a single human can solder before the madness kicks in. It has not been easy, it has not been cheap — but it’s an idea that haunted [James] for more than a decade now, and it’s amazing to see it finished. Enjoy the video where [James] takes you on a tour through the machine:

It seems that building discrete processors is all the rage this days. Just a couple of months ago we got a good look at a 6502 processor faithfully recreated with individual transistors.


Filed under: computer hacks

Build A 3D Printer Workhorse, Not an Amazing Disappointment Machine

พุธ, 07/06/2016 - 21:01

3D printers have become incredibly cheap, you can get a fully workable unit for $200 – even without throwing your money down a crowdfunded abyss. Looking at the folks who still buy kits or even build their own 3D printer from scratch, investing far more than those $200 and so many hours of work into a machine you can buy for cheap, the question “Why the heck would you do that?” may justifiably arise.

The answer is simple: DIY 3D printers done right are rugged workhorses. They work every single time, they never break, and even if: they are an inexhaustible source of spare parts for themselves. They have exactly the quality and functionality you build them to have. No clutter and nothing’s missing. However, the term DIY 3D printer, in its current commonly accepted use, actually means: the first and the last 3D printer someone ever built, which often ends in the amazing disappointment machine.

This post is dedicated to unlocking the full potential in all of these builds, and to turning almost any combination of threaded rods and plywood into a workshop-grade piece of equipment.

Taming Shaky Frames

The age of the shaky Mendel threaded rod frame is long over, it has been replaced by the age of shaky single-sheet Prusa i3 frames. Decent printing results require a darn sturdy frame, so add brackets and stabilizers wherever you can.

If you’re building a cube-style printer from aluminum extrusion, use angle brackets to stabilize the frame. If you’re building a Prusa i3 variant, make sure you’re either getting a frame with stabilizers or add stabilizers later. If you’re building a classic Mendel, add stabilizer boards to the cross struts.

Facing 3D printed parts

PLA is a horrible material choice for the 3D-printed portion of a DIY 3D printer, first for it’s low melting point, and second for its brittleness. Almost any material will perform better, but at least ABS parts can last forever. Print them really hot – at least 255 °C to get a good layer adhesion and they will never fail on you. Nevertheless: Always keep a set of spares, because you can. It needn’t be a 3-pack.

Yet, the absolute accuracy and surface quality of 3D printed parts isn’t generally as polished as the aluminum extrusion and sheet materials they attach to. When you attach a 3D printed part to a flat surface using screws, you have basically two options to get a solid connection: Make the screws very tight – which almost always breaks the 3D printed part – or use a fine grit sandpaper to flatten the contact surface of the 3D printed part to get a good contact between the two. Once the screws apply a reasonable amount of pressure, the static friction between the two surfaces takes over and provides a high resistance to shearing forces.

Drive systems

In conjunction with a rigid frame, both belt drives in various configurations (except for the H-bot) and spindle drives can achieve a repetitive accuracy that exceeds the requirements of FDM in the X and Y direction by magnitudes. However, the quality and longevity of any drive system depends a lot on the quality of the involved components. Eccentric pulleys or couplings, as well as components that introduce backlash, are the most common pitfalls here. Grinding belt teeth can cause vibrations, so make sure all belts are running in the center of their pulley and idler tracks. Use flanged idlers or at least washers to prevent the belts from rubbing against other parts of the printer.

For the Z-axis, it’s worth mentioning that the quality improvement you may expect from a stepper motor with integrated ACME lead screw shaft over the common threaded-rod-on-a-flex coupling solution is pretty insignificant – even in terms of longevity. Stainless steel M5 threaded rods in the Z-axis allow for great printing results and last for many years, even when exposed to the steady stress of auto bed leveling. In this case, the budget solution may be good enough. Of course, large and heavy printer assemblies do indeed require proper leadscrews.

Linear guides

As long as your build doesn’t exceed the typical size and weight of a desktop 3D printer, avoid using linear ball bearings in the X and Y axis, as they are a very common failure point. Their quality varies greatly depending on the manufacturer, and even if the cheap shot works seemingly great in the beginning, they won’t last for long. 3D printed plastic debris and even fragments of their own assembly will sooner or later cause them to block. Tribological, polymeric slide bearings are the way to go here. They are self-lubricating, maintenance-free and virtually last forever, at least by the standards of linear ball bearings. They are also available in Japan standard compatible form factors as drop-in replacements for the commonly used LM8UU.

Don’t use multiple linear bearings in line to increase the angular stability of a carriage. There are prolonged versions available for almost every linear bearing type , for example, use the LM8LUU form factor instead of two LM8UU.

Motors and drivers $3 difference, double printing resolution

Even if you’re on a budget, think about using stepper motors with a 0.9° step angle instead of 1.8° for the X and Y axis and for any ungeared extruder. They will probably cost you $2 or $3 more a piece, but they double your mechanical resolution, which can be extremely visible. Microstepping is great for reducing vibrations, but – contrary to popular belief – does not increase the effective printing resolution. The following images of Yoda heads show the quality difference quite clearly. They are printed at 0.1 mm layer height on the very same Prusa i3 from the very same G-Code — the only difference is the physical step angle of the motors.

 

It’s a dirty hack, but it’s better than driving two motors from a single driver.

The rated current of your stepper motor drivers must be able to deliver the rated current of the stepper motors, as the stepper motors will only deliver their full torque at that current. Leave a margin of 20% to prevent constantly maxing out your drivers. Even if some retailers ship Pololu-style driver modules (i.e. A4988 and DRV8825) with (wrong-sized) heatsinks and thermal adhesive pads (of questionable quality), these heatsinks usually do more harm than good. Leave them out and stick to the 20% current margin, and you will always get the full torque.

Besides that, don’t wire multiple stepper motors to a single driver, especially the tiny Pololus. If you can’t get your hands on a proper port duplicator with buffer capacitors for each driver, a cheap and fully useable workaround is soldering female headers to one Pololu driver, add male headers for the motors, and backpack a second on top of it.

Controller Board

The particular choice of 3D printer controller board mostly depends on your individual requirements in terms of pure functionality. If you want a plug and play machine that works every time in any environment, avoid clones of Arduino based boards or other products that use cheap usb-to-serial bridge replacements, such as the CH340/CH341. They may eventually work, but long term plug-and-play driver support for all major operating systems might be something that’s worth paying for since it eventually becomes part of the user experience.

Thermistors And Thermocouples

Know your components and only use temperature sensors that come with a trustworthy datasheet. Otherwise, the measured temperature will just be a slightly better guess. Make sure the sensor has a good thermal coupling to the heated bed or hotend heater block to allow the temperature controller to keep the temperature steady. Thermal compound is the way to go here. NTC Thermistors typically don’t survive temperatures above 300° C required to print some engineering plastics, you’re locked in with thermocouples. Besides that, whether you measure the temperature of the heated bed and hotend with an EPCOS NTC, a Vishay NTC, a Semitec NTC or a welded tip K-type thermocouple does not necessarily matter, they are all accurate enough.

LCD Controllers ReprapDiscount SmartController (by Reprapdiscount, image source)

An LCD controller with SD-card reader turns your 3D printer into a stand-alone factory. The classic RepRap Discount SmartController with a non-graphical display will absolutely do for most configurations. There are clones around that work just fine when used with the provided RAMPS adapter, but some of them have their connector column flipped 180°, so pay attention when you hook them up to boards with dedicated EXT ports for the display panel, such as the RUMBA.

The click-and-scroll menu most firmwares provide for the common LCD controllers may be a bit cluttered and dissatisfactory to use, but that can be fixed quite easily and we’ll cover that later in this post.

OctoPrint

A Raspberry Pi loaded with OctoPrint, maybe even with an LCD touchscreen, greatly improves the usability and productivity over the sparse LCD controller. It lets you send G-Code directly from the slicer to the printer over the air and allows you to conveniently control your printer through a pleasant user interface. However, it does add several failure points to the machine. While the SPI connection between the SD card and the microcontroller is pretty much bullet proof, you will almost certainly experience a frozen Raspberry Pi or a hung OctoPrint sooner or later. It’s still rare, but if you are using OctoPrint to stream G-code to the printer, make sure you add

M85 S30; activate 30-second idle timeout

at the very beginning of your start G-code to activate the idle timeout and

M85 S0; deactivate idle timeout

at the very end of the end G-code to deactivate it again. The 30-second timeout will kill the printer and shut off all heaters in case the OctoPrint host freezes or otherwise stops sending commands before the print finishes as scheduled.

Hotend

ABS layer bonding at 280° printing temperature is strong as hell and makes printing large, tough ABS models without cracking and warping on the first attempt a breeze. Full metal hotends are the way to go here, as PEEK insulators and PTFE liners that reach down to the melting zone start degenerating at much lower temperatures. So, use a full metal hotend and at least a 40W cartridge for fast heatup time. Make sure the hotend sits rock-solid in it’s mount on the print head.

Extruder

Bowden extruders do have a certain backlash, but that’s not necessarily a problem when printing ABS, PLA and Nylon. Yet, the 1.75 mm variants of flexible materials such as (insert distinctive term here)Flex are pretty much incompatible with Bowden extruders and at best extremely troublesome. If you’re planning to work with these, use a direct drive extruder. Even when using a direct drive extruder, make sure the filament is delivered to the extruder through a Bowden tube that is safely attached to a tube fitting on the spool holder. Setups, in which an extruder on a flimsy linear guide pulls the material right off the spool typically deliver poor results as the pulling force unpredictably deflects the print head during the print.

Go for hardened steel and sharp teeth. The MK8 drive gear and the black hobbed bolt shown above are just examples. Most regular hobbed bolts (right) wear out after the first meters and suffer from filament slip.

Most 3D printed extruder assemblies, such as Wade’s extruder or AirTripper’s Bowden extruder work just as well as the more expensive ones you can buy. The most important factor for the consistency and reliability of the extrusion is the drive gear. Go for a high-quality, hardened steel drive gear or hobbed bolt, with sharp teeth and good grip.

Heated Bed

Long heat up times are a productivity killer, and to reach the temperature fast – within 3 minutes or so, a regular PCB heated bed needs to have a power density of about 1+ W/cm2 (6.5 W/in2). To reach 110° (230 °F) under normal conditions at all, a heated bed should deliver a minimum power density of about 0.3 W/cm2 (2 W/in2). If you want to print materials like ABS, that require a high bed temperature, take the necessary wattage of the heated bed relative to its size into account.

Single sided PCB heated beds tend to breathe up and down, due to the non-uniform thermal expansion of the copper traces and the board material, which can result in a surface finish that is affected by banding patterns. The animation shows the issue quite clearly:

Single-sided PCB heated bed (left) / Double-sided PCB-heater (right)

Since high-quality prints rely on a Z-positioning accuracy in the tens of microns, even minor temperature fluctuations can cause a single sided PCB heater to introduce unwanted artifacts. Use double sided PCB heaters or other alternatives that don’t suffer from this issue (i.e. silicone heater mats attached to a solid slate of aluminum), along with a well-tuned PID control loop.

Modern heated beds, such as the Prusa MK42, achieve a more uniform temperature distribution by compensating non-uniform heat losses with a non-uniform power density, which helps a lot with making large structures stick to the build plate in its corners. In any case, always use a thermal cutoff fuse attached directly to the center of the bottom side of the heated bed.

Thermal image of legacy Prusa MK2B (left) and new Prusa MK42 (right) (by Josef Prusa, image source)

The heated bed must be mounted rock-solid to the frame or carriage it rests on. Don’t use loose adjustment screws with wobbly springs to mount them, as they will seriously affect the printing quality. Ideally, bolt the heated bed down as straight as possible and use auto bed leveling for the fine adjustment.

Enclosed build chamber

Enclosing your printer in a box prevents draft and the retained heat allows you to print larger objects from ABS with fewer distortions. The enclosure itself can be anything from a large enough box or a beautiful acrylic printarium. As long as the heat stays inside, it will just work. Keep the electronics of your printer outside the heated build chamber to prevent overheating of the motor drivers and power supply. Mind that actively heated build chambers also require actively cooled hotend-heatsinks.

Dual enclosed build chamber with glass sliding doors from a $50 OSB terrarium, because, why not?

Don’t add insulation material to the underside of your heated bed, since it decreases the overall heat output. Passively heated build chambers without excessive insulation can easily reach about 40° C or more, just by retaining the heat from the heated bed. Keep maintenance easy by making sure the enclosure can be removed without disassembling the whole thing, and well, a door would be nice. In any case, avoid draft. When printing ABS and HIPS, even an improvised enclosure or just a little cabinet is better than none at all.

Printing Surface

Regular window glass plates or mirrors are indeed able to withstand high temperatures, but at 110° C the slightest impact lets them shatter. If you print on glass, which works great for materials like PLA and PET(-G), use borosilicate glass. For printing ABS, HIPS, and also PLA, a Polyetherimide (PEI) printing surface is rightfully celebrated as the best option. ABS sticks to it rock-solid during the print, and still just pops off afterward. HIPS and PLA work just as well.

From right to left: 1/8″ glass fiber reinforced PEI plate, 1/4″ Garolite plate, Prusa MK2 heated bed, Makertum MK1 heated beds

However, not only is PEI an expensive material with kilogram prices in the hundreds of dollars, it is also in low supply, which led to increased use of thin PEI adhesive films. These films do offer the same great adhesion and printing experience but are quite fragile and easily get damaged. For heavy workshop use, use a 1/8“ PEI sheet instead. It might be slightly more expensive but will last forever and can even be re-faced on a CNC mill once it shows wear. For an even printing surface, the PEI sheet must be stabilized, preferably by gluing it to a sheet of borosilicate glass or aluminum with the help of a heat resistant transfer adhesive tape.

Don’t use heated aluminum printing plates with only a thin film of PEI or Kapton on them. The high heat conductivity of the aluminum overshoots the goal of keeping the contact layer at temperature and heats through the entire print object to a point where it usually gets too soft to support itself.

It’s worth mentioning that the best known printing surface for Nylon is still Garolite (aka. Tufnol). Nylon adheres well to it and even larger Nylon parts can be printed reliably on Garolite.

Auto Bed Leveling / Automated Mesh Bed Leveling

While the classic servo-deployed probe always worked somewhat good enough, the most versatile, accurate and reliable sensor type for auto bed leveling is the contactless capacitive distance switch. Many builds, especially ones with a metal build plate (i.e. the Prusa MK42) or carrier, still use inductive sensors, but these sensors ignore non-metallic printing surfaces (such as a sheet of glass, PEI or Garolite) and only respond to the underlying metal sheet. While this can, of course, be accounted for with an offset, that offset is rarely constant and uniform. Besides that, all contactless distance switches have a certain accuracy, typically about 10% relative to an adjustable trigger distance. Mount them with a short trigger distance, ideally 1 or 2 mm, to get the maximum accuracy. Of course, any sensor needs to be mounted rock-solid to the print head for accurate probings.

Firmware

There are several great firmware projects out there, with the most celebrated ones being Marlin and Repetier. Marlin and Repetier have quite different approaches when it comes to their configuration. Marlin clones from a GitHub repository with two well documented and commented configuration files, one for the basics and one for the advanced settings. Repetier in contrast uses a website that lets you compose your firmware settings in a graphical web interface and download the pre-configured sources. These sources also contain configuration files, but they aren’t quite as well documented as Marlin’s counterpart.

When it comes to features and functionality, Marlin offers fewer features, but a rock-solid highly configurable and reliable platform worthy of a workhorse 3D printer. In contrast, Repetier offers many experimental features, including but not limited to virtual extruders for color mixing. It’s the ideal firmware for exploring the frontiers of more exotic 3D printing applications. Although, not all of its plentiful features are always well documented, which is bound to cause trouble if you’re just looking for something clean and reliable for workshop use.

Temperature Control Algorithms

Only a steady temperature lets you print high-quality models without banding and artifacts. A simple bang-bang temperature control switch does not provide the necessary temperature stability. The easiest and best way to achieve a steady hotend and heated bed temperature is a PID control loop, and both Marlin and Repetier offer that option. They also offer a PID autotune program, which will iron out any ripple in your temperature curve without compromising heat up times or overshooting too much. Repetier also offers an alternative dead time control algorithm, which in many cases works just as well. However, the accuracy and effectiveness of a dead time control loop depend on the ratio of effective dead time and the polling/update interval of the control loop. This results in poor temperature stability on high-power heating elements that happen to have a dead time in the tens of milliseconds. Just use PID.

Cluttered LCD controller menus

The standard Marlin or Repetier firmware with activated display support makes almost every control option available through the scroll-and-click menu. It’s complete, but also cluttered, and lets you navigate through four levels before you can move an axis.

The Marlin menu (simplified, by open-electronics.org, CC-BY-SA, image source)

For workshop use, only a fraction of the entries are actually required. Just remove unnecessary entries in the firmware source code. In the source of Marlin, that can be easily done by commenting out unnecessary items in the rather self-explaining ultralcd.cpp.

/* DISABLING "CONTROL" MENU MENU_ITEM(submenu, MSG_CONTROL, lcd_control_menu); */

You can also simplify the move menu to skip the feed rate selection:

/* DISABLING ORIGINAL MOVE MENU static void lcd_move_menu() { START_MENU(); MENU_ITEM(back, MSG_PREPARE); if (_MOVE_XYZ_ALLOWED) MENU_ITEM(submenu, MSG_MOVE_10MM, lcd_move_menu_10mm); MENU_ITEM(submenu, MSG_MOVE_1MM, lcd_move_menu_1mm); MENU_ITEM(submenu, MSG_MOVE_01MM, lcd_move_menu_01mm); //TODO:X,Y,Z,E END_MENU(); } */ // ADDING CLUTTER-FREE MOVE MENU static void lcd_move_menu() { START_MENU(); move_menu_scale=0.1; MENU_ITEM(back, MSG_PREPARE); if (_MOVE_XYZ_ALLOWED){ MENU_ITEM(submenu, MSG_MOVE_X, lcd_move_x); MENU_ITEM(submenu, MSG_MOVE_Y, lcd_move_y); MENU_ITEM(submenu, MSG_MOVE_Z, lcd_move_z); } END_MENU(); } Fire Prevention

It’s rare, but 3D printers can catch fire. Use the safety features provided by the firmware, but don’t solely rely on them. Both plain MOSFETs and solid state relays typically fail in their conducting state, which can result in runaway heating with disastrous outcomes. Thermal cutoff fuses are $1 components, but they are well able to prevent a runway heated bed from turning your workshop into a crater.

This $1 component is priceless. Use thermal cutoff fuses. External Factors Uninterruptible Printing

If your mains power line is unsteady, or if highly inductive power equipment happens to be turned on in the same workshop – cheap handheld plasma cutters for instance – it’s a good idea to operate your printer from an UPS (uninterruptible power supply). Even a short power failure during the printing process ruins the print, and a small cheap UPS will help you out in that case.

Filament Quality

Apparently, making great filament is a little more complex than feeding pellets into a heated something with an auger. It requires accurate measurements and a closed feedback loop to actually keep the tolerances low. Filament defects I found in cheap, low-quality filaments range from trapped air bubbles, variations in properties, color, and diameter. I even found a spool of ABS that faded into PLA half-way through. All this does not contribute to reliable high-quality printing, and if half of the prints fail, it’s not even cheap. So make sure you get a good filament that benchmarks your machine’s capabilities.

The Extra Mile

One great advantage of DIY printers is maintenance. The availability of spare parts and documentation makes it possible, but it should also be fun to work on the machine. Tidy wiring, cable guides as well as a consistent color code for voltages and signals across the printer will save you a lot of time, frustrations, and magic smoke as soon as you need to revisit the internals of your machine a year or two after you initially built it.

I hope you enjoyed this compilation of learnings from more than 20 unique 3D printer builds. Most open source projects maintain a detailed assembly manual but miss out on the details that make a machine a great, reliable, and fun-to-use piece of workshop equipment. The article has grown long, but hopefully fills enough of the gaps to turn any DIY 3D printer project into a success. It’s also bound to be incomplete, so add your own findings in the comment section!


Filed under: 3d Printer hacks, Engineering, Hackaday Columns, slider

Using The Vive’s Lighthouse With DIY Electronics

พุธ, 07/06/2016 - 18:01

The HTC Vive is the clear winner of the oncoming VR war, and is ready to enter the hallowed halls of beloved consumer electronics behind the Apple Watch, Smart Home devices, the 3Com Audrey, and Microsoft’s MSN TV. This means there’s going to be a lot of Vives on the secondhand market very soon, opening the doors to some interesting repurposing of some very cool hardware.

[Trammell Hudson] has been messing around with the Vive’s Lighthouse – the IR emitting cube that gives the Vive its sense of direction. There’s nothing really special about this simple box, and it can indeed be used to give any microcontroller project an orientation sensor.

The Vive’s Lighthouse is an exceptionally cool piece of tech that uses multiple scanning IR laser diodes and a bank of LEDs that allows the Vive to sense its own orientation. It does this by alternately blinking and scanning lasers from left to right and top to bottom. The relevant measurements that can be determined from two Lighthouses are the horizontal angle from the first lighthouse, the vertical angle from the first lighthouse, and the horizontal angle from the second lighthouse. That’s all you need to orient the Vive in 3D space.

To get a simple microcontroller to do the same trick, [Trammell] is using a fast phototransistor with a 120° field of view. This setup only works out to about a meter away from the Lighthouses, but that’s enough for testing.

[Trammell] is working on a Lighthouse library for the Arduino and ESP8266, and so far, everything works. He’s able to get the angle of a breadboard to a Lighthouse with just a little bit of code. This is a great enabling build that is going to allow a lot of people to build some very cool stuff, and we can’t wait to see what happens next.


Filed under: Virtual Reality

Seeing the Truly Invisible with DIY Shortwave UV Imaging

พุธ, 07/06/2016 - 15:01

We’ve all seen how to peel IR filters off digital cameras so they can see a little better in the dark, but there’s so much more to this next project than that. How about being able to see things normally completely outside the visual spectrum, like hydrogen combustion or electrical discharges?

[David Prutchi] has just shared his incredible work on making his own shortwave ultraviolet viewers for imaging entirely outside of the normal visible spectrum – in other words, seeing the truly invisible. The project has not only fascinating application examples, but provides detailed information about how to build two different imagers – complete with exact part numbers and sources.

If you’re thinking UV is a broad brush, you’re right. [David Prutchi] says he is most interested in Solar Blind UV (SBUV):

Solar radiation in the 240 nm to 280 nm range is completely absorbed by the ozone in the atmosphere and cannot reach Earth’s surface…

Without interference from background light, even very weak levels of UV are detectable. This allows ultraviolet-emitting phenomena (e.g. electrical discharges, hydrogen combustion, etc.) to be detectable in full daylight.

There is more to the process than simply slapping a UV filter onto a camera, but happily he addresses all the details and the information is also available as a PDF whitepaper. [David Prutchi] has been working with imaging for a long time, and with his sharing of detailed build plans and exact part numbers maybe others will get in on the fun. He’s also previously shared full build plans for a Raspberry Pi based multispectral imager, [David’s] DOLPHi Polarization Camera was a finalist in the 2015 Hackaday Prize, and he spoke at the Hackaday SuperConference about the usefulness of advanced imaging techniques for things like tissue analysis in medical procedures, and landmine detection for the purposes of cleaning up hazardous areas.


Filed under: digital cameras hacks, video hacks

Hackaday Prize Entry: Cheap, Open LiDAR

พุธ, 07/06/2016 - 12:00

[adam] is a caver, meaning that he likes to explore caves and map their inner structure. This is still commonly done using traditional tools, such as notebooks (the paper ones), tape measure, compasses, and inclinometers. [adam] wanted to upgrade his equipment, but found that industrial LiDAR 3D scanners are quite expensive. His Hackaday Prize entry, the Open LIDAR, is an affordable alternative to the expensive industrial 3D scanning solutions out there.

The 3D scan of a small cave near Louisville from [caver.adam’s] Sketchfab repositoryLiDAR — Light Detection And Ranging —  is the technology that senses the distance between a sensor and an object by reflectively measuring the time of flight of a light beam between the two. By acquiring a two-dimensional array of multiple distance readings, this can be used for 3D scanning. Looking at how the industrial LiDAR scanners capture the environment using fast spinning mirrors, [adam] realized that he could basically achieve the same by using a cheap laser range finder strapped to a pan and tilt gimbal.

The gimbal he designed for this task uses stepper motors to aim an SF30-B laser rangefinder. An Arduino controls the movement and lets the eye of the sensor scan an object or an entire environment. By sampling the distance readings returned by the sensor, a point cloud is created which then can be converted into a 3D model. [adam] plans to drive the stepper motors in microstepping mode to increase the resolution of his scanner. We’re looking forwards to see the first renderings of 3D cave maps captured with the Open LIDAR.

The HackadayPrize2016 is Sponsored by:








Filed under: The Hackaday Prize

Niklas Roy’s Music Construction Machine

พุธ, 07/06/2016 - 09:01

If you think of a music box, the first image that might come to mind is that of a small tabletop device with a simple mechanism and a single instrument. Usually a row of chimes triggered by points etched on a roller. If you are a bit more ambitious maybe you thought of a player piano with a roll of perforated paper carrying a tune, but yet again with only the single voice of one instrument.

[Niklas Roy] however has a different vision when it comes to mechanical music. He’s created an entire ensemble with real musical instruments, a drum kit, keyboard, and electric guitar. His Music Construction Machine is no simple music box with a single tune though, it generates a constantly changing melody through a mechanically implemented algorithm with a complex interaction of cyclic variables that periodically alternate between harmonic and discordant. Unfortunately we can’t find any audio examples of the installation at work.

There is a timeliness to this post, the machine is part of an art installation at the Goethe-Institut Pop Up Pavillion on the Nowy Targ square in Wrocław, Poland, and it will be exhibited until the 10th of July. We hope some of our Central European readers will be within range and can make the trip. If you do, we’d love to hear some sample audio from your visit.

We’ve featured [Niklas]’s work many times before here at Hackaday. Just a few highlights are a past musical project powered by water, God on the CB radio, and his all-terrain mobile beer crate.


Filed under: musical hacks

Build A Circular Aerofoil Kite

พุธ, 07/06/2016 - 06:00

[Waalcko] fell in love with kites when he was 13 years old. He saw a NASA Para Wing kite fly and couldn’t get it out of his head. Now, years later, he shares how to build a circular foil kite design he came up with.

We’re all particular about our chosen hobbies. Some of us like one design direction and hate another. For [Waalcko], he really hates internal supports in kites. When he spied a single line kite in a circular foil configuration he was enraptured, but the design had those hideous spars. So, he got to work and pushed himself to the limit coming up with a kite that was a circular foil, flew with one line, and had no internal supports.

His instructable is a great read and goes into deep detail about the basics of kite construction. (After reading it we’re certain that even the shallows have depths when it comes kites.) It goes through the terminology used when talking about kits, the techniques used to assemble them, the common problems, and more.

Many hours later, if all goes well, one should end up with a really cool kite.


Filed under: misc hacks

A 150MHz 6502 Co-Processor

พุธ, 07/06/2016 - 03:00

If you are familiar with ARM processors, you may know of their early history at the 1980s British home computer manufacturer Acorn. The first physical ARM system was a plug-in co-processor development board for Acorn’s BBC Micro, the machine that could be found in nearly every UK school of the day.

For an 8-bit home computer the BBC Micro had an unusually high specification. It came with parallel, serial and analog ports, built-in networking using Acorn’s proprietary Econet system, and the co-processor interface used by that ARM board, the Tube. There were several commercial co-processors for the Tube, including ones with a 6502,  a Z80 allowing CP/M to be run, and an 80186.

As with most of the 8-bit generation of home computers the BBC Micro continues to maintain a strong enthusiast following who have not stopped extending its capabilities in all directions. The Tube has been interfaced to the Raspberry Pi, for instance, on which an emulation of original co-processor hardware can be run.

And thus we come to the subject of this article, [Hoglet] and [BigEd]’s 150MHz 6502 coprocessor for the BBC Micro. Which of course isn’t a 6502 at all, but a 6502 emulated in assembler on an ARM which is in a way the very distant descendant of the machine it’s hosted upon. There is something gloriously circular about the whole project, particularly as the Pi, like Acorn, the BBC Micro, and modern-day ARM, has its roots in Cambridge. How useful it is depends on your need to run 8-bit 1980s software in a tearing hurry, but they do report it runs Elite, which if you were there at the time we’re sure you will agree is the most important application to get running on a BBC Micro.

We’ve featured the Tube interface before when we talked about an FPGA co-processor with a PDP/11 mode that was definitely never sold by Acorn. And we’ve also featured an effort to reverse engineer the primordial ARM from that first BBC Micro-based co-processor board.

BBC Micro image: Stuart Brady, Public Domain, via Wikimedia Commons.


Filed under: classic hacks, computer hacks, Raspberry Pi

The Future Of Eagle CAD

พุธ, 07/06/2016 - 00:01

Last week, Autodesk announced their purchase of CadSoft Eagle, one of the most popular software packages for electronic design automation and PCB layout.

Eagle has been around for nearly thirty years, and has evolved to become the standard PCB design package for electronic hobbyists, students, and engineering firms lead by someone who learned PCB design with Eagle. The reason for this is simple: it’s good enough for most simple designs, and there is a free version of Eagle. The only comparable Open Source alternative is KiCad, which doesn’t have nearly as many dedicated followers as Eagle.  Eagle, for better or worse, is a standard, and Open Source companies from  Sparkfun to Adafruit use it religiously and have created high-quality libraries of parts and multiple tutorials

I had the chance to talk with [Matt Berggren], former Hackaday overlord who is currently serving as the Director of Autodesk Circuits. He is the person ultimately responsible for all of Autodesk’s electronic design products, from Tinkercad, 123D, Ecad.io, and project Wire, the engine behind Voxel8, Autodesk’s 3D printer that also prints electronics. [Matt] is now the master of Eagle, and ultimately will decide what will change, what stays the same, and the development path for Eagle.

Eagle Licenses

Eagle is famous for the free version of its software. 20 years ago, in the days of Protel and other expensive EDA and electronic design packages, Eagle always had a limited freeware version. Arguably, this is the reason for Eagle’s popularity; a free educational version means schools can use it, and those students will enter the workforce with a desire to use what they already know. A freeware version of Eagle means electronics hobbyists can design their own PCBs at home, using the same tools used by professionals. The freeware version is not going away.

Aside from a freeware version, buying the correct license for Eagle was not easy. Last week, Eagle had five versions available, with different combinations of add ons like the Schematic, Layout, and Autorouter. Each version had limitations on the number of schematic sheets, signal layers, and routing area. For a single user license, there were almost fifty different options, all with different prices.

Now there are only six Eagle products. The commercial licenses range from one schematic sheet, two signal layers, and a 100x80mm routing area to the Ultimate license with 16 signals and a four meter square routing area. For non-commercial licenses, the free educational edition features 99 schematic sheets, six signal layers, and a 160x100mm routing area. This is Eagle getting with the times; a freshly minted engineer must know how to lay antennas on the board, impedance controlled feed lines, DDR routing, how to break out huge BGAs, and everything else a multi-layer board enables.

The big question when it comes to Autodesk licenses is an auspicious cloud looming on the horizon. The Internet is a thing, and now software phones home. Altium’s Circuit Maker is inexorably tied to this cloud, and locks your designs up in an online vault. Will the same be true of Autodesk’s Eagle?

Eagle will, of course, be integrated with other Autodesk products – the entire point of Autodesk buying Eagle is for full-stack hardware development, from mechanical design to electronic. Whether this means Eagle will become a subscription-only model is still up in the air, but from the casual observer’s position it’s doubtful; there are still perpetual licenses of Eagle out there, and right now that’s what Autodesk is selling.

The most common (and dreaded) error in EAGLE New Features

Despite being a near-standard when it comes to PCB design, there are a ton of features Eagle doesn’t have. To do a design or electrical rule check on a project, you have to press a button – it doesn’t happen automatically. There’s going to be a long, hard look at live DRC and ERC. Autodesk is also “Definitely going to take a close look at routing.” Whether this means push and shove routing, dragging traces around, or anything else the newest version of KiCad does exceptionally well is up in the air, but it must be noted Eagle is now Autodesk’s premier EDA suite.

What does [Matt] have planned that he can say to the press? Eagle’s core, mostly – hierarchy, modularity, mechanical integration (in keeping with integration with other Autodesk products), and revision management. Whether this means the dreaded F/B Annotation has been severed! notification will finally disappear is still up in the air, but one can only hope.

With a new direction comes possible changes to the UI. A decade and a half ago, installing Autocad on a machine would quickly wear off the lettering on your escape key. More modern CAD packages, such as Autodesk Fusion and Inventor are much simpler. Interfaces, even for the most complex pieces of software, have gotten simpler, and there’s no reason Eagle’s baroque UI couldn’t use a few updates.

That said, there is a lot of history in the Eagle UI. It has been around since before Windows 3.1. Some people love it, and any changes to the UI of a beloved program will be met with bricks through windows. A few slight tweaks wouldn’t hurt, though, and keyboard shortcuts are an obvious addition.

Autodesk’s Play For The Future Of Design

Autodesk’s acquisition of Eagle didn’t happen in a vacuum. In 2014, Autodesk bought Circuits.io, an electronic design software that, like Fritzing, is based around the solderless breadboard paradigm. Despite being easily compared to Fritzing, Circuits.io has some fairly advanced capabilities including simulation of breadboarded circuits. It’s not a SPICE simulation, but you can’t look at something like this and not see the future of electronic design.

Circuits.io, Tinkercad, and Autodesk’s series of 123D apps are their play at the Maker market. Yes, you can design a simple circuit and have it do real work, but you’re not going to implement an FPGA or anything designed for EMC compliance with these tools.

When it comes to Serious Business™, Autodesk’s portfolio of electronic design software has been severely lacking. There’s a reason for this: Altium has been working on the problem for several decades, it’s still not perfect. KiCad is old enough to vote, and there are still problems. Eagle, too, is almost thirty years old. Building EDA suites and PCB design software is hard, and possibly the hardest single domain of software development. Autodesk simply can’t spin their own electronic design software and expect it to be good. Eagle was already there, Premier Farnell was selling stuff off, and Autodesk’s purchase of Eagle should come as no surprise.

What this purchase does mean is integration into the rest of Autodesk’s offerings. Already, you can use Autodesk products to build a six-speed transmission, a house, and a spaceship. The addition of Eagle means you can also build a credit card sized ARM dev board. The path forward is to integrate all these capabilities under one roof; you’ll be able to design the electronics for a portable video game console, and take that board file and build an enclosure around it.

On a personal note

I’ve been using Eagle for years now. I’ve known it was a fairly limited tool, and I’ve known about KiCad. I know I need a better electronic design tool. The question I ask myself is, “do I want to spend the time and effort to learn KiCad, when all I really need to do right now is design a simple board that would take an hour in Eagle?”

This is the reason people don’t use better software packages: I know Eagle, and in the time it would take to learn KiCad, I could finish the project I’m working on, make a sandwich, take a nap, and get my boards in the mail. Yes, it’s lazy, but Eagle is good enough.

With the new direction for Eagle, I believe I will never have to learn KiCad. Eagle is about to get good – really good – and I can’t wait to see the first Eagle release under the Autodesk banner.


Filed under: Hackaday Columns, Interviews

The Sunday Morning Breakfast Machine

อังคาร, 07/05/2016 - 22:31

Breakfast is a meal taken very seriously indeed by Brits. So seriously that continual attempts have been made to perfect the experience mechanically. Who could not delight to be woken up by a Teasmade alarm clock delivering a fresh cup of hot beverage, and where else would the getting out of bed sequence in Wallace and Gromit be, not the comedic animated film, but a documentary?

Latest in a long line of British builders of mechanical morning repast generators are [Peter Browne] and [Mervyn Huggett]. Working from a garden shed – where else! – in Sussex, they have spent three months and a thousand man hours creating their “Sunday Morning Breakfast Machine“, designed to cook and serve a slice of toast and a boiled egg alongside a cup of tea or coffee and the morning paper. Prototyping was done in Meccano , could there be any other medium for a machine like this one?

The machine itself is a mix of the practical and the whimsical. The giant-sized facsimile of a vintage Ever Ready battery and the toy rooster hide some pretty accomplished metalwork and control systems. They do admit that the primary purpose is to make people laugh, but it does the job, albeit with what looks like a leak from a cracked egg.

A full description from [Peter] is in the video below the break.

This isn’t the first breakfast machine to feature on these pages, our pair of British pensioners have been pipped to the post by a team from Japan. The quest to perfect the British breakfast has been featured with the help of workshop tools though, but as is so often the case when it comes to food it’s the French who steal the crown with their automatic crêpe machine.

Thanks [Niklas] for the tip [via Huffington Post].


Filed under: cooking hacks

Don Eyles Walks Us Through the Lunar Module Source Code

อังคาร, 07/05/2016 - 21:01

A couple weeks ago I was at a party where out of the corner of my eye I noticed what looked like a giant phone book sitting open on a table. It was printed with perforated green and white paper bound in a binder who’s cover looked a little worse for the wear. I had closer look with my friend James Kinsey. What we read was astonishing; Program 63, 64, 65, lunar descent and landing. Error codes 1201, 1202. Comments printed in the code, code segments hastily circled with pen. Was this what we thought we were looking at? And who brings this to a party?

We were looking at what is rumored to be the only remaining paper copy of the Lunar Module’s source code . This is the source code book used by Don Eyles during Apollo missions and for development. Don was responsible for writing code for the Lunar Module, specifically about 2000 lines that actually landed man on the moon. He turned up at the MIT Faculty Club in June and brought this original print out along, in its own suitcase of course.

How it works

Both the Apollo Command Module (CM) and Lunar Module (LM) were humankind’s first fly-by-wire aircraft. This means that the human does not actually fly it manually by stick, the computer is the one that controls the throttle, thrusters, gimbals (which are servo motors that control the direction of the larger thrusters), in real-time. This was done by necessity. Humans could not fly these spacecraft manually especially the LM during descent, which was very unstable.

One Page Per Millisecond

The core of the system was the Apollo Guidance Computer (AGC). Part real-time OS, part National Instruments Data Acquisition System, the AGC was a multi-threaded computer & feedback control system in communication with everything from radars, to telescopes, to gyroscopes and accelerometers controlling massive space engines and performing all tasks in real-time. Numerous programs shared CPU cycles, an executive program kept track and prioritized it all. You can read about it for yourself, the best book on this topic is Digital Apollo.

Don graciously took us through a tour of the code where he explained problems with various missions and how they were solved in the code. One example was an issue with LM descent engine’s frequency responses. The manufacturer did not specify an accurate transfer function for the engine’s throttle causing the system to be unstable. Remember, this is a feedback control system, this would be equivalent to not knowing the frequency response in the output circuit of an op-amp.

The error codes I mentioned earlier (1201, 1202 and etc.) were famously displayed during Apollo 11’s landing. These made Neil Armstrong very nervous during the last portion of the lunar landing. Don explained that these errors were due to leaving the docking radar on by accident. Unfortunately this scenario was never simulated or practiced on the ground.

The docking radar was sending numerous interrupts to the processor taking away precious cycles which caused the AGC to warn Neil Armstrong that it was over-taxed and that it would cease any non-essential programs. Essential programs, like flying and maintaining stability of the LM and navigation remained, non-essential programs like updating the DSKY were paused.

Although the picture in the video below can be a choppy at times, hear what Don has to say is where it shines. In addition to the examples above, he mentions so many interesting details like the rule of thumb during code development; each page of code takes about 1ms of CPU time. In this clip Dana Yoerger is asking most of the questions.

The Seventies: Weird-Looking Freak Saves Apollo 14!

Don was a rebel working for the military industrial complex knowing that he served a greater purpose which was to help land humankind on another world for the first time. This 1971 Rolling Stone piece provides a fascinating perspective of what motivated hackers like Don in the late 60’s.

It is truly spectacular to run into engineers from these world-changing projects and to hear what they have to say. If you are one such engineer, or can connect us with one, please don’t hesitate to reach out using the article tips line.

Very Heavy Source Code

I did not hide my enthusiasm for this history lesson. I think it was for this reason that Don asked if I wanted to carry the code back to his car. He was joking, but I took him up on the chance to handle artifact that will be sealed behind glass and displayed at a museum sooner or later. The source code was very heavy, I had to switch arms about three times over a journey of only two city blocks.

From left to right; James Kinsey, Dana Yoerger, Don Eyles, Gregory L. Charvat. In the foreground, possible the last paper copy of the Lunar Module source code.

Like many involved with the Apollo program Don is very personable, kind, will not brag about himself, and is hesitant to take credit. This is a refreshing attitude in an era of reality television and self-promotion. We’ll learn more soon, keep an eye out for Don’s book due to be published within the next year or so.

Author Bio: Gregory L. Charvat takes every opportunity to learn from those who were involved with the Apollo program. Greg’s author bio can be found here.


Filed under: Featured, History, news, slider

Retrotechtacular: How Solidarity Hacked Polish TV

อังคาร, 07/05/2016 - 18:01

In the 1980s, Poland was under the grip of martial law as the Communist government of General Wojciech Jaruzelski attempted to repress the independent Solidarity trade union. In Western Europe our TV screens featured as much coverage of the events as could be gleaned through the Iron Curtain, but Polish state TV remained oblivious and restricted itself to wholesome Communist fare.

In September 1985, TV viewers in the city of Toruń sat down to watch an action adventure film and were treated to an unexpected bonus: the screen had a brief overlay with the messages “Solidarity Toruń: Boycotting the election is our duty,” and “Solidarity Toruń: Enough price hikes, lies, repression”. Sadly for the perpetrators, they were caught by the authorities after their second transmission a few days later when they repeated the performance over the evening news bulletin, and they were jailed for four months.

The transmission had been made by a group of dissident radio astronomers and scientists who had successfully developed a video transmitter that could synchronise itself with the official broadcast to produce an overlay that would be visible on every set within its limited transmission radius. This was a significant achievement using 1980s technology in a state in which electronic components were hard to come by. Our description comes via [Maciej Cegłowski], who was able to track down one of the people involved in building the transmitter and received an in-depth description of it.

Transmission equipment seized by the Polish police.

The synchronisation came courtesy of the international effort at the time on Very Long Baseline Interferometry, in which multiple radio telescopes across the world are combined to achieve the effect of a single much larger instrument. Before GPS made available a constant timing signal the different groups participating in the experiment had used the sync pulses of TV transmitters to stay in time, establishing a network that spanned the political divide of the Iron Curtain. This expertise allowed them to create their transmitter capable of overlaying the official broadcasts. The police file on the event shows some of their equipment, including a Sinclair ZX Spectrum home computer from the West that was presumably used to generate the graphics.

There is no surviving recording of the overlay transmission, however a reconstruction has been put on YouTube that you can see below the break, complete with very period Communist TV footage.

We’ve looked across the Iron Curtain a few times before here at Hackaday, once examining the world of 1980s Communist home computers, and again with the story of a daring escape from East Germany.

Thanks [gnif] for the tip.


Filed under: classic hacks, radio hacks, Retrotechtacular

Data Exfiltration With Broadcast Radio And CD-ROM Drives

อังคาร, 07/05/2016 - 15:01

The first music played on personal computers didn’t come out of fancy audio cards, or even a DAC. the first audio system in a personal computer was simply holding an AM radio up to the case and blinking address pins furiously. This worked wonderfully for homebrew computers where EMC compliance hadn’t even become an afterthought, but the technique still works today. [Chris] is playing music on the radio by sending bits over the system bus without using any wires at all.

[Chris]’ code is based on the earlier work of [fulldecent], and works pretty much the same. To play a sound over the radio, the code simply writes to a location in memory when the waveform should be high, and doesn’t when the waveform is low.

Of course the ability to exfiltrate information over an airgap has a few more nefarious purposes, but [Chris] also has another way of doing just that which is undefeatable by a TEMPEST shielded computer. He can send one bit at a time by opening and closing a CD-ROM drive, capturing these bits with a webcam. Is it useful? It’s hard to imagine how this setup could ever capture any valuable data, but it is a proof of concept.


Filed under: security hacks