Hackaday

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

A Cleverly Concealed Magnetic Loop Antenna

5 hours 50 minก่อน

We’re sure all radio amateurs must have encountered the problem faced by [Alexandre Grimberg PY1AHD] frequently enough that they nod their heads sagely. There you are, relaxing in the sun on the lounger next to the crystal-blue pool, and you fancy working a bit of DX. But the sheer horror of it all, a tower, rotator, and HF Yagi would ruin the aesthetic, so what can be done?

[Alexandre]’s solution is simple and elegant: conceal a circular magnetic loop antenna beneath the rim of a circular plastic poolside table. Construction is the usual copper pipe with a co-axial coupling loop and a large air-gapped variable capacitor, and tuning comes via a long plastic rod that emerges as a discreet knob on the opposite side of the table. It has a 10 MHz to 30 MHz bandwidth, and should provide a decent antenna for such a small space. We can’t help some concern about how easy to access that capacitor is, on these antennas there is induced a surprisingly large RF voltage across its vanes, and anyone unwary enough to sit at the table to enjoy a poolside drink might suffer a nasty RF burn to the knee. Perhaps we’d go for a remotely tuned model instead, for this reason.

[Alexandre] has many unusual loop projects under his belt, as well as producing commercial loops. Most interesting to us on his YouTube feed is this one with a capacitor formed from co-axial soft drink cans.

Thanks [Geekabit] for the tip.

TerraDome Gives Plants And Dinosaurs A New Home

8 hours 49 minก่อน

Housing exotic plants or animals offer a great opportunity to get into the world of electronic automation. When temperature, light, and humidity ranges are crucial, sensors are your best friend. And if woodworking and other types of crafts are your thing on top, why not build it all from scratch. [MagicManu] did so with his Jurassic Park themed octagonal dome built from MDF and transparent polystyrene.

With the intention to house some exotic plants of his own, [MagicManu] equipped the dome with an Arduino powered control system that regulates the temperature and light, and displays the current sensor states on a LCD, including the humidity. For reasons of simplicity regarding wiring and isolation, the humidity itself is not automated for the time being. A fan salvaged from an old PC power supply provides proper ventilation, and in case the temperature inside the dome ever gets too high, a servo controlled set of doors that match the Jurassic Park theme, will automatically open up.

[MagicManu] documented the whole build process in a video, which you can watch after the break — in French only though. We’ve seen a similar DIY indoor gardening project earlier this year, and considering its simple yet practical application to learn about sensors, plus a growing interest in indoor gardening itself (pun fully intended), this certainly won’t be the last one.

Your Own Sinclair Scientific Calculator

11 hours 49 minก่อน

We’ve talked about the Sinclair scientific calculator before many times, and for some of us it was our first scientific calculator. If you can’t find yours or you never had one, now you can build your own using — what else — an Arduino thanks to [Arduino Enigma]. There’s a video, below and the project’s homepage on Hackaday.io describes it all perfectly:

The original chip inside the Sinclair Scientific Calculator was reverse engineered by Ken Shirriff, its 320 instruction program extracted and an online emulator written. This project ports that emulator, written in Javascript, to the Arduino Nano and interfaces it to a custom PCB. The result is an object that behaves like the original calculator, with its idiosyncrasies and problems. Calculating PI as arctan(1)*4 yields a value of 3.1440.

Special care was taken in the design of the emulator to match the execution speed of the
original calculator, which varies from acceptable to atrocious for trigonometric functions involving small angles.

Oddly, the calculator started life as a hack on the KIM-1 UNO. However, six board revisions changed the layout quite a bit and made the emulation more and more accurate both software-wise and physically. If you fancy a close look at an original Sinclair we subjected one to a teardown.

The KIM-1 UNO board has had a lot of life poured into it. We used it as a clock and an 1802 emulator. Oscar even built off of the 1802 code to add video output.

The History and Physics of Triode Vacuum Tubes

14 hours 49 minก่อน

The triode vacuum tube might be nearly obsolete today, but it was a technology critical to making radio practical over 100 years ago. [Kathy] has put together a video that tells the story and explains the physics of the device.

The first radio receivers used a device called a Coherer as a detector, relying on two tiny filaments that would stick together when RF was applied, allowing current to pass through. It was a device that worked, but not reliably. It was in 1906 that Lee De Forest came up with a detector device for radios using a vacuum tube containing a plate and a heated filament. This device so strongly resembled the Fleming Valve which John Fleming had patented a year before, that Fleming sued De Forest for patent infringement.

After a bunch of attempts to get around the patent, De Forest decided to add a third element to the tube: the grid. The grid is a piece of metal that sits between the filament and the plate. A signal applied to the grid will control the flow of electrons, allowing this device to operate as an amplifier. The modification created the triode, and got around Fleming’s patent.

[Kathy]’s video does a great job of taking you through the creation of the device, which you can watch after the break. She also has a whole series on the history of electricity, including a video on the Arc Transmitter which we featured previously.

Linear Track Makes Plasma Cuts Neat And Simple

17 hours 49 minก่อน

No microcontroller, no display, and not even an LED in sight. That’s how [Made in Poland] decided to roll with this motorized linear plasma cutter, and despite the simplicity it really gets the job done when there’s metal to be cut.

Plasma cutting makes slicing and dicing heavy stock a quick job, but it’s easy to go off course with the torch or to vary the speed and end up with a poor edge. This tool takes the shakes out of the equation with a completely homebrew linear slide fabricated from square tubing. A carriage to hold the plasma cutter torch moves on a length of threaded rod chucked into the remains of an old cordless drill. The original clutch of the drill removes the need for limit switches when the carriage hits either end of the slide, which we thought was a great touch. Simple speed and direction controls are provided, as is a connection in parallel with the torch’s trigger. One nice feature of the carriage is the ability to swivel the torch at an angle, making V-groove welds in thick stock a snap. No need for a complicated bed with sacrificial supports and a water bath, either — just hang the stock over the edge of a table and let the sparks fall where they may.

