Machine Learning Crash Course From Google

We’ve been talking a lot about machine learning lately. People are using it for speech generation and recognition, computer vision, and even classifying radio signals. If you’ve yet to climb the learning curve, you might be interested in a new free class from Google using TensorFlow.

Of course, we’ve covered tutorials for TensorFlow before, but this is structured as a 15 hour class with 25 lessons and 40 exercises. Of course, it is also from the horse’s mouth, so to speak. Google says the class will answer questions like:

  • How does machine learning differ from traditional programming?
  • What is loss, and how do I measure it?
  • How does gradient descent work?
  • How do I determine whether my model is effective?
  • How do I represent my data so that a program can learn from it?
  • How do I build a deep neural network?

Continue reading “Machine Learning Crash Course From Google”

Hands-On: Flying Drones with Scratch

I’ll admit it. I have a lot of drones. Sitting at my desk I can count no fewer than ten in various states of flight readiness. There are probably another half dozen in the garage. Some of them cost almost nothing. Some cost the better part of a thousand bucks. But I recently bought a drone for $100 that is both technically interesting and has great potential for motivating kids to learn about programming. The Tello is a small drone from a company you’ve never heard of (Ryze Tech), but it has DJI flight technology onboard and you can program it via an API. What’s more exciting for someone learning to program than using it to fly a quadcopter?

For $100, the Tello drone is a great little flyer. I’d go as far as saying it is the best $100 drone I’ve ever seen. Normally I don’t suggest getting a drone with no GPS since the price on those has come down. But the Tello optical sensor does a great job of keeping the craft stable as long as there is enough light for it to see. In addition, the optical sensor works indoors unlike GPS.

But if that was all there was to it, it probably wouldn’t warrant a Hackaday post. What piqued my interest was that you can program the thing using a PC. In particular, they use Scratch — the language built at MIT for young students. However, the API is usable from other languages with some work.

Information about the programming environment is rather sparse, so I dug in to find out how it all worked.

Continue reading “Hands-On: Flying Drones with Scratch”

Raspberry Pi Keeps Cool

In general, heat is the enemy of electronics. [Christopher Barnatt] is serious about defeating that enemy and did some experiments with different cooling solutions for the Raspberry Pi 3. You can see the results in the video below.

A simple test script generated seven temperature readings for each configuration. [Barnatt] used a bare Pi, a cheap stick-on heatsink, and then two different fans over the heatsink. He also rigged up a large heatsink using a copper spacer and combined it with the larger of the two fans.

Continue reading “Raspberry Pi Keeps Cool”

Dual SDR Receives Two Bands at Once

There was a time when experimenting with software defined radio (SDR) was exotic. But thanks to cheap USB-based hardware, this technology is now accessible to anyone. While it is fun to play with the little $20 USB sticks, you’ll eventually want to move up to something better and there are a lot of great options. One of these is SDRPlay, and they recently released a new piece of hardware — RSPduo — that incorporates dual tuners.

We’ve talked about using the SDRPlay before as an upgrade from the cheap dongles. The new device can tune either a single 10 MHz band over the range of 1 kHz to 2 GHz, or you can select two 2 MHz bands. This opens up a lot of applications where you need to pick up signals in different areas of the spectrum (e.g., monitoring both sides of a cross-band repeater).

Continue reading “Dual SDR Receives Two Bands at Once”

Online Logic Simulator Is Textual — No, Graphical

We have a bit of a love/hate relationship with tools in the web browser. For education or just a quick experiment, we love having circuit analysis and FPGA tools at our fingertips with no installation required. However, we get nervous about storing code or schematics we might like to keep private “in the cloud.” However, looking at [Lode Vandevenne’s] LogicEmu, we think it is squarely in the educational camp.

You can think of this as sort of Falstad for logic circuits (although don’t forget Falstad does logic, too). The interface is sort of graphical, and sort of text-based, too. When you open the site, you’ll see a welcome document. But it isn’t just a document, it has embedded logic circuits in it that work.

Continue reading “Online Logic Simulator Is Textual — No, Graphical”

Internet of Laundry — Let the ESP8266 Watch Your Dirty Drawers Get Clean

When you think of world-changing devices, you usually don’t think of the washing machine. However, making laundry manageable changed not only how we dress but how much time people spent getting their clothes clean. So complaining about how laborious our laundry is today would make someone from the 1800s laugh. Still, we all hate the laundry and [Andrew Dupont], in particular, hates having to check on the machine to see if it is done. So he made Laundry Spy.

How do you sense when the machine — either a washer or a dryer — is done? [Andrew] thought about sensing current but didn’t want to mess with house current. His machines don’t have LED indicators, so using a light sensor wasn’t going to work either. However, an accelerometer can detect vibrations in the machine and most washers and dryers vibrate plenty while they are running.

The four-part build log shows how he took an ESP8266 and made it sense when the washer and dryer were done so it could text his cell phone. He’d already done a similar project with an Adafruit HUZZAH. But he wanted to build in some new ideas and currently likes working with NodeMCU. While he was at it he upgraded the motion sensor to an LIS3DH which was cheaper than the original sensor.

[Andrew] already runs Node – RED on a Raspberry Pi, so incorporating this project with his system was a snap. Of course, you could adapt the approach to lots of other things, as well. The device produces MQTT messages and Node – RED subscribes to them. The Pushover handles the text messaging. Node – RED has a graphical workflow that makes integrating all the pieces very intuitive. Here’s the high-level workflow:

You might wonder why he didn’t just have the ESP8266 talk directly to Pushover. That is possible, of course, but in part 2, [Andrew] enumerates some good reasons for his design. He wants to decouple components in the system for easier future upgrades. And MQTT is simple to publish on the sensor side of things compared to API calls which are handled by the Raspberry Pi for now.

Laundry monitoring isn’t a unique idea and everyone has a slightly different take on it, even some Hackaday authors. If phone notification is too subtle for you, you can always go bigger.

Parallel Programming for FPGAs

One of the best features of using FPGAs for a design is the inherent parallelism. Sure, you can write software to take advantage of multiple CPUs. But with an FPGA you can enjoy massive parallelism since all the pieces are just hardware. Every light switch in your house operates in parallel with the others. There’s a new edition of a book, titled Parallel Programming for FPGAs that explores that topic in depth and it is under the Creative Commons license. In particular, the book focuses on using Vivado HLS instead of the more traditional Verilog or VHDL.

HLS allows a designer to express a high-level algorithm in C, C++, or SystemC. Given a bit more information, HLS will convert that into an FPGA configuration. That doesn’t mean, though, that you can just cut and paste ordinary C code. HLS has several restrictions due to the fact that it is compiling to logic gates, not lines of code. Actually, it also generates Verilog or VHDL, but if you do it right, that should be transparent to you.

After the introduction, the book is more like a series of monographs on very specific topics, but the depth of each is very impressive. There’s plenty of DSP examples, of course. There’s also general math, so if you ever wondered how to compute a sine or cosine in an FPGA, read chapter 3.

Continue reading “Parallel Programming for FPGAs”