Ask Hackaday: How Do You Draw Schematics?

The lingua franca of electronic design is the schematic. I can pick up a datasheet written in Chinese (a language I do not read or speak) and usually get a half-decent idea of what the part is all about from the drawings. Unfortunately, even as my design experience has grown over the years, I haven’t quite learned to think in schematics — I need to see it on paper (or on a screen) to analyze a circuit. Whether it’s literally on the back of an envelope or sketched in the condensation on the shower stall, actually drawing a design or idea makes a huge difference in being able to understand it. And, if you’ve ever tried to explain a circuit without a schematic — in an on-line forum or over the phone, for instance — you know how difficult it is.

So, given the importance of the schematic for design and communication, you’d think choosing a tool to draw them would be an easy task. Not so. There are dozens of choices, from dedicated schematic drawing programs to using the schematic-capture facilities of simulation or PCB design tools, or even old-fashioned pencil-and-paper and its modern equivalents. Each one has its pros and cons, and may be better suited to one specific application, but you have to choose something.

So, readers of Hackaday, what do you use to convey your electronic design ideas to the world?

Continue reading “Ask Hackaday: How Do You Draw Schematics?”

A 3D Printed Blooming Rose For (Next) Valentines Day

Inspiration runs on its own schedule: great ideas don’t always arrive in a timely manner. Such was the case with [Daren Schwenke]’s notion for creating a 3D-printed blooming rose for his valentine, a plan which came about on February 13. Inspired by [Jiří Praus]’s animated wireframe tulip, [Daren] figured he could make a rose from clear printed petals colored by RGB LEDs. 24 hours seemed tight but sufficient, so he diligently set to work, but – after a valiant effort – finally had to extend the schedule. It’s now more than a month later, and tweaks to the design continue, but the result is nothing short of spectacular.

We first saw a discussion of the idea over on Hack Chat, and followed as it evolved into a project on hackaday.io. There, you can read the full details of the trials and tribulations that had to be endured to make this project happen. From a printer that wouldn’t boot, through testing PLA, TPU, and nylon filament, trying a number of different approaches for springs and hinges to operate the petals, and wiring the delicate DotStar LEDs with magnet wire, you can get a really good sense of the amount of experimentation it takes to complete a project like this. If you know anyone who still thinks 3D printing is as easy as clicking a button, send them over to read the logs on this project.

An early try at forming PLA petals

What finally materialized is a terrific combination of common hacker technologies. The petals are printed flat in nylon, then formed over a hot incandescent chandelier bulb. The stem and leaves are also printed, but the side stem has a piece of magnet wire embedded in the print as a capacitive touch sensor; when the leaf is touched, the rose blossom opens or closes. Magnet wire for the LEDs and a connecting rod for the mechanics run through the main stem to the base, where a 9g servo is responsible for controlling the bloom. The whole thing is controlled, naturally, with an Arduino. To move the project along a little more quickly, [Daren] enlisted the help of another Hack Chat denizen, [Morning.Star], who did an amazing job on the software without any access to the actual hardware.

Be sure to check out the video of the rose in action, after the break.

Continue reading “A 3D Printed Blooming Rose For (Next) Valentines Day”

A DIY Slip Roll On The Cheap

When you need to roll sheet or thin flat bar stock into an arc, you need a rolling machine, also known as a slip roll. If you’ve priced these lately, you’ll know that they can be rather expensive, especially if you are only going to use them for one or two projects. While building a fenced enclosure for his dog, [Tim] realized he could use steel fence posts and connectors to build his own slip roll for much less, and posted a video about it on his YouTube channel.

The key realization was that not only are the galvanized posts cheap and strong, but the galvanized coating would act as a lubricant to reduce wear, especially when augmented with a bit of grease. The build looks pretty straightforward, and a dedicated viewer could probably re-create a similar version with little difficulty. The stock fence connectors serve double-duty as both fasteners and bushings for the rollers, and a pair of turnbuckles supplies tension to the assembly.

The one tricky part is the chain-and-sprocket linkage which keeps the two bottom rollers moving in tandem. [Tim] cut sprockets from some plate steel with his plasma cutter, but mentions that similar sprockets can be found cheaply online and only need to be modified with a larger hole. Although most of the build is held together with set screws in the fence post fittings, the sprockets appear to be welded to the galvanized pipe. We’re sure [Tim] knows that welding galvanized steel can lead to metal fume fever, so we were hoping the video would caution viewers to remove the zinc coating on those parts before welding.

[Tim] demonstrates forming some 4 mm flat steel into circles, and the operation seems easy enough, especially given the inexpensive nature of this build. Overall, this seems like the sort of thing we could see ourselves trying on a lazy Saturday afternoon – it certainly seems like more fun than building a fence with the parts, so be sure to check out the video, after the break.

Continue reading “A DIY Slip Roll On The Cheap”

Do You Know Where Your Drone is Headed? HJWYDK Article Explores Limits of MEMS Sensors

Knowing in what absolute direction your robot is pointed can be crucial, and expensive systems like those used by NASA on Mars are capable of calculating this six-dimensional heading vector to within around one degree RMS, but they are fairly expensive. If you want similar accuracy on a hacker budget, this paper shows you how to do it using cheap MEMS sensors, an off-the-shelf motion co-processor IC, and the right calibration method.