Simple is better sometimes, but a CNC plasma table may still be your heart’s desire. We understand.

Evolving the 3D Printed Linear Actuator

19 hours 20 minก่อน

Our open source community invites anyone with an idea to build upon the works of those who came before. Many of us have encountered a need to control linear motion and adapted an inexpensive hobby servo for the task. [Michael Graham] evaluated existing designs and believed he has ideas to advance the state of the art. Our Hackaday Prize judges agreed, placing his 3D Printed Servo Linear Actuator as one of twenty winners of our Robotics Module Challenge.

[Michael]’s actuator follows in the footstep of other designs based on a rack-and-pinion gear such as this one featured on these pages, but he approached the design problem from the perspective of a mechanical engineer. The design incorporated several compliant features to be tolerant of variances between 3D printers (and slicer, and filament, etc.) Improving the odds of a successful print and therefore successful projects. Beginners learning to design for 3D printing (and even some veterans) would find his design tips document well worth the few minutes of reading time.

Another useful feature of his actuator design is the 20mm x 20mm screw mounting system. Visible on either end of the output slider, it allows mixing and matching from a set of accessories to be bolted on this actuator. He is already off and running down this path and is facing the challenge of having too many things to share while keeping them all organized and usable by everyone.

The flexible construction system allows him to realize different ideas within the modular system. He brought one item (a variant of his Mug-O-Matic) to the Hackaday + Tindie Meetup at Bay Area Maker Faire, and we’re sure there will be more. And given the thoughtful design and extensive documentation of his project, we expect to see his linear servos adopted by others and appear in other contexts as well.

This isn’t the only linear actuator we’ve come across. It isn’t even the only winning linear actuator of our Robotics Module Challenge, but the other one is focused on meeting different constraints like compactness. They are different tools for different needs – and all worthy additions to our toolbox of mechanical solutions.

The HackadayPrize2018 is Sponsored by:





VCF East XIII: Another Day in Retro Paradise

20 hours 50 minก่อน

While the weather alternated between mist and monsoon for most of it, the thirteenth annual Vintage Computer Festival East was still a huge success. People came from all over the country, and indeed the world, to show off computers and equipment that was easily older than many of those in attendance. From 1980’s robots to recreations of the very first machines to ever carry the name “computer” as we understand it today, there were a dizzying array of fascinating exhibits to see for those who made the pilgrimage to the InfoAge Science Center in Wall, New Jersey. The people who own and maintain these technological touchstones were in many cases were just as interesting as the hardware they brought to show off; walking encyclopedias of knowledge about the particular piece of vintage gear that they’ve so lovingly shepherded into the modern day.

Through it all, save for a brief intermission to get chili dogs from the nearest WindMill, Hackaday was there. We got up close and personal with [Brian Stuart]’s impressive ENIAC emulator, listened to some ethereal chiptunes courtesy of [Bill Degnan]’s MITS Altair 8800, saw relics from the days when the “app store” needed stamps from [Allan Bushman]’s impressive colleciton, and got inspired by the [Alexander Pierson]’s somewhat more modern take on the classic kit computers of the 1970’s.

But those were’t the only things on display at the Vintage Computer Festival, not by a long shot. There were over 100 individual exhibits this year at VCF, and that doesn’t even include the workshops, classes, tours, or the daily keynote presentations. To say you get your money’s worth on the ticket is something of an understatement.

It’s fair to say that there’s no real substitute for seeing a show like this in person. But in addition to the aforementioned articles, a rundown (in no particular order) of some of the interesting exhibits and attractions from this year’s VCF is a decent consolation prize. If this piques your interest, we’d invite you to keep an eye out for the next Vintage Computer Festival. We’ll be there.

A Truck Computer, Sans Truck

Today we think of mobile computing as being a tablet, smartphone, or maybe even a laptop. But in 1956 when the United States Army made its request for a mobile computer, the goal was to build a computer that could be transported by truck to the front lines of a battlefield. Considering computers up to this point took up whole buildings, it was a fairly tall order.

In the end, Sylvania won the bid and built the “MOBIle DIgital Computer”, or MOBIDIC. The computer was housed in a thirty foot long trailer, and consumed so much energy that a second truck containing a generator had to follow it around. For good measure, two more vans were added to the convoy, one holding spare parts and another a repair shop. It was a far cry from your laptop as far as mobile computers go, but it was still pretty good for the era.

[Jeff Salzman] has been fascinated with the MOBIDIC for years, and is currently working on an emulator to bring its unique architecture back to life. As the MOBIDIC was designed at the Camp Evans Signal Laboratory, which is now the home of InfoAge and VCF East, there’s even talk of getting an old Army trailer and building a life-size exhibit to show visitors what it would have been like to work inside of MOBIDIC. At this point [Jeff] is still in the very early stages and was mainly presenting information on how the computer worked and his research, but it all sounds very promising. Definitely a project to keep an eye on.

Commodore 64 Photo Booth

There’s nothing like being in a room full of pre-1980 computers to remind you of just how far technology has come in what’s really an exceptionally short amount of time. Pretty much any exhibit at the show was a sharp contrast to the smartphones most of us now carry, but perhaps the most succinct of them was the “8-Bit Digital Portraits” table run by [Jeffrey Brace].

Using an old Panasonic CCTV camera, a Commodore 64, and a relatively rare product called “ComputerEyes”, [Jeffery] would take pictures of willing participants and then print them out on a Star NX-1000 dot matrix printer as a memento. For younger attendees, the whole process was something of a culture shock. With relatively high-end cameras in every smartphone on the market, we take for granted the ability to take a multi-megapixel image on a whim.

As an interesting aside, the person getting their picture taken by the Commodore when I stopped by the table was [John Sutley], whose work involving the restoration of vintage CRT monitors we’ve covered here on Hackaday before.

