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”
[Darell] recently purchased a fancy new bathroom scale. Unlike an average bathroom scale, this one came with a wireless digital display. The user stands on the scale and the base unit transmits the weight measurement to the display using infrared signals. The idea is that you can place the display in front of your face instead of having to look down at your feet. [Darell] realized that his experience with infrared communication would likely enable him to hack this bathroom scale to automatically track his weight to a spreadsheet stored online.
[Darell] started by hooking up a 38khz infrared receiver unit to a logic analyzer. Then he recorded the one-way communication from the scale to the display. His experience told him that the scale was likely using pulse distance coding to encode the data. The scale would start each bit with a 500ms pulse. Then it would follow-up with either another 500ms pulse, or a 1000ms pulse. Each combination represented either a 1 or a 0. The problem was, [Darell] didn’t know which was which. He also wasn’t sure in which order the bits were being transmitted. He modified a software plugin for his logic analyzer to display 1’s and 0’s on top of the waveform. He then made several configurable options so he could try the various representations of the data.
Next it was time to generate some known data. He put increasing amounts of weight on the scale and recorded the resulting data along with the actual reading on the display. Then he tried various combinations of display settings until he got what appeared to be hexadecimal numbers increasing in size. Then by comparing values, he was able to determine what each of the five bytes represented. He was even able to reconstruct the checksum function used to generate the checksum byte.
Finally, [Darell] used a Raspberry Pi to hook the scale up to the cloud. He wrote a Python script to monitor an infrared receiver for the appropriate data. The script also verifies the checksum to ensure the data is not corrupted. [Darell] added a small LED light to indicate when the reading has been saved to the Google Docs spreadsheet, so he can be sure his weight is being recorded properly.
You know how sometimes you just can’t resist collecting old hardware, so you promise yourself that you will get around to working on it some day? [Danny] actually followed through on one of those promises after discovering an old Radio Shack TRS-80 TP-10 thermal printer in one of his boxes of old gear. It looks similar to a receipt printer you might see printing receipts at any brick and mortar store today. The original printer worked well enough, but [Danny] wasn’t satisfied with its 32 character per line limitation. He also wanted to be able to print more complex graphics. To accomplish this goal, he realized he was going to have to give this printer a brain transplant.
First, [Danny] wanted to find new paper for the printer. He only had one half of a roll left and it was 30 years old. He quickly realized that he could buy thermal paper for fax machines, but it would be too wide at 8.5 inches. Luckily, he was able to use a neighbor’s saw to cut the paper down to the right size. After a test run, he knew he was in business. The new fax paper actually looked better than the old stuff.
The next step was to figure out exactly how this printer works. If he was going to replace the CPU, he was going to need to know exactly how it functioned. He started by looking at the PCB to determine the various primary functions of the printer. He needed to know which functions were controlled by which CPU pins. After some Google-Fu, [Danny] was able to find the original manual for the printer. He was lucky in that the manual contained the schematic for the circuit.
Once he knew how everything was hooked up, [Danny] realized that he would need to learn how the CPU controlled all of the various functions. A logic analyzer would make his work much easier, but he didn’t happen to have one lying around. [Danny] he did what any skilled hacker would do. He built his own!
He built the analyzer around an ATMega664. It can sample eight signals every three microseconds. He claims it will fill its 64k of memory in about one fifth of a second. He got his new analyzer hooked up to the printer and then got to work coding his own logic visualization software. This visualization would provide him with a window to the inner workings of the circuit.
Now that he was able to see exactly how the printer functioned, [Danny] knew he would be able to code new software into a bigger and badder CPU. He chose to use another ATMega microcontroller. After a fair bit of trial and error, [Danny] ended up with working firmware. The new firmware can print up to 80 characters per line, which is more than double the original amount. It is also capable of printing simple black and white graphics.
[Danny] has published the source code and schematics for all of his circuits and utilities. You can find them at the bottom of his project page. Also, be sure to catch the demonstration video below. Continue reading “Thermal Printer Brain Transplant is Two Hacks in One”
[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 in the video above.
Continue reading “Talking BeagleBoard with [Jason Kridner]”
When [Marco] was planning on a storage oscilloscope build, he realized having a small device to display eight digital signals on an analog scope would be extremely useful. This just happens to be the exact description of a simple logic analyzer and managed to turn his idea into a neat little project (German, Google translation).
The theory of operation for this surprisingly simple, and something that could be completed in a few hours with a reasonably well stocked hackerspace or parts drawer in a few hours. A clock generator and binary counter are fed into the lower three bits of a simple R2R DAC, while the 8 inputs are fed into an 8-input multiplexer and sent to the last bit of the DAC. With nothing connected to the logic analyzer inputs, the output to the scope would just be an 8-step ramp that would appear as eight horizontal lines on the screen. With something connected to the logic analyzer input, an extremely primitive but still very useful logic analyzer appears on the screen.
While it’s not the greatest analyzer, it is something that can be cobbled together in an hour or two, and the capabilities are more than sufficient to debug a few simple circuits or figure out some timings in a project.
Here’s a quick tip to extend the usefulness of your multimeter. It’s a set of mini test hooks soldered to alligator clips with a short hunk of stranded wire in between. You can buy mini test hooks that go right on the metal probes of your meter, but the weight and bulk of the meter probes and cords sometimes get in the way. This rig allows more flexibility because of that wire.
Staying on the theme of test equipment tips, here’s a simple way to make a Y-connector for logic analyzers. [Thomas] uses a dual-row pin header, shorting each pair of pins so that both rows are connected. When this is plugged into a pin socket it leave two pins for connecting your test equipment and the rest of the project hardware.
After seeing our feature of a 3-wire Character LCD [Chad] wrote in to mention he built a 1-wire version using an ATmega328.
If you’re going to be in Anaheim this week you can stop by the ATX-West expo and see a 3D printer with a 1m x 1m x 0.5m printing area. [Thanks Martin]
Speaking of 3D printers, here’s a big delta robot (seven feet tall) outfitted for alternative material printing. It’s printing a CT scan of ribs and a heart in hot glue. This seems to be a popular material for more artistic uses. We just saw a hexapod which deposits hot glue as it roams.
The weaponized quadcopter post from Tuesday was a controversial one. The really bad part of it was the laser, which strapped to anything is extremely dangerous. But the other hack may have just been poorly executed. Hackaday alum [Jeremy Cook] wrote in to mention that fireworks and quadcopters can be used more responsibly. He strapped a sparkler to his quadro and used it to make light graffiti. You may remember that [Jeremy] wrote an introduction to light graffiti for us back in November.
We like [Tim’s] drive for improvement. He wrote a WS2812 driver library that works with AVR and ARM Cortex-M0 microcontrollers, but he wasn’t satisfied with how much of the controller’s resources the library used to simply output the required timing signal for these LED modules. When he set out to build version 2.0, he dug much deeper than just optimizing his own code.
We remember [Tim] from his project reverse engineering a candle flicker LED. This time, he’s done more reverse engineering by comparing the actual timing performance of the WS2812(B) module with its published specs. He learned that although several timing aspects require precision, others can be fudged a little bit. To figure out which ones, [Tim] used an ATtiny85 as a signal-generator and monitored performance results with a Saleae logic analyzer. Of course, to even talk about these advances you need to know something about the timing scheme, so [Tim] provides a quick run-through of the protocol as part of his write-up.
Click the top link to read his findings and how he used them to write the new library, which is stored in his GitHub repository.