HackerBox 0067: Origin Story

Greetings to HackerBox Hackers around the world.

HackerBox 0067 includes the Genesis Training Tester Kit. Assembling and experimenting with the Genesis Kit guides us from the flow of electrons, through the testing and application of a variety of electronic components, and finally on to the operation of semiconductor transistors. After reviewing the use of transistors to implement logic gates, we combine simple logic gates to demonstrate a binary adder. This basic building block of computation is cascaded to implement a full adder demonstration platform.

HackerBoxes is the monthly subscription box for enthusiasts of electronics and computer technology - Hardware Hackers - The Dreamers of Dreams.

There is a wealth of information for current and prospective members in the HackerBoxes FAQ. Almost all of the non-technical support emails that we receive are already answered there, so we'd really appreciate it if you can take a few minutes to read the FAQ.

This Instructable contains information for getting started with HackerBox 0067. The full box contents are listed on the product page for HackerBox 0067 where the box is also available for purchase while supplies last. If you would like to automatically receive a HackerBox like this right in your mailbox each month with a $15 discount, you can subscribe at HackerBoxes.com and join the revolution!

A soldering iron, solder, and basic soldering tools are generally needed to work on the monthly HackerBox. A computer for running software tools is also required. Have a look at the HackerBox Deluxe Starter Workshop for a set of basic tools and a wide array of introductory activities and experiments.

Most importantly, you will need a sense of adventure, hacker spirit, patience, and curiosity. Building and experimenting with electronics, while very rewarding, can be tricky, challenging, and even frustrating at times. The goal is progress, not perfection. When you persist and enjoy the adventure, a great deal of satisfaction can be derived from this hobby. Take each step slowly, mind the details, and don't be afraid to ask for help.

An updated layout of the beloved Arduino Nano is included with HackerBox 0067. It is a very well-executed update to the Nano, which adds a USB-C connector in place of the previous MiniUSB or MicroUSB.

Do not solder the pins onto the Arduino Nano module yet.

A white USB-C to USB-C cable is also included. That cable works great if your PC (or hub) has an open USB-C port. If instead you only have USB-A available, there is a black/silver USB-C to USB-A adapter inside the plastic box of components.

If you do not already have a recent version of the Arduino IDE software on your computer, let's download and install it now.

Looking closely at the Arduino Nano, notice the square black chip just behind the USB-C connector. That chip is an ATmega328 single-chip microcontroller. It is the brains of the operation. The square package of the chip is called a 32-pin thin quad flat pack (TQFP-32).

The ATmega328 Microcontroller features a modified Harvard architecture 8-bit RISC processor core, 32 KB ISP flash memory with read-while-write capabilities, 1 KB EEPROM, 2 KB SRAM, 23 general purpose I/O lines, 32 general purpose working registers, three flexible timer/counters with compare modes, internal and external interrupts, serial programmable USART, a byte-oriented 2-wire serial interface, SPI serial port, and an 8-channel 10-bit A/D converter.

Of the 32 pins on the ATmega328, let's make note of these three:

VCC is the "power" pin. On the Arduino Nano, the VCC pin (there are actually two) is suppled with 5Volts DC power from the USB cable. Electrons flow into this pin to power operations of the ATmega328 Microcontroller.

GND is the reference for the VCC pin. On the Arduino Nano, the GND pin (there are actually three) connects to the ground of the USB cable. Electrons flow out of this pin after powering the ATmega328 Microcontroller.

ARDUINO PIN 13 is one of the General Purpose IO (GPIO) pins. It is circled in red on the image of the ATmega328 Microcontroller above. Notice that this pin has a few contradictory "names". It is the 17th pin of the chip, so it call be called pin 17. It is controlled by the 5th bit of IO port B inside the chip, so it can be called B5. And finally the Arduino software calls it pin 13. Since it is called "13" within an Arduino program, let's also stick with calling it "13" for now.

On the Arduino Nano, there is a lot of circuitry and components. For now, let's consider the isolated portion shown in the image. Arduino Pin 13 is connected to a resistor (the zig zag). That resistor is connected to an LED light. The other end of the LED is connected to ground. (Note that the resistor and LED discussed here come soldered on the Arduino Nano module. We do not have to "build" this circuit.)

