[RandomTask] has posted a nice tutorial on how to use a FTDI serial to usb converter, and a couple analog to digital converters to make a simple software oscilloscope. Using a “Universal Serial to USB converter” and one of many FTDI break out boards, he first reprograms the chip using FTDI’s programming software to put the device into a FIFO (first in first out) mode.

From there a pair of ADC0820 8 bit digital to analog converters are wired up, and input is fed to a couple 555′s for testing. It should be noted that there is no input protection, so things like voltages above 5 volts, or negative voltages are a big no-no with this setup. It still could be very handy while working with micro controllers or other digital circuits.

Data is then sent to the computer and displayed using a VB.net program, which has some basic features like scale and triggering, but also contains a couple bonuses like Calc Freq and Calc V delta calculation.

Many people have these little serial to usb converters, and might be in need of a simple scope. If you’re one of them, then you can cobble this together pretty darn quickly, and cheaply.

We see people driving around the night before trash collection and reclaiming items doomed to the land fill (or on their way to recycling… who knows). We’re beginning to think we need to join those ranks. Case in point is this vintage oscilloscope which [Bob Alexander] plucked from the curb in the nick of time. Here’s the kicker, when he got it home he found it still worked! He couldn’t let this opportunity go to waste, so he figured out how to turn it into a clock without losing the ability to use it as a scope.

You probably already know that it’s possible to display your own graphics on an oscilloscope. In fact, you can buy a board from Sparkfun which will turn the scope into an analog clock, and that’s exactly what [Bob] did. But he was met with two problems, the X-axis was flipped and he didn’t have an easy way to power the board.

He struggled with the voltage supply, frying his first attempt at boosting the internal 6.3V supply to use with a linear 5V regulator. His second attempt worked though, soldering a 12V regulator to the transformer. He was then on to the X-axis correction, using a rail-to-rail op-amp to invert the signal. The project finishes by adding toggle controls and buttons on the back of the case to switch between scope and clock modes, and to set the time.

We love our little Rigol 1052E oscilloscope. It’s seen us through some perplexing problems and loved being upgraded from 50 MHz to 100 MHz. We’ve always been pleased with its role dictating waveforms for us, but we never thought we’d see homebrew apps for our little ‘scope.

We’re not exactly sure who [Krater] is, but he’s been working on some homebrew development for the Rigol DS1052E oscilloscope. Right now the capabilities are somewhat limited; all programming is via PEEKs and POKEs. Still, this is a fairly impressive development.

This wonderful little ‘scope has already had some time in the limelight by being easy to upgrade to 100 MHz. Hopefully with the new capabilities (Tetris, somebody make Tetris), this scope will become a staple in workshops around the world.

A tip ‘o the hat goes to [Rainer Wetzel] for sending this one in. Check out the video after the break to see an almost-working game of Pong playing on the 1052E

EDIT: [krater] dropped into the comments to tell us about his blog entry. Keep up the good work.

Here’s [Rob]‘s free form circuit that’s a Christmas ornament for geeks. It looks great, but sadly isn’t powered through a Christmas light strand. It’s just as cool as the skeletal Arduino we saw.

Prototyping with flowers

Well this is interesting: protoboard that’s specifically made to make SMD soldering easier. The guys at elecfreaks went through a lot of design iterations to make sure it works.

We’ll call it Buzz Beer

The days are getting longer and cabin fever will soon set in. Why not brew beer in your coffee maker? It’s an oldie but a goodie.

Christmas oscilloscope

With just an ATtiny and a little bit of  futzing around changing the coefficients of a partial differential equation, you too can have your very own oscilloscope Christmas tree. Don’t worry though, there are instructions on how to implement it with an Arduino as well. HaD’s own [Kevin] might be the one to beat, though.

So what exactly does a grip do?

You know what your home movies need? A camera crane, of course. You’ll be able to get some neat panning action going on, and maybe some shots you couldn’t do otherwise. Want a demo? Ok, here’s a guy on a unicycle.

If you are considering repurposing some old computer equipment to create music, be aware that the bar has been raised just a tad. YouTube user [BD594] spent some time sifting through his bin of used electronics and put together a 5-piece band that plays a pretty awesome rendition of The Animals’ “House of the Rising Sun”.

