Hands On Electricity

May 6, 2009

I know I have not updated here in a long while, but seeing as my schooling had me skip a few bits, I need to catch you readers up.

The point of the next few entries will be to bring you up to speed on what exactly is meant by AC power versus DC power. We will cover what the terms mean, the tools of each, the real-world-implementation and fun facts. But where to start?

Let’s start simple and hands on with an experiment.

A 1.5v dry cell battery (standard AA will do just fine)
A magnet (you’ll want something with a little kick to it. I used a simple round magnet. Fridge magnets won’t work very well)
A voltmeter
about 1 foot of solid copper wire
A compass
An iron nail (something that can be picked up by magnetism)

1) Getting started
-Touch the probes to each end of the battery and see that there is a voltage difference. We are measuring the amount of potential energy in the battery. Much like a roller-coaster at the top of its climb, it has only so much energy to expel and therefore is bounded in a similar way.

2) Neat Tricks
-you will need the compass, wire and battery. Complete a circuit by touching the copper wire to both ends of the battery and moving the wire near the compass. You should see the compass needle become magnetically attracted to the wire. Much like normal magnets, the field in the wire is aligned, but is moving. Because of this movement it created a magnetic field.

3) Neater tricks: Creating electricity
-Attach each end of the copper wire to the volt meter probes. Once that is done take the free magnet and move it across the wire at varying speeds, do not stop. As you pass the magnet over the wire, the electrons inside should either be attracted or repelled and show some readings on the voltmeter. Electrical current is defined as the change in charge over time, or the rate of flow. This is where the “electricity is like water” analogy comes in. Because of the “flow” of electrons endued by the magnet, a current can be measured.

Lessons learned:
Voltage: Difference in potential. It is a way of defining how much “push” you have behind your circuit.

Current: Change in charge over time. The rate of “flow” inside your circuit. The more electrons you push through, the higher the current.

We will revisit the electricity/magnetism topic several times in the following articles, so don’t worry, more will be explained.

Tune in next time for learning about DC circuitry and its applications and forms.


Lab 7: Flip Flops Revisited

November 26, 2008

As said in one of the first entries on this blog Flip-Flops are logic devices that “hold” data. Also said in that entry, I could not come up with a particularly compelling reason to use these devices other than “you can”. Well, I was sadly mistaken, flip-flops are incredibly useful.

For instance, if you were building a clock or counter, it would be incredibly useful to remember where you were last. A calculator would also be a good place so that you could “enter” each number and operation. Both applications require vastly different approaches. We’ll start with the calculator, since it’s easier.

To build a calculator, let’s use our imaginations for a second. On a traditional digital calculator you enter your first number then the operation then the next number, repeating the process over and over until you get to your final answer. Alright, let’s imagine a canal, each number is held in a dike and pushed forward through the canal one at a time. Then let us imagine that our operations are each a path this water can go through. Now, the problem is how to do we hold the number so we can continue to add/subtract as long as we see fit. Basically input-operation-hold-more input-operation-etc.

So we need a method of holding since we already created an adder/subtractor that works perfectly well. A “D” flip-flop does the trick very well, actually by definition. A D flip-flop takes in an entry at an instant (defined by a periodic clock usually) and only changes that input when the clock hits again. Usually you’d just program a regular frequency for a clock, but in this case, the clock operation is going to be the add or subtract queue. Like when you press + on a simple digital calculator and the screen changes, the “clock pulse” will be the + button.

Once we understand the underlying problem and solution, the design is exceedingly simple. We just need to plug the parts together, see the diagram:

Image source

With the following diagram it’s a matter of plug-and-chug to create the circuit. The user input (switches for binary numbers) is tied to one input of the full adder (see lab 3) while the output is fed into a D flip flop. The D’s output (read as D+) is sent both to the Y input of the full adder (so initially it’s user’s input + 0, then all further operations are “previous number” + “user input”) and to the ROM we designed in lab 5/6. Same use, same setup. The ROM translates the final output to normal decimal.

Some important things to make note of:
-the number of flip flops depends on number of inputs. You would arrange them to cover all possible outcomes. So, if there are 2n combinations, then you’d need N flip flops.
-There are many types of flip flops with their own usages. I will cover them further in another post.
-The XOR thing in the full schematic is to handle subtraction. This was covered in Lab 3-part b.

Full sized schematic can be found [HERE]

Lab 5/6: Usable Output (7-segment displays)

November 12, 2008