The BBS Experience

You can read about the heyday of bulletin board system (BBS), you can even “dial” into some modern ones over the internet, but there’s nothing quite like using a BBS on vintage hardware and at vintage speeds. Just in case anyone forgot what it was like actually sending messages on one of these systems back when they were all the rage, [Michael Lee] brought in some era appropriate hardware for attendees to use while chatting on the Diversi-Dial BBS.

An Apple IIe was running as the host, sporting Hayes MicroModems for connectivity. On the client side DEC VT-100 and 220 terminals were on hand, complete with acoustic couplers. Even for show-goers who were old experienced enough to have used dial-up connections or chatted on the original BBS were shocked to be confronted with the tech again after all these years. Watching messages get typed out character by character got more than a few chuckles from those in attendance. Nostalgia has a funny way of making things seem a lot better than they were.

VCF Museum

While the actual Vintage Computer Festival East only happens once a year at InfoAge, the Vintage Computer Federation maintains a computer museum there year round which contains an absolutely incredible amount of hardware. From the monstrous Univac 1219-B mainframe recovered from the U.S. Navy to essentially every significant desktop computers from the 80s and 90s, there’s really something for everyone in the collection.

Many of the desktop computers are powered up and can be used by visitors, though naturally under supervision by a staffer. Demonstrations are given for the mainframes, allowing those in attendance a chance to see these behemoths at work. Really a must-see collection if you’re interested in computer history and within reasonable distance of the Jersey shore.

Consignment Room

The consignment room was an absolute treasure trove, with a wide array of items and in some cases preposterously low prices. Those bringing their old hardware to get sold at VCF are obviously in it more to keep the stuff out of a landfill than they are to make a profit for themselves. Respect.

Like the rest of VCF, the consignment room featured an incredible number of things to check out, though there were some standouts. This HP 64000 Logic Development System, complete with crates of documentation and adapters for chips such as the Z80 and 8088 is a particularly good example of something you’re not likely to see anywhere else:

Not everything for sale was an old computer either. From classic gaming to test equipment, there were plenty of deals to be had.

Vendor Room

Not to be confused with the consignment area which was staffed by volunteers, the vendor room was were professional sellers had their wares on display. Here you could find newly manufactured kit computers and electronic gear. Even a few Raspberry Pis were spotted. The vintage hardware that was available in the vendor area was also a bit higher up the scale in terms of condition, but as expected, so to were the prices.

Garnering particular interest in the vendor area was the table for Corsham Tech, which was showing off a very slick KIM-1 clone, as well as new manufactured accessories for the original machine:

Looking Ahead

The Vintage Computer Festival East XIII was an amazing event, but like all good things, it too had to come to an end. But don’t despair, there’s more vintage computing where that came from. VCF East may be gone until next year, but VCF West will be taking place August 4th and 5th in Mountain View, California. If your next ideal system-upgrade is a paper tape reader, and you can get out to the somewhat less dreary side of the United States, we’d strongly recommend you check it out.

Beats an Extension Cord

ศุกร์, 06/22/2018 - 22:30

What does your benchtop power supply have that [Pete Marchetto]’s does not? Answer: an extension cord draped across the floor. How often have you said to yourself, “I just need to energize this doodad for a couple seconds,” then you start daisy chaining every battery in the junk drawer to reach the necessary voltage? It is not uncommon to see battery packs with a single voltage output, but [Pete] could not find an adjustable one, so he built his own and put it on Tindie.

Presumably, the internals are not going to surprise anyone: an 18650 battery, charging circuit, a voltage converter, display, adjustment knob, and a dedicated USB charging port. The complexity is not what intrigues us, it is the fact that we do not see more of them and still wind up taping nine-volt batteries together. [Editor’s note: we use one made from an old laptop battery.]

This should not replace your benchtop power supply, it does not have the bells and whistles, like current regulation, but a mobile source of arbitrary voltage does most of the job most of the time. And it’s what this build hasn’t got (a cord) that makes it most useful.

There’s RC2014 Life In The TMS9918A Display Chip Yet

ศุกร์, 06/22/2018 - 21:10

One of the outliers in the home computer wars of the early 1980s was the Texas Instruments TI99/4A. It may not have had the games library of its rivals and its TMS9900 processor may not have set the world on fire with its registers-in-RAM architecture, but its range of support chips included one whose derivatives would go on to delight subsequent generations. If you had an MSX or one of the 8 or 16-bit Sega consoles, the TMS9918A graphics chip provided the architecture that sat behind Sonic in his adventures.

A few decades later, there is still significant interest in this classic chip. [J.B. Langston] has an RC2014 retrocomputer, and wishing to play MSX demos upon it, has created a TMS9918A-based graphics card for the RC2014 bus. The success of the board hinges upon a circuit showing how to interface the 9918A to SRAM, and since it is mapped to the same ports as its MSX equivalent it should in theory be compatible with Z80 demos written for that platform. He’s already achieved some success with that aim, as can be demonstrated by the video we’ve placed below the break of the Bold MSX demo running on an RC2014.

The RC2014 has gained a significant following in the retrocomputer scene, and has appeared here many times. We reviewed an early model in 2016. Surprisingly though the TMS9918A has only appeared here once, as part of a homebrew 6809-based system.

Linux Fu: The Great Power of Make

ศุกร์, 06/22/2018 - 21:01

Over the years, Linux (well, the operating system that is commonly known as Linux which is the Linux kernel and the GNU tools) has become much more complicated than its Unix roots. That’s inevitable, of course. However, it means old-timers get to slowly grow into new features while new people have to learn all in one gulp. A good example of this is how software is typically built on a Linux system. Fundamentally, most projects use make — a program that tries to be smart about running compiles. This was especially important when your 100 MHz CPU connected to a very slow disk drive would take a day to build a significant piece of software. On the face of it, make is pretty simple. But today, looking at a typical makefile will give you a headache, and many projects use an abstraction over make that further obscures things.