Last week, we saw a pretty impressive hack with a floppy drive that could bang out music using a calculator, but this takes things to a whole new level. [BD594] used an old HP ScanJet to simulate the song’s vocals, while an Atari 800XL combined with an oscilloscope is used as an organ. A Ti-99/4a is used in conjunction with another scope to play guitar notes, while a PIC-controlled hard drive does double duty, playing both the bass drum and cymbals.

We dare you to watch the video below and NOT be thoroughly impressed with his work.

[BD594] says that once he has a bit of free time, he’ll be putting out another video – something we’ll be anxiously waiting to see.

[Privatier] wrote in to let us know about lxardoscope, his project that lets you use an Arduino as hardware input for a Linux-based oscilloscope display. This implementation offers two channels with about 3000 samples per second from each. He touts some of the GUI options like vertical resolution between 2mV and 10V per division. That part kind of stumps us because we don’t see how a measurement of 10V (or more) can be taken using the schematic included. But you’re comprehension may surpass ours so do take a look yourself.

He is using an Arduino Uno for his testing. But to get around some issues he’s experienced with other USB-based solutions he implemented a serial port connection instead. You’ll need to remove the ATmega chip from the Arduino board after flashing the code to it, and then build a circuit around it which includes a power source where -2.5V is ground and 2.5V is VCC. All in all, you’ll need a 16 Mhz crystal, HEF4069 hex inverter, ATmega8-family microcontroller, and a few passive components to build this on a breadboard.

1. Simple low resolution dot drawing
2. A font example
3. A very quickly and badly written demo of pong

The software runs on an Attiny84 micro controller clocked at 16Mhz, paired up with a Microchip MCP42100 dual 100k 8 bit digital potentiometer though the Attiny’s USI (Universal Serial Interface) pins. This is a fast, stable and accurate arrangement, but it requires sending 16 bits every time you want to change the value of one of the potentiometers so its also very piggy. I was just out to have some fun and did not have a proper 8 bit DAC. This was the closest thing outside of building one.
Join us after the break for pictures a (very) brief video and more.

This project has a total resolution of 256x256x1. This sounds like a lot of resolution but don’t get too excited. You can have only a few hundred to maybe 1000 pixels on screen before it starts flickering pretty badly. I am sure this can be solved by someone who is not using GCC commands for almost all of an Arduino script, furiously tying to shove 16 or 32 bits of data out of its SPI port PER PIXEL with an Attiny that has no dedicated SPI.

I had originally thought that I was going to do some form of raster scan display, much like a TV or computer monitor scanning a row of pixels one column at a time. You can see examples of this on electronixandmore in the projects section where the author converts RS170 television, and also VGA to an oscilloscope (along with a bunch of other cool stuff). Also take a look at this project that ran recently on Hackaday: NintendOscope.On my little 84 it ended up being extremely slow to scan each and every pixel and then modulating the Z axis on the back of the scope to change the pixels brightness.

Ok fine let’s keep it simple, how about some vector lines? I copied the site’s logo and quickly traced it out using the gimp using its [Web > Image Map] function. This spits out a file like this:

<img src="Untitled.bmp" width="125" height="120" border="0" usemap="#map" />
<map name="map">
<!-- #$-:Image map file created by GIMP Image Map plug-in -->
<!-- #$-:GIMP Image Map plug-in by Maurits Rijk -->
<!-- #$-:Please do not edit lines starting with "#$" -->
<!-- #$VERSION:2.3 -->
<!-- #$AUTHOR:kevin -->
<area shape="poly" coords="17,16,36,37,49,66,37,98,20,103,19,48" nohref="nohref" />
</map>

By drawing only points in that file I was able to produce the first “image” below. With a little refinement I produced a slightly cleaner result in the second image. As you can see you have to be very mindful where your little pointer is going because it leaves a trail. I was not really happy with the quality of these first try results, though its generally a very fast way to draw out wire-frame polygons (think Asteroids).