Pin 13 is an I/O pin which means that the chip can input or output signals through it. In order to operate the LED, the pin will be used as an output. More specifically, a digital output. A digital output can only be set to HIGH (5V) or LOW (GND).

When Pin 13 is set to HIGH (5V) there will be a potential difference between that 5V and the GND on the other side of the LED. This difference will attract electrons from the GND (-) to the 5V (+). Opposites attract so the negative electrons (all electrons are negatively charged) are pulled towards the +5V direction.

So why exactly are we talking about electrons? Never trust atoms (they make up everything) but do trust that they'll have some electrons floating around them. Some of those electrons can be made to move. The electrons move more easily from metal atoms than from atoms of insulating matter. Thus metals can conduct electricity (electrons). What that means is when a voltage (also called a potential difference) is applied across a conductor (like metal wire), some electrons in the conductor are drawn from the negative side of the voltage to the positive side of the voltage.

Fine, so when ARDUINO PIN 13 is set to HIGH (5V), electrons get sucked from ground through the LED and towards 5V. When electrons flow through the LED, it glows with light. Let's do that now!

1. Connect the (completely unsoldered) Arduino Nano to a USB port of your computer
2. Run the Arduino IDE
3. In the IDE, select Tools > Board > Arduino Nano
4. Also select Tools > Processor > ATmega328P (Old Bootloader)
5. Also select Tools > Port > (the one connected to the Nano)

Now we're set up. Let's write a program. In a new, empty sketch there are two empty functions: setup() and loop().

Inside setup() type:

pinMode(13, OUTPUT);

This tells the chip that we will use ARDUINO PIN 13 as an output from the chip.

Inside loop() type:

digitalWrite(13, HIGH);

This tells the chip to output a HIGH value (5V) to ARDUINO PIN 13.

Click the arrow above the code window to upload the code into the Nano board. The Green LED (power on indicator) on the Nano should already be on. During download, some other LEDs with flicker briefly. Finally the Red LED, which is connected to ARDUINO PIN 13 will glow steady. You did it!

OK, now add these three lines right under the "digitalWrite" from before:

delay(500);

digitalWrite(13, LOW);

delay(500);

And then click the upload arrow again and let it run. These four lines of code are fairly simple, but still interesting. They set ARDUINO PIN 13 high, waits 500ms (half of a second), sets PIN 13 low, waits 500ms again, and loop that forever... BLINKY LIGHT! Mess around with the two delay numbers of milliseconds and reload the code to the Nano. Try making a short blink HIGH and a long pause LOW or whatever other pattern you like.

What is happening to the LED circuit when ARDUINO PIN 13 is LOW (aka GND or 0V)? Since there is no potential difference (Voltage) across the circuit elements (both ends are GND or 0V), no electrons are being pushed through the LED and so it does not light up. Basically, the GPIO pin output can be used as an automated switch for turning the LED on and off.

CURRENT AFFAIRS: It is worth committing to memory that while electric current is the flow of electrons, the convention for specifying the direction of current flow is in the opposite direction of the flow of the electrons. Electrons flow negative to positive but "Conventional Current" flows positive to negative. Just accept it, or read under the heading "conventions" on the Wikipedia page for electric current to learn more.

We mentioned that the zigzag in the LED circuit is a "resistor". What gives?

A resistor is a simple electrical component that partially restricts, or reduces, the flow of electrons. If you like to visualize electrical current as flowing water, then a resistor is a narrow point in the pipe or river, or maybe it's a clump of hair in a drain pipe. Again, it's a partial restriction against the flow.

The resistor in the LED circuit is there to serve as a "current limiter" and is simply to ensure that too much current does not flow through the LED and burn it up. That resistor has a value of 330 Ohms. The more Ohms, the more restrictive the resistor is against the flow of electrons. A wire can be thought of as having about 0 Ohms. It doesn't restrict the flow. It is a conductor.

Resistors are useful because they can control and establish the flow of current according to their value, which is their amount of resistance. Resistance is specified by the units Ohms. Note that 50 Ohms is often typed as 50R, but this very informal for use among us electrical folk. Don't write that in a physics class. Larger resistances can be specified in K or M (1,000s or 1,000,000s of Ohms).

The plastic component box has three values of resistors in it: 1K, 680R, and 470K.

Note the convention for color stripe markings in the image.

