No one is sitting around their workbench trying to come up with the next great oscilloscope or multimeter, but function generators still remain one of the pieces of test equipment anyone – even someone with an Arduino starter pack – can build at home. Most of these function generators aren’t very good; you’re lucky if you can get a sine wave above the audio spectrum. [Bruce Land] had the idea to play around with DMA channels on a PIC32 and ended up with a function generator that uses zero CPU cycles. It’s perfect for a homebrew function generator build, or even a very cool audio synthesizer.
The main obstacles to generating a good sine wave at high frequencies are a high sample rate and an accurate DAC. For homebrew function generators, it’s usually the sample rate that’s terrible; it’s hard pushing bits out a port that fast. By using the DMA channel on a PIC32, [Bruce] can shove arbitrary waveforms out of the chip without using any CPU cycles. By writing a sine wave, or any other wave for that matter, to memory, the PIC32 will just spit them out and leave the CPU to do more important work.
[Bruce] was able to generate a great-looking sine wave up to 200 kHz, and the highest amplitude of the harmonics was about 40db below the fundamental up to 100 kHz. That’s a spectacular sine wave, and the perfect basis for a DIY function generator build.
Typically bit-banging an I/O line is the common method of driving the WS2812B (WS2811) RGB LEDs. However, this ties up precious microcontroller cycles while it waits around to flip a bit. A less processor intensive method is to use one of the built-in Serial Peripheral Interface (SPI) modules. This is done using specially crafted data and baud rate settings, that when shifted out over the Serial Data Out (SDO) pin, recreate the needed WS2812B signal timing. Even when running in SPI mode, your hardware TX buffer size will limit how many pixels you can update without CPU intervention.
[Henrik] gets around this limitation by using peripheral DMA (Direct Memory Access) to the SPI module in the Microchip PIC32MX250F128B microcontroller. Once properly configured, the DMA controller will auto increment through the defined section of DMA RAM, sending the pixel data over to the SPI module. Since the DMA controller takes care of the transfer, the micro is free to do other things. This makes all of DMA memory your display buffer. And leaves plenty of precious microcontroller cycles available to calculate what patterns you want the RGB LEDs to display.
Source code is available at the above link for those who would like to peruse, or try it out. This is part of [Henrik’s] Pixel Art Project. Video of DMA based SPI pixels after the break:
Continue reading “Driving WS2812B Pixels, With DMA Based SPI”
An interesting trick you can do with a a fast CPU and a GPIO pin mapped directly to memory is an FM transmitter. Just toggle a pin on and off fast enough, and you have a crude and kludgy transmitter. [Brandon] saw a few builds that turned a Raspberry Pi into an FM radio transmitter and realized a lot of toy remote control cars use a frequency in the same range a Pi can transmit at. It’s not much of a leap to realize the Pi can control these remote control cars using only a length of wire attached to a GPIO pin.
The original hack that turned a Pi GPIO pin into an FM transmitter mapped a GPIO pin to memory, cycled through that memory at about 100 MHz, and added a fractional divider to slightly adjust the frequency, turning it into an FM transmitter. Cheap RC cars usually listen for radio signals at 27 and 49 MHz. It doesn’t take much to realize commanding RC cars with a Pi is possible.
The only problem with this idea is that most RC cars use pulse modulation. For an RC transmitter to send the command for ‘forward’, a synchronization pulse is sent, then a series of pulses and pauses. The frequency doesn’t change at all, something the originally FM code doesn’t do. [Brandon] realized that if he just moved the frequency up to something the RC car wasn’t listening to, that would register as a zero.
All that was left was to figure out the command codes for his RC truck. For this, [Brandon] decided brute force would be the best option. Armed with a script and a webcam, he cycled through all possible combinations until the webcam detected a moving truck. Subtlety brilliant, if you ask us. Of course more complex commands required an oscilloscope, but now [Brandon] has a git full of all the code to control a cheap RC car with a Pi.
It’s pretty well known by now that the LED pixel hardware which is starting to be commonplace, both WS2811 and WS2812, needs pretty strict timing in order to address them. There are libraries out there which mean almost no work on your part, but that’s no fun. [Elia] started looking into what it takes to drive the hardware, trying out a few 8-bit micros before moving to 32-bit with the help of an STM32VL Discovery Board. The move to a beefier processor brings a lot of speed, but why bit bang everything? He came up with a way to use the PWM and DMA features of the chip to drive the LEDs.
DMA is the Direct Memory Access unit that allows you to change the values being sent to the pixel without interrupting the processor. This is done by pre-loading the data at a memory location. This buffer is automatically read by the DMA unit — its values are used to set the PWM timer compare trigger in order to send out logic values show in the diagram above.
If you do want to delve further into this topic here’s a collection of techniques for driving the WS2811.
Continue reading “Using DMA to Drive WS2812 LED Pixels”
Now here’s a project that actually hacks the Rapsberry Pi rather than just using it as an embedded computer. [Londons Explorer] figured out how to turn the RPi into an FM transmitter. For now it’s done entirely in the user space, but we’re sure it could be improved if someone wanted to drill down further into the hardware. For those wanting to give it a try he’s rolled everything into a simple python package.
The technique requires nothing additional except a 20cm wire to serve as an antenna. The trick is to map GPIO pin number 4 to a position in memory. The clock generator is then used to toggle this pin at 100 MHz, which is the frequency to which your radio should be tuned. A fractional divider adjusts the frequency based on the sound file being transmitted.
The proof of concept for this was able to reliably transmit at a distance of about fifty meters through several walls. The problem is that this technique is limited in the amount of data which can be sent. Right now it’s only about 6-bit audio. But descending deeper through the abstraction layers to put DMA (Direct Memory Access) to use may be able to improve upon this.
[Thanks Owen via Reddit]
Here’s the first project we’ve seen for the new Stellaris Launchpad. It’s a frequency analyzer which displays a graph on an 8×8 LED module. What’s that you say? You haven’t received your new Launchpad board yet? Neither have we since they don’t start shipping until the end of the month. But [EuphonistiHack] works as a software dev for TI and snagged one of the early development units.
Hardware is rather simple. He uses an OpAmp to feed audio from his laptop to the ARM processor. The 8×8 LED module is an MSP430 booster pack that is addressed via SPI. On the software side of things he’s really taking advantage of hardware peripherals to simplify his work. A timer triggers each ADC reading which in turn writes the values using uDMA. Digital Signal Processing (available as a CMSIS library for many ARM chips) is then used to translate the ADC value to one that can be displayed on the LEDs. Check out the video after the break to see the final version.
The Hackaday writers are looking for an easier name for this hardware than “Stellaris Launchpad”. It doesn’t seem to lend itself to a shorter name, like RPi or Raspi does for the Raspberry Pi. If you’ve got a catchy nick name for the new board please share it in the comments.
[Arthur Benemann] started a little project for his electrical engineering program, and suffered the worst case of feature creep we’ve ever seen. He just posted an instructable of his picChess project that is able to play chess on a VGA monitor with a keyboard, with sound, a clock, temperature sensor. Apparently, [Arthur] was bored one evening and threw in an implementation of Conway’s game of life.
[Arthur] chose a DSPIC33F μC for his project with everything laid out on a bread board. He’s quite proud of his VGA routine, the first time he’s ever used DMA. We’re really impressed by [Arthur]’s chess engine – his is the first homebrew chess engine we’ve seen on Hack A Day. Although the engine is a brute-force search with Alpha-beta pruning, the engine itself seems fairly advanced that will even supports castling.
Although a few rules aren’t supported and the ELO rating of the engine isn’t known, [Arthur]’s engine should still be able to beat an amateur player. A fairly impressive feat indeed.
Check out [Arthur]’s video after the break.
Continue reading “Playing chess on a microcontroller”