I ended up doing a mix. Instead of scanning every row and column, I only scan the rows and columns that have pixels to show. This produces a dot matrix image. I also needed an easy, but not epic, effort to convert images from computer to AVR. This was accomplished using the gimp, the XPM image format, and a little blob of lua.

Using the Hack a Day logo as an example, I roughly cropped out the skull and then used [Image >> Autocrop Image]. Next I went to [Image >> Canvas Size] and changed this to a 128×128 canvas. Finally I used [Image >> Flatten Image] with black set as the color background. The next step is to remove the black background. That’s easy enough with [Colors >> Color to Alpha].

I could display this as a solid raster but it would be way too slow to make out an image with this hardware and software. I need to remove most of the pixels. In order to do this, I use a quickie gimp cheat, go to [Filters >> Alpha to Logo >> Neon]. Now change the effect size to 5 and the glow color to white. Finally, delete the neon glow layer and flatten.

Since I am using a 1 bit per pixel color choice, I use [Image >> Mode >> Indexed], and choose 1 bit with no dithering. This produces a high quality outline of the logo, but it is still heavy on the pixels. In order to trim both ROM space and draw time I removed every other row and column by using [Filters >> Distorts >> Erase every other row]. I want it to fill with background which should be black. I did this once with rows and once with columns, even or odd is your choice, whichever looks better..

I dug in at 800% and touched up all the graphics with a 1 pixel paintbrush and saved as XPM format. XPM format is a basic text format where different characters represent a different pixel and color value. With only 1 bit per pixel you can quite clearly see the image in the text.

I removed the entire header, and so a lua script could phrase it I added “strings ={“ minus quotes so the file looks like:

strings = {
“data”,
“data”,
};

after the bracket and semi colon I added the following little blob of lua:

file = io.open("logo.out","w")
counter = 1;
for y = 1, #strings do
    for x = 1,#strings[y] do
        if string.sub(strings[y], x, x) == "+" then
            file:write(y .. ",".. x .. ",")
            counter = counter + 1
        end
    end
end
print(counter*2)
file:close()

This scans through the data and makes a file that contains a single line of comma separated values of every white pixel of the graphic. It also spits out a number in the command line which is the number of pixels * 2 for number of XY values. You need to know the number of pixels if you want to draw any graphic since the program loops though the lua generated CSV file. It’s basic and big but it works well enough for the example.

If you have lua installed its generally “lua filename.ext”, sometimes “lua51 filename.ext”, minus the quotes.

AvrGCCiberishduino code is an Arduino sketch with void setup, void loop, and I used analog read because there was no advantage to implementing it myself. Arduino’s expandability to other models of AVR and simplified functionality does very good for many things. When you need to bring out the speed it has its issues.

Pretty soon you are twiddling port registers and looking into how to use the USI (universal serial interface) to send out SPI because it is faster than you can do it in software blah blah blah. Eventually I had an Arduino sketch tied to only the attiny84, though one would need to only change pins for other attiny’s like the 85 or 2313.
Atmegas, like what is on a normal Arduino would need different SPI code to function.)

// System
#include <avr/pgmspace.h>
#define cmdOne 0x11 // write to pot 0(X)
#define cmdTwo 0x12 // write to pot 1(Y)

