The NOAA-19 APT signal is a relatively simple signal to understand. When the satellite captures an image, it scans through it line-by-line, at a rate of two lines per second. The brightness of the image during scanning is amplitude modulated on to a 2.4kHz carrier tone, and sounds like this:

You can hear the (slightly painful) 2.4kHz carrier tone. Also notice the tick-tock-tick-tock pulse of the signal. Each tick and tock is a sync signal followed by a line of image data. Why a tick *and* a tock? APT transmits *two* images at a time, so the “tock” is the sync signal between data from the first and second images.

I rigged up a GNU Radio Companion “patch” to demodulate the APT signal. It’s based off a APT decoder by Alexandru Csete. It filters and demodulates the signal and outputs a file of demodulated data.

I tweaked the demodulated file a bit with Python, normalizing the data to the range (0,255) and writing out a byte-per-sample file:

import numpy
raw = numpy.fromfile('words.f32', dtype=numpy.float32)
normalized = raw / max(raw) * 255.0
output_u8 = numpy.array(normalized, dtype=numpy.uint8)
output_u8.tofile('pixels.u8')

Following Alexandru’s lead, I used ImageMagick’s “convert” to translate the byte-samples to a PNG image:

convert -size 2080x1194 -depth 8 gray:pixels.u8 image.png

And behold! A really noisy satellite image!

There are two images visible, side-by-side. The left side seems to be a visible spectrum image, while the right seems to be infrared. You can see parts of California, Oregon, and Washington. The Columbia River, a few miles from my house, is somewhat visible, too:

This was my first attempt at capturing a satellite signal, so I was using a crappy all-purpose dipole antenna. Hence the wretched amount of noise. But still, for my first attempt, I’m pretty pleased! Now, to build a better antenna…

Share/Bookmark

The first thing I did after recording the NOAA-19 APT signal was load it up in Audacity and examine the spectrum of the signal.

That’s a cool looking pattern — and it’s a bit suspicious too. The pinkish-purple curves indicate frequencies in the signal changing over time, over the ten minutes I recorded the signal. Notice how the frequencies change slowly at the beginning (left of the graph) when the satellite was rising over the horizon. The same thing happened at the end (right of the graph) when the satellite was descending back toward the horizon. When the satellite was directly overhead, the signal’s frequency changed very quickly. Hmmm. (think think think…) Hey, that’s the Doppler effect!

Indeed, the satellite is moving very fast — it orbits the Earth every 102 minutes. One Web site claims NOAA-19 is orbiting at 7.55 km/s, which is 27,180 km/h.

Let’s say we don’t already know how often the satellite orbits the Earth, or we don’t know the distance the satellite travels in one orbit. If we measure the Doppler shift of the signal, we can calculate the satellite’s speed ourselves. Here’s my measurement of the frequency shift in the signal — I get 5.6kHz from the the start to end of the satellite’s pass:

When the satellite is coming at me, the signal is “squeezed” and the frequency is increased by 2.8kHz — half of the 5.6kHz total shift I measured. As the satellite is traveling away from me, the signal is stretched and the frequency is decreased by 2.8kHz — the other half of the 5.6kHz shift. The frequency change as a percentage of the signal’s original frequency (137.1MHz) is 0.00204% — pretty small. But consider that this percentage is the speed of the satellite as a percentage of the speed of the signal. The signal is traveling at the speed of light, which is roughly 1,079,000,000 kilometers per hour. If we take that percentage from the speed of light, we get… Drum roll… 1,079,000,000 km/h * 0.0000204 = 22,000 km/h.

That’s close, but no cigar. Why is that number 19% lower than the actual satellite speed over the Earth (27,180 km/h, from above)? That’s pretty easy. The satellite is roughly 850 km above the Earth, and didn’t go directly overhead, but perhaps 450 km to the west. Calculating the hypotenuse: sqrt(850*850+450*450) = 962 km is the closest the satellite came to me. If the satellite went right through me, the Doppler shift I measured would’ve given the right answer. (…and I’d be splattered all over.) But the speed that the satellite was traveling relative to me was less than the satellite’s speed over the Earth.

Credit: Heavens-Above GmbH

Because I’m lazy and I’ve run out of room on my sketch-napkin, I’m offering a free Chronulator kit to the first person who can produce worked math that correctly compensates for the distance of the satellite from me, and gives an answer that’s within a few percent of the actual satellite orbit speed. I’m sure there’s a cosine or arctangent involved… Tweet your solution to @sharebrained or e-mail it to info@sharebrained.com — a camera-phone photo of a hand-written solution is fine (as long as I can read it!).

In part 3, I decode the signal to get at the weather images inside.

Share/Bookmark

Credit: NOAA

