Tiny Cube Hosts A Hearty Tube

October 25, 2019 by Kerry Scharfglass 17 Comments

Tiny PCBAs and glowy VFD tubes are like catnip to a Hackaday writer, so when we saw [hamster]’s TubeCube tube segment driver we had to dig in to learn more. We won’t bury the lede here; let’s enjoy a video of glowing tubes before we go further:

The TubeCube is built to fit the MiniBadge badge addon standard, which is primarily used to host modules on the SAINTCON conference badge. A single TubeCube hosts a VFD tube, hardware to provide a 70 V supply, and a microcontroller for communication and control. Each TubeCube is designed to accept ASCII characters via UART to display on it’s display, but they can also be chained together for even more excitement. We’re not sure how [hamster] would be able to physically wear the beast in the video above, but if he can find a way, they all work together. If you’re interested in seeing the dead simple UART communication scheme take a look at this file.

We think it’s also worth pointing about the high voltage supply. To the software or mechanically minded among us it’s easy to get trapped thinking about switching power supplies as a magical construct which can only be built using all-in-one control ICs. But [hamster]’s supply is a great reminder that a switching supply, even a high voltage one, isn’t as complex as all that. His design (which he says was cribbed from Adafruit’s lovely Ice Tube Clock) is essentially composed of the standard primitives. A big low voltage capacitor C1 to source the burst of energy which will be boosted, the necessary inductor/high voltage cap C2 which ends up at the target voltage, and a smoothing cap C3 to make the output a little nicer. It’s controlled by the microcontroller toggling Q1 to control the current flow through L1. The side effect is that by controlling the PWM frequency [hamster] can vary the brightness of the tubes.

Right now it looks like the repository has a schematic and sources, which should be enough to build a small tube driver of your own. If you can’t get enough TubeCubes, there’s one more video (of a single module) after the break.

Continue reading “Tiny Cube Hosts A Hearty Tube” →

Converting A Tesla To A Pickup Truck

October 19, 2019 by Sharon Lin 38 Comments

The renowned inventor of useless robots [Simone Giertz] has outdone herself this time. She, along with a team of engineers featuring [Rich Rebuilds], [Laura Kampf], and [Marcos Ramirez], recently decided to convert a Tesla into a pickup truck, and make a video along the way, all while salvaging what remains they can of the back of the car and making the final product roadworthy. Yeah, this is a couple weeks old now, and yeah, it’s kind of a commercial, but really: [Simone Giertz] and Co. rock.

In her vlog of the experience, the team starts by gutting out the interior of the car in order to find out the weight distribution and form of the outer frame. Essentially, in order to create the pickup truck, a portion of the back of the car needs to be removed, with additional beams and support welded in depending on the consequent structural integrity. With a sawzall and angle grinder, the top portion of the frame is cut and taken out, but not before a worrying glance brings about the realization that the car needs exterior support during its modifications.

After the cushions, glass, wiring, and all other accessories are removed, they install a truck bed from another sacrificial pickup truck, as well as a roof rack to complete the look. Amidst the deconstruction and reconstruction, there are moments when the car encounters a “Safety restraint system fault” or when the team accidentally lines the inside of the car with fiberglass right before shooting their video. Between complaints of the different clip sizes used and the clear time pressure of the project, it’s a funny and informative look into a pretty unique car mod.

The final commercial they made of their Tesla-pickup hybrid, dubbed Truckla, is available on [Giertz]’s YouTube channel.

Continue reading “Converting A Tesla To A Pickup Truck” →

The Smallest Homebrewed TTL CPU In The World

October 16, 2019 by Sharon Lin 16 Comments

This may very well be the smallest homemade TTL CPU we’ve ever seen. Measuring at one square inch, this tiny chip boasts 40 connections, an 8-bit databus, a 16-bit address bus, a 64 kB memory space, reset and clock inputs, and 5 V power lines.