// Graphics
prog_uchar hadlogo[] PROGMEM ={5,19,5,21,5,23,5,25,5,103,5,105,5,107,5,109,6,27,6,101,7,19,7,29,7,99,7,107,7,109,8,21,9,23,9,31,9,97,9,105,11,25,11,33,11,95,11,103,13,26,13,34,13,94,13,103,15,25,15,35,15,93,15,103,17,23,17,35,17,93,17,105,19,7,19,9,19,21,19,35,19,92,19,107,19,119,19,121,21,7,21,11,21,19,21,36,21,91,21,109,21,117,21,121,23,8,23,13,23,15,23,17,23,37,23,89,23,111,23,113,23,115,23,121,25,9,25,39,25,87,25,119,27,10,27,41,27,85,27,118,29,11,29,43,29,83,29,117,30,13,30,45,30,115,31,15,31,47,31,81,31,113,32,17,32,111,33,19,33,21,33,23,33,25,33,49,33,57,33,59,33,61,33,63,33,65,33,67,33,69,33,71,33,79,33,105,33,107,33,109,34,103,35,27,35,51,35,53,35,55,35,73,35,75,35,77,35,101,36,99,37,29,37,31,37,49,37,77,37,97,39,33,39,47,39,79,39,95,41,35,41,45,41,81,41,93,43,37,43,43,43,83,43,91,45,39,45,41,45,85,45,89,47,40,47,87,49,39,49,87,51,38,51,88,53,37,53,89,55,37,55,47,55,49,55,51,55,53,55,55,55,71,55,73,55,75,55,77,55,89,56,79,57,37,57,45,57,57,57,69,57,81,57,89,59,37,59,45,59,57,59,69,59,83,59,89,61,37,61,44,61,57,61,69,61,83,61,89,63,37,63,57,63,69,63,83,63,89,64,43,65,37,65,53,65,55,65,70,65,73,65,83,65,89,66,45,66,51,66,75,67,37,67,47,67,49,67,77,67,83,67,89,68,79,69,37,69,81,69,89,71,36,71,38,71,63,71,65,71,89,71,91,73,35,73,39,73,87,73,93,74,64,75,33,75,40,75,86,75,95,77,31,77,41,77,63,77,65,77,85,77,97,78,29,78,99,79,27,79,42,79,83,79,101,80,25,80,104,81,17,81,19,81,21,81,23,81,44,81,82,81,107,81,109,81,111,82,15,83,13,83,46,83,81,83,83,83,113,83,115,85,11,85,43,85,47,85,80,85,85,85,117,87,9,87,41,87,48,87,58,87,70,87,80,87,87,87,119,89,8,89,39,89,49,89,57,89,59,89,69,89,71,89,79,89,89,89,121,90,15,91,7,91,13,91,17,91,37,91,51,91,53,91,55,91,61,91,63,91,65,91,67,91,73,91,75,91,77,91,91,91,111,91,113,91,115,91,121,93,7,93,11,93,19,93,35,93,91,93,109,93,117,93,121,95,7,95,9,95,21,95,35,95,92,95,107,95,119,95,121,97,23,97,35,97,93,97,105,99,25,99,35,99,93,99,103,101,25,101,34,101,94,101,103,103,25,103,33,103,95,103,103,104,23,105,21,105,31,105,97,105,105,105,107,107,19,107,29,107,99,107,109,108,27,108,101,109,19,109,21,109,23,109,25,109,103,109,105,109,107,109,109};

// Functions
void qshift(byte input) // using the USI for SPI
{
USIDR = input; // put a byte into the register
USISR = _BV(USIOIF); // clear flag
while ( (USISR & _BV(USIOIF)) == 0 ) // send away
{
USICR = (1<<USIWM0)|(1<<USICS1)|(1<<USICLK)|(1<<USITC);
}
}
void latch(bool state) // toggle CS pin on digipot
{
if(state == 1) PORTA |= (1 << 3); // raise the latch
else PORTA &=~ (1 << 3); // lower the latch
}</p>
void logoscrn() // draw the Hack A Day logo
{
for (int i = 0; i < 674; i += 2)
{
// 0,0 on an image is upper left, on scope its lower left
// subtract pixel Y value from 255 to flip right side up
latch(0); // lower the latch
qshift(cmdTwo); // send the write channel two command
qshift(255 - (64 + pgm_read_byte_near(hadlogo + i))); // send Y data
latch(1); // raise the latch
// image is offset by 64 as it is only has a 128x128 canvas
latch(0); // lower the latch
qshift(cmdOne); // send the write channel one command
qshift(64 + pgm_read_byte_near(hadlogo + (i + 1))); // send X data
latch(1); // raise the latch
}
}
// Arduino Setup
void setup()
{
// set pins of PORTA, PA7 & PA2 as inputs, the rest are outputs</p>
DDRA = 0x7B;
}
// Arduino Loop
void loop()
{
logoscrn();
}

As you can see, this is a much improved picture quality.