There are two different types of 1K resistors shown (5% and 1%). Your kit may contain either of those and both are fine for what we are doing here. What do those tolerance percentages mean?

Can you measure out EXACTLY 1 liter of water? Not really. If you're very careful, it might be 1.032 liters or maybe 0.9984 liters. That is plenty accurate enough for making a drink or cooking. Just like you cannot exactly measure out 1L, we cannot make a resistor that is exactly 1000R (aka 1K). That said, you can get arbitrarily close to exactness when you really need to, but you have to pay for it.

The 1K 1% resistors are manufactured to a tolerance between 990R and 1010R (plus or minus 1% or 10R). The 1K 5% resistors are manufactured to a tolerance between 950R and 1050R (plus or minus 5% or 50R). Which one do you think costs more to make? Our main use of the 1K resistors will be as pull ups (or pull downs) which is basically the electrical version of a doorstop - not highly precise. For that purpose, 1% or 5% (or probably even 20%) tolerance is totally fine. However, the 680R and the 470K resistors will be used for measurement, so they are very high precision resistors (0.1% tolerance) which are harder to find and cost a lot more. For that increased precision, they each cost about 30 times as much as 1% or 5% resistors of the same value.

The Genesis Training Tester Kit, when combined with the Arduino Nano, provides a platform for learning about and testing the operation of a variety of electronic components. The kit includes:

• Exclusive PCB with BBC micro:bit inspired edge connector
• OLED Display 128X64 pixels I2C interface
• Two Tactile Momentary Buttons
• Female Test Point 2x3 Header
• Three 680 Ohm High-Precision Resistors
• Three 470K High-Precision Resistors
• LM4040 Precision 2.5 Voltage Reference
• One 1K Pull-Up Resistor (for LM4040)

A variety of additional electronic components are provided for experimentation and testing:

• Red LED
• 10KOhm Potentiometer
• 100nF Ceramic Capacitor ("104")
• 10uF Electrolytic Capacitor
• 2N2222 NPN BJT Transistor
• 2N2907 PNP BJT Transistor
• IRF9540 P-Channel MOSFET Transistor
• 680uH Inductor Coil

In Phase One, we will solder two switch buttons, the Arduino Nano, and the female 2x3 test header.

The two momentary switch buttons are the smallest components and should be soldered first.

The Arduino Nano should be soldered second. The Nano goes on the opposite side of the Genesis PCB from the two buttons. The USB connector must be positioned at the edge of the Genesis PCB and facing away from the PCB such that the ATmega328 and the reset button are exposed (not underneath). The two long rows of header pins are used, but the 2x3 pin male headers are not used. Note that each pin of the two strips of header pins must be soldered twice - once to the Nano and once to the Genesis PCB.

Finally, the 2x3 FEMALE test header (NOT the 2x3 male pins that came in the Nano Baggie) is mounted on the same side of the Genesis PCB as the two tactile switch buttons.

Grab the sketch MomentaryLED.ino from this page and upload it to the Arduino Nano.

The sketch should be easy to follow:

It reads ARDUINO PIN 12 to see if the left momentary switch is pressed.

If the switch is pressed (shorted to LOW), then the LED on ARDUINO PIN 13 is turned on just as we've done before.

If the switch is not pressed (pulled HIGH by the internal pull-up resistor), then the LED on ARDUINO PIN 13 is turned off.

Maybe you are already thinking, "Wow, that is really a stupid waste of a microcontroller! A momentary button could just be used between a power source and an LED such that the button closing allows current to flow to the LED." Yes, that is correct.

You'd normally only involve a microcontroller if you wanted to perform a number of other operations as well or even do one thing but perhaps it is a little more complicated. Another advantage to using a programmable microcontroller is that it is very flexible, which brings us to an exercise assignment:

The right button of the Genesis PCB is connected to pin 10 just like the left is connected to pin 12. Update the sketch from momentary operation to ON-OFF toggle operation. More specifically, make the left button turn the LED on (and leave it on even when released) and make the right button turn the LED off (and leave it off).

The Arduino Nano can't measure resistance. It can only measure voltage.

Should we give up? No way. Let's try some trickery.

Grab the sketch ResitanceTrick.ino and upload it to the Arduino Nano.

Once "Uploading is Done", select Tool > Serial Monitor.