Joby was interested in receiving APT (automatic picture transmission) signals from the NOAA POES (polar operational environmental satellite). POES satellites orbit the earth every 102 minutes, and scan the entire Earth twice a day. They beam back radio signals containing images that we see every time we check the weather.

Credit: Fred E. Piering

I checked out the status of the POES satellites. NOAA-19 seemed like my best bet for reception of an APT signal on 137.1MHz. So I consulted Heavens Above (a great planet/star/satellite tracking Web site) to see when NOAA-19 would go over my town.

Credit: Heavens-Above GmbH

A few minutes before NOAA-19 was due to go overhead, I scrambled outside with my laptop, radio board, and cheap telescoping antenna. I hooked everything up and enticed my wife outside to help. As she monitored the waterfall spectrum on the computer, I waved the antenna around, trying to get the strongest possible signal. And here’s what we caught:

Wow! I didn’t expect my radio and antenna to be sensitive enough to receive a 10-Watt signal from 1,000 kilometers away! That signal should be strong enough to decode — which I’ll do in an upcoming post. Until then, stay tuned for tomorrow’s post: “Doppler Shift: How to calculate the speed of a satellite from your back yard”!

On to part 2 (computing satellite speed with “Doppler” shift) or part 3 (decoding the signal).

Here’s the Bus Pirate (red, foreground) hooked up to my audio prototype board (purple, in the background):

I’ve been through this before, the hard way. Bringing up new devices on the I2C bus can be tedious, and it’s hard to know what you’re doing wrong. Is my I2C peripheral driver bad? Or am I sending bad commands to the I2C device? Without a fancy logic analyzer, it’s hard to tell for sure. Now I can remove one variable from the process. I have a set of commands I *know* will correctly configure my audio codec, so later on, when I’m programming the microcontroller to do the configuration, I can rule out having a botched or malformed set of I2C configuration commands. Woo hoo!

Oh, wait. I still need to write an I2C driver for the STM32 microcontroller… Eeeew.

Share/Bookmark

How small? It’s common to use “0402″ resistors, capacitors, and inductors on a circuit board that operates at gigahertz frequencies. The name “0402″ comes from the dimensions of the components — 0.04″ x 0.02″ (1.0mm x 0.5mm). That’s really tiny. I don’t want to hand-solder those because I drink too much coffee and can’t hold still enough… So I investigated reflow soldering, a technique my Dorkbot colleagues have used with great success. It usually involves an cheap hot plate and some solder paste. The solder paste is applied to the board at places where solder needs to join components. Then the components are placed on top of the solder paste points. When the assembly is heated, the solder paste melts, and the surface tension of the molten solder pulls the components into place on their respective solder pads. It’s immensely easier than hand-soldering, and produces beautiful results.

The Hard and Messy Way

My first attempt involved applying solder paste in coarse blobs on the board, using a toothpick. That barely worked. The largest problem was that some solder joints had too much solder and flowed together with other solder joints. Other solder joints were too dry and in some cases didn’t connect reliably between the board and component.

In the real world of mass-production circuit board assembly, solder stencils are used. The solder paste is applied through a screen (stencil) that ensures the right amount of solder is applied in precisely the right places. As an individual, you can order laser-cut stencils cut from metal or expensive, high-temperature Kapton plastic. I didn’t want to wait for a stencil, take on the added cost, or have to procure large amounts of specialized plastic.

A colleague of mine suggested cutting stencils on the laser cutter we have in the office. Our laser cutter can’t cut metal, but it can cut paper. Since I’m making prototypes, not mass-producing products, it’s OK if the paper stencil is destroyed by using it. So I cut a stencil from paper and tried it.

The result with the paper stencil was OK, but not great. The paste bled underneath the stencil. In those spots, I had too much solder. It was also a bit tricky keeping the paper still as I applied the solder paste with the squeegee. Then, I had a revelation…

Adhesive Mailing Labels — SRSLY?

I have these Avery mailing labels that I use to address Chronulator kit shipments to my customers. They’re made of paper, and they stick to stuff. What if I cut my stencil from a mailing label? Let’s give it a try…

To start with, I need to prepare a solder paste template. I output a PDF with the paste layers shrunk a bit. I shrink the paste layer because the mailing label is quite thick, and therefore so is the paste when it’s applied. So I need to compensate for the thick paste by making the paste areas smaller.

From the paste template file, I laser the mailing label with the Epilog 45W laser at work. My settings are “speed 25″ and “power 25″. I use raster mode, as it tends to produce more accurate, even results.

Then, I cut out the template. I leave enough border so I have some room to spread the solder paste without getting it on the board. I also need a border to hold on to when I peel off the label.

I clean the circuit board with rubbing alcohol to make sure there’s no dirt or grime that will foul up soldering. Then I stick the template to the circuit board. Lining up the stencil is a bit tricky, but the mailing labels are only mildly sticky, and can easily be pulled up and reapplied if the alignment is off.

