Year: 2015

Bouncing Radio Off Of Airplanes

December 18, 2015 by 49 Comments

Amateur radio operators are always trying some new stunt or other. It’s like they’ve got something to prove. Take Aircraft scatter for instance: the idea is to extend your radio’s range by bouncing it directionally off of overhead airplanes.

Radio signals travel in straight lines, which is a bummer because the Earth (despite what you’ve heard) is round. Inevitably, if you want to talk to someone far enough away, they’re over a hill. We’ve covered various oddball propagation methods recently, so if you don’t know about moonbounce, you’ve got some background reading to do. But airplane scatter was new to us.

Actually pulling it off requires knowing where the airplanes are, of course. To do so, you could simply look up the aircraft in your target area on the web, using something like FlightRadar24, but where’s the fun in that? There’s also the possibility of tracking local aircraft yourself using RTL-SDR if you’re feeling hard core.

The rest is just details. Hams [Rex Moncur (VK7MO)] and [David Smith (VK3HZ)], for instance, got 10 GHz signals to skip off airplanes over 842 km (PDF). If you’re an old-school ham operator, you’re double-checking the “gigahertz”, but it’s not a mistake. It’s tremendously impressive that these guys got a link over such a long distance using only 10 watts — but note that they’re doing it with highly directive dishes, and telescopes to aim them.

Not to discourage you from trying this at home, but there are all sorts of difficulties that you’ll encounter when you do. Airplanes moving perpendicular to the path between sender and receiver will Doppler-shift the signal, and there’s still quite a chunk of atmosphere to get the signal through. Finally, although airplanes look pretty big when they’re on the ground, they’re actually tiny when they’re up in the sky at 35,000 ft and 500 miles away; you’re bouncing your signal off of a small target.

The good news? People like [W3SZ] are sharing their well-documented results, and at least it’s 20dB easier than bouncing signals off the moon!

Thanks [Martin] for the tip!

The rust language logo being branded onto a microcontroller housing

Programming With Rust

December 18, 2015 by 108 Comments

Do hardware hackers need a new programming language? Your first answer might be no, but hold off a bit until you hear about a new language called Rust before you decide for sure.

We all know real hackers use assembly language to program CPUs directly, right? Well, most of us don’t do as much assembly language as we used to do. Languages like C can generate tight, predictable code and are easier to manage.

Although some people use more abstract languages in some embedded systems, it is no secret that for real-time systems, device driver development, and other similar tasks, you want a language that doesn’t obscure underlying details or generate code that’s difficult to reason about (like, for example, garbage collection). It is possible to use special techniques (like the Real-Time Java Specification) to help languages, but in the general case a lean language is still what most programmers reach for when you have to program bare metal.

Even C++, which is very popular, obscures some details if you use things like virtual functions (a controversial subject) although it is workable. It is attractive to get the benefit of modern programming tools even if it does conceal some of the underlying code more than straight C.

About Rust

That’s where Rust comes in. I could describe what Rust attempts to achieve, but it is probably easier to just quote the first part of the Rust documentation:

Rust is a systems programming language focused on three goals: safety, speed, and concurrency. It maintains these goals without having a garbage collector, making it a useful language for a number of use cases other languages aren’t good at: embedding in other languages, programs with specific space and time requirements, and writing low-level code, like device drivers and operating systems. It improves on current languages targeting this space by having a number of compile-time safety checks that produce no runtime overhead, while eliminating all data races. Rust also aims to achieve ‘zero-cost abstractions’ even though some of these abstractions feel like those of a high-level language. Even then, Rust still allows precise control like a low-level language would.

Continue reading “Programming With Rust” →

A Tiny Servo Motor Controller

December 18, 2015 by 33 Comments

If you’re building a moving thing with a microcontroller, you’ll probably want to throw a servo controller in the mix. Driving a servo or two with a microcontroller takes away valuable cycles that just babysit the servo, making sure all the PWM signals are in sync. The thing is, most servo controllers are a massive overkill, and you don’t need that much to control a few servos over a UART. The proof of this is an attiny13 servo controller over on hackaday.io.

