Math and the Internet is a summer course for advanced high school students. It is part of the Michigan Math and Science Scholars program, which is sponsored by several departments at the University of Michigan. The course lasts for two weeks, and we have class for 6 hours a day. It was originally developed by Jason Howald and Mark Conger, and in 2010 the instructors were Mark Conger (that's me), Sunny Fawcett, and Shashir Reddy.
We covered a number of topics, including error correcting codes, Google's Page Rank, several data compression algorithms (which led to discussions of fractals and Fourier series), and cryptography, which culminated when we learned the RSA publickey encryption algorithm and exchanged messages with another class doing the same thing. Pictures from all 10 days were posted for the parents and anyone else to look at.
We also spent 2½ days working on understanding computer hardware, from the bottom up. That means we started with transistors, Then we built logic gates, then we built NAND Latches to see how memory works, then we convinced ourselves that we could use our latches to build FlipFlops. At each stage we took the attitude that if we'd built it, it was fair game to use a chip that someone else had built to do the same thing. So eventually we used 74LS00 (nand), 02 (nor), 04 (not), 08 (and), 32 (or), and 86 (xor) ICs for our logic gates, and 74LS74 ICs for flipflops.
Pictures of our hardware exploits are available here and here . We used breadboards, power suppies, and workstations donated by Matt Smith of the UM Electrical Engineering and Computer Science Department. The reason EECS was willing to give them to us is that EECS students design all their circuits in an online simulator these days, and don't ever build with wires. Matt thinks this is a shame.
By the end of the first day we had built binary adding machines, with capacity up to 3 bits + 3 bits. That is, the user could key in a number from 07 in binary using a bank of three on/off switches, then do the same for another number on another bank of switches, and the sum of the two would appear as a binary number represented by 4 LEDs. The movie to the left shows an adder in process (not quite working yet), made by Sabrina Lato and Jonathon Racz. 
On the second day we learned how to make memory and then set an ambitious goal for ourselves: build a 24hour digital chronometer by lunchtime of the next day. (We used the word "chronometer" because "clock" has a technical meaning—see below.)
The specifications were for 6 digits, H_{10} (the tens digit of the hour), H_{1} (the ones digit of the hour), M_{10}, M_{1}, S_{10}, and S_{1}, two each for hours, minutes, and seconds. We had purchased 6 large 7 segment LEDs from Jameco. Each digit required three parts to make it work:
S_{1}, M_{1}, and H_{1} need to hold values from 0 to 9, and pass from 9 to 0. S_{10} and M_{10} hold values from 0 to 5, and pass from 5 to 0. Finally, H_{10} holds values from 0 to 2, and passes from 2 to 0. There's also the added problem that H_{1} needs to pass from 3 to 0 if H_{10} is 2. That is, the next hour after 23 is 00.
We split the job into tasks, and everyone took on a task.
A flipflop represents one bit of memory. That is, it contains a wire which is either at +5V or +0V. It's useful sometimes to call +5V "true" or "1", and to call +0V "false" or "0". This wire is memory in the sense that we can set it to a particular value, and then read that value later.
Well, that doesn't seem so impressive; after all, you can set a wire to a given voltage just by attaching it to either +5V or +0V. What makes the flipflop so useful, though, is that there's a time delay between reading it and writing it. Here's how it works:
So Q is like "the president" and D is "the president elect". When the clock ticks, the president elect is promoted. This timing mechanism turns out to be the key to making a computer, because it allows things to happen is a proscribed order, rather than all at once. In other words, you can write computer programs which do one thing, then stop and think before deciding what to do next.
Our registers need to count from 0 to some maximum value, and then roll back to 0 again. But most don't increment each second. S_{1} does, but S_{10} increments every 10 seconds, M_{1} evey minute, M_{10} every 10 minutes, H_{1} every hour, and H_{10} every 10 hours. So each register needs to be told when it's time to increment. Therefore it needs an input wire, which we'll called INC, which is 1 if the register should increment the next time the clock ticks, and 0 if it should not. INC(S_{1}) can be wired to a switch, and then we can start and stop the clock with the switch.
But what about the other INC's? How do we decide when to tell, say, S_{10} to increment? Well, it should only increment when S_{1} is changing from 9 to 0. That is, when S_{1} is "overflowing": being asked to increment when it's already at its maximum value. Likewise, M_{1} should increment when S_{10} is overflowing, M_{10} when M_{1} is overflowing, etc. So each digit should have an output, OVR, which will be attached to the INC of the next digit.
We need one flipflop for each bit our register will have. Let's say we're making S_{1}. It needs to hold values from 0 to 9, so it requires 4 bits, which is to say, 4 flipflops. Call the bits Q_{0}, Q_{1}, Q_{2}, and Q_{3} in order from least significant to most significant. We use Q to remind us of how the flipflop works. Then incrementing is like adding INC to the number Q_{3}Q_{2}Q_{1}Q_{0}. That is, doing the addition problem
C_{3}  C_{2}  C_{1}  
INC  
+  Q_{3}  Q_{2}  Q_{1}  Q_{0} 
R_{3}  R_{2}  R_{1}  R_{0} 
where the C's are the carry bits (just like the way we all learned to do addition in 2nd or 3rd grade). So R_{0} is the sum (mod 2) of INC and Q_{0}, which is to say, R_{0} = INC xor Q_{0}. Likewise, R_{1} = C_{1} xor Q_{1}, and so on. We'll need to carry to the 2's column only if the sum in the ones column is at least 2, which only happens if INC and Q_{0} are both 1. So C_{1} = INC and Q_{0}. Similarly C_{2} = C_{1} and Q_{1}, and so on. In fact, if we accept C_{0} as an alternate name for INC, we can summarize the rules as
So what should we do with the R's? Well, they should be the next values of the register, so we should send them to the D pins on the flipflops, of course. Well, almost. We want to do that unless the register is about to overflow, in which case the D's should be set to 0. So here on the left is a proposed scheme for the counting part of the register. UND = not OVR.
The rest of the register needs to compute OVR and UND, the former for output to the next digit, and the latter for use by the counting part. This part will be different for each digit, since their max values are different. For S_{1}, the max is 9, so this scheme will do:
The final challenge is, of course, to build that using ICs. Here is one built by Jeff Walker, Nicholas Zajciw, Effie Landau, and Aaron Fein. (They didn't have the benefit of the labels on the chips; I only thought to stick those on later.) If you look closely you can see that three of the flipflops are being used, so this is a 05 register.
The second part of a digit is the logic which takes the register bits (which describe the value of the digit in binary) as input and for output produce a 0 or a 1 for each of the 7 segments of the LEDs. For technical reasons, in this case, 0 means "on" and 1 means "off".
For example, consider the top right segment. It should be on for most digits—in fact, for all of the digits 09 except 5 and 6. So here's a truth table connecting register bits to that segment:

Now the challenge is to find a series of logic gates which can be applied to the Q's to produce the right column, and thus control the topright LED segment. Our 6 students from Gyeonggi Science High School in South Korea, Jihoon Choi, Seung Hyeon Jo, YongJik Kim, Bryan Dongik Lee, Su Young Lee, and Ju Sang Lee, worked on this problem, for both the 05 LEDs and the 09 LEDs. Note the Korean 7 in the list above—it has an extra vertical bar in the upper left. (Doubleclick the movie on the left to see a test.) They came up with logic for each segment in each case. For the topright segment of a 09 LED, they came up with this operation: 
The reader can check that that will be 1 for 5 and 6, and 0 for all the other digits. That was one of the simpler segments—some required as many as 5 gates. They figured out logic for all and then built it as efficiently as possible, because space on the boards was tight. The picture on the right shows how the LED logic looked for a 09 segment. 
Each LED segment contains 5 LEDs, and the voltage drop across each is about 1.6 volts. They're wired in series, so the total drop is about 8 volts, which is too much for our 5volt logic circuits to power directly. The recommended current is 30 mA.
We borrowed a 14volt power supply from writer, electrical engineer, ham radio operator, and friend of the class Dan Romanchik. Dan and I struggled for most of an evening to find a good way to control the LEDs, and finally settled on using a relay for each segment. So the basic setup is this:
We actually ended up using 220 ohm resistors instead of 200, which makes the current
which is close enough to the target of 30. The task of setting up the relays required care but not ingenuity, so in the interest of time, Sunny, Shashir and I did the wiring. A typical setup for 7 segments plus the decimal point looked like this:
The one blue resistor in the picture is 1000Ω, and it's for the decimal point, which only has 1 LED. The pins of the LEDs are off the bottom of the picture, and the cluster of wires in the SE corner shows where the logic wires plug in.
We worked on the digits all day Thursday 7/15. That evening Shashir and Sunny and I installed the relays, and tested to make sure we had enough power to run all the LEDs at once. The logic for one of them, H_{10}, which goes from 0 to 2, was completely working. It was built by Michael Lacy and Brian Chantrupon, and it's the "2" in the upper left corner of the picture.
The next morning we marshalled on. I had announced to all the other instructors, and to the students, that we would have a show at noon to display our accomplishments. So the pressure was on.