Announcing: BeagleLogic Standalone

Today, I’m delighted to announce something that I’ve been working on the past four months, which is now alive and doing exactly what it was meant for. A Standalone, turnkey logic analyzer based on the work I did for BeagleLogic. And is aptly titled – BeagleLogic Standalone.

BeagleLogic Standalone is a specialized version of the BeagleBone which is intended to be used a logic analyzer based on BeagleLogic.

Describing it as an equation, (BeagleLogic Standalone) > (BeagleBone) + (BeagleLogic). The greater than comes from the fact that the BeagleBone + BeagleLogic has up to 14 logic inputs, BeagleLogic Standalone has 16. It has 1000Mbps Ethernet, while the BeagleBone has just 100Mbps.

This logic analyzer has networking capabilities (10/100/1000Mbps Ethernet); it can be used to used to debug circuits remotely. And as it is a full-featured Linux computer, you can run the sigrok set of tools directly on the BeagleLogic Standalone board (they come preinstalled in the BeagleLogic system image), or on your host PC. It has 16 channels and can sample up to 1.5 seconds of data at the maximum sample rate, which is 100MSamples/sec (3 seconds of data if using only the first 8 channels).

If you are interested in purchasing one of these boards, please fill up this form, and I’ll keep you informed.

The rest of this post is dedicated to describing the story behind the creation of BeagleLogic Standalone.

Background

Using the BeagleBone Black with BeagleLogic as a Logic Analyzer had its limitations, first, there were only 14 channels possible out of the maximum 16. Only 12 channels were enabled by default and in order to get the next two channels, the onboard eMMC has to be disabled. This involved a number of steps and wasn’t easy for someone just getting started or getting a BeagleBone just for use with BeagleLogic.

Second, there was no interface fast enough to bring out all the data that BeagleLogic was generating into the outside world. The Ethernet and USB RNDIS interface maxed out at 100Mbps; the USB host too wasn’t fast enough. The AM335x had Gigabit Ethernet, but there was no board variant yet that could use it (since some time we’ve had the SanCloud BeagleBone Enhanced that did have a Gigabit Ethernet PHY on board).

Since creating BeagleLogic in 2014, I’ve wondered – what if I could create a custom version of BeagleBone that would address these limitations? I didn’t have an easy answer back then as the process of designing a board like the BeagleBone Black required a lot of engineering resources. Even though the BeagleBoard design was all open hardware, source files were readily available, how would I customize it without an Allegro license? Even if I managed to customize it, how would I manufacture prototypes of it, and where? These unanswered questions would soon have its answer, and it came in the form of…

A System-In-Package

Octavo Systems‘ in late 2015 announced their OSD3358 System-in-Package based on the AM3358 SoC. It can be practically described as a BeagleBone-on-a-chip as it includes the AM3358 SoC, DDR RAM, a TPS65217 PMIC – all the essential components into a 400-ball BGA package. It got me excited because I could concentrate on the core features I wanted to add to the solution and not have to reinvent the wheel.

In the summers of 2016, I met Jason and other members of the BeagleBoard.org community at the Bay Area Maker Faire. They encouraged me to come up with a design. However life caught up, and the idea remained in limbo for a year, until I resumed a development streak on BeagleLogic in May-June 2017 to move it from the old kernel version 3.8.13 to the newer 4.9-ti kernel which entailed a partial rewrite of the PRU firmware and the kernel driver. In doing the rewrite, I revisited the idea of having a standalone version of BeagleLogic. The Hackaday Prize was already round the corner, I thought that the standalone version could make a good entry into the “Best Product” category of the contest. This got me started with the design.

Schematics and Routing

I announced the project on the Hackaday.io page on July 2, 2017. Shortly after announcing, Michael Welling of QWERTY Embedded, also the creator of the PocketBone offered to do a design review. Drew Fustini of OSHPark offered to sponsor the PCBs (Thanks, Drew and Michael!). I started working on the schematics after spending some time with the TI Pinmux utility to make sure I got all the basics right (RGMII interface, 16 PRU inputs, 8-bit eMMC, etc). The schematics were completed by mid-July.

I was designing with the OSD3358 but it was at this time that I noticed that Octavo systems had announced their new SiP, the OSD3358-SM which was smaller, had an EEPROM and an optimized ball map that promised to escape all signals on a single layer. This would help me in routing the board. Jason also encouraged me to use the OSD3358-SM. Since the datasheet was not available at that time, I wrote a small script to copy the OSD3358-SM ball map from the preliminary technical data and used it to change the schematic symbol to migrate the design from OSD3358 to the OSD3358-SM using the kipart script and some manual cleanup. The migration was completed in late July.