In this article, I want to show you how simple a makefile can be. If you can build a simple makefile, you’ll find they have more uses than you might think. I’m going to focus on C, but only because that’s sort of the least common denominator. A make file can build just about anything from a shell prompt.

No IDE?

You may scoff and say that you don’t need a makefile. Your IDE builds your software for you. That may be true, but a lot of IDEs actually use makefiles under the covers. Even IDEs that do not often have a way to export a makefile. This allows you to more easily write build scripts or integrate with continuous release tools which usually expect a makefile.

One exception to this is Java. Java has its own set of build tools that people use and so make isn’t as common. However, it is certainly possible to use it along with command line tools like javac or gcj.

The Simplest Makefile

Here’s a simple makefile:

hello: hello.c

That’s it. Really. This is a rule that says there is a file called hello and it depends on the file hello.c. If hello.c is newer than hello, then build hello. Wait, what? How does it know what to do? Usually, you’ll add instructions about how to build a target (hello) from its dependencies. However, there are default rules.

If you create a file called Makefile along with hello.c in a directory and then issue the make command in that directory you’ll see the command run will be:

cc hello.c -o hello

That’s perfectly fine since most distributions will have cc pointing to the default C compiler. If you run make again, you’ll see it doesn’t build anything. Instead, it will report something like this:

make: 'hello' is up to date.

To get it to build again, you’ll need to make a change to hello.c, use the touch command on hello.c, or delete hello. By the way, the -n command line option will tell make to tell you what it will do without actually doing it. That’s handy when you are trying to figure out what a particular makefile is doing.

If you like, you can customize the defaults using variables. The variables can come from the command line, the environment, or be set in the makefile itself. For example:

CC=gcc CFLAGS=-g hello : hello.c

Now you’ll get a command like:

gcc -g hello.c -o hello