At the bottom of the Serial Monitor screen, make sure the baud rate is set to 9600. You should see a stream of random(ish) numbers pouring into the serial monitor display.

Check out the 2x3 pin black female test header: The left most stack of two pin holes connects to Arduino Pin A0 (as does the left most edge connector labeled "1"). The center stack of two pin holes are Pin A1, and the right most stack of two pin holes are A2.

Looking at the code, we can see that Pin A0 is internally connected to 5V and Pin A2 is internally connected to GND (0V).

The values printed to the Serial Monitor are the voltage read from Pin A1 (the center 2 pins).

Notice that the analogRead returns a 10bit value (0...1023 decimal) so each step of that range represents 1/1023 of 5V. A little math maps that 10bit value to the correct voltage sensed at pin A1.

The initial numbers displayed are "random" because A1 is floating. That is a fancy way to say that nothing is connected to it.

We're going to need two 1K resistors and two 680R resistors. Get those out now.

At the 2x3 pin test header, insert any one of the resistors with one side in A0 (the left most 2 pins) and the other side in A1 (the center two pins). The displayed voltages should now all be 5V since A0 is tied to 5V internally and the measurement at A1 is being pulled up to A0 through the resistor you just inserted.

Now change: Pull out the resistor and insert one side in A2 (the right most 2 pins) and the other side in A1 (the center two pins). The displayed voltages should now all be 0V since A2 is tied to GND (0V) internally and the measurement at A1 is being pulled down to A2 through the resistor you just inserted.

It doesn't mater what resistance you use like this, it will just pull the measurement all the way to 5V or 0V. That isn't very useful, right?

Here comes the trick... If all you can measure is voltage, you can measure resistance by "opposing" two resistors, measuring the voltage between them, and doing a little math. So let's insert any of the four resistors between A0 and A1 and then any other of the four resistors between A1 and A2. Try all four combinations as shown in the table and write down the values for the four empty spaces.

We described the trick in the last step by claiming that you can measure resistance by "opposing" two resistors.

The correct technical terminology for this is to create a voltage divider.

You should have observed that when R1 and R2 are the same value, the output voltage (V1) of the divider is 2.5V (exactly one half of the total 5V).

You can use the voltage divider equation above to compare your measurements from the last step with theory. They should be very close.

Note that a potentiometer is basically a moving voltage divider. Pull the two resistors out and insert the potentiometer into the 2x3 header such that the three pins go into one of the rows of three header holes. Note how the values on the Serial Monitor change as you turn the shaft of the potentiometer.

Now close the Serial Monitor window and open Tools > Serial Plotter

Turn the potentiometer slowly. This is what we call a one-axis etch-a-sketch. You can change the "responsiveness" of the dial by modifying the delay() value in the code.

The Genesis Training Tester uses six high-precision resistors as a measurement network. Three 680 Ohm resistors and three 470K resistors. Solder these in place as indicated just below the Arduino Nano. Be careful not to switch the values around. The 680R and 470K resistors are not interchangeable. Resistors can be inserted in either direction.

Each of these six resistors is connected on one side to one of the test point pins (A0, A1, A2). The other side of each resistor is connected to a separate digital IO pin of the Arduino Nano according to the following definitions:

#define A0_680R 9

#define A0_470K 8

#define A1_680R 7

#define A1_470K 6

#define A2_680R 4

#define A2_470K 3

Considering the first define as an example, is there is a 680R resistor connected between A0 and Arduino Pin 9. If Pin 9 is defined as an output and driven HIGH, then the 680R resistor connected to A0 is pulled up to 5V. If Pin 9 is defined as an output and driven LOW, then the 680R resistor connected to A0 is pulled down to 0V. If Pin 0 is defined as an input, then the 680R resistor connected to A0 is open (Z) and has no effect on A0.

Similarly, there are three conditions (HIGH, LOW, Z) for the 470K resistor connected to A0. These conditions are selected by controlling Arduino Pin 8 the same way as described for Pin 9.

These six different settings for A0 (680R HIGH, LOW, Z and 470K HIGH, LOW, Z) are also available for A1 and A2. All of these settings provide for a very flexible and capable measurement network.

Grab the sketch SimpleResistor.ino and upload it to the Nano. It uses one of the measurement resistors (the 680R attached to A0) to measure a resistor placed between A0 and A1. Read through the code to understand how it works and what its limitations are.

