A Drone Photosphere Is Worth 4000 Times Pi Words

One of the problems with a cheap drone is getting good video, especially in real time. Cheap hobby quadcopters often have a camera built-in or mounted in a fixed position. That’s great for fun shots, but it makes it hard to get just the right shot, especially as the drone tilts up and down, taking the camera with it. Pricey drones often have a gimbal mount to keep the camera stable, but you are still only looking in one direction.

Some cheap drones now have a VR (virtual reality) mode to feed signal to a headset or a Google Cardboard-like VR setup. That’s hard to fly, though, because you can’t really look around without moving the drone to match. You can mount multiple cameras, but now you’ve added weight and power drain to your drone.

MAGnet Systems wants to change all that with a lightweight spherical camera made to fit on a flying vehicle. The camera is under 2.5 inches square, weighs 62 grams, and draws less than 3 watts at 12 volts. It picks up a sphere that is 360 degrees around the drone’s front and back and 240 degrees centered directly under the drone. That allows a view of 30 degrees above the horizon as well as directly under the drone. There is apparently a different lens that can provide 280 degrees if you need that, although apparently that will add size and weight and be more suitable for use on the ground.

The software (see video below) runs on Windows or Android (they’ve promised an iOS version) and there’s no additional image processing hardware needed. The camera can also drive common VR headsets.

Continue reading “A Drone Photosphere Is Worth 4000 Times Pi Words” →

Gawking Hex Files

Last time I talked about how to use AWK (or, more probably the GNU AWK known as GAWK) to process text files. You might be thinking: why did I care? Hardware hackers don’t need text files, right? Maybe they do. I want to talk about a few common cases where AWK can process things that are more up the hardware hacker’s alley.

The Simple: Data Logs

If you look around, a lot of data loggers and test instruments do produce text files. If you have a text file from your scope or a program like SIGROK, it is simple to slice and dice it with AWK. Your machines might not always put out nicely formatted text files. That’s what AWK is for.

AWK makes the default assumption that fields break on whitespace and end with line feeds. However, you can change those assumptions in lots of ways. You can set FS and RS to change the field separator and record separator, respectively. Usually, you’ll set this in the BEGIN action although you can also change it on the command line.

For example, suppose your test file uses semicolons between fields. No problem. Just set FS to “;” and you are ready to go. Setting FS to a newline will treat the entire line as a single field. Instead of delimited fields, you might also run into fixed-width fields. For a file like that, you can set FIELDWIDTHS.

If the records aren’t delimited, but a fixed length, things are a bit trickier. Some people use the Linux utility dd to break the file apart into lines by the number of bytes in each record. You can also set RS to a limited number of any character and then use the RT variable (see below) to find out what those characters were. There are other options and even ways to read multiple lines. The GAWK manual is your friend if you have these cases.

BEGIN { RS=".{10}"   # records are 10 characters
      }

   {
   $0=RT
   }

   {
   print $0  # do what you want here
   }

Once you have records and fields sorted, it is easy to do things like average values, detect values that are out of limit, and just about anything else you can think of.

Spreadsheet Data Logs

Some tools output spreadsheets. AWK isn’t great at handling spreadsheets directly. However, a spreadsheet can be saved as a CSV file and then AWK can chew those up easily. It is also an easy format to produce from an AWK file that you can then read into a spreadsheet. You can then easily produce nice graphs, if you don’t want to use GNUPlot.

Simplistically, setting FS to a comma will do the job. If all you have is numbers, this is probably enough. If you have strings, though, some programs put quotes around strings (that may contain commas or spaces). Some only put quotes around strings that have commas in them.

To work around this problem cleanly, AWK offers an alternate way to define fields. Normally, FS tells you what characters separate a field. However, you can set FPAT to define what a field looks like. In the case of CSV file, a field is any character other than a comma or a double quote and then anything up to the next double quote.

The manual has a good example:

BEGIN {
  FPAT = "([^,]+)|(\"[^\"]+\")"
  }

  {
  print "NF = ", NF
  for (i = 1; i <= NF; i++) {
  printf("$%d = <%s>\n", i, $i)
  }

This isn’t perfect. For example, escaped quotes don’t work right. Quoted text with new lines in it don’t either. The manual has some changes that remove quotes and handle empty fields, but the example above works for most common cases. Often the easiest approach is to change the delimiter in the source program to something unique, instead of a comma.

Hex Files

Another text file common in hardware circles is a hex file. That is a text file that represents the hex contents of a programmable memory (perhaps embedded in a microcontroller). There are two common formats: Intel hex files and Motorola S records. AWK can handle both, but we’ll focus on the Intel variant.

Old versions of AWK didn’t work well with hex input, so you’d have to resort to building arrays to convert hex digits to numbers. You still see that sometimes in old code or code that strives to be compatible. However, GNU AWK has the strtonum function that explicitly converts a string to a number and understands the 0x prefix. So a highly compatible two digit hex function looks like this (not including the code to initialize the hexdigit array):

function hex2dec(x) {
  return (hexdigit[substr(x,1,1)]*16)+hexdigit[substr(x,2,1)]
}

If you don’t mind requiring GAWK, it can look like this:

function hex2dec(x) {
  return strtonum("0x" x);
}

In fact, the last function is a little better (and misnamed) because it can handle any hex number regardless of length (up to whatever limit is in GAWK).

Hex output is simple since you have printf and the X format specifier is available. Below is an AWK script that chews through a hex file and provides a count of the entire file, plus shows a breakdown of the segments (that is, non-contiguous memory regions).

BEGIN { ct=0;
  adxpt=""
}


function hex4dec(y) {
  return strtonum("0x" y)
}


function hex2dec(x) {
  return strtonum("0x" x);
}

/:[[:xdigit:]][[:xdigit:]][[:xdigit:]][[:xdigit:]][[:xdigit:]][[:xdigit:]]00/ {

  ad = hex4dec(substr($0, 4, 4))
  if (ad != adxpt) {
  block[++n] = ad
  adxpt = ad;
    }
  l = hex2dec(substr($0, 2, 2))
  blockct[n] = blockct[n] + l
  adxpt = adxpt + l
  ct = ct + l
  }

END { printf("Count=%d (0x%04x) bytes\t%d (0x%04x) words\n\n", ct, ct, ct/2, ct/2)
  for (i = 1 ; i <= n ; i++) {
  printf("%04x: %d (0x%x) bytes\t", block[i], blockct[i], blockct[i])
  printf("%d (0x%x) words\n", blockct[i]/2, blockct[i]/2)
  }

}

This shows a few AWK features: the BEGIN action, user-defined functions, the use of named character classes (:xdigit: is a hex digit) and arrays (block and blockct use numeric indices even though they don’t have to). In the END action, the summary uses printf statements for both decimal and hex output.

Once you can parse a file like this, there are many things you could do with the resulting data. Here’s an example of some similar code that does a sanity check on hex files.

Binary Files

Text files are fine, but real hardware uses binary files that people (and AWK) can’t easily read, right? Well, maybe people, but AWK can read binary files in a few ways. You can use getline in the BEGIN part of the script and control how things are read directly. You can also use the RS/RT trick mentioned above to read a specific number of bytes. There are a few other AWK-only methods you can read about if you are interested.

However, the easiest way to deal with binary files in AWK is to convert them to text files using something like the od utility. This is a program available with Linux (or Cygwin, and probably other Windows toolkits) that converts a binary file to different readable formats. You probably want hex bytes, so that’s the -t x2 option (or use x4 for 16-bit words). However, the output is made for humans, not machines, so when a long run of the same output occurs, od omits them replacing all the missing lines with a single asterisk. For AWK use, you want to use the -v option to turn that behavior off. There are other options to change the output radix of the address, swap bytes, and more.

Here are a few lines from a random binary file:

0000000 d8ff e0ff 1000 464a 4649 0100 0001 0100
0000020 0100 0000 dbff 4300 5900 433d 434e 5938
0000040 484e 644e 595e 8569 90de 7a85 857a c2ff
0000060 a1cd ffde ffff ffff ffff ffff ffff ffff
0000100 ffff ffff ffff ffff ffff ffff ffff ffff
0000120 ffff ffff ffff ffff ffff 00db 0143 645e
0000140 8564 8575 90ff ff90 ffff ffff ffff ffff
0000160 ffff ffff ffff ffff ffff ffff ffff ffff
0000200 ffff ffff ffff ffff ffff ffff ffff ffff
0000220 ffff ffff ffff ffff ffff ffff ffff c0ff
0000240 1100 0108 02e0 0380 2201 0200 0111 1103
0000260 ff01 00c4 001f 0100 0105 0101 0101 0001
0000300 0000 0000 0000 0100 0302 0504 0706 0908
0000320 0b0a c4ff b500 0010 0102 0303 0402 0503
0000340 0405 0004 0100 017d 0302 0400 0511 2112
0000360 4131 1306 6151 2207 1471 8132 a191 2308

This is dead simple to parse with AWK. The address will be $1 and each field will be $2, $3, etc. You can just convert the file yourself, use a pipe in the shell, or–if you want a clean solution–have AWK run od as a subprocess. Since the input is text, all of AWK’s regular expression features still work, which is useful.

Writing binary files is easy, too, since printf can output nearly anything. An alternative is to use xxd instead of od. It can convert binary files to text, but also can do the reverse.

Full Languages

There’s an old saying that if all you have is a hammer, everything looks like a nail. I doubt that AWK is the best tool to build full languages, but it can be a component of some quick and dirty hacks. For example, the universal cross assembler uses AWK to transform assembly language files into an internal format the C preprocessor can handle

Since AWK can call out to external programs easily, it would be possible to write things that, for example, processed a text file of commands and used them to drive a robot arm. The regular expression matching makes text processing easy and external programs could actually handle the hardware interface.

awk-wolfensteinThink that’s far fetched? We’ve covered stranger AWK use cases, including a Wolfenstien-like game that uses 600 lines of AWK script (as seen to the right).

So, sure it is software, but it is a tool that has that Swiss Army knife quality that makes it a useful tool for software and hardware hackers alike. Of course, other tools like Perl, Python, and even C or C++ can do more. But often with a price in complexity and learning curve. AWK isn’t for every job, but when it works, it works well.

Build Your Own Brushless Motor

Building an electric motor from a coil of wire, some magnets, and some paper clips is a rite of passage for many budding science buffs. These motors are simple brushed motors. That is, the electromagnet spins towards a permanent magnet and the spinning breaks the circuit, allowing the electromagnet to continue spinning from inertia. Eventually, the connection completes again and the cycle starts over. Real brushed motors commutate the DC supply current so that the electromagnet changes polarity midway through the turn. Either way, the basic design is permanent magnets on the outside (the stationary part) and electromagnets on the inside (the rotating part).

Brushless motors flip this inside out. The rotating part (the rotor) has a permanent magnet. The stationary part (the stator) has multiple electromagnets. By controlling the electromagnets, the rotor spins. With no brushes, these motors are often more efficient, they don’t generate as much electrical noise, and there is no danger of brushes wearing out. In addition, the electromagnets staying put make the motor easier to wire and, if needed, easier to cool the electromagnets. The principle of operation is similar to a stepper motor. Steppers are usually optimized for small precise steps. Brushless motors are optimized for spinning, not stepping.

[Axbm] built a clever brushless motor out of little more than PVC pipe, some magnets, wire, and iron rods. The plan is simple: construct a PVC frame, build a rotor out of PVC and magnets, and mount electromagnets on the frame. An Arduino and some FETs drive the coils, although you could drive the motors using any number of methods. You can see the whole thing work in the video below.

Continue reading “Build Your Own Brushless Motor” →

Gremlins Are Air To Air Drones

If you are like most people, your drone flights start on the ground and end either on the ground or–in more cases than most of us want to admit–in a tree. Earlier this year, DARPA awarded initial contracts for the Gremlins program. The idea is to produce unmanned aircraft that can launch from another aircraft and then later have another aircraft recover it.

The idea is to allow a plane to launch an unmanned sensor, for example, while out of range of enemy fire. Later another aircraft can retrieve the drone where a ground crew would get it ready for another flight within 24 hours. An aircraft facing missile fire could unleash a swarm of drones, confusing attackers. The drones have a limited life of about twenty flights, allowing for inexpensive airframes that use existing technology. You can see a concept video from DARPA about how air-launched drones might play a role in future air combat below.

Continue reading “Gremlins Are Air To Air Drones” →

Avoiding Exercise With An ESP8266 And Blynk

[Mike Diamond] was tired of climbing down (and back up) 40 stairs to check his mailbox. He decided to create a mailbox alert using the ESP8266 to connect to his WiFi. The idea was simple: have the ESP8266 monitor when the mailbox flap opened using a magnet and a reed switch. As always, though, the devil is in the details. [Mike] got things working with a little help and shares not only the finished design but how he got there.

To handle the sending of e-mail, [Mike] used the Blynk app. You often think of Blynk as a way to build user interfaces on an Android or iOS device that can control an Arduino. In this case, though, [Mike] used the library with the ESP8266 and had it send e-mail on his behalf.

Continue reading “Avoiding Exercise With An ESP8266 And Blynk” →

What’s Special About Fifty Ohms?

If you’ve worked with radios or other high-frequency circuits, you’ve probably noticed the prevalence of 50 ohm coax. Sure, you sometimes see 75 ohm coax, but overwhelmingly, RF circuits work at 50 ohms.

[Microwaves 101] has an interesting article about how this became the ubiquitous match. Apparently in the 1930s, radio transmitters were pushing towards higher power levels. You generally think that thicker wires have less loss. For coax cable carrying RF though, it’s a bit more complicated.

First, RF signals exhibit the skin effect–they don’t travel in the center of the conductor. Second, the dielectric material (that is, the insulator between the inner and outer conductors) plays a role. The impedance is also a function of the dielectric material and the diameter of the center conductor.

Continue reading “What’s Special About Fifty Ohms?” →

Open Source Solar

What’s the size of a standard euro-palette, goes together in 15 minutes, and can charge 120 mobile phones at one time? At least one correct answer is Sunzilla, the open source solar power generator. The device does use some proprietary components, but the entire design is open source. It contains solar panels, of course, as well as storage capacity and an inverter.

You can see a video about the project below. The design is modular so you can pick and choose what you want. It also is portable, stackable, and easy to transport. The team claims they generate 900W of solar power and can store 4 kWh. Because of the storage device, the peak power out is 1600W and the output is 230V 50Hz AC.

Continue reading “Open Source Solar” →