TTL (transistor transistor logic) logic chips are pretty outdated today, but they do have all of the basics necessary for building a computer – logic gates, counters, buffers, and registers. The transistors perform both the logic and amplifying, as compared to resistor-transistor logic (RTL) and diode-transistor logic (DTL). In the 60s, when the technology was still fairly new, TTL ICs were commonly used in computers and industrial controls. Even after the advent of VLSI, TTL ICs were still being used for interfacing more densely integrated chips. Even so, most TTL chips tend to be on the bulkier side, which is what makes [roelh]’s project so unique. The entire PCB is hardly any larger than a coin.

On top of the hardware specs, [roelh] also implemented several useful software features: zero page addressing, load/store/compare instructions, stacks, conditioning branching, subroutine calls, and memory-mapped I/O. The registers are also in RAM, which has been implemented in microprocessors in the past (see TMS9900) for speed considerations, but in this case was implemented for size constraints.

An ALU was also left out of the design in order to constrain its size, leaving only 8 ICs on either side of the 2-layer PCB.

Microprograms are stored in Flash memory and can be programmed with a Raspberry Pi. by saving the Assembly code to a memory card and downloading the assembled binary code. Once the Raspberry Pi is connected to the development board, you can burn the binary code onto the Flash memory of the board using a Python script. An online Javascript editor also exists for assembling the Assembly code for the chip and simulating the CPU.

There is currently a development board made for the CPU, which includes six seven-segment displays and an I/O connector for running a digital clock and other applications. [roelh] has since built a retro TTL computer around the chip, which reintroduces the ALU and includes address registers, 256 KB of RAM, VGA video, PS/2 keyboard port, a sound system, and I/O pins. It’s a really exciting project that’s seriously pushing the constraints of retro computing.

DIY Video Microscopy

October 16, 2019 by Anool Mahidharia 8 Comments

Owning a Microscope is great fun as a hobby in general, but for hackers, it is a particularly useful instrument for assembly and inspection, now that we are building hardware with “grain of sand” sized components in our basements and garages. [voidnill] was given an Eduval 4 microscope by a well-meaning friend during a holiday trip. This model is pretty old, but it’s a Carl Zeiss after all, made in Jena in the erstwhile GDR. Since an optical microscope was of limited use for him, [voidnill] set about digitizing it.

He settled on the Raspberry-Pi route. The Pi and a hard disk were attached directly to the frame of the microscope, and a VGA display connected via a converter. Finally, the Pi camera was jury-rigged to one of the eyepieces using some foam. It’s a quick and dirty hack, and not the best solution, but it works well for [voidnill] since he wanted to keep the original microscope intact.

The standard Pi camera has a wide angle lens. It is designed to capture a large image and converge it on to the small sensor area. Converting it to macro mode is possible, but requires a hack. The lens is removed and ‘flipped over’, and fixed at a distance away from the sensor – usually with the help of an extension tube. This allows the lens to image a very small area and focus it on the (relatively) large sensor. This hack is used in the “OpenFlexure” microscope project, which you can read about in the post we wrote earlier this year or at this updated link. If you want even higher magnification and image quality, OpenFlexure provides a design to mate the camera sensor directly to an RMS threaded microscope objective. Since earlier this year, this open source microscope project has made a lot of progress, and many folks around the world have successfully built their own versions. It offers a lot of customisation options such as basic or high-resolution optics and manual or motorised stages, which makes it a great project to try out.

If the OpenFlexure project proves to be an intimidating build, you can try something easier. Head over to the PublicLab where [partsandcrafts] shows you how to “Build a Basic Microscope with Raspberry Pi”. It borrows from other open source projects but keeps things simpler making it much easier to build.

In the video embed below, [voidnill] gives a brief overview (in German) of his quick hack. If you’ve got some microscope hacks, or have built one of your own, let us know in the comments section.

Continue reading “DIY Video Microscopy” →

Not All 7-Segment Displays Are Electronic

October 13, 2019 by Jenny List 23 Comments

