hardware

1631 Articles

This Robot Barfs Comics!

May 25, 2018 by 7 Comments

If there’s one thing that’s more fun than a comic, it’s a randomly generated comic. Well, perhaps that’s not true, but Reddit user [cadinb] wrote some software to generate a random comic strip and then built a robot case for it. Push a button on the robot and you’re presented with a randomly generated comic strip from the robot’s mouth.

The software that [cadinb] wrote is in Processing, an open source programming language and “sketchbook” for learning to code if you’re coming from a visual arts background. The Processing code determines how the images are cropped and placed and what kind of background they get. Each image is hand drawn by [cadinb] and has information associated with it so the code knows what the main focus of the image is. Once the panels are created, the final image is passed on to a thermal printer for printing. Everything is controlled from a Python script running on a Raspberry Pi and the code, strip artwork, and case is all available online to check out.

Now that the comic can print, a case is needed for the printer and controls. [cadinb] designed a case in Illustrator after creating a prototype out of foam core. The design was laser cut and then coloured – the main body with fabric dye and the arms stained with coffee!

Now [cadinb] has a robot that can sit on his table at conventions and a fan can press a button and have a randomly generated comic strip printed out before their eyes! We have a neat article about printing a comic on a strand of hair, and one about bringing the Banana Jr. 6000 to life!

Continue reading “This Robot Barfs Comics!” →

Automatic I2C Address Allocation For Daisy-Chained Sensors

May 23, 2018 by 23 Comments

Many readers will be familiar with interfacing I2C peripherals. A serial line joins a string of individual I2C devices, and each of the devices has its own address on that line. In most cases when connecting a single device or multiple different ones there is no problem in ensuring that they have different addresses.

What happens though when multiple identical devices share an I2C bus? This was the problem facing [Sam Evans] at Mindtribe, and his solution is both elegant and simple. The temperature sensors he was using across multiple identical boards have three pins upon which can be set a binary address, and his challenge was to differentiate between them without the manufacturing overhead of a set of DIP switches, jumpers, or individual pull-up resistors. Through a clever combination of sense lines between the boards he was able to create a system in which the address would be set depending upon whether the board had a neighbour on one side, the other, or both. A particularly clever hack allows two side-by-side boards that have two neighbours to alternate their least significant bit, allowing four identical boards each with two sensors to be daisy-chained for a total of eight sensors with automatic address allocation.

We aren’t told what the product was in this case, however it’s irrelevant. This is a hardware hack in its purest sense, one of those which readers will take note of and remember when it is their turn to deal with a well-populated I2C bus. Of course, if this method doesn’t appeal, you can always try an LTC4316.

Investigating The Tiny Salvaged UPS From A Lightbulb

May 21, 2018 by 34 Comments

Recently I had the opportunity to do a teardown of a battery-backed LED bulb, and found some interesting details on how the device operated. Essentially, the bulb contained a low voltage DC uninterruptible power supply that would automatically switch between AC power and internal battery as needed. The implications of this seemed pretty exciting. For around $12 at big box retailers, this little bulb could be a cheap and convenient solution for providing fault tolerant power to microcontrollers and other low-power devices.

The teardown was a runaway success, with quite a bit of discussion of the UPS idea specifically. Some people hated it, others loved it. But as we’ve come to expect from Hackaday readers, the comments from both sides of the aisle contained keen observations and invaluable real-world experience. From the safety of the device to the accuracy of the manufacturer’s claims, it seems like every element of the product was addressed.

I had ended the teardown with a promise that I’d continue experimenting with the tiny salvaged UPS, but even if I hadn’t, with so much feedback it seemed revisiting the subject was all but a necessity. It this little UPS really viable? Is it too dangerous to safely implement in your project? Will the thing just blow up?

So with your comments as a guide, and free of the somewhat restrictive teardown format, I set out to conduct a more thorough investigation of this little circuit that caused so much debate last month. It’s not all good news, but it’s not in the trash either. Not yet, anyway.

Continue reading “Investigating The Tiny Salvaged UPS From A Lightbulb” →

Stretching The Definitions Of A Custom IC

May 20, 2018 by 31 Comments

Maker Faire is the nexus for all things new and exciting. At the Bay Area Maker Faire this weekend, zGlue introduced a new platform that stretches the definition of custom ICs. Is this custom silicon? No, not at all. zGlue is a platform allowing anyone to take off-the-shelf ICs and package them into a single module, allowing you to build a smaller PCB with a shorter BOM.

The zGlue module found in the zOrigin

The idea behind zGlue is to take all of the fun chips available today from accelerometers to tiny microcontrollers with integrated wireless and put them on a tiny, tiny board that is then encapsulated. At Maker Faire, the zGlue team was busy demonstrating their cloud-based platform that allows anyone to add off-the-shelf chips to the zGlue stack and assemble it into a custom module.

Of course, every new tech startup needs a demo, so zGlue has come up with zOrigin, a small fitness tracker that features a suite of chips crammed into one encapsulated package. The chips included in the zOrigin ZiP package are a Dialog DA14585 microcontroller with BLE, an Analog Devices heart rate monitor, a crystal, a bit of Flash, a power monitoring IC and an accelerometer. There are also thirty passives stuck in this single chip, and with a battery, some LEDs, and a vibration motor, this chip becomes a complete solution for wearable fitness trackers.

Shoving a bunch of chips into a single module is nothing new; most of wireless modules available on the market are just that. NextThingCo experimented with a Linux computer on a chip with the GR8 module, again, just a bunch of chips slathered in epoxy. The most visible benefit of custom modules is probably the Octavo System on a Chip that became the PocketBone.

