Blindingly Fast ADC For Your BeagleBone

July 31, 2016 by Elliot Williams 28 Comments

[Jason Holt] wrote in to tell about of the release of his PRUDAQ project. It’s a dual-channel 10-bit ADC cape that ties into the BeagleBone’s Programmable Realtime Units (PRUs) to shuttle through up to as much as 20 megasamples per second for each channel. That’s a lot of bandwidth!

The trick is reading the ADC out with the PRUs, which are essentially a little bit of programmable logic that’s built on to the board. With a bit of PRU code, the data can be shuttled out of the ADC and into the BeagleBone’s memory about as fast as you could wish. Indeed, it’s too fast for the demo code that [Jason] wrote, which can’t even access the RAM that fast. Instead, you’ll want to use custom kernel drivers from the BeagleLogic project (that we’ve covered here before).

But even then, if you don’t want to process the data onboard, you’ve got to get it out somehow. 100 mbit Ethernet gets you 11.2 megabytes per second, and a cherry-picked flash drive can save something like 14-18 megabytes per second. But the two 10-bit ADCs, running full-bore at 20 megasamples per second each, produces something like 50-80 megabytes per second. Point is, PRUDAQ is producing a ton of data.

So what is this cape useful for? It’s limited to the two-volt input range of the ADCs — you’ll need to precondition signals for use as a general-purpose oscilloscope. You can also multiplex the ADCs, allowing for eight inputs, but of course not at exactly the same time. But two channels at high bandwidth would make a great backend for a custom SDR setup, for instance. Getting this much ADC bandwidth into a single-board computer is an awesome trick that used to cost thousands of dollars.

We asked [Jason] why he built it, and he said he can’t tell us. It’s a Google Research project, so let the wild conjecture-fest begin!

BeagleBone Pin-Toggling Torture Test

April 21, 2016 by Elliot Williams 20 Comments

Benchmarks often get criticized for their inability to perfectly model the real-world situations that we’d like them to. So take what follows in the limited scope that it’s intended, and don’t read too much into it. [Joonas Pihlajamaa]’s experiments with toggling a hardware pin as fast as possible on different single-board computers can still show us something.

The take-home result won’t surprise anyone who’s worked with a single-board computer: the higher-level interfaces are simply slow compared to direct memory-mapped GPIO access. But really slow. We’re talking around 5 kHz from Python or any of the file-based interfaces to the pins versus 3 MHz for direct access. Worse, as you’d expect when a non-realtime operating system is in the middle, there are glitches on the order of ten milliseconds with all the file-based methods.

This test only tells us so much, though, and it’s not really taking advantage of the BeagleBone Black’s ace in the hole, the PRUs — onboard hardware processors that bring real-time IO capabilities to the system. We’d like to see a re-write of the code to take advantage of libpruio, for instance. A 20 MHz square wave is a piece of cake with the PRUs.

Of course, it’s not interacting, which is probably in the spirit of the benchmark as written. But if raw hardware speed on a BeagleBone is the goal, it’s likely that the PRUs are going to feature prominently in the solution.

BeagleBones At MRRF

March 22, 2015 by Brian Benchoff 7 Comments

[Jason Kridner] – the BeagleBone guy – headed out to the Midwest RepRap Festival this weekend. There are a lot of single board computers out there, but the BeagleBoard and Bone are perfectly suited for controlling printers, and motion control systems thanks to the real-time PRUs on board. It’s not the board for you if you want to play retro video games or build a media center; it’s the board for building stuff.

Of interest at the BeagleBooth were a few capes specifically designed for CNC and 3D printing work. There was the CRAMPS, a clone of the very popular RAMPS 3D printer electronics board made for the Beagle. If you’re trying to control an old mill that is only controllable through a parallel port, here’s the board for you. There are 3D printer boards with absurd layouts that work well as both printer controller boards and the reason why you should never come up with the name of something before you build it.

[Jason]’s trip out to MRRF wasn’t only about extolling the virtues of PRUs; Machinekit, a great motion control software, was also there, running on a few Beagles. The printer at the BeagleBooth was running Machinekit and apart from a few lines of GCode that sent the head crashing into the part, everything was working great.

Continue reading “BeagleBones At MRRF” →

Turn Your BeagleBoneBlack In To A 14-channel, 100Msps Logic Analyzer

February 19, 2015 by Anool Mahidharia 34 Comments

The BeagleBoneBlack is a SoC of choice for many hackers – and quite rightly so – given its powerful features. [abhishek] is majoring in E&E from IIT-Kharagpur, India and in 2014 applied for a project at beagleboard.org via the Google Summer of Code project (GSoC). His project, BeagleLogic aims to realize a logic analyzer using the Programmable Real-Time units on board the AM335X SoC family that powers the BeagleBone and the BeagleBone Black.

The project helps create bindings of the PRU with sigrok, and also provides a web-based front-end so that the logic analyzer can be accessed in much the same way as one would use the Cloud9 IDE on the BeagleBone/BeagleBone Black to create a new application with BoneScript.