In a complex makefile you might want to add options to ones you already have and you can do that too (the number sign, #, is a comment):

CC=gcc CFLAGS=-g # Comment next line to turn off optimization CFLAGS+=-O hello : hello.c

In fact, the implicit rule being used is:

$(CC) $(CFLAGS) $(CPPFLAGS) hello.c -o hello

Note the variables always use the $() syntax by convention. In reality, if you have a single character variable name you could omit it (e.g., $X) but that may not be portable, so the best thing to do is always use the parenthesis.

Custom Rules

Maybe you don’t want to use the default rule. That’s no problem. The make program is a little bit of stickler for file format, though. If you start subsequent lines with a tab character (not just a few spaces; a real tab) then that line (along with others) will run like a script instead of the default rules. So while this isn’t very elegant, here’s a perfectly fine way to write our makefile:

hello : hello.c     gcc -g -O hello.c

In fact, you ought to use variables to make your rules more flexible just like the default ones do. You can also use wildcards. Consider this:

% : %.c $(CC) $(CPPFLAGS) $(CFLAGS) $< -o $@

This is more or less the same as the default rule. The percent signs match anything and the $< gets the name of the first (and in this case, only) prerequisite which is hello.c. The $@ variable gives you the name of the target (hello, for this example). There are many more variables available, but these will get you started.

You can have multiple script lines (processed by the default system shell, although you can change that) as long as they all start with a tab. You can also add more prerequisites. For example:

hello : hello.c hello.h mylocallib.h

This gets tedious to maintain, though. For C and C++, most compilers (including gcc) have a way to create .d files that can automatically tell make what files an object depends on. That’s beyond the scope of this post, but look up the -MMD option for gcc, if you want to know more.

I Object

Normally, in a significant project, you won’t just compile C files (or whatever you have). You’ll compile the source files to object files and then link the object files at the end. The default rules understand this and, of course, you can write your own:

hello : hello.o mylib.o hello.o : hello.c hello.h mylib.h mylib.o : mylib.c mylib.h

Thanks to the default rules, that’s all you need. The make program is smart enough to see that it needs hello.o, it will go find the rule for hello.o and so on. Of course, you can add one or more script lines after any of these if you want to control what happens for the build process.

By default, make only tries to build the first thing it finds. Sometimes you’ll see a fake target as the first thing like this:

all : hello libtest config-editor

Presumably, then, you’ll have rules for those three programs elsewhere and make will build all three. This works as long as you never have a file name “all” in the working directory. To prevent that being a problem, you can declare that target as phony by using this statement in the makefile:

.PHONY: all

You can attach actions to phony targets, too. For example, you’ll often see something like:

.PHONY: clean clean:       rm *.o

Then you can issue make clean from the command line to remove all the object files. You probably won’t make that the first target or add it to something like all. Another common thing to do is create a phony target that can burn your code to a microcontroller so you can issue a command like “make program” to download code to the chip.

Stupid Make Tricks

Usually, you use make to build software. But like any other Unix/Linux tool, you’ll find people using it for all sorts of things. For example, it would be easy to build a makefile that uses pandoc to convert a document to multiple formats any time it changes.

The key is to realize that make is going to build a dependency tree, figure out what pieces need attention, and run the scripts for those pieces. The scripts don’t have to be build steps. They can copy files (even remotely using something like scp), delete files, or do anything else a Linux shell script could do.

But Wait, There’s More

There’s a lot more to learn about make, but with what you already know you can do a surprising amount. You can read the manual, of course, to learn more. If you look at a significant makefile like the one for Arduino projects, you’ll see there’s a lot there we didn’t talk about. But you still should be able to pick through a lot of it.

Next time, I’ll talk a little about schemes that take a different input format and generate a makefile. There are a few reasons people want to do this. One is the abstraction software might determine dependencies or make other changes to the generated makefile. In addition, most of these tools can generate build scripts for different platforms. As an example, if you’ve seenautomakeorcmake, these are the kinds of tools I’m talking about.

However, you don’t need anything that fancy for a lot of small projects like we often do on a Raspberry Pi or other embedded system. Basic make functionality will take you a long way. Especially for a project targeting a single kind of computer with a small number of files and dependencies.

When Vortex Rings Collide

ศุกร์, 06/22/2018 - 18:00

Intrigued by a grainy video from 1992, [Destin] from Smarter Every Day decided to jump in and fund his own research into the strange phenomenon of vortex ring collisions.

This hack started with a scientific publication and a video from back in 1992. The paper, written by Dr. T T Lim and TB Nichols, illustrated what happens when two vortex rings collide perfectly head-on. The rings collide and spread out forming a thin membrane. Then smaller rings form at a 90-degree angle to the original collision. It’s a beautiful effect when created with multicolored dye in water. But what causes it? There are theories about the fluid mechanics involved, but not much research has gone on since Dr. Lim’s paper.

[Destin] wanted to find out more about the effect, and get some video of it. Being the guy behind Smarter Every Day, he had the high-speed photography equipment and the funds to make that happen. Little did he know that this passion project would take four years to complete.

The initial prototype was built as part of a senior design project by a group of college students. While they did show the phenomenon, it was only barely visible, and not easily repeatable. [Destin] then got an engineer to design and build the experiment apparatus with him. It took numerous prototypes and changes, and years of development.

The final “vortex cannons” are driven by a computer controlled pneumatic cylinder which ensures both cannons get a perfect pulse of air. The air pushes a membrane which moves the dye and water out through an orifice. It’s a very finicky process, but when everything goes right, the result is a perfect collision. Just as in Dr. Lim’s video, the vortexes crash into each other, then form a ring on smaller vortexes.

Destin didn’t stop there. He’s made his data public, in the form of high-speed video – nearly 12 hours worth when played at normal speed. The hope is that researchers and engineers will now have enough information to better understand this phenomenon.

You can check out the videos after the break. If you’re a Smarter Every Day fan, we’ve covered [Destin’s] work in the past, including his backwards brain bike and his work with magnets.

Analog Meters Become a Clock for Father’s Day

ศุกร์, 06/22/2018 - 15:00

Around Father’s Day each year, we usually see a small spate of dad-oriented projects. Some are projects by dads or granddads for the kids, while others are gifts for the big guy. This analog meter clock fits the latter category, with the extra bonus of recognizing and honoring the influence [Micheal Teeuw]’s father had on him with all things technological.

[Michael] had been mulling over a voltmeter clock, where hours, minutes and seconds are displayed on moving coil meters, for a while.  A trio of analog meters from Ali Express would lend just the right look to the project, but being 200-volt AC meters, they required a little modification. [Michael] removed the rectifying diode and filtering capacitor inside the movement, and replaced the current-limiting resistor with a smaller value to get 5 volts full-range deflection on the meters. Adobe Illustrator helped with replacing the original scales with time scales, and LEDs were added to the meters for backlighting. A TinyRTC keeps time and generates the three PWM signals to drive the meters. Each meter is mounted in its own 3D-printed case, the three of which are linked together into one sleek console. We love the look, which reminds us of an instrument cluster in an airplane cockpit.

Bravo to [Michael’s Dad] for getting his son into the tinkering arts, and cheers to [Michael] on the nice build. We like seeing new uses for old meters, like these server performance monitoring meters.

[via r/DIY]

[Festo’s] Underwater Robot Uses Body-Length Fins

ศุกร์, 06/22/2018 - 12:00

[Festo] have come up with yet another amazing robot, a swimming one this time with an elegant propulsion mechanism. They call it the BionicFinWave. Two fins on either side almost a body-length long create a wave which pushes water backward, making the robot move forward. It’s modeled after such fish as the cuttlefish and the Nile perch.

What was their elegant solution for making the fins undulate? Nine lever arms are attached to each fin. Those lever arms are controlled by two crankshafts which extend from the front of the body to the rear, one for each side. A servo motor then turns each crankshaft. Since the crankshafts are independent, that means each fin operates independently. This allows for turning by having one fin move faster than the other. A third motor in the head flexes the body, causing the robot to swim up or down.

There’s also a pressure sensor and an ultrasonic sensor in the head for depth control and avoiding objects and walls. While these allow it to swim autonomously in its acrylic, tubular track, there is wireless communication for recording sensor data. Watch it in the video below as it effortlessly swims around its track.

[Festo] has created a lot of these marvels over the years. We’ve previously covered their bionic hopping kangaroo (we kid you not), their robot ants with circuitry printed on their exoskeleton, and perhaps the most realistic flapping robotic bird ever made.

Computers Go Hollywood

ศุกร์, 06/22/2018 - 09:00

Have you ever been watching a TV show or a movie and spotted a familiar computer? [James Carter] did and he created a website to help you identify which old computers appear in TV shows and movies. We came across this when researching another post about an old computer and wondered if it was any old movies. It wasn’t.

You can search by computer or by title. There are also ratings about how visible, realistic, and important the computer is for each item. The database only contains fictional works, not commercials or documentaries. The oldest entry we could find was 1950’s Destination Moon which starred a GE Differential Analyzer. Well, also John Archer, we suppose. We assume GE had a good agent as the same computer showed up in Earth vs. the Flying Saucers (1956) and When Worlds Collide (1951). You can see a clip of the computer’s appearance in Earth vs. the Flying Saucers, below.

We got excited when we didn’t see the Altair 8800 listed with The Six Million Dollar Man. But, alas, [James] has a list of things he hasn’t got around to yet and it is on that list. It is hard to tell which computer has the most screen credits, although we were amused to see how often the Burroughs B205 turned up, including in the Batcave.

We often spot some piece of gear other than a computer on the air, but we haven’t found a reference website for that. The old Battlestar Galactica had a fortune in Tektronix test equipment aboard. If you remember the show Buck Rogers in the 25th Century, Dr. Huer had an autoclave on his desk that one of the Hackday crew had in his lab at the same time.

We keep waiting for Mr. Robot to open up Hackaday on his tablet, but so far no joy. Of course, how computers are used on the screen can range from accurate to ridiculous. If you want to know which is which, it seems everyone has an opinion.

Is It A Golden Gun If It’s Made Out Of Brass?

ศุกร์, 06/22/2018 - 06:00

On today’s episode of ‘this is a really neat video that will soon be demonetized by YouTube’ comes this fantastic build from [John]. It is the Golden Gun, or at least it looks like a Golden Gun because it’s made out of melted down brass casings. It’s a masterclass demonstration of melting stuff down and turning a thirteen-pound blob of metal into a two-pound precision machined instrument.

This build began by simply cutting a wooden block, packing it in sand, and melting approximately 1425 shell casings of various calibers in a DIY furnace. The molten brass was then simply poured into the open mold. This is standard yellow brass, with about 70% copper and 30% zinc. There’s a bit of aluminum in there from the primers, and the resulting block isn’t terribly great for machining. [John] says this could be fixed by adding a few percent of lead to the melt. To all the jokesters suggesting he add some unfired bullets to the melt, don’t worry, we already have that covered.

chiseling a hole square, with a chisel.

The machining went as you would expect it would with a large mill, but there are a few things that made this entire video worthwhile. For some of the holes, [John] had to square up the corners. The simplest and easiest way to do this is to break out a file. This is brass, though, and with some steel chisels hanging around the shop your mortise and tenon skills might come in handy. With the very careful application of force, [John] managed to put corners on a circle with a standard wood chisel. A bit later in the build video, a few more sharp corners were created by shoving a broach in the mill and jamming it down into the work.

When it comes to machining builds, this is high art. Yes, it’s the same as building an AR-15 out of a few hundred soda cans, but this one is made out of brass. It looks just great, and that final polish turns the entire project into something that looks like it’s out of a video game. Simply amazing.

If you’re looking for more ways to push your metalwork boundaries, give cast iron a try!

Simple Camera Slider Adds a Dimension or Two to Your Shots

ศุกร์, 06/22/2018 - 03:00

Camera sliders are a popular build, and properly executed they can make for impressive shots for both time-lapse sequences or real-time action. But they seem best suited for long shots, as dollying a camera in a straight line just moves subjects close to the camera through the frame.

This slider with both pan and tilt axes can make moving close-ups a lot easier. With his extremely detailed build log, [Dejan Nedalkovski] shows how he went about building his with only the simplest of materials and tools. The linear rail is simply a couple of pieces of copper pipe supported by an MDF frame. The camera trolley rides the rails on common skateboard bearings and is driven by a NEMA-17 stepper, as are the pan and tilt axes. [Dejan] also provided a barn-door style pivot to tilt the camera relative to the rails, allowing the camera to slide up and down an inclined plane for really interesting shots. The controller uses an Arduino and a joystick to drive the camera manually, or the rig can be programmed to move smoothly between preset points.

This is a step beyond a simple slider and feels a little more like full-blown motion control. We’ve got a feeling some pretty dramatic shots would be possible with such a rig, and the fact that it’s a simple build is just icing on the cake.

CNC Mod Pack Hopes To Make Something Useful From A Cheap Machine Tool

ศุกร์, 06/22/2018 - 01:30

It is probable that many of us have noticed a variety of very cheap CNC mills in the pages of Chinese tech websites and been sorely tempted. On paper or as pixels on your screen they look great, but certainly with the more inexpensive models there soon emerges a gap between the promise and the reality.

[Brandon Piner] hopes to address this problem, with his CNC Mod Pack, a series of upgrades to a cheap mill designed to make it into a much more useful tool. In particular he’s created a revised 3D-printed tool holder and a set of end stop switches. The tool holder boasts swappable mounts on a dovetail fitting with versions for both a laser diode and a rotary tool, allowing much better tool positioning. Meanwhile the end stops are a necessary addition that protects both tool and machine from mishaps.

The same arguments play out in the world of small CNC mills as do in that of inexpensive 3D printers, namely that the economy of buying the super-cheap machine that is nominally the same as the expensive one starts to take a knock when you consider the level of work and expense needed to make your purchase usable. But with projects like this one the barrier to achieving a quality result from an unpromising start is lowered, and the enticing prospect is raised of a decent CNC machine for not a lot.
The HackadayPrize2018 is Sponsored by:





This Is The Year Conference Badges Get Their Own Badges

ศุกร์, 06/22/2018 - 00:00

Over the last few years, the art and artistry of printed circuit boards has moved from business cards to the most desirable of all disposable electronics. I speak, of course, of badgelife. This is the community built on creating and distributing independent electronic conference badges at the various tech and security conferences around the globe.

Until now, badgelife has been a loose confederation of badgemakers and distributors outdoing themselves each year with ever more impressive boards, techniques, and always more blinky bling. The field is advancing so fast there is no comparison to what was being done in years past; where a simple PCB and blinking LED would have sufficed a decade ago, now we have customized microcontrollers direct from the factory, fancy new chips, and the greatest art you’ve ever seen.

Now we have reached a threshold. The badgelife community has gotten so big, the badges are getting their own badges. This is the year of the badge add-on. We’re all building tiny trinkets for our badges, and this time, they’ll all work together. We’re exactly one year away from a sweet Voltron robot made of badges.

The Pre-History of Badge Add-Ons

Even though this is the year add-ons for conference badges will sweep the floors of casinos, it is not by any means the beginnings of the age of badges for badges.

The genesis of a standardized spec for add-ons began with the 2016 Queercon badge, distributed at DEF CON 24. This badge, either a squid or a cuttlefish, featured two four-pin headers for ‘hats’. The reason for the hats was simple — one of the main features of the 2016 Queercon badge was the use of clear soldermask, giving the badge a lovely unoxidized copper finish. However, there had to be some differentiation between ‘Uber’ badges for the Queercon organizers and the normal ‘human’ badges for everyone else. Traditionally, this is done with different colors of soldermask. Without that option, Queercon turned to literal light-up hats. The Uber hat was a light-up top hat, the ‘handler’ hat was a red police hat loaded up with a 555, and the normal ‘human’ hat was a beanie with a propeller on top.

The spec for the Queercon hats was leaked a few weeks before DEF CON, and that meant a few people were able to build their own accessories. A light-up unicorn horn was probably the most desirable, and there were even a few emo haircut PCBs that made it onto the Queercon badge:

The add-ons for the 2016 Queercon badge were a smash, and showcased the creativity of the community with independent add-ons supported by the official badge. The idea for add-on badges was picked up by other groups, and the 2017 Saintcon badge was loaded with expansion headers for independent add-ons.

2017’s AND!XOR badge featured a brainslug add-on

The 2017 Saintcon badge contained four spaces for add-ons arranged as two 8-pin headers on a footprint 0.8″ square. Everything to create a functional and interesting add-on was there: the add-on badges had connections for SPI, I2C, as well as 5 Volts and 3.3 Volts.

The results were spectacular: there were more than a handful of unofficial mini-badges that were soldered onto the Saintcon badge, including a very impressive 8×8 LED matrix from [compukidmike]. For the rest of 2017, add-ons were shoehorned into other badges. Last year’s Bender Badge from AND!XOR had a header for an add-on, and there was a fantastic Brain Slug add-on for members of that crew.

By early 2018, it was obvious add-ons were going to be a thing. The 2016 Queercon add-ons were brilliant in their simplicity, and proved adding a header for an add-on isn’t really that hard, and shouldn’t cost anything. Every microcontroller already has I2C, and if you’re designing a badge, you’re going to have a power rail in there somewhere.

The Beginning of a Standard for Add-Ons The standard for Shitty Add-ons. Note the Comic Sans

At the beginning of this year, it was clear there had to be a standard for badge add-ons. In February, the badgelife community was busy with the initial layout of their badges, and everyone needed some sort of standard pinout for power, ground, and some connection to a microcontroller.

This led to the creation of the Shitty Add-On Standard. It is, simply, the easiest way to add mini badges to other badges: a 2×2 header with 0.1″ spacing. There is no current limiting, there is no polarity protection. If you plug an add-on in wrong, it will kill the main badge. In fact, that’s the entire point of some add-ons. There is very little mechanical stability for these add-ons, and if you’re using surface mount pin headers, they will rip off.

In short, this spec for add-ons was designed in ten minutes by a complete moron in Microsoft Paint.

However, there is one great strength to the Shitty Add-On spec: it’s dead simple to implement. Nearly every badge being produced for this year’s badgelife extravaganza will have a 3.3 Volt rail. Every microcontroller has an I2C bus somewhere. 0.1″ pin headers are cheap, too. There are problems with it, but the Shitty Add-On spec is the simplest way to support multiple add-on badges.

This Year’s Crop of ‘Shitty Add-Ons’

We’re several weeks out from DEF CON, the main badgelife event, and already the art and artistry coming from badge creators is incredible. There will be dozens of different shitty add-ons, each demonstrating the remarkable craftsmanship of the community:

These are only a handful of the add-ons the badgelife community is making.

This is a banner year for electronic badges. We don’t even know what the official DEF CON badge will be, but the independent badgelife community is managing to do something spectacular this year. If you count add-ons as individual badges, it’s entirely possible there will be more independent badges at this year’s DEF CON than there are attendees. Let that sink in for a moment. DEF CON can’t manage to create enough electronic badges for everyone, and here we have a community of badge builders that have managed to not only build enough badges for everybody, but also to create a platform that everyone can experiment with.

What This Means For You

Badgelife is a hardware demoscene. Instead of typing assembly into a Commodore or Amiga, the badgelife community is rendering electronics in fiberglass and soldermask. It’s an open season for design and engineering, and it’s all happening this summer at various tech and security cons around the world.

The Shitty Add-On standard is the easiest way to get started in Badgelife. Nearly every major badge being distributed this year will come with the proper header, the power supply is taken care for you, and all you have to do is come up with a great design and figure out a way to blink some LEDs.

This is the year the badges get badges, and it’s never been a better time to get started designing your own PCB. It’s the demoscene for hardware, and now it’s open to everybody.

Clock This! A 3D-Printed Escapement Mechanism

พฤ, 06/21/2018 - 22:30

Traditional mechanical clockmaking is an art that despite being almost the archetype of precision engineering skill, appears rarely in our world of hardware hackers. That’s because making a clock mechanism is hard, and it is for good reason that professional clockmakers serve a long apprenticeship to learn their craft.

Though crafting one by hand is no easy task, a clock escapement is a surprisingly simple mechanism. Simple enough in fact that one can be 3D-printed, and that is just what [j0z] has done with a model posted on Thingiverse.

The model is simply the escapement mechanism, so to make a full clock there would have to be added a geartrain and clock face drive mechanism. But given a pair of 608 skateboard wheel bearings and a suitable weight and string to provide a power source, its pendulum will happily swing and provide that all-important tick. We’ve posted his short video below the break, so if Nixie clocks aren’t enough for you then perhaps you’d like to take it as inspiration to go mechanical.

A pendulum escapement of this type is only one of many varieties that have been produced over the long history of clockmaking. Our colleague [Manuel Rodriguez-Achach] took a look at some of them back in 2016.

Make A Natural Language Phone Bot Like Google’s Duplex AI

พฤ, 06/21/2018 - 21:01

After seeing how Google’s Duplex AI was able to book a table at a restaurant by fooling a human maître d’ into thinking it was human, I wondered if it might be possible for us mere hackers to pull off the same feat. What could you or I do without Google’s legions of ace AI programmers and racks of neural network training hardware? Let’s look at the ways we can make a natural language bot of our own. As you’ll see, it’s entirely doable.

Breaking Down The Solution

One of the first steps in engineering a solution is to break it down into smaller steps. Any conversation consists of a back-and-forth between two people, or a person and a chunk of silicon in our case.

Let’s say we want to create a bot which can order a pizza for us over the phone. The pizza place first says something to us. Some software then converts that speech to text or breaks it down into some other useful form. More software then formulates a response. And lastly, text-to-speech software or pre-recorded sound bites reply to the pizza place through a speaker into the phone.

The first half of the solution falls under the purview of natural language processing, at least part of which involves converting speech to a form which software can easily understand.

Converting Speech To Text

While there are plenty of open software options for converting text to speech, there aren’t as many for going the other way, from speech to text. They’re also typically in the form of libraries, which is fine for our use. Examples of open ones are CMU Sphinx, Julius, and Kaldi.

More recently, Mozilla has been working one called DeepSpeech which uses TensorFlow and deep learning. We’ve seen it used once so far when [Michael Sheldon] adapted it to convert speech to text which he then injects into X applications.

Understanding The Text

Once you’ve converted the speech to text, what do you do with it?

In our diagram, the human at the pizza place asked us “Will that be all?”. This could have been worded any number of other ways, for example: “Is that it?”, “That’s all?”.

One way to handle all these possibilities is to write the formulate-a-response code by throwing together a bunch of if-then-else statements, or perhaps write up a parser backed by some tables. If the conversation is expected to be structured then you can create a decision tree and have the code use that as a guide.

AIML (Artificial Intelligence Markup Language) makes that approach easier. AIML was created between 1995 and 2002 by Richard Wallace and has been the basis for a number of chatbots since, including an award-winning one called A.L.I.C.E. Since 2013, the A.L.I.C.E. foundation has been working on a specification for AIML 2.0.

With AIML, you fill an XML file with all the possible things the pizza place could say. The number of them can be minimized using patterns such as “Hi *”, but the pattern language in AIML is limited. It also allows you to provide responses and to limit the conversation to specific topics as they arise. And among its many other features, it has the ability to learn by writing novel things to a file.

For starting out with AIML, see the docs at pandorabots.com. There is also a relatively old interpreter called ProgramAB.

This video shows AIML in use by an open source InMoov robot.

Determining Intent

Much of the process-speech portion of our solution basically involves figuring out the intent of whatever the pizza place is saying, except that if our code is a mass of if-then-else statements or decision tree structures, it might not seem that way. Ultimately, when the pizza place asks in one of its myriad ways if that’s all we’d like to order, we’d like to boil down all the possibilities down to a single, simple intent, “asking_is_that_all”.

Or the intent may come with additional data for us to use. They may say “It’ll be ready in 20 minutes.” or “You can pick it up in 20 minutes.”. In that case we can label the intent “give_order_ready_time” and store the duration, 20 minutes, as additional data.

Online Services

Free online services exist which do both the speech recognition and determining the intent and capturing of any data. Wit.ai, owned by Facebook, is one such. Another is DialogFlow, formerly Api.ai and now owned by Google. DialogFlow does charge for some things, but nothing a hacker would need. IBM’s Watson Assistant is also free but has a mix of limits.

While Wit.ai does speech recognition and intent determination, DialogFlow and Watson implement the full decision tree, allowing you to use their UIs to script the whole conversation.

Ordering Pizza Using Wit.ai

I decided to try out Wit.ai and here’s the resulting conversation, placing an order for a pizza with a fictitious Johnny’s Pizza. Disclosure: No phone call was actually made, but more on that below.

https://hackadaycom.files.wordpress.com/2018/06/wit_pizza_ordering_phone_conversation.wav

In brief, here’s how I did it. First, I wrote up a script with all the possible combinations of things Johnny’s Pizza could say as well as what my bot should respond with. Then I went to Wit.ai and created an App. That involved giving it all the things in my script which Johnny’s Pizza says and for each one, assigning intents and indicating any data which should be reported to my code.

In Wit.ai you actually create entities, of which intents are just one type, but I found my code was easier to write if I made everything an intent. Shown here is a snapshot of some of the expressions, i.e. the things the pizza place might say. I’ve expanded the “Will that be all?” one to show the intent entity with a value of “asking_is_that_all”, which is what I’ll look for in my code. The expression above it and the one below it share that same entity so for any of them my code only has to look for “asking_is_that_all”.

After that, it was just a matter of writing some Python code on my Raspberry Pi based on their docs and example code on their Github. I have an amplifier (a noisy DIY one) and speaker attached to the Pi. I recorded a separate sound clip for each part of the conversation and saved them in individual .wav files. Since my voice was used for both sides of the conversation, I deepened the voice of the bot’s side.

In the code, I iterate through the sound clips for the pizza place as if I’d just received them from a phone, sending them one at a time to Wit.ai. Wit.ai does the speech recognition and analysis and returns the intent and data. I also play the clip to the speaker. Then I use the intent to figure out which of the bot’s clips to play in response. What you hear above is the resulting conversation just as I heard it from the Pi’s speaker.

The code can be found on our Github.

The Ultimate: How Google Duplex AI Did It

Listen again to the conversations Google’s Duplex AI had and you’ll be astounded at the language produced by the AI. Impressive as that is, more amazing is that there’s no if-then-else or decision tree involved. Instead, all that logic was trained into a neural network using copious amounts of sample phone conversations on hardware we can only dream of (or pay to use through online services). So for now we’ll have to do that part the old school way.

Adding Natural Language To AIML

One thing we can do, which would be a great open source project, would be to combine something like DeepSpeech with AIML, producing something more similar to DialogFlow or IBM Watson. Perhaps then ordering a pizza over the phone will become only a matter of pressing a button, or we could hook it up to Alexa and have her initiate it. Of course, we might want to announce that we’re a bot at the start of the call and be alerted to intervene if the conversation goes awry. Or record the conversations for posterity, so that the AIs have something to laugh about in ten years.