So after going through the previous labs, I understand that the content is a little much. The major problem is that the systems work in binary while we all know decimal. What would make this all much better is a “translator” so that we could read the outputs quickly and easily without being some computer wiz-kid.

For numbers we will use a 7-Segment display, as seen below:

These readers can be found in all sorts of gadgets. Microwaves, calculators, watches, billboards, etc. They are easy to read and we are all very familiar with them.

The Catch: We need a way to translate from binary to a form that turns on/off the proper segments.

There are two ways we can tackle the problem. Both with widely different solutions.

Use BCD:
By using 4 bits to convey each digit, we can solve the problem with logic gates. For instance: 8 = 1000. We change that into 1111111 or 0000000 (depending on the device) and we get a usable output.

-Can build with basic parts
-Can (if you had too much free time) count with other bases up to base 16

-Hard to expand
-Can display errors
-Extra outcomes

By using some Boolean tricks we can minimize/eliminate much of the errors. The final outcome looks something like [LINK].

The other possibility is a full translator. A custom piece of machinery that just spews out an answer for whatever input provided. This tool is called a ROM.

For a ROM, you program all possible outputs so that it just “answers” the input automatically, regardless of “logic”.

-Easily implemented
-Scalable (up to max size)

-Must be programed (time consuming)
-Has MAX scale. Larger arrays will require larger ROMs

This comes in handy with large systems. For instance, we can logically solve a system with up to 6 inputs. Any larger than that requires a 4th dimension or powerful computing equipment. So, for a system of 8 inputs (in this case) a programed ROM saves a lot of time.

For this case, the programed ROM will handle numbers from 0->255. This way, we can have a reusable part (much like the Full Adder from lab 3) that we can implement in further labs.

For instance, much like the previous image, we can have a 8-bit translator that is much simpler to implement.

NOTE Quartis “simplifies” the inputs/outputs into busses. Those thick lines are technically several inputs in one. Also, it compresses inputs/outputs into one symbol that you assign for all “addresses”.
Writer’s Note: I will post images later tonight. I do not have access to all the parts on this machine, but the tags have already been added. Check back soon!

Lab 4: Multiplyer

November 11, 2008

After creating an adder/subtracter, a multiplier is a good next step.

Once again, before we start talking about any circuit logic or design, we need to figure out the mechanics of the problem. Multiplication, like addition, isn’t very difficult. We all know the rules, but once again, binary adds a new perspective.

Note 1: Multiplication consists of 2 parts. First the multiplication, then addition. Because we will need to multiply numbers larger than 1, such as 8 (1000), we are forced to do the addition step.

Note 2: With binary, 1×1 still equals 1, so no need to carry bits in the multiplication step.

So, starting with regular multiplication let’s take a look:

As you can see, there are some digits highlighted. As said by note 2, we will not have to carry numbers in the multiplication step, only the addition step. Therefore, the multiplication is easy.


Which by definition matches an AND gate (ironic, no?). The tough part is figuring out how to handle all the additions. As I said in both the adder posts, the adder can be expanded infinitely to add TWO sets of bits together. When you start having to add multiple lines of bits, things get sticky.

The layout of our math (to keep the notation straight) is gonna look like this:

An and Bn are the bits being multiplied. Design does depend on how many digits are being combined.
Xn = Bn x A0
Yn = Bn x A1
Zn = Bn x A2
Vn = Bn x A3

Also, in all this mess is carry bits. We will tackle that in the design stage.

So, we have the basic framework to build our multiplier, but how to put the pieces together? Let’s look at the image again.
F0 = X0 Easy!
F1 = Y0 + X1 also easy. No carry!
F2 = Z0 + Y1 + X2 Okay, problematic…

How to solve this? Well, simple design can be just as useful as talking about it.

The image may be hard to see in this blog, so try a LINK.

As you can see, the adders are in a similar orientation to our multiplication tables at the top. The addition is sandwiched between the bits. If you look across the top of the design, the An bits are taken care of vertically, while the Bn bits are added in horizontally (to make the design less of a rat-trap). All the layers are added together like VZYX0 + VZYZ1 THEN + VZYZ2 and so on. The design is easy to expand or condense and is convenient.

So, to expand the design, here are the equations:
Full adders: B across by (A-1) down (number of bits)
AND gates: B x A
Fn (outputs) = A + B

The real trouble of the design is making sure that all wires are connected properly. One foul connection and the system will not work.


November 3, 2008

This was a fun programing assignment (if only because I heard so much whining and head-scratching from my fellow classmates).

