At first, the problem looks like it might just be an exercise in resistance simplification using the well-known laws of parallel and serial resistances: Serial resistances add linearly, and parallel resistances follow 1/R = 1/R1 + 1/R2 etc. Unfortunately, this one isn’t quite so simple — three resistors meet at each vertex of the cube, and no two are directly parallel to or in series with each other.

A cube of 1-ohm resistors. What is the equivalent resistance between opposite corners?

One solution to this problem is to use the Wye-Delta conversion formula. Each of the corners of the cube is the center node of three resistors in a wye configuration.  These three resistors can be replaced, and the central node removed, by following the formula:

(formula from Wikipedia)

Rp in the formula is the sum of products — that is, R1R2 + R2R3 + R1R3.

Delta and Wye configurations. (Click for larger.)

(image from Wikipedia)

Using this formula, corners of the cube where three 1-ohm resistors meet can be removed; the three outer vertices of this wye are then connected by the equivalent network of one 3-ohm resistor between each pair of vertices (see image).

The cube, with one (shaded) corner transformed. Note the 3-ohm resistors.

One way you can think about this is that, initially, the resistance between any two nodes of the wye is 2 ohms (the inbound resistor plus the outbound resistor.) In order for the delta network to be equivalent, this resistance must be the same; the value of the delta resistor connecting those two nodes, in parallel with the sum of the other two delta resistors (for the long path around the triangle), must equal the original value of the resistance between the two nodes of the wye. For a wye of 1-ohm resistors, this is 3 ohms, since a 3-ohm resistor in parallel with a 6-ohm equivalent will equal two ohms. (1/3 + 1/6 = 1/2)

You can continue reducing the network in this way — but it turns out that symmetry and a little common sense provide an easier way to solve the puzzle.

The cube, with equipotential points shown, assuming resistance measured between blue and red. (Click for larger.)

Suppose that in the cube above, a voltage source is connected between the blue and red nodes. The resulting current can be used to determine the overall resistance. To calculate this without resulting to Wye-Delta conversions, note that all of the “purple” nodes are at the same voltage (due to symmetry), and all of the “green” nodes are at the same voltage (also due to symmetry). Because of this, the three purple nodes and the three green nodes can therefore be connected by wires in order to simplify the analysis. Because no voltage difference exists between the nodes, no current will flow across these wires, so the nature of the circuit hasn’t been fundamentally changed.

Here is a schematic of the original cube configuration…

A schematic for a circuit electrically equivalent to the Resistor Cube. (Click for larger.)

…and here is a schematic of the cube with the equipotential connections in place.

The same schematic, with connections added between the equipotential points. (Click for larger.)

The problem now becomes trivially easy. The blue node is connected to the green node via three 1-ohm resistors; the green node is connected to the purple node via six 1-ohm resistors; and the purple node is connected to the red node via another three 1-ohm resistors.

The equivalent circuit -- a simple series-parallel network. (Click for larger.)

The total circuit resistance is therefore 1/3 + 1/6 + 1/3 ohms, or 5/6 ohm.

The Teensy 3.0 running from a 3.7V coin cell on a breadboard. (Click for larger.)

It also runs a 48MHz, 32-bit Arm processor, making it not only easy to use, but a speed demon. If that’s not enough, it can be overclocked to 96MHz reliably enough that this is left as an option in the Arduino plug-in code provided with the board.

Like all Arduinos, the Teensy can be programmed from the Arduino IDE, although the various differences mean that you’ll need the Teensyduino mod before you can get up and running. Install the latest Arduino IDE first, then Teensyduino.

With additional features such as digitalWriteFast(), the high speed of the Teensy 3.0 can be put to use. Within a few minutes of setup, I had an I/O pin toggling at speeds as high as 50MHz.

Dev boards like this can come in handy for all kinds of projects. A board like this has the horsepower to handle color displays with complex graphics, autopilot and other control-system-type computations, and many other tasks — even simultaneously.

Several version control solutions have been developed over the past couple of decades or so. One of the most popular ones for open-source projects is git. Developed by Linus Torvalds (of Linux fame), git allows version tracking of software projects (or really, any file-based project.)

Here are my initial impressions as I start using git. Disclaimer: I am a git newbie; while I have a reasonable understanding of what version control in general and git in particular are about, I am by no means an expert.

To start using git, a git client must first be installed. Traditionally, this is git for Linux, but I decided to try out git starting with a chip tester project written in PIC assembly, so I installed the GitHub client for Windows. (GitHub is a central service which can store open-source projects free of charge, and/or private, closed-source projects for a subscription fee.)

A git “repository” (project) is started by creating a local repository (the directory in which the files will reside, along with a few small files describing the repository contents.) These files contain the repository name, a brief description, and usually a list of files to include or ignore when updating the repository online.

Once the source files have been added, they are staged and then “committed.” This creates a “commit,” which is a snapshot of the project at that point. (It’s advisable to have the project in a reasonably stable state, when performing a commit.) At that point, other developers can “clone” the repository, to pick up a copy of the entire project.

