Bela: Real-Time BeagleBone Audio/Analog Cape

Bela is a cape for the BeagleBone Black that’s aimed at artists and musicians. Actually, the cape is much less than half of the story — the rest is in some clever software and a real-time Linux distribution. But we’re getting ahead of ourselves. Let’s talk hardware first.

First off, the cape has stereo input and output as well as two amplified speaker outs. It can do all of your audio stuff. It also has two banks of analogue inputs and outputs, each capable of handling eight signals. In our opinion, this is where the Bela is cool. In particular, the analog outputs are not Arduino-style “analog outputs” where it’s actually a digital output on which you can do PWM to fake an analog signal. These are eight 16-bit outputs from an AD5668 DAC which means that you can use the voltages directly, without filtering.

Then there’s the real trick. All of these input and output peripherals are hooked up to the BeagleBone’s Programmable Realtime Units (PRUs) — a hardware subsystem that’s independent of the CPU but can work along with it. The PRU is interfaced with the real-time Linux core to give you sub-microsecond response in your application. This is a big deal because a lot of other audio-processing systems have latencies that get into the tens of milliseconds or worse, where it starts to be perceptible as a slight lag by humans.

The downside of this custom analog and audio I/O is that it’s not yet supported by kernel drivers, and you’ll need to use their “Heavy Audio Tools” which compiles Pd programs into C code, which can then drive the PRUs. Of course, you can write directly for the PRUs yourself as well. If you just want to play MP3s, get something you have a bunch of simpler, better options. If you need to do responsive real-time audio installations, Bela is a way to go.

The project is open-source, but we had to do a bunch of digging to find what we were looking for. The hardware is in zip files here, and you’ll find the software here. The demo projects look/sound pretty cool and their Kickstarter is long over-funded, so we’re interested to see what folks make with these.

A Digital Canvas That’s Hard to Spot

While sorely lacking in pictures of the innards of this digital canvas, we were extremely impressed with the work that went into making such a convincing object. [Clay Bavor] wanted a digital picture frame, but couldn’t find one on the market that did what he wanted. They all had similar problems, the LCDs were the lowest quality, they were in cheap bezels, they had weird features, they had no viewing angle, and they either glowed like the sun or were invisible in dark environments.

[Clay] started with the LCD quality, he looked at LCD specs for the absolute best display, and then, presumably, realized he lived in a world where money is no object and bought a 27″ iMac. The iMac has a very high pixel density, no viewing angle, and Apple goes through the trouble of color balancing every display. Next he got a real frame for the iMac, cut a hole in the wall to accommodate it, and also had a mat installed to crop the display to a more convincing aspect ratio for art. One of the most interesting part of the build is the addition of a Phidgets light sensor. Using this, he has some software running that constantly adjusts the Mac to run at a brightness that’s nearly imperceptible in the room’s lighting.

Once he had it built he started to play around with the software he wrote for the frame. Since he wanted the frame to look like a real art print he couldn’t have the image change while people were looking, so he used the camera on the Mac and face detection to make sure the image only changed when no one was looking for a few minutes. He also has a mode that trolls the user by changing the image as soon as they look away.

We admit that a hackier version of this would be tearing the panel out of a broken iMac and using a lighter weight computer to run all the display stuff. [Clay] reached the same conclusion and plans to do something similar for his version 2.0.

Continue reading “A Digital Canvas That’s Hard to Spot”

Prof Gershenfeld Speaks on Fab Labs and all-things Digital

Fab Labs have developed hand-in-hand with the all-too-familiar hackerspaces that we see today. If you’re curious to discover more about their past and future, [Prof Gershenfeld], founder of the Fab Lab, and director of MIT’s Center for Bits and Atoms brings us a fresh perspective on both these fab labs and the digital world we live in.

In a casual one-hour chat on Edge, [Prof Gershenfeld] dives deeply into the concept of digital in our world. We might consider digital to be a binarized signal, an analog waveform discretized into a 0 and 1 from which all of computer architecture is built upon today. Digital doesn’t just exist in the computing sense, however; it’s a concept that has been applied to communication, computation, and, these days: personal fabrication.

[Prof Gershenfeld’s] talk may highlight coming changes in the future, but changes are already happening today. These days, fab labs and hackerspaces serve their communities in a very special way. They take “experts-of-the-field” away from universities and isolated labs, and they scatter them all over the world. With this shift, anyone can walk through their doors and build a solid foundation in fields like embedded programming and computer aided manufacturing by striking a conversation with these local experts. In a nutshell, both spaces found a culture for development of expertise far more accessible to the world community than their university counterparts.

If you can spare the hour, put on some headphones, tune in, and resume your CAD work, PCB layout, or that Arduino library. You may discover that your work is built on a number of digital principles, and that your contributions push the rest farther along the development chain towards building something awesome.

Finally, if you’re interested in taking notes on building your own fab lab, have a look at the inventorylayout, and guidelines at the CBA website.

From Gates to FPGA’s – Part 1: Basic Logic

It’s time to do a series on logic including things such as programmable logic, state machines, and the lesser known demons such as switching hazards. It is best to start at the beginning — but even experts will enjoy this refresher and might even learn a trick or two. I’ll start with logic symbols, alternate symbols, small Boolean truth tables and some oddball things that we can do with basic logic. The narrative version is found in the video, with a full reference laid out in the rest of this post.

Invert