The other 2 demos use this basic system with a button wired up between pin 6 and ground to switch demos. Demo 2 uses a counter and a scale variable to zoom from the upper left corner to full size large font with 3 lines of text and room for a few more. Demo 3 is the start of a sloppy pong game with a (stupid and jumpy) cpu opponent, no scorekeeping and a looping ball. Just hook up a potentiometer with one end on ground the other on +5 and the middle to pin to pin 11 of the Attiny84.

Software.zip you will need a Programmer, Arduino or Arduino Core, and Arduino Tiny

Unfortunately for now I have to move on from this idea, but please fear that I shall return soon enough!

[Andrew Rossignol] was curious one day and decided that he wanted to display graphics on an oscilloscope after playing around with the X and Y inputs.

[Andrew] started out with a resistor ladder on the DAC of his AVR Butterfly. He was able to to draw a line on the oscilloscope’s screen but bandwidth limitations forced him to reconsider his approach. A friend wrote a Python script to generate C code so the ports of the Butterfly can be toggled. After getting the Butterfly to generate a voltage for every non-white pixel, [Andrew] was impressed with the results so the code was modified determine the brightness of each pixel. The setup managed 10 shades of gray and careful selection of what graphics to post on the build log assured the project a little bit of blog cred.

There are a few ways to display a picture on an oscilloscope, like plugging the Hsync and Vsync into the inputs of a scope. Except for a few music visualizations, we haven’t seen a scope display generated from a microcontroller. Great work [Andrew], but we’d like to mention there’s a grayscale Hack a Day logo from way back when.

Check out a video of [Andrew]‘s oscilloscope after the break.

If you don’t have an oscilloscope you’d be surprised how many times you find yourself needing one. But if you have an Arduino on hand, the next time you might be able to get by with this software suite that can use a development board as oscilloscope inputs. The project is called xoscillo, and it allows an Arduino, or a Parallax USB Oscilloscope, to probe the signals while a computer does the heavy lifting.

The Arduino can be used for up to four input channels at 7 kHz. It’s possible to probe seven signals at 4 kHz as well. But the main feature that caught our eye is the ability to use several Arduino boards at one time in increase the number of channels available to you.

Granted, this is pretty slow for many digital electronic troubleshooting needs. But at least it’s something you can pull out when you just don’t have any other ideas about what is going wrong with your prototype circuit. We’re sure that sooner or later you’ll break down and buy a proper hackable oscilloscope. After all, your Arduino is probably already occupied as an I2C sniffer.

[Thanks Adam]

[Aaron] wrote in to share with us a quick hack that has made his life a little easier. He bought a Rocketfish RF-HV3 portable iPod dock to listen to his music, but he wanted to utilize it as an alarm clock as well. He also found that the speakers worked quite well when he hooked up his Yaesu handheld transmitter to the dock.

The only problem he had with it was that the dock would automatically power down when there was no input for 5 minutes. That’s fine when the dock is running on batteries, but if [Aaron] was going to use it as an alarm clock or to listen to his HAM radio, that simply wouldn’t do.

He pulled the dock apart and started poking around with his DSO Nano scope. He found that if pin 16 stays low for 5 minutes, it turns off the dock even if there is a signal coming through. His fix for the problem was actually quite simple – all he did was solder the VDD pin to the pin in question, and the 5-minute timeout was disabled.

We’re glad that [Aaron] was able to solve his problem in such an easy manner – it just goes to show what you can do with a scope and a few minutes’ time.

[Todd Harrison] recently wrote in to tip us off on his submission to the Tektronix oscilloscope contest – using a scope to tune a piano. In his video he demonstrates how a Fast Fourier Transform can be used to determine the fundamental frequency of the note being played. This is a quick and easy way to determine if that key is in tune, and if not, how far off it is from the desired frequency and in which direction.

He goes on to explain that a scope can only be used as a starting reference point since “mathematically correct” tuning on a piano doesn’t sound right to the human ear. It turns out that when struck, the stretched wires in the piano behave less than ideally. In the case of a piano, the overtones (the other peaks shown on the scope higher in frequency than the fundamental) are actually slightly sharper (higher in frequency) than the expected harmonic whole-number multiple of the fundamental frequency.  As a result, the frequency ranges of each octave must be “stretched” in order to accommodate this and sound correct when multiple notes are played together across octaves.

