The rust language logo being branded onto a microcontroller housing

Programming With Rust

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” →

Open Sesame Raspberry Pi Style

[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” →

Xilinx FPGAs In C For Free

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” →

Christmas Star Uses Two AA Batteries

When [hkdcsf] was a teenager, he made a Christmas star with an up counter driving decoder logic and using transistors to light LEDs in festive patterns. He’s revisited this project using modern techniques including a microcontroller, a DC/DC converter, and constant current LED drivers.

The project uses two AA batteries, and that’s what makes the DC/DC converter necessary. Blue LEDs have a forward voltage of just over 3V, and the LED driver chip requires about 0.6V of overhead. Two fresh AAs will run a tad above 3V, but as they discharge, or if he’s using rechargeables, there just won’t be enough potential. To make sure the star works even with whatever LEDs are chosen, the converter takes the nominal 3V from the batteries and converts it to 3.71V.

Continue reading “Christmas Star Uses Two AA Batteries” →

Taking The Pulse (Width Modulation) Of An FPGA

I like to think that there are four different ways people use FPGAs:

  1. Use the FPGA as a CPU which allows you to add predefined I/O blocks
  2. Build custom peripherals for an external CPU from predefined I/O blocks
  3. Build custom logic circuitry from scratch
  4. Projects that don’t need an FPGA, but help you learn

I’d bet the majority of FPGA use falls into categories one and two. Some FPGAs even have CPUs already built-in. Even without an onboard CPU, you can usually put a CPU “core” (think reusable library) into the chip. Either way, you can always add other cores to create UARTs, USB, Ethernet, PWM, or whatever other I/O you happen to need. You either connect them to a CPU on the chip, or an external one. With today’s tools, you often pick what you want from a list and then your entire project becomes a software development effort.

Continue reading “Taking The Pulse (Width Modulation) Of An FPGA” →

TI Releases New Edition Analog Engineer’s Pocket Reference

We aren’t sure that a PDF with 100 pages in it qualifies as a pocket reference, but TI’s Analog Engineer’s Pocket Reference is certainly a good read. You do have to register with TI (use a disposable address if you are too paranoid to do that), but the free download is well worth the effort. The document’s been around for awhile, but TI recently released a new 4th edition.

The first few pages might underwhelm you. You probably know the standard decimal prefixes and are more likely to ask Google to convert circular mils to square millimeters, for example. The second part, though, gets more into electronics. There’s standard values for resistors and quick reminders about the difference between X7R and Y5V ceramic in capacitors, for example.

Things get progressively more interesting, covering measurements and phase shifts, and then amplifiers. The little circuits are pithy but cover the bases including things like frequency response.

Continue reading “TI Releases New Edition Analog Engineer’s Pocket Reference” →