The task: Create a game of rock-paper-scissors to play against the computer.

For this, we need a random number generator so that it’s like playing the game against a dice. You don’t know what it’s outcome will be and the computer isn’t able to “cheat”. Luckily enough, java comes with a random number generator, so it’s just a matter of handling the outcomes.

I assembled my program in two halves. The first half, it’s own method, checked the user input and returns a number to correspond with the choice (1 for rock, 2 for paper, 3 for scissors, and 4 if the user doesn’t enter the right value). Then the computer generates a random number and compares it against the user input using a switch/catch tree with an if/else tree inside. So, it catches the computer input and tests it against the user input.

Thankfully, it worked on the first try and is rather clean and concise. The code.

Number theory and lab 3 continued

November 3, 2008

So, the schematics below may not make a terrible amount of sense, so let me go through the process.

The idea is that you have a set of tools, namely AND, OR, NOT and XOR. With these four operators you can express just about any set of outcomes. In the case of lab 3, we are looking for a way of expressing addition and subtraction in a simple manner that can be infinitely expanded.

This may sound daunting, but it’s not; it’s only a puzzle. So, like a puzzle, we are looking for not only correct combination, but efficient ones. This usually requires stripping a problem into smaller chunks and analyzing what the exact parts.

Let’s start with normal addition, namely two numbers at a time. If you add just single digit numbers it may look like the following:

This is the simplest addition possible. No carry, only 1 digit numbers. We can also do larger numbers and carries, but how to look at them? Well, for instance, you will never carry a number larger than 1 in this kind of addition, even in the largest numbers we can muster.

So, it can stand to reason that you will never have to carry a number larger than 1 in any base. A valuable piece of information.

Next, we figure out that we will have up to 3 numbers being added, the “x” bit, the “y” bit and the “carry” bit. It also stands to reason that if all 3 were 1’s, the largest outcome is 1 with a carry of 1. So we split the system twice. X + Y + Carry (handled by using XOR gates) and then figuring out IF there is another carry. It stands to reason that if ANY 2 of the 3 inputs are 1, then the carry will need to be one.

Great, so how do we implement that? Well, we construct a table of all possibilities, like so:

I unfortunately do not have the space to explain the methods to how I built the “carry” system in my adder, this is what the entire system looks like:

The next section we need is to be able to handle subtraction. Usually, in binary we use two’s compliment. To oversimplifiy, you express negative numbers by inverting the bits + 1. This also requires an extra bit. So +9 (01001) can be expressed as -9 (10110+1=11000). This may sound overly complicated, but it makes life very easy on the logic level. By tying one end of an XOR to a switch (creating 0 for addition and 1 for subtraction) then the other to the “y” input (in this case) it will flip the bits as so. This way with using our “full adder” we can also have a subtracter with the flip of a switch.

Next Lab: Multiplying

Lab 3 – Adder/Subtracter

October 31, 2008

Was about to post the most recent lab in which this lab is simplified into one input at a time, much like an every day calculator. But fat lot of good that particular explanation does without talking about the original adder construction.

So, as the previous entry talked about, everything will be handled in binary and therefore the math is gonna be a little funny, so let’s start there.

When handling any sort of math with binary, the only two answers possible are 0 and 1. So, same rules apply in binary as in decimal. Therefore, 0+0=0, 1+0=1, 1+1=10 (zero carry-the-one). Simple enough yes?

So, to add one “bit” to another, we need two parts. First ,the actual addition and then the carry. Without getting terribly technical the addition is handled by an XOR and the carry by an AND operator. The circuit looks like this:

But that only works for the first bit. Just with normal addition, the first digit is easy, but all further digits need to take into effect the carry digit from the previous addition. Now, just like with normal addition, you’ll never have to carry any number larger than 10 for instance, so in binary, same idea applies, your carry bit never is larger than 1… rather nice, no? Also, another fact, in this case, is if any 2 of the inputs is one, then there will be a carry. Therefore, behold the “full adder”.

Then, you don’t want to have to build that over and over and over again for each pair of bits added, so we simplify the setup to one custom part as seen below:

This particular part can be reused over and over again for as many bits need to be added and is particularly useful in a myriad of scenarios. Just connect the carry out and carry ins.

More to be covered later.

What the hell is he talking about? Boolean for dummies

October 29, 2008