Start this phase by trimming the pins that extend through the Genesis Board from the Arduino Nano.

Optionally, you can touch the cut end of each pin with a hot soldering iron to smooth over the cut.

The OLED display can now be mounted onto the opposite side from the Arduino Nano.

It is recommended to tape or glue a small square of cardboard or plastic between the OLED and the Genesis Board to prevent shorting onto the back of the OLED module.

The LM4040 Precision 2.5 Volt Reference is in a TO-92 package (like a traditional transistor). There are three different TO-92 devices in the parts box, so be sure to select the one with "4040" printed on it. Do not use either of the TO-92 transistors. These have "2222" and "2907" printed on them.

The LM4040 is inserted adjacent to the Arduino Nano on the same side of the board. The flat face of the LM4040 is positioned against the Nano as indicated by the PCB silkscreen. A 1K pull-up resistor is soldered just below the LM4040 also as indicated on the PCB silkscreen.

For the OLED display, an Arduino Library is required. Go to Tools > Manage Libraries and once the Library Manager Opens, search for SSD1306. There will be several options, but install the one from Alexey Dynda.

Once the library is installed, go to File > Examples > ssd1306 > demos > ssd1306_demo

Upload this example to the Arduino Nano. It will run on the OLED display as is.

Here are some ideas to improve the resistance meter...

Add Support for Big Resistors

Start with SimpleResistor.ino and when a resistor measures over 20K, call another copy of the measurement code that uses the 470K sense resistor instead of the 680R resistor. The 470K measurement resistor can be used to measure from about 20K to 20M ohms, while the 680R resistor can be used to measure up to about 20K ohms.

Calibrate Using Precision Voltage Reference