Typically, only the A4 key is actually tuned to its correct frequency of 440Hz and all of the other keys are manually tuned off of this baseline. The amount of necessary stretch applied to each octave increases as you get further away from this initial reference point in either direction and is unique to each and every individual instrument – thus there is no universal device capable of perfect tuning. Although [Todd] admits that he won’t attempt to tune the entire piano himself using this technique, he finds it a convenient way to keep the most heavily played center sections of the piano closer to true between professional tunings.

If you have any interesting or unique uses for your Techtronix scope, you can enter the contest here. Just don’t forget to tip us off too!  Thanks [Todd]!

[Joey] likes to dabble in laser projection, building his own hardware and writing the software that drives it. One way that he tests his setup is by replacing the laser assembly with an analog oscilloscope. This allows him to ensure that the driver board is receiving data from the software, and translating it into the correct electrical signals to drive the motors controlling the mirrored redirection of the laser beam.

In the video linked above [Joey] walks us through this process. It starts by connecting scope probes to the digital-analog-converter card that outputs image data for the projector. From there the XY mode is used to map the two channels perpendicular to each other; the motors that these signals are meant to control have mirrors that also move perpendicular to one another. After adjusting the scale and the timebase you will see the pattern the laser dot is meant to trace.

[Joey] entered this in a Tectronix contest. There’s plenty of other interesting entries to browse though. If have an entry that you’d like to see featured, or if you come across any other interesting stuff, don’t forget to tip us off.

Seeed Studio’s line of hacker-friendly tools has expanded by one, they’ve announced that beta units of their DSO Quad oscilloscope are now available for shipping. The DSO Quad is about the size of a thick iPod yet packs impressive features such as two 72MSPS analog channels and a signal generator. By far the coolest ‘feature’ of the DSO Quad is that it’s completely open source.

DSO Quad is a pocket size four-channel digital oscilloscope designed “for common electronic engineering tasks.” It’s based on an ARM Cortex M3 that provides 72MSPS analog bandwidth on two channels with an integrated FPGA and a high speed ADC. In addition to the four data acquisition channels (two analog, two digital), the DSO Quad has a signal generator.  This lets you put out square, triangle, saw, and sine waves from 10Hz to 1MHz. An internal 2MB USB stick can be used to store sampled data, upgrade the firmware, or run custom programs. Since the device is still in beta, some of the software specifications aren’t firm, but if you’re looking for a relatively inexpensive ‘scope, this could be the one for you. Just bear in mind that for this pre-production run you’re not getting any documentation, so be prepared to be off the reservation and on your own.

There is nothing wrong with your television set. Do not attempt to adjust the picture.

Where would we be if we listened to advice like that? [Eric] writes that with a fairly simple circuit, he’s able to split a composite video signal into its constituent X and Y ramp signals for display on his trusty Tektronix 465m. A LM1881 IC does the bulk of the heavy lifting. After running the signal through a few passive components, the generated ramp signals are ready for consumption by his venerable ‘scope. All that’s needed past that is some additional glue logic to invert the levels so the image shows up properly. The end result is a display that has an almost ethereal quality to it, like an old TV set or something out of the movie Brazil.

Hit the break to catch a video of the circuit in action.

This is a hack in the finest sense of the term. It not only allows you to capture data from an analog oscilloscope for later analysis, but provides you with a great tool if you’re posting on the Internet about your projects. [J8g8j] used an empty cashew container to add a camera mount to the front of his scope. This is possible because the bezel around the display has a groove in it. A bit of careful measuring helped him make an opening that was just right.

You can see that the red cap for the jar holds the camera and gave him a bit of trouble in the original prototype. This version has a tray where camera sits, which replaces the Velcro with didn’t hold the camera level the first time around. He’s also painted the inside of the clear plastic to reduce glare on the oscilloscope readout. Black and white images seem to come out the clearest, but it can be difficult to make out the grid lines. The addition of LEDs to help them stand out is one of the improvements we might see in the future.