I’ve noticed that the mailing label adhesive gets stickier after being on the board a while. If you leave the label on the board for more than a day or two, it’s very hard to remove without ripping (and messing up your solder paste).

Like Buttering Toast

I apply the solder paste with a little metal squeegee. At first, I apply a lot of solder paste (several times what I need) and squeeze it against the board to get the paste deep into the template’s holes. The layer of paste is very thick.

After I have a thick layer of paste on the board, I scrape off all the excess — until I can see the template paper through the paste. Sometimes, I wind up scraping some of the paste out of a hole in the template, so I have to re-apply the paste and re-squeegy it to be smooth.

Once the solder paste is even, it’s time to peel off the template!

The hardest part of the whole process is placing the components on the board without damaging the solder paste. It’s essential to have a good eyesight, a good pair of tweezers, a steady hand, and lots of patience.

If you do smudge your solder paste, you can try to reshape it with the tip of a pen knife. And if one of your components doesn’t want to move into place, nudging it with the side of a pen knife blade seems to be the easiest way.

Turn On the Heat

After all the components are placed on the board, gently transfer it to the hot plate. Or better yet, put the board on the hotplate before you place the components.

Other people use fancy PID controllers to control their hot plate temperature. Since I’m building very small prototypes, I don’t need a lot of temperature precision. I warm up the board to the point where I see the first wisp of smoke (130C or so, I think), then turn off the heat and let it sit for a minute to stabilize the temperature. I turn the heat back on until I see the solder melt on all the components. I immediately turn the heat off. I let the board cool down for a couple of minutes, then move the board off the hot plate to cool the rest of the way. I’m probably stressing the components by shock-cooling them…

Go Forth and Modify

At this point, the board is done and it’s time to hook it up and see it work! So far, all the boards I’ve made with this technique (four) have worked great (except for the solder flux incident). Good luck to all who try it, and I hope to see people discussing improvements…

Lessons? Don’t assume your solder flux is non-conductive. Don’t use too much solder flux. If you do use solder flux, clean it off with rubbing alcohol and a stiff brush (like a toothbrush). And don’t trust any circuit until you’ve cleaned it of solder flux.

Duh. Well, some of us have to learn things the hard way…

Start with your libraries. If you try to browse your libraries in the 4.x Control Panel, you’ll get warnings about all the libraries that are too new. Make list of those libraries.

For each library on your error list:

• Open the library in EAGLE 5.x.
• Choose “File->Export…” and choose “Script” from the popup menu.
• Name the script file after your library (e.g. “analog_devices.scr”). I saved the script in the same directory as the library.
• Close the library.
• Move the library file (e.g. “analog_devices.lbr”) and backup files (“analog_devices.l#1″ through “analog_devices.l#9″) to a safe place.

For each script file (e.g. “analog_devices.scr”) you saved:

• Create a new library in EAGLE 4.x.
• Choose “File->Script…” and select the .scr file.
• Close the library. You’ll be prompted to save the library. Give it the same name as the original library.
• Delete the script file.

Now you’ve got your libraries rebuilt. Next up, your schematics. Download the ULP file “export-schematic.ulp” from the EAGLE Web site.

For each schematic file:

• Open the schematic in EAGLE 5.x.
• Choose “File->Run…” and choose the “export-schematic.ulp” file from where you downloaded it.
• The ULP will write out a file named “temp.scr”, in the same folder as the schematic file.
• Close EAGLE 5.x.
• Open EAGLE 4.x.
• Create a new folder for the 4.x version of your project.
• In the new folder, create a new schematic.
• Choose “File->Script…” and open the “temp.scr” script file you saved from EAGLE 5.x. It’ll take a while if your schematic is substantial. If you get questions about moving one net into another, say “yes”.
• Close the schematic, saving the file to the 4.x project folder you created, and using the same filename as your EAGLE 5.x project.

Next, your PCB layouts. Download my ULP file “export-board-layout.ulp” (derived from “export-board.ulp” from the EAGLE Web site).

For each board:

• Start EAGLE 5.x.
• Open your board file. Don’t do ANYTHING else at this point, or your export script file will get weird.
• Choose “File->Run…” and choose the “export-board-layout.ulp” file from where you downloaded it.
• The ULP will write out a file named “temp.scr”, in the same folder as the board file.
• Close EAGLE 5.x.
• Open EAGLE 4.x.
• Open the 4.x version of your schematic.
• Choose “File->Switch to board”.
• Allow EAGLE to “create from schematic”.
• Choose “File->Script…” and choose the “temp.scr” file you saved in an earlier step.
• Close the board, saving the file to the 4.x project folder you created, and using the same filename as your EAGLE 5.x project.

Whew. Not easy, but a whole lot easier than re-entering the schematic and board layout for a 100-component design… I hope this is helpful to somebody!