There are a variety of means by which numbers can be displayed from an electronic circuit, and probably the most ubiquitous remains the seven-segment display. Take seven LEDs, lamps, LCDs, VFD segments or mechanical flip-dot style units in the familiar rectangular figure eight, and your microcontroller or similar can display numbers. There are a variety of different interfaces, but at most all that is needed is a level shifter and a driver.

Sometimes though we encounter a completely novel 7-segment display, and such is the case with [Fhuable]’s all mechanical single digit display. It bears a superficial resemblance to a flipdot display, but instead of a magnetic actuator, it instead uses a complex system of gears and cams to flip the segments sequentially from the turning of a small crank. It appears to be the same mechanism he’s used in his subscription counter project whose video we’ve placed below the break, and it is truly a thing of beauty. We’re not entirely certain how useful it would be as a general-purpose display in its current form, however, we can see it being adapted with relative ease. A clock might, for example, be an eye-catching project.

Most displays that make it here have some electrical components, so it’s unusual to see an entirely mechanical one. But that’s not necessarily always the case.

Continue reading “Not All 7-Segment Displays Are Electronic” →

DIY MIDI Looper Controller Looks Fantastic!

October 13, 2019 by Rich Hawkes 4 Comments

Due to pedalboard size, complicated guitar pedals sometimes reduce the number of buttons to the bare minimum. Many of these pedals are capable of being controlled with an external MIDI controller, however, and necessity being the mother of invention and all, this is a great opportunity to build something and learn some new skills at the same time. In need of a MIDI controller, Reddit user [Earthwin] built an Arduino powered one to control his Boss DD500 Looper pedal and the result is great looking.

Five 16×2 LCD screens, one for each button, show the functionality that that button currently has. They are attached (through some neat wiring) to a custom-built PCB which holds the Arduino that controls everything. The screens are mounted to an acrylic backplate which holds the screens in place while the laser-cut acrylic covers are mounted to the same plate through the chassis. The chassis is a standard Hammond aluminum box that was sanded down, primed and then filler was used to make the corners nice and smooth. Flat-top LEDs and custom 3D printed washers finish off the project.

[Earthwin] admits that this build might be overkill for the looper that he’s using, but he had fun building the controller and learning to use an Arduino. He’s already well on his way to building another, using the lessons learned in this build. If you want to build your own MIDI controller, this article should help you out. And then you’re ready to build your controller into a guitar if you want to.

[Via Reddit]

Dealing With Missing Pin Allocations

October 12, 2019 by Sharon Lin 3 Comments

Blindsided by missing pin allocations? Perhaps you’re working on a piece of hardware and you notice that the documentation is entirely wrong. How can you get your device to work?

[Dani Eichhorn]’s troubles began when running an IoT workshop using a camera module. Prior to the work, no one had through to check if all of the camera modules ordered for the participants were the same. As it turns out, the TTGO T-CAM module had a number of revisions, with some even receiving a temperature/pressure sensor fixed on top of the normal board.

While the boards may have looked the same, their pin allocations were completely different.Changing the pin numbers wouldn’t have been difficult if they were simply numbered differently, but because the configurations were different, errors started to abound: Could not initialize the camera

As it turns out, even the LillyGo engineers – the manufacturers of the board – may have gotten a bit lost while working on the pin allocations, as [Eichhorn] was able to find some of the pins printed right onto the PCB, hidden behind the camera component.

To find information not printed on the board, a little more digging was required. To find the addresses of the devices connected to the I2C bus, running a program to find peripherals listening on the bus did the trick. This was able to print out the addresses of the SSD1306 OLED display driver and the microphone for the board at hand.

To find the pins of peripherals not printed on the PCB or hidden on the silkscreen, a GPIO scanner did the trick. This in particular worked for finding the PIR (passive infrared) motion sensor.

We picked up a few tips and tricks from this endeavor, but also learned that reverse-engineering anything is hard, and that there isn’t any one method for finding pin allocations when the documentation’s missing.