It has come to my attention that I am talking over a lot of heads on this blog. I will be doing my best to bring my readership up to speed by posting previous labs (as time allows) so that you the reader will at least get why the info is important, even if the process doesn’t make a terrible amount of sense.

Allow me, for a few minutes, to explain the very background of the engineering in these circuit labs.

In the mid 1800’s a man by the name of George Boole, who was fascinated by number theory, created what is now known as Boolean Logic. This system strives to translate all algebra and arithmetic into a two value system with simple operators. As is widely trivial knowledge today, all computers work in binary (a system of 0’s and 1’s), and therefore uses Boolean logic to actually function.

Why Boolean and why binary? Well, as Murphy’s Law dictates; the more moving parts, the more likely the system will fail. So why do operations in this crazy math system? With only two possible outcomes and further cooperation at the atomic level (with magnetism and “spin”) then Boolean algebra is the only real choice.

I will explain the processes further in other labs, but I will try to do a brief overview.

There are a few theories in Binary that need to be covered before we continue. Mainly, translating numbers into and out of binary. Let us start with base 10 (decimal) which we are all familiar with. First, start with a number, like 425. When you say it aloud, it’s four hundred-twenty-five. This can also be construed as (4×100 + 2×10 + 5×1). Binary is much the same, but smaller. So, if your number is 110100111, then you just work down the line in powers of 2. So 110100111 is 1×1 + 1×2 + 1×4 + 0x8… and so on, returning 423.

Also in computer-speak, shorthand for binary comes in incredibly useful. The two most common are octal (base 8) and hexadecimal (base 16).

To convert from binary to octal, just group numbers by 3’s. So 110100111 becomes 110 100 111 and then translates to 6 4 7.

To convert from binary to hexadecimal, group numbers by 4’s. So 110100111 becomes 0011 1010 0111 which then is translated to 3 A(9+1=A) 7.

These shorthand translations come in incredibly useful when trying to simplify keystrokes for instance, seeing as they are all handled by ASCII code. There are other uses, but it comes down to hex or oct are just ways to shorten code.


With Boolean algebra, there are 4 operators. 

NOT: this inverts the input given.  If input is 1, then output will be 0.  This operation can be drawn as a prime mark (‘) or a bar over the input.

AND: This operator handles a situation that is true for both inputs.  Usually this is modeled by “multiplication” or a V.

OR: This operator handles situations where ANY input is
true.  Usually this is modeled by “addition” or an inverted V.  This is, in general terms, like the opposite of AND. 

XOR:  The last combination required.  This handles variables when you only care if ONE of them is 1.  This is usually shown by a
circled plus sign.

This all may sound confusing… and I will agree. These are just the basics and raw facts. More info can be found on wikipedia and other online sources. I will be explaining their uses and implementations further in other lab reports, seeing as information without context is useless.

Until next time,

More info

October 27, 2008

So, after talking directly to some of my readers, I think some background info would be helpful. I will be posting both a ECE article and a JAVA article to try and bring readers up to speed. Also, I am working on getting older labs/projects written up so they can be posted. I am sure you guys don’t want to read the direct lab write-ups as they are rather dry. I meant this blog to be a lay-mans sharing of what I am working toward in a greater scheme. It is not my intention to teach exactly everything that is going on but instead write a “how it’s made” set of articles so when people ask me “what on earth does an E.E. do?” I can answer here.

Stay tuned for more stuff!

Simple Calculator… Yeah Right

October 24, 2008

First, HUGE thanks to Karel. Without his help, I would not have been able to finish this assignment on time.

So, as I stated in my previous entry, this week’s Java homework was to make a calculator that took user input like “3 + 4” or “3.7 / 6” kind of thing. I was having all sorts of trouble with it.

First try:
Tried to implement the program with a method that checked the sign and then passed the value and a true/false value that checked if the numbers were actually numbers.

Second try:
Could not get the program to recognize the signs I was putting in. Solution: figure out the ASCII value and use a SWITCH statement to handle the 5 different operations. Next, implement a TRY-CATCH statement to test if the numbers were numbers and life would be good? No. Asked for help from the professor about my program and he responded “No TRY-CATCH. Can’t use those, they haven’t been covered yet”.

Third try:
With some input from Karel, I used hasNextDouble() which returns boolean values. If TRUE, then go through the program, if FALSE, program quits before an error can occur. By then using the equals(char) method, I was able to get the whole program to work. Took a last hit of the crowbar to get it to compile correctly, but it works. Even had enough time to do a INT or DOUBLE checker to return even cleaner values.

Link to code