The latest article to be published in our own peer-reviewed Hackaday Journal is Limits of Absolute Heading Accuracy Using Inexpensive MEMS Sensors  (PDF). In this paper, Gregory Tomasch and Kris Winer take a close look at the heading accuracy that can be obtained using several algorithms coupled with two different MEMS sensor sets. Their work shows that when properly used, inexpensive sensors can produce results on par with much more costly systems. This is a great paper that illustrates the practical contributions our community can make to technology, and we’re proud to publish it in the Journal.

Continue reading “Do You Know Where Your Drone is Headed? HJWYDK Article Explores Limits of MEMS Sensors”

Make XKCD-Style Plots From Python

[Randall Munroe] certainly understands the power of graphical representation of data. The humorous plots in his xkcd webcomic are one of the favorite parts for many readers. Their distinctive, Tufteian style delivers the information – in this case, a punch line – without excessive decoration. To be honest, we can’t get enough of them. A recent reddit thread reminded us that you can generate a similar look for your own data (humorous or otherwise) in Python using Matplotlib.

If you already have a plot generated with Matplotlib, activating xkcd-mode is as simple as calling a method on the pyplot object:

matplotlib.pyplot.xkcd()

The documentation recommends that you install the “Humor Sans” font for best effect. On one of our linux boxes, we were able to do this with a simple:

sudo apt-get install fonts-humor-sans

There will undoubtedly be similar incantations for other operating systems. It’s really that simple. In fact, the featured image above was generated with this minimal script:

#!/usr/bin/env python3

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 1, 100)
y = (x > 0.5) * (x - 0.5)

plt.xkcd(scale=5, length=400)
plt.xticks([])
plt.yticks([])
plt.ylabel('Downloads of "humor sans" font')
plt.text(0, 0.25, 'Article on xkcd() published')
plt.plot(x, y)
plt.plot([0.3, 0.475], [0.2, 0.025], 'black')
plt.gca().set_aspect(2*9/16)
plt.savefig('xkcd_plot.png', dpi=300)

Beyond generating humorous graphs for those with little artistic talent, these plots can also be used instead of hand-drawn sketches to indicate a simple model or expected result. The comic look of the plots conveys the idea that they don’t represent actual data, perhaps only a concept. We saw this done at one of the talks at the Hackaday SuperConference 2018.

We’ve also covered some of the xkcd comics before, such as when they subtly dissed Arduino back in 2010, before that was cool.

Computer Algebra for Electronic Design

Don’t get me wrong. Like most people, there’s nothing I enjoy more than solving a long, involved math problem by hand. But, sometimes, a few pages of algebraic scratches on paper is just a means to an end. I find this especially true during electronic design sessions, be it circuit design or PCB layout; I just need the answer, and any time spent finding it distracts me from the larger task at hand. For me, at least, this seems to happen at least once a week, and about five years ago I decided to do something about it. I had heard of computer algebra packages, of course, but they weren’t taught as part of the undergraduate engineering curriculum when I went to school. So, I set about learning one: let the computers do the math!

The package I chose is wxMaxima, a document-based front-end to the Maxima computer-algebra system. Descended from code originally written in the late 1960s, it’s a general-purpose package supporting symbolic computation for algebra and calculus. There’s solid, mature code underneath with a modern UI veneer on top. Plus, it’s FOSS.

As I’ve progressed, I’ve found that some additional functions make the Maxima environment especially convenient for circuit design. A few are simple enough that I’d typically just re-create them as needed, so I never really got organized – there were several versions of my “library” floating around on various machines. I finally got my act together, cleaned up the most-frequently used functions, and put them into a GitHub repo.

Let’s have a look at how we can use them to take the tedium out of math for some design problems.

Continue reading “Computer Algebra for Electronic Design”

DIY X-Ray Machine Becomes CT Scanner

Once you’ve built your own X-ray machine to take 2D images of the insides of stuff, there’s really only one logical next step: building your own computed tomography (CT) scanner to get 3D reconstructions instead. That’s exactly what [Fran Piernas] has done, and documented over on hackaday.io. While the original X-ray machine build dealt with scary hardware stuff such as high voltage and ionizing radiation, this time it’s the turn of scary mathematics like inverse radon transforms.

The original build, which we wrote about in December, uses a commercial dental X-ray tube and a home-made 65 kV power supply to send X-rays through objects. Transmitted X-rays are viewed using an intensifying screen that converts the rays to visible light. The result is a 2D image similar to that we’re all familiar with.

To create a 3D reconstruction of an object, you need a number of X-ray images taken from different angles. If you’ve ever been unlucky enough to need a medical CT scan, you’ll remember staying motionless in the tunnel while the X-ray apparatus rotated around you. In this build, [Fran] rotates the object instead, using a motor that may have once been part of a microwave oven (one of those “mystery motors” we all have laying around). The required sequence of images is simply obtained by recording video of the X-ray screen while the motor rotates the object.

Continue reading “DIY X-Ray Machine Becomes CT Scanner”