While the ability to create custom modules from off-the-shelf chips is nothing new for manufacturers, the ability for anyone to create their own custom ICs has remained out of reach for the Average Joe hardware hacker. zGlue is the solution to this problem, and the prices seem fairly reasonable, starting at around $100 for the initial R&D.

Scrapped Motors Don’t Care About Direction

May 19, 2018 by 18 Comments

Spinners built into games of chance like roulette or tabletop board games stop on a random number after being given a good spin. There is no trick, but they eventually rest because of friction, no matter how hard your siblings wind up for a game-winning turn. What if the spinning continued forever and there was no programming because there was no controller? [Ludic Science] shows us his method of making a perpetual spinner with nothing fancier than a scrapped hard disk drive motor and a transformer. His video can also be seen below the break.

Fair warning: this involves mains power. The brushless motor inside a hard disk drive relies on three-phase current of varying frequencies, but the power coming off a single transformer is going to be single-phase AC at fifty or sixty Hz. This simplifies things considerably, but we lose the self-starting ability of the motor and direction control, but we call those features in our perpetual spinner. With two missing phases, our brushless motor limps along in whatever direction we initiate, but the circuit couldn’t be much more straightforward.

This is just the latest skill on a scrapped HDD motor’s résumé (CV). They will run with a 9V battery, or work backwards and become an encoder. If you want to use it more like the manufacturer’s intent, consider this controller.

Continue reading “Scrapped Motors Don’t Care About Direction” →

Nuclear Synchroscope Gets New Life

May 18, 2018 by 11 Comments

The Synchroscope is an interesting power plant instrument which doubles up as two devices in one. If the generator frequency is not matched with the grid frequency, the rotation direction of the synchroscope pointer indicates if the frequency (generator speed) needs to be increased or decreased. When it stops rotating, the pointer angle indicates the phase difference between the generator and the grid. When [badjer1] [Chris Muncy] got his hands on an old synchroscope which had seen better days at a nuclear power plant control room, he decided to use it as the enclosure for a long-pending plan to build a Nixie Tube project. The result — an Arduino Nixie Clock and Weather Station — is a retro-modern looking instrument which indicates time, temperature, pressure and humidity and the synchroscope pointer now indicates atmospheric pressure.

Rather than replicating existing designs, he decided to build his project from scratch, learning new techniques and tricks while improving his design as he progressed. [badjer1] is a Fortran old-timer, so kudos to him for taking a plunge into the Arduino ecosystem. Other than the funky enclosure, most of the electronics are assembled from off-the-shelf modules. The synchroscope was not large enough to accommodate the electronics, so [badjer1] had to split it into two halves, and add a clear acrylic box in the middle to house it all. He stuck in a few LEDs inside the enclosure for added visual effect. Probably his biggest challenge, other than the mechanical assembly, was making sure he got the cutouts for the Nixie tubes on the display panel right. One wrong move and he would have ended up with a piece of aluminum junk and a missing face panel.

Being new to Arduino, he was careful with breaking up his code into manageable chunks, and peppering it with lots of comments, for his own, and everyone else’s, benefit. The electronics and hardware assembly are also equally well detailed, should anyone else want to attempt to replicate his build. There is still room for improvement, especially with the sensor mounting, but for now, [badjer1] seems pretty happy with the result. Check out the demo video after the break.

Thanks for the tip, [Chris Muncy].

Continue reading “Nuclear Synchroscope Gets New Life” →

Open Source Calculator Teaches Us About Quality Documentation

May 18, 2018 by 80 Comments

Graphing calculators are one of those funny markets that never seem to change. Standardized testing has created a primordial stew of regulatory capture in which ancient technology thrives at modern retail prices while changing little. The NumWorks calculator certainly isn’t the first competitor to challenge the Texas Instruments dynasty with a more modern interface (and a design from this decade), but behind it’s subtle color pops and elegant lines lies the real gem; a fantastically well documented piece of open source hardware. The last time we wrote about the NumWorks, it was to demonstrate a pretty wild hack that embedded an entire Pi Zero but it’s worth drawing attention to the calculator itself.

Hackaday readers traveling to the NumWorks website might spy the section at the bottom of the page titled “Developers” with tantalizing links like “Hardware,” “Software,” and “GitHub.” These lead to a wealth of knowledge about how the product is put together and sources to build the enclosure and firmware yourself (the PCB schematic and layout sources seem to be missing, though there is this handy gerber viewer). However merely posting sources is a low bar NumWorks far exceeds.

How is the firmware put together? Here’s a handy architecture guide! Why did they choose C++ and what tradeoffs were made to fit everything in a resource constrained embedded system? Here’s a design guide! How exactly does the math engine take in text, comprehend the expression contained therein, and evaluate it? There’s a document for it! There’s even a multi-platform SDK setup guide.

Firmware documentation is old hat; we’ve come to expect (or at least hope!) for it. For us the most interesting documentation is actually for the mechanical and electrical systems. The EE guides start with part selection (with datasheet links) then move on to walkthroughs of major areas of the schematic. At this point is should be no surprise that the board has pads for a completely standard 10 pin ARM debug connector and documented test points for UART, SPI, and an SD card.

The mechanical pages read like a quick primer on design for injection molding and tricks to reduce assembly errors (called “poka-yoke“). Ever wondered what that funny frame plastic models come in is called? The NumWorks calculator’s buttons are made in one, and it’s called a “sprue”. There are pages describing each piece of the housing one at a time.

Treat yourself to a reading of NumWorks’ excellent documentation. And if you need a new calculator, maybe consider the open source option.

Continue reading “Open Source Calculator Teaches Us About Quality Documentation” →