The LM4040CIZ-2.5 (datasheet) is a precision Voltage Reference. Voltage measurements in the Nano are made in relationship to the power supply from the USB cable which is rarely exactly 5.0V. The LM4040 is connected to pin A3 of the Nano and always outputs 2.5V (it's a reference after all) without influence by the 5V supply. Pulling an analogRead(A3) will give a value that is close to 2.5V but usually not exactly because of error in the USB provided VCC. Whatever number you have to multiply that A3 reading by to make it read like 2.5V is a correction factor that should be multiplied onto all voltage readings to make them more accurate.

Leverage the OLED Display

Display instructions, diagram of a resistor, measurement output, etc.

Correct for Port Resistance

There are 19R and 22R "port resistors" in the measurement path. For resistors under about 5K, these should be accounted for. They have little effect on measuring large resistors. You can see these (and read more) in Figures 5.2 and 5.11 of the paper Transistor Tester with AVR Microcontroller and a Little More by Karl-Heinz Kubbeler which is the classic inspiration for measuring components using microcontrollers.

By now, you know what to do with CapacitorMeter.ino

It measures capacitors between A0 and A1.

TWO VERY SERIOUS WARNINGS:

The negative terminal of any polarized capacitor must connect only to test port 0 (A0).

Any capacitors must be fully discharged before being connected to the Nano for measurement.

References:

For additional details (including original source code) see CircuitBasics

A diode includes a junction between a n-type and p-type semiconductor material. Thus a diode is often called a P-N junction. The LEDs we've been using are Light Emitting Diodes and work like other P-N diodes but they also happen to give off light. Diodes generally only allow electrons to flow from the N side to the P side but not the other way around. The opposite direction of flow (from P to N) is true for for current. Using the water analogy, a diode is a one-way valve.

BJTs have two P-N junctions. BJTs can be P-N-P or N-P-N while the diode is simply P-N. The pins of the BJT are called collector, base, and emitter. This video covers the operation of diodes and BJTs in excellent detail.

Because the BJT looks like two diodes, we can test which type it is by measuring if current flows from the base (center pin) out to the other two pins (NPN), or from the other two pins into the base (PNP). That is exactly what the BJTtester.ino sketch does.

After doing that test, the sketch displays a diagram of the detected BJT on the OLED along with the orientation of the pins as CBE or EBC. Note that the the base is always assumed to be connected to A1 (the center pin). The other two pins do not matter which way they go. They can usually be detected because the emitter side of a BJT can usually drop a little more voltage as is it slightly larger.

The kit includes two BJTs to test:

2N2222 NPN BJT Transistor

2N2907 PNP BJT Transistor

Try them both in both directions by inserting each (one at a time) into the test header. Hit the left button to restart the test process. The PNP and NPN diagram on the OLED should change when you swap the parts. The CBE and EBC orientation indicators should reverse when you flip the device around with respect to the test header pins.

The field-effect transistor (FET) is a type of transistor that uses an electric field to control the flow of current. FETs are devices with three terminals: source, gate, and drain. FETs control the flow of current by the application of a voltage to the gate, which in turn alters the conductivity between the drain and source. FETs are known as unipolar transistors since they involve single-carrier-type operation. That is, FETs use either electrons or holes as charge carriers in their operation, but not both. The most widely used field-effect transistor is the MOSFET (metal-oxide-semiconductor field-effect transistor). (Wikipedia)

Get the sketch FETtester.ino and upload it to the Arduino Nano.

First run the sketch with nothing in the test header. Change the gate voltage (A0) by pressing the left button on the Genesis board. Since that gate voltage is not actually driving a MOSFET gate, nothing happens at the measured Vout.

Insert the included IRF9540 P-Channel MOSFET Transistor into the test header with the metal side facing the OLED display (this places the gate pin into port A0 where it belongs). Now, pressing the button should drive the gate and change the Vout reading on the screen. MOSFET are most often used as switches. That is the case here.

Transistors can do a lot of amazing things. One of those amazing things is using transistors to create logic gates such as AND, OR, NAND, NOR, XOR.

Take a look at the box guide (including the video) for HackerBox 0039 - Level Up which included the Transistor-to-Gates Kit. The Transistor-to-Gates kit uses the same 2N2222 BJT Transistors that we've worked with here to implements various logic gates.

From logic gates, we can implement data storage elements (such as FLIP FLOPS) and rudimentary computational blocks (such as ADDERS). As we will see in the future, these can be combined to create state machines and microprocessors.

Next, we will take the step from logic gates to computational blocks by implementing a four bit adder circuit.

The Full Adder is a binary adder that adds three inputs and produces two outputs. The first two inputs are A and B and the third input is the carry-in. The primary output S is the sum of the three inputs. An additional output is the carry-out containing the binary carry bit (when necessary).

Full adder logic blocks are "bit slices" that can be banked together by cascading the carry-out from one position into the carry-in of the next highest place value. This allows the creation of 4-bit, 8-bit, and larger adders by simply cascading together blocks of full adders.

This kit implements a 4-bit adder from basic logic gates. The demo circuit can add together two 4-bit values (input using DIP switches) to generate an output 5-bit value (represented by the LEDs).

This video covers the general theory and practical design of a 4-bit full adder.

Start by soldering in the thirteen 1K resistors.

Each can go in either direction, resistors are not polarized.

Next insert and solder the five DIP sockets. Match the orienting notch on the docket to the same shape on the PCB silkscreen.

Insert and solder the four-pin DIP switches. Orient the switches so that the text on the switches is in the same direction as the text on the PCB silkscreen.

Insert the five LEDs. Orient each LED such that the short lead is closest to the flat side of the outline on the PC silkscreen. Solder the LEDs into place.

Solder the MicroUSB breakout onto the bottom side the PCB matching up the 5V to VCC pins and the GND to GND pins. Instead of placing the black plastic spacer of the header pins between the two PCBs, it can be placed on the outside of one of the boards so that the breakout lies flush against the adder PCB and then the spacer can be slid off from the pins to finalize the soldering.

Inset the chips into the sockets matching the part numbers on the silkscreen. Also match up the orienting notches on the silkscreen, sockets, and chips. Be careful not to bend any of the chip leads.

Once assembled, the adder board can be dressed up with decals as shown shown in the photo.

Playing with this board and verifying the outputs is an exercise that will make you much quicker at converting decimal numbers to binary (and back) in your head.

We hope you are enjoying this month's HackerBox adventure into electronics, computer technology, and hacker culture. Reach out and share your success in the comments below or other social media. Also, remember that you can email support@hackerboxes.com anytime if you have a question or need some help.

What's Next? Join the revolution. Live the HackLife. Get a cool box of hackable gear delivered right to your mailbox each month. Surf over to HackerBoxes.com and sign up for your monthly HackerBox subscription.