The git client also tracks which files have been updated since the last commit. If, for example, a bug was fixed in an include file and the README file was updated, the git client would flag these as having been changed. Once the changed (and/or new) files are selected and a commit comment is entered, the main repository can be easily updated.

If you work with PIC microcontrollers and want to try out a (very pre-alpha) chip tester, you’re welcome to check out the repository I created.

“Share and enjoy!”

On the other hand, if I brought my wallet, I’d be broke for the next six months for sure. Maybe it’s a good thing that I’m some ten thousand miles and a travel visa away?

In a simple circuit, DC analysis is straightforward. Resistances in series, parallel, or simple combinations of the two can be numerically lumped together, and the resulting currents and voltages calculated using Ohm’s Law. In the circuit below, for example, the two central 1k resistors can be viewed as a single 2k resistance. This, in parallel with R2, forms 1k of resistance. When R1 is added, the total circuit resistance is 2k. By Ohm’s Law, 5mA of current flow through the circuit. It is fairly straightforward to see that all 5mA flow through R1, and that 2.5mA flow through R2, R3, and R4.

A simple, easy-to-analyze DC circuit.

When more than one voltage and/or current source is involved, though, things get trickier. Resistances cannot be simply combined as before, since there could be voltages and/or currents due to several different sources. Another approach is needed.

A more complex circuit, with multiple independent sources. (Click for larger.)

Fortunately, superposition provides a straightforward, practical way to analyze circuits with multiple power sources. By following a few simple steps, voltages and currents can be calculated through a circuit of arbitrary complexity. (For some configurations, simplification using Wye-Delta conversions may also be needed.)

To analyze current flow in a circuit with multiple sources, analyze the circuit with only one source at a time present, setting all other sources temporarily to zero:

• Replace all voltage sources not being analyzed with a short (zero voltage), and
• Replace all current sources not being analyzed with an open (zero current).

Once these substitutions have been made, re-analyze the circuit, noting the current flow in each branch due to this source. Do the same for any remaining sources, re-enabling them in the circuit, and setting the already-analyzed source to zero voltage or zero current, as appropriate.

Here is a simple example of circuit analysis of using the above example, with two voltage sources and a current source:

First, calculate and note all currents due to V1 with other sources V2 and I1 removed. (Click for larger.)

Next, calculate and note all currents due to V2 only, with V1 and I1 removed. (Click for larger.)

Finally, calculate and note all currents due to I1, with V1 and V2 removed. (Click for larger.)

After calculating and noting current flows due to all of the sources, add them up. One way to do this is to assign a color for each source, and note the current flow due to that source through each resistor. (Remember to note which direction each current component flows; current flows going in the same direction add, but currents flowing in opposite directions cancel!)

Currents from each source are noted independently. These are then added to determine total current. (Click for larger.)

Once all of the currents have been noted, they can be added (and subtracted, depending on direction) to show the total current flow…

The total currents in each branch, summed. (Click for larger.)

Note that Kirchoff’s Current Law (net current flow into or out of a point is zero) must be satisfied for each point in the circuit. For example, at the node represented in green, 2.33mA of current is flowing in through R1. This current must leave the node, and therefore 1mA flows through R3 and 1.33mA flows through R2. The net current into the node is therefore zero, so no charge accumulates over time.

The Agilent 34401 Digital Multimeter (DMM). (Click for larger.)

Measurement of voltage

The most basic function of a DMM is as a basic voltmeter. Most DMMs are autoranging, meaning that they automatically select the correct voltage range (millivolts, volts, etc) based on the measurement being made at the time. To measure DC voltage with the 34401A:

• Turn on the meter using the power switch on the left end of the front panel.
• Press the “DC V” button (if you will be measuring DC voltages.)
• Connect the negative probe (typically black in color) to the rightmost black “LO” port. (The two ports in the left column are used for four-wire resistance measurements, which are not covered in this guide.)
• Connect the positive probe (typically red) to the upper right “HI” port.
• Connect the probes to the circuit under test. Voltage is measured in parallel with a component, so you would not break the circuit to measure voltage.
• Read the voltage data on the meter.

Connect the voltmeter in parallel with the resistor to measure volts. (Click for larger.)

Measurement of current

Another useful function of a DMM is as an ammeter — a meter designed to measure current flow. Since current flow is measured within a conductor, the meter must be actually inserted in the circuit in order to measure this flow. (There are “clamp” ammeters which do not work this way, but they are not covered here.) Because of this requirement, measuring current in a circuit is done differently than measuring voltage — the connections are made differently. Instead of simply clipping on to a circuit, the DMM replaces one of the wires in the circuit, and the current is made to flow through the meter. It is important to make sure that the meter replaces a wire of the circuit in this way, or else it could cause a short circuit. (That is, you need to break a connection, then insert the DMM in the gap.)
To measure DC current with the 34401A:

• Turn on the meter
• Press the blue SHIFT button once, then press the DC V button. This will put the meter into “DC I” (DC current) mode.
• Connect the negative lead to the right “LO” port
• Connect the positive lead to the right “I” port (at the lower right).
• Disconnect power to the circuit to be tested
• Choose a wire in your circuit where you will measure current. Disconnect it.
• Connect the black lead to one end of where the wire was (ideally, its more negative end.)
• Connect the red lead to the other end of where the wire was (ideally, its more positive end.)
• Reconnect power to the circuit to be tested.
• Read the current value on the meter’s display. (Note mA or A, as well.)

Connect the DMM in series with the resistor to measure current. (Click for larger.)

Measurement of resistance

DMMs can also function as ohmmeters, allowing the measurement of resistance. Unlike measurements of voltage and current, this must be done with power disconnected from the circuit. (In fact, since parallel resistances can affect the measurement, resistance is usually measured with the component disconnected from the circuit, at least at one end.) When measuring resistance, the meter passes a small amount of current through the resistor and measures the resulting voltage. To measure resistance with the 34401A:

• Turn on the meter
• Press the “Ω 2W” button.
• Connect the negative lead to the right “LO” port
• Connect the positive probe (typically red) to the upper right “HI” port.
• Disconnect at least one end of the resistor to be tested from the circuit.
• Connect one probe to one lead of the resistor to be tested.
• Connect the other probe to the resistor’s other lead. (Direction doesn’t matter.)
• Read the resistance value on the meter’s display. (Note mΩ, Ω, kΩ, or MΩ.)

To measure resistance, disconnect the power supply and connect the DMM across the resistor to be measured. (Click for larger.)

The 34401A has many other measurement capabilities (frequency, continuity, four-wire resistance, diode check, etc.) It can even connect to a computer via RS232 or GPIB for automated measurements.

I therefore present a new, shorter site alias:   pt0.us (with a zero, not an “o.”)

Scan me!

URLs at pt0.us point to the same content as paleotechnologist.net (and paleoengineer.net and paleoengineer.org, for that matter). New and existing content will be available at all of these domains.

Why PT0? Simple:

• PT stands for PaleoTechnologist;
• Zero is the most central, the most unique, and possibly the most important of the integers;
• …and while .us is geographically appropriate as a TLD, I chose it for its shortness.

Rumors that this is in preparation for site-related QR code generation are completely unsubstantiated. That’s not to say that they are incorrect, however!

In order to make the process as straightforward as possible, I will make several (hopefully reasonable) assumptions:

• The image exists in memory, in a format (an array, for instance) which can be easily read in random-access order;
• A color depth of 24 bits is used (eight bits each for Red, Green, and Blue);
• BITMAPCOREHEADER (the simplest header) is used; and
• The height and width of the image are reasonable and known.
  (I will call these variables XSIZE and YSIZE.)

Values given here are in hexadecimal. All multi-byte values in BMP files are little-endian.

Bitmap files consist of three parts:

• The bitmap header;
• The DIB header; and
• The pixel data array.

The bitmap header is straightforward enough:

• Two bytes to denote a bitmap file: ASCII “BM”, or hex 0×42 0x4D
• Four bytes, representing the size of the BMP file in bytes.
• Two bytes reserved: these can safely be 0×00 0×00.
• Two more bytes reserved: these can also be 0×00 0×00.
• Four bytes for the offset address of the pixel data.
  (If using BITMAPCOREHEADER, this is 0x1A 0×00.)

The BITMAPCOREHEADER is next, and also relatively simple:

• Four bytes for the size of the header (14 bytes, so 0x0E 0×00 0×00 0×00).
• Two bytes for the image width in pixels;
• Two bytes for the image height in pixels;
• Two bytes for the number of pixel planes (must be 0×01 0×00); and
• Two bytes for the bits per pixel (0×18 0×00 in our 24-bit example.)

The last structure is the bitmap data itself. This is three bytes per pixel, with each row padded to the next multiple of four bytes, as needed. Each pixel is in BBGGRR order.

We now have all of the pieces of information we need to create the bitmap file…

• Output ASCII “BM” (0×42 0x4D)to the file
• Calculate the size of the file:
• – 14 bytes for the bitmap header, plus
• – 12 bytes for the DIB header, plus
• – The number of rows (image height) times the row size in bytes.
  (The row size is the image width, times three, rounded up to
  the next multiple of four, if needed.)
• Write this figure to the file, in little-endian hex, using four bytes.
• Write 0×00 0×00 0×00 0×00 to the file, for the two reserved fields.
• Write 0x1A 0×00 (representing the 26-byte offset for the start of data.)
• Write 0x0C 0×00 0×00 0×00 (representing the DIB header size.)
• Write XSIZE in two-byte little-endian hex.
• Write YSIZE in two-byte little-endian hex.
• Write 0×01 0×00 for the number of pixel planes;
• Write 0×18 0×00 to represent 24 bits per pixel.
• Loop over the number of rows (YSIZE) in the image:
• – For each pixel in that row, write its image value in little-endian hex (BBGGRR)
• – At the end of the row, pad it with zero to three extra bytes to make the number of bytes in the row a multiple of four.
• Close the file. You’re done!

Here is an example in FreeBASIC, which produces a simple 3×3 bitmap.