Routing commenced in mid-August. This time I was also relocating as I had got a new job, so the work took longer than usual to complete as I was busy finding a house, and all. The placement was finalized in the last week of August, and the board outline frozen. Initially, I was really apprehensive if I’ll be able to complete the routing in 4 layers or not, but thanks to the optimized ball map of the OSD3358, I was able to finish it in 4 layers. After a week the routing was complete and shared for review. After addressing the comments, the board was ready for ordering by the 12th of September. On the morning of the 13th of September, I placed the order with OSHPark. 6 purple 4-layer boards.

Manufacturing

With over 200 parts across both sides of the board, I knew that hand assembling this board was out of the question, and I had to get it manufactured. It was at this time that I was connected with GHI Electronics in Michigan who agreed to assemble the first prototypes of the project. Parts were purchased, and this went on in parallel with the boards being fabricated. This was my first experience working with a manufacturer on a project.

Finally the day. I got an email from OSHPark on the 26th of September that the boards had been despatched with shipping upgraded to UPS Next Day. On the 27th, they were received and the bottom layer was assembled. On the 28th the top and the through-hole assembly was finished and the boards shipped to India. Here’s a pic from the assembly line as the board came out of reflow:

It was a long wait until…

Board Bringup

On the 4th of October, *the* package showed up at my door and I felt the surge of excitement as I rushed to open it. The boards were right here and the first thing I did was to connect them to my PC over USB. The power LED came on, and on a closer look at the system logs, a USB device (the AM335x network interface) showed up. This was a good sign (no magic smoke), but the boards had not yet been booted.

Robert Nelson provided and pointed me to u-boot patches that I’d apply to a version of u-boot that I would compile on my system. The board EEPROM had to be programmed before I could boot, and I had to boot the system in order to program the EEPROM. Turns out, to solve this chicken-and-egg problem, there is a third patch that is not applied to production u-boot. This patch causes the board to be recognized as a generic BeagleBone and it boots. So the board booted and I was in!

However as soon as I flashed the EEPROM with the BeagleLogic EEPROM board header, it refused to boot. Turns out this was a bug in u-boot and I found it and fixed it. Once this was done, my board was booting.

After a successful boot, I finalized the device tree sources for BeagleLogic in order to get the pinmux and the peripherals right. Post the device tree finalization I was able to get the Ethernet, the eMMC, the USB host, the expansion port all working.

However, the real test was to install BeagleLogic on the board and try doing a sample data capture. I tried, and it worked! This is one of the first captures from the BeagleLogic standalone board.

This meant the board was both alive and functional. I was happy that everything worked out in the first revision itself.

3D Printed Case and send-off to Hackaday

In two iterations, I designed and 3D printed a snug fit “open” case for the BeagleLogic standalone board. I’ve written more about it in a Hackaday.io project log. This is how it looks:

After the case was printed, I prepared three of the prototypes for sending to Hackaday for the Best Product round. You can read more about it here and here. The prototypes were shipped on the 13th of October and received on the 16th of October, well before the cut-off date of the 21st of October.

Next Steps

BeagleLogic Standalone is one of the 20 finalists in the Best Product round of the Hackaday Prize. The results are awaited on the 11th of November. It’s been a great journey taking BeagleLogic standalone from a concept to a prototype and giving a glimpse as to what it could be as a finished product and the experience I gained during the process is invaluable, and I wish to thank Hackaday for providing me with this opportunity.

If enough people sign up, I plan on organizing a group buy for BeagleLogic Standalone boards. If you want to get one, please do not hesitate and sign up here.

There are still some software kinks to be ironed out, but I’ll do that in due course of time. I plan next to work on improving the web interface of BeagleLogic. I’ve been spending some time learning React this July and hope to apply that knowledge to develop a great web front-end for BeagleLogic as it will be a key differentiating factor that can make BeagleLogic a great product.

Acknowledgements

I wish to thank the following people/entities, whose contributions helped make the BeagleLogic Standalone project possible and in the state that it is today:

Jason Kridner and BeagleBoard.org for supporting the BeagleLogic project since 2014 when it began through the Google Summer of Code program;

GHI Electronics for the really great assembly of the boards. Their support and timely assembly was critical to getting the prototypes to Hackaday in time and ensuring that I was still part of the competition;

Robert Nelson for helping with the board bring-up and software support;

Octavo Systems for their great SiP that made this project possible in the first place;

The sigrok project for the open source stack that BeagleLogic makes use of to make logic capture and protocol decoding possible on the board itself.