Besides it’s obvious use as a debugging tool, the logic analyzer can also be a learning tool that can be used to understand digital signals. BeagleLogic turns the BeagleBone Black into a 14-channel, 100Msps Logic Analyzer. Once loaded, it presents itself as a character device node /dev/beaglelogic. In stand-alone mode, it can do binary captures without any special client software. And when used in conjunction with the sigrok library, BeagleLogic supports software triggers and decoding for over 30 different digital protocols.

The analyzer can sample signals from 10Hz upto 100MHz, in 8 or 16 bits and up to a maximum of 14 channels. Sample depth depends on free RAM, and upto 320MB can be reserved for BeagleLogic. There’s also a web interface, which, once installed on the BeagleBone, can be accessed from port 4000 and can be used for low-volume captures (up to 3K samples).

[abhishek] recently added the BeagleLogic Cape which can be used to debug logic circuits up to 5V safely. Source files for BeagleLogic as well as the Cape are available via his github repos. [abhishek] blogged about his project on his website where there’s a lot more information and links to be found. Catch a video of BeagleLogic after the break.

Continue reading “Turn Your BeagleBoneBlack In To A 14-channel, 100Msps Logic Analyzer” →

Library Upgrade To PRU Gives Fast IO On Beaglebone

February 16, 2015 by Anool Mahidharia 19 Comments

The BeagleBone Black has a powerful featureset: decent clock speed, analog inputs, multiple UART, SPI and I2C channels and on-board memory, to name a few. One missing feature seems to be the lack of support for the two on-board Programmable Real-time Units (PRU’s). Each of these 32-bit processors run independently of the main processor, but are able to interface with the main processor through the use of shared RAM and some interrupts. Unfortunately, PRU’s are not supported and in the absence of information, difficult to program. Enabling the PRU’s will allow them direct access to external sensors via the GPIO pins, for example. Perhaps most enticing is the idea that the PRU’s add real-time processing capability to the BBB.

[Thomas Freiherr] is working on the libpruio project to allow PRU support on the BBB. It is “designed for easy configuration and data handling at high speed. libpruio software runs on the host (ARM) and in parallel on a Programmable Realtime Unit SubSystem (= PRUSS or just PRU) and controls the subsystems”. Additional information about the project is available on the libpruio wiki, and files can be downloaded from here (German Page).

This paper presented at inter.noise2014 (PDF) a couple of months ago has a nice comparison of various small computer/controller boards and outlines the advantages of the BBB once its PRUs are enabled. If readers come across applications of the BBB with PRUs enabled, let us know in the comments. If you want to work your way into the world of the PRU we highly recommend this tutorial series.

Thanks for sending in the tip, [Patrick]

[Image Source: libpruio stepper motor example]

Talking BeagleBoard With [Jason Kridner]

July 22, 2014 by Mike Szczys 8 Comments

[Jason Kridner] is a member of the i3 Detroit hackerspace and during the Hackaday meet-up we were able to spend a few minutes talking about what’s going on with BeagleBoard right now. For those of you that don’t know, BeagleBoard is a non-profit foundation which guides the open hardware initiative of the same name. This includes BeagleBone which is the third iteration of the platform. [Jason’s] a good guy to talk to about this as he co-founded the organization and has been the driving force in the community ever since.

Right now the organization is participating in the Google Summer of Code. This initiative allows students to propose open source coding projects which will help move the community forward. Students with accepted proposals were paired with mentors and are paid for the quality code which is produced. One of the projects this year is a 100 Megahertz, 14-channel Logic Analyzer which [Jason] is waving around in the video. It’s the GSoC project of [Kumar Abhishek] and you can learn more from his proposal.

Also of interest in the video is a discussion about the power of the BeagleBone’s PRUs, or Programmable Real-Time Units. They’re basically unused microcontrollers that have direct access to a lot of the processor’s features and are just waiting for you to bend them to your will. Having these is a huge boon for hardware hackers. If you haven’t played with them before, check out our earlier article on what PRUs are all about and then give it a whirl yourself.

After the break there’s a brief table of contents which maps the topics shown off in the video.

Continue reading “Talking BeagleBoard With [Jason Kridner]” →

An Introduction To The BeagleBone PRU

June 22, 2014 by Brian Benchoff 21 Comments

BBB While the BeagleBone is usually compared to the Raspberry Pi, there are a few features that make the ‘Bone a vastly more capable single board computer. There is a small difference in the capabilities of the processor, but the real power of the BeagleBone comes from the PRUs available: two small cores that give the BeagleBone the hardware equivalent of bitbanging pins. [Texane] has put up two great tutorials for using the PRU in the BeagleBone that should be required reading for every BeagleBone owner.

The first tutorial goes over the capabilities of the PRUs in the BeagleBone and setting up the software environment to develop your own hardware interfaces with the PRU. While writing code for the PRU has usually involved the Beagleboard packages, TI has recently released a version of Code Composer Studio that gives the option to compile C code for the PRU.

[Texane] used this C compiler to rehash the earlier, assembly only PRU program, making development significantly easier. There’s still a bit of inline assembly, and the inline assembly support isn’t as advanced as in GCC, but it’s still much easier than the assembly only variant.

While [Texane] is using the PRU in his BeagleBone to develop something at a synchrotron facility, three are a few things where really fast hardware bitbanging comes in handy: it can be used to make a video card for a vintage mac, or any sort of VGA video card, really. Very cool stuff, especially now that you can write something in C.