[arief] developed his tiny servo controller around one of the tiniest microcontrollers – the ATtiny13. This chip has just 1kB of Flash and 64 Bytes of RAM, but that’s enough to keep a few servos going and listen in to a UART for commands to drive the servo.

The construction of this servo controller board is simple enough – just a single sided board, microcontroller, and a few headers, caps, and resistors. Commands are sent to the ATtiny through a half duplex UART we covered before, with servos responding to simple serial commands.

If you’re building a robot army, this is the board to make. You’re going to need a high-powered controller to take over the world, but there’s no need to bog down that controller by babysitting a few servos.

Open Sesame Raspberry Pi Style

December 17, 2015 by 5 Comments

[Don] installed an Android tablet into his wife’s vehicle and realized he wanted to allow it to operate and monitor the garage door. His biggest challenge? Meeting the (what he refers to) as the WAF or Wife Acceptance Factor. He decided to use a Web app on a Raspberry Pi, along with a handful of switches and a relay. His list of goals were straightforward:

  • Provide the status of the door (open/closed/unknown)
  • Open and close the door
  • Work across multiple platforms
  • Secure enough to connect to the Internet
  • Reliable and simple

Continue reading “Open Sesame Raspberry Pi Style” →

ATtiny Does 170×240 VGA With 8 Colors

December 17, 2015 by 96 Comments

The Arduino is a popular microcontroller platform for getting stuff done quickly: it’s widely available, there’s a wealth of online resources, and it’s a ready-to-use prototyping platform. On the opposite end of the spectrum, if you want to enjoy programming every bit of the microcontroller’s flash ROM, you can start with an arbitrarily tight resource constraint and see how far you can push it. [lucas][Radical Brad]’s demo that can output VGA and stereo audio on an eight-pin DIP microcontroller is a little bit more amazing than just blinking an LED.

[lucas][RB] is using an ATtiny85, the larger of the ATtiny series of microcontrollers. After connecting the required clock signal to the microcontroller to get the 25.175 Mhz signal required by VGA, he was left with only four pins to handle the four-colors and stereo audio. This is accomplished essentially by sending audio out at a time when the VGA monitor wouldn’t be expecting a signal (and [lucas][Rad Brad] does a great job explaining this process on his project page). He programmed the video core in assembly which helps to optimize the program, and only used passive components aside from the clock and the microcontroller.

Be sure to check out the video after the break to see how a processor with only 512 bytes of RAM can output an image that would require over 40 KB. It’s a true testament to how far you can push these processors if you’re determined. We’ve also seen these chips do over-the-air NTSC, bluetooth, and even Ethernet.

Continue reading “ATtiny Does 170×240 VGA With 8 Colors” →

Xilinx FPGAs In C For Free

December 17, 2015 by 16 Comments

When you think of developing with FPGAs, you usually think of writing Verilog or VHDL. However, there’s been a relatively recent trend to use C to describe what an FPGA should do and have tools that convert that to an FPGA. However, at least in the case of Xilinx parts, this capability is only available in their newest tool (Vivado), and Vivado doesn’t target the older lower-cost FPGAs that most low-cost development boards use.

[Sleibso] who blogs for Xilinx, has an answer. It turns out you can use the Vivado C compilation tools to generate code for older FPGAs; it just involves a less convenient workflow. Vivado (even the free version) generates unique files that the rest of the tool uses to pick up compiled C code. However, it also generates RTL (Verilog or VHDL) as a by-product, and you can import that into the older ISE tool (which has a perfectly fine free version) and treat it as you would any other RTL files.

There’s an example of using the Vivado tool in the video below. [Sleibso] points out that the video is three years old, and the talk about licensing on the video is out of date. The free tools now including this capability. [Sleibso] talks about using a Spartan 6, but the same split workflow should work with most devices ISE supports.

Continue reading “Xilinx FPGAs In C For Free” →