1The most simple piece of logic is inversion; making a high change to low or a low change to high. Shown are a couple of ways to write an inversion including the ubiquitous “bubble” that we can apply almost anywhere to imply an inversion or a “True Low”. If it was a one it is now a zero, where it was a low it is now a high, and where it was true it is now untrue.

AND

2Moving on to the AND gate we see a simple truth table, also known as a Boolean Table, where it describes the function of “A AND B”. This is also our first opportunity to see the application of an alternate symbol. In this case a “low OR a low yields a low”

NAND

3Most if not all of the standard logic blocks come in an inverted form also such as the NAND gate shown here. The ability to invert logic functions is so useful in real life that I probably used at least three times the number of NAND gates as regular AND gates when doing medium or larger system design. The useful inversion can occur as spares or in line with the logic.

Continue reading “From Gates to FPGA’s – Part 1: Basic Logic”

How Green Screen Worked Before Computers

If you know anything about how films are made then you have probably heard about the “green screen” before. The technique is also known as chroma key compositing, and it’s generally used to merge two images or videos together based on color hues. Usually you see an actor filmed in front of a green background. Using video editing software, the editor can then replace that specific green color with another video clip. This makes it look like the actor is in a completely different environment.

It’s no surprise that with computers, this is a very simple task. Any basic video editing software will include a chroma key function, but have you ever wondered how this was accomplished before computers made it so simple? [Tom Scott] posted a video to explain exactly that.

In the early days of film, the studio could film the actor against an entirely black background. Then, they would copy the film over and over using higher and higher contrasts until they end up with a black background, and a white silhouette of the actor. This film could be used as a matte. Working with an optical printer, the studio could then perform a double exposure to combine film of a background with the film of the actor. You can imagine that this was a much more cumbersome process than making a few mouse clicks.

For the green screen effect, studios could actually use specialized optical filters. They could apply one filter that would ignore a specific wavelength of the color green. Then they could film the actor using that filter. The resulting matte could then be combined with the footage of the actor and the background film using the optical printer. It’s very similar to the older style with the black background.

Electronic analog video has some other interesting tricks to perform the same basic effect. [Tom] explains that the analog signal contained information about the various colors that needed to be displayed on the screen. Electronic circuits were built that could watch for a specific color (green) and replace the signal with one from the background video. Studios even went so far as to record both the actor and a model simultaneously, using two cameras that were mechanically linked together to make the same movements. The signals could then be run through this special circuit and the combined image recorded all simultaneously.

There are a few other examples in the video, and the effects that [Tom] uses to describe these old techniques go a long way to help understand the concepts. It’s crazy to think of how complicated this process can be, when nowadays we can do it in minutes with the computers we already have in our homes. Continue reading “How Green Screen Worked Before Computers”

Minicomputers on Microcontrollers

Developed in the very late 60s and through the 70s, the PDP-11 series of minicomputers was quite possibly the single most important computer ever created. The first widely distributed versions of Unix and C were developed on the PDP-11, and it’s hardware influence can be found in everything from the Motorola 68000 to the MSP430.

When [Dave Cheney] saw the recent 8086 simulator written in 4kB of C code, he realized simulating entire computer systems doesn’t actually require a whole lot of resources outside a big chunk of memory. Armed with an Arduino Mega clone, he set out on one of the coolest projects we’ve seen in a while: simulating a PDP-11 on an AVR.

[Dave] used an ATMega2560-powered Arduino Mega clone with an Ethernet module for the hardware of this build. Attached to it is a shield filled up with a pair of RAM chips that expand relatively limited amount of RAM on the ‘Mega.

So far, [Dave] has his simulated system booting Unix V6 off an SD card. For PDP-11 storage, he’s also simulating an RK05 disk drive, a massive 14 inch platter containing 2.5 Megabytes of data. Compared to the original PDP-11/40, [Dave] estimates his machine is about 10 times slower. Still, an original 11/40 system fills multiple server racks, and the most common installations consume several kilowatts of power. The Arduino Mega can fit in a pocket and can be powered over USB.

Future developments for this system include improving the accuracy of the simulator, running more advanced operating systems and the DEC diagnostic programs, and possibly speeding up the simulation. We’d suggest adding some switches and blinkenlights on an additional shield, but that’s just us.

All the code can be found on [Dave]’s git, with a description of his SPI RAM shield coming shortly.

USB adapter for an old VT100 keyboard

VT100

Ah, the VT100, the first dumb terminal that was controlled with a microprocessor. This ancient beast from the late 70s is quite unlike the terminals you’d find from even five years after its vintage – the keyboard connects via a TRS quarter-inch jack – the electronic and code design of this terminal is a bit weird. [Seth] was up to the challenge of making this mechanical keyboard work as a standard USB device, so he created his own USB adapter.

On the little quarter-inch to USB adapter, [Seth] included an HD 6402 UART to talk to the keyboard, along with a Teensy dev board and a few bits of circuits stolen from DEC engineers. The protocol between the keyboard and terminal is a little weird – first the terminal sets a bit in a status word, then the keyboard scans all the key rows and columns in sequence before telling the terminal it’s done. Yes, this gives the VT100 full n-key rollover, but it’s just weird compared to even an IBM Model M keyboard that’s just a few years younger.

[Seth] finally completed his circuit and wired it up on a perfboard. Everything works just as it should, although a little key remapping was done to keep this keyboard adapter useful for Mac and Windows computers. It’s a wonderful bit of kit, and any insight we can get into the old DEC engineers is a wonderful read in any event.

Vidias below.

Continue reading “USB adapter for an old VT100 keyboard”