Awesome.. Just awesome..

I find this both baffling and frustrating as the government wants to mediate everything else in the world. But nevertheless, I figured I would throw out the message I received from my state representative.

June 4, 2010

Dear Mr. Cameron:

Thank you for contacting me about network neutrality. I appreciate knowing your thoughts on this issue. The principle of net neutrality is designed to ensure that internet access providers do not engage in favoritism when configuring their networks and delivering Internet content. Such favoritism, known as “bit discrimination,” could occur if a provider transmitted its own offerings at faster speeds than those of its competitors or if it charged other companies a fee for equally fast delivery.

A recent court case, Comcast v. Federal Communications Commission (FCC), struck down the FCC’s basis for a previous ruling regarding Comcast’snetwork management, throwing into question the FCC’s ability to address network neutrality. Due to this decision, many consumers and consumer advocates are concerned that internet providers will be able to move forward with bit discrimination.

This issue has gained attention in the past because of comments made by telecommunications company executives suggesting that content providers or consumers may have to pay additional fees for fast delivery. Many executives later clarified that they have no intention of degrading or blocking Internet traffic but merely wish to offer their customers a premium service.

Nevertheless, it is reasonable to be concerned about the impact of such steps on consumers.

I will continue to keep your thoughts in mind in case net neutrality legislation is debated on the Senate floor.

Thank you again for your message. Please feel free to keep in touch.

Sincerely,

Richard J. Durbin
United States Senator
RJD/ab

This email about killed me. It’s frustrating because it’s so convincing that the internet providers claim to have our best interests in mind, but let’s not cast aside some of the most important issues that the lobbyists obviously tip-toed around. I responded promptly to the best of my ability.

Senator Durbin,

I appreciate the timely response and definitely understand that communications companies want more flexibility in how they deliver content. I also do believe that some individuals within these companies truly believe that this will help them better serve the customer and will not hinder any aspect of their user-base in any way.

However, as we all know, business are modeled around maximizing their profits while reducing their costs, as they should be! These companies want to offer a premium service to deliver faster internet. To do so, they will need to optimize their traffic, or otherwise buy better equipment to allow more traffic.

With equipment enhancement being very costly, all these companies would prefer to find more significant ways to utilize the equipment they have. This alone should be seen as a good thing, however, the methods they are proposing to do this will modify user traffic.

Customers will see very little change, it’s the providers that are going to see the most change. The very act of prioritizing the internet puts small and new web companies out of the picture. If the FCC does not regulate this prioritization, I have no doubt that there will never be another company like google again, another company like yahoo, or facebook, or youtube. These websites were developed by small companies with very private investors and little starting money and succeeded not because they knew the right people or companies, but because the sites were just better, more efficient and faster than their competitors’ services.

These websites were examples of the heart of democracy. They became successful because they were better than their competitors. By changing these regulations, individuals who create a web page, now will have to convince companies like Comcast or At&t to give them more priority, they will have to follow whatever rules are established by big businesses to define what makes their site “good”. This system will turn our internet providers into internet gatekeepers.

One could argue that perhaps these companies will monitor what users like and these small starter businesses could be given more bandwidth as they become more popular, however, it will be difficult to outperform a big business web-page in the very beginning if said website does not have high enough priority.

I see a grim future where new companies will only succeed if they manage to acquire representation and backing from bigger companies to establish credibility, instead of just being a platform where anyone, be it you or I, can walk in, establish a storefront and create an enterprise.

You can see real life examples of the implications of this right now on YouTube. Surf around for a few hours and you will find that some videos are slower than others. You will likely naturally get tired of waiting for the small users’ videos to load and move on to something that isn’t as slow. This is directly due to how that user is prioritized, not due to the quality of his video. That user will lose hits, or points, or whatever you would like to call it, he or she will lose attention from the public due to prioritization of a gatekeeper.

In the above example, that user is seen as a guest and is at the mercy of that company. However, I am not a guest on the internet, I am a customer.  I have the right to access all websites equally without being hindered.

Our internet needs to be treated as a learning and communication resource, like a public library. By putting a price tag on our ability to interact with each other and our neighboring countries, we very likely will close the door on a very powerful asset that is so available to us right now in our lives.

Sincerely,

Keith Cameron

Our internet providers are very intent on emphasizing they are not going to modify the way they prioritize the internet, but I don’t understand what they plan to do. I never hear any details on this magical method of prioritizing the internet without modifying the way the internet is accessed based on some type of “favoritism”.

The only thing I can think is maybe they want to designate percentages that can access certain types of internet, like maybe peer to peer networks get a percentage and video delivery networks get another percentage. I’m unsure. But even then, consumer’s traffic is going to be modified which will definitely determine the type of web page that upcoming providers are going to try to create.

As an IT person, I have a fairly solid understanding of administering network traffic. We monitor and modify the traffic as needed here at my work to ensure that everyone has a pleasant experience, and what I have found is that you will never make everyone happy, but the feeling of having a webpage blocked or obviously hindered creates much more frustration than a slow connection all around.

As a provider, you cannot regulate what content you deliver without some type of discrimination. Whether it be based on profits, bandwidth, or traffic type.

I hope with all my heart that we all recognize the importance of not letting this go. We have to keep the internet open!

There is a wonderful tutorial on http://www.arduino.cc on the 4021 PISO shift register (http://www.arduino.cc/en/Tutorial/ShiftIn) however, having already been working with the 595 shift register for sending data to outputs, I decided to pick up a number of 74HC597N’s and just couldn’t get them to work.

After hooking it up in the same way as the tutorial states on arduino.cc, I just couldn’t get this thing to work. I had been reading around on the internet and realized there is almost no information on these registers. After a large amount of time staring at the data-sheet, bouncing thoughts off my dad and reading every little thing we could find, we managed to find a walk through for pic controllers coded in BASIC (http://www.scritube.com/limba/engleza/technical/BASIC-for-PIC-microcontrollers152311720.php) navigate to section 6.7 if you want to see the hookup info.

Finally, I had figured it out. With the 4021 and the 595, there are three pins that are used. You can read more about that on one of my previous posts, but essentially, there is the CLOCK pin (signifies that a cycle has occurred), a LATCH pin (signifies when to lock the data into memory) and lastly a DATA pin which receives the serial data connection and interprets it into a value between 0 and 255 (or higher if you have a chain of the chips). The 597, however, has another pin, there is a LOAD pin.

In the 597, it appears that the LATCH pin moves the data to a MID-REGISTER. Then, from the mid register, you have to initialize the LOAD pin to move it from the mid register to the actual memory of the shift register.

Doing so was extremely simple. The following diagram is how to hook up the 597 chip to the arduino duemilanove:

From here, we simply append the code that was listed on the tutorial for the 4021 as follows:

[code]

//**************************************************************//
//  Name    : shiftIn 595 Example 1.0                           //
//  Author  : Keith Cameron                                     //
//  Date    : 15 May, 2010                                      //
//  Version : 1.0                                               //
//  Notes   : Code for using a 74HC597N Shift Register          //
//          : Code based on the CD4021B tutorial by             //
//          : Carlyn Maw, found at arduino.cc                   //
//****************************************************************

//define where your pins are
int latchPin = 8;
int dataPin = 9;
int clockPin = 7;
int loadPin = 6;

//Define variables to hold the data for shift register.
//starting with a non-zero numbers can help troubleshoot
byte switchVar1 = 72;  //01001000

void setup() {
 //start serial
 Serial.begin(9600);

 //define pin modes
 pinMode(latchPin, OUTPUT);
 pinMode(clockPin, OUTPUT);
 pinMode(loadPin, OUTPUT);
 pinMode(dataPin, INPUT);

}

void loop() {

 // Pulse the latch pin:
 // Set it to 1 to collect parallel data
 digitalWrite(latchPin,1);
 // Set it to 1 to collect parallel data, wait
 delayMicroseconds(20);
 // Set it to 0 to transmit data serially
 digitalWrite(latchPin,0);

 // while the shift register is in serial mode collect
 // each shift register into a byte the register
 // attached to the chip comes in first
 switchVar1 = shiftIn(dataPin, clockPin, loadPin);

 // Print out the results.
 // leading 0's at the top of the byte (7, 6, 5, etc)
 // will be dropped before the first pin that has a
 // high input reading
 Serial.println(switchVar1, BIN);

 // white space
 Serial.println("-------------------");
 // Delay so all these print satements can keep up.
 // You would remove this if you weren't updating via
 // serial.
 delay(500);
}

////// ----------------------------------------shiftIn function
///// just needs the location of the data pin and the clock pin
///// it returns a byte with each bit in the byte corresponding
///// to a pin on the shift register. leftBit 7 = Pin 7 / Bit 0= Pin 0

byte shiftIn(int myDataPin, int myClockPin, int myLoadPin) {
 int i;
 int temp = 0;
 int pinState;
 byte myDataIn = 0;


 pinMode(myLoadPin, OUTPUT);

 pinMode(myClockPin, OUTPUT);
 pinMode(myDataPin, INPUT);
 // we will be holding the clock pin high 8 times (0,..,7) at the
 // end of each time through the for loop

//at the beginning of each loop when we set the clock low, it will
//be doing the necessary low to high drop to cause the shift
//register's dataPin to change state based on the value
//of the next bit in its serial information flow.
//The register transmits the information about the pins from pin 7 to pin 0
//so that is why our function counts down

 digitalWrite(myLoadPin, 0);
 delayMicroseconds(0.2);
 digitalWrite(myLoadPin, 1);

 for (i=7; i>=0; i--)
 {
 digitalWrite(myClockPin, 0);
 delayMicroseconds(0.2);
 temp = digitalRead(myDataPin);
 if (temp) {
 pinState = 1;
 //set the bit to 0 no matter what
 myDataIn = myDataIn | (1 << i);
 }
 else {
 //turn it off -- only necessary for debuging
 //print statement since myDataIn starts as 0
 pinState = 0;
 }

 //Debuging print statements
 //Serial.print(pinState);
 //Serial.print("     ");
 //Serial.println (dataIn, BIN);

 digitalWrite(myClockPin, 1);
 }

 //debuging print statements whitespace
 //Serial.println();
 //Serial.println(myDataIn, BIN);
 return myDataIn;
}

[/code]

That’s it! Just add perform the same action on the load pin that you performed on the latch pin. It’s totally simple, but I had a hard time finding it. Hopefully this will clear things up for someone, some day.

Conception

The initial project was simple. Make a binary clock. That was it. These things are so simple and basic, you can buy them for 15$ from just about anywhere, but that really doesn’t help me learn anything. So, I set out to make my own. I said I would take the project from beginning to end and get it running on its own. I carried it from the prototyped version to the stand-alone board in about 3 months (it probably would have been 3 weeks if I had limitless money and spare time to mess with it).

So, I set out with the initial design taken from daniel andrade’s webpage. I started with the code being identical. Below was the PCB layout for my design.

As you can see, the project originally was pretty simple. Everything below the 2 square switches is the layout to power the arduino board. With this design, I had 13 led’s and 2 switches (15 pins used). This was possible with the number of pins I had available with some to spare! Cool! But I wanted more. This thing needed to count seconds.

Adding seconds

Adding seconds would normally be quite simple, no more difficult than adding minutes or hours. The problem was that I didn’t have enough pins on the atmega328 (the arduino microcontroller) to add them. On the atmega328, there are 20 available pins for operation. That includes input AND output. If we add up the number of LED’s, we need 20 pins just for the LED’s, then we need 2 pins for the buttons to set the thing. If you didn’t have to set it, you could squeak by with all the pins, but that wouldn’t make a very effective binary clock if you couldn’t set the time. It would just be a binary timer.

So, I set out to figure out how to multiply my outputs. My first thought was to create some kind of matrix of the led’s which was an available project on arduino.cc, but keeping track of that proved difficult when not actually listed in a matrix. Also, I had alot of trouble lighting multiple LED’s, and it just seemed like it would be hard to explain to the students. After some further thinking, I started asking myself how I could just expand my pins. What if I had a second microprocessor that was listening for instructions on the first one. I could basically send this in the form of instructions like serial communication. Then, it would only take 3 pins from my main atmega to the second one. So basically, I would have 2 atmega’s talking, with a total of 40 pins – 6 pins to talk to eachother. 34 pins! That is more than enough.

This was great, but extremely costly. Each atmega chip is approximately 3-5$ depending on how many you buy and they take up alot of real estate on the board, plus they use a good chunk of power. “Argh! What am I going to do?”

Shift register to save the day

After some more reading, I found out about shift registers. These things are really cool and work really simply. Put simply, it takes 3 inputs and gives you 8 pins on the other side as output. Hooray! I can turn 3 pins into 8 pins, I have effectively found my solution. I can turn my 20 pins into 25 pins (remember i lose 3 pins to communicate to the shift register).

What is a shift register?

So how does this thing add outputs? We really need to know that before we can use this thing. Basically, there are 3 pins that go into it from the main microprocessor, a clock, a latch and an input.

The input (shown below as bit_in) is simply on or off.

The clock basically just says “next”.

The latch is like a camera that takes a picture. The minute you let go of the latch, it “snaps  a picture” of the position of all the pins and displays it.

Basically, you start with bit-in and clock at 0 (low), and the latch is at 1 (high). When the clock goes high (or turns on) it grabs the state of the bit-in and remembers it, then the clock immediately goes low again.

0——-

The next time the clock goes high, it pushes the last number blindly to the next flip-flop and reads wither the bit-in is on or off again (let’s say it was on this time) the clock immediately goes back low.

10——

This continues until you have filled all 8 available switches, they pass the info from one to the next like buckets of water like so:

10000000 -> 01000000 -> 10100000 -> 11010000 -> 01101000 -> 00110100 -> 00011010

As shown above, you can see that basically the numbers get handed from one switch to the next until they hit the end. The numbers in red are the old value, it never clears even if you turn off the power, which could be seen as a fault or a feature.

At this point, if it looks the way it wants, the latch will be told to go low (turn off), to signify that it has acquired the needed information and it “snaps a photo of it” and immediately puts it in memory as the pinout configuration. So, basically, with the above number, you end up with this:

• pin1- off
• pin2- off
• pin3- off
• pin4- on
• pin5- on
• pin6- off
• pin7- on
• pin8- off

The next sequence would look like this (I’m going to insert 01001001 into memory):

00011010 -next-> 10011010 -next-> 01001101 -next-> 00100110 -next-> 10010011 -next-> 01001001 -next-> 00100100 -next-> 10010010 -next-> 01001001 (“snap” into memory)

Essentially, just as it’s named, the bits get shifted from one slot into the next. This is really well illustrated at play-hookey (unfortunately, it appears the site was not renewed.. Which is a damn shame as it was a really helpful webpage with interactive switch explanations).

Design with seconds

After some smashing things together, I managed to get the whole project fitted into the same space (this is important because these boards are expensive!

You can see that now the board has been placed horizontally to fit everything in place. arduino.cc has the entire shift-out project that I used for testing the project before laying it out and shows how to plug it into the actual arduino board. Basically, pins 15-17 are used to interface with the shift register, and i piggybacked the power straight around to the top right pin on it. lastly i grounded it and put a 22pf capacitor on the st_cp as suggested in the shift-out project linked a few sentences back.

You could also note that it has rx and tx being run to the side. Those could be used to monitor the time.

The code

The code is moderately long to just post up, so I’m going to post the file to be looked at.

binary clock code.txt open it in a code editor as a C file

I’m still trying to figure out a few things. Starting line 87, there is a really big hex array that shows numbers in decimal. I tried everything to make that some kind of loop statement to make it 2 or 3 lines long, but it kept interpreting my decimal data as hexidecimal (i.e. 16 became  16 + 6, so 22) The led’s would then light up happily, but it didn’t look right. If you have a solution for this PLEASE let me know and I’ll be happy to try it.

I also want to simplify the hours and minutes into 2 seperate functions, but just left it how I had found it for the time being.

Finishing up

After alot of reading and learning, I finally had the layout I wanted and set out to order the boards. I purchased them from expressPCB and got the order in under 3 days! After putting it together, it wouldn’t power on. Oh no! I found out that the voltage regulator (ka7805 as illustrated above) requires 7.5 or higher voltage to push out 5v, I was trying it with usb power input and it just wouldn’t push quite enough, it was about .05 volts underpowered with this design and that was just not quite enough to power the atmega. Also, the 10k resistor in between the voltage regulator and the microprocessor/shift register had to be removed (I left that there as suggested by my father, for troubleshooting) and replaced it with a peice of wire to jumper it.

The final product! This is the whole thing running. You can see the resistor towards the bottom is jumpered to be bypassed.

Final thoughts

This thing EATS BATTERIES! That should be obvious with 20 led’s. You can literally watch the battery drain with a voltmeter at .005v per second (.3v per minute). Remember it needs 7.5v to run, so you basically got 10-20 minutes before it dies. Batteries are just not an option. I had already given up on this before even ordering it but still was interested in how fast it would drain, so I tried it.

battery monster!

I have currently got it plugged into 9v dc adapter and it is running happily and holding accurate time to the second over 2 days. If it is constant with the prototype, it should be accurate to the second for 1-2 weeks before it falls 1s out of sync which is within a reasonable tolerance (about as accurate as your standard wristwatch).

I am currently preparing the plexiglass housing, which will basically just be a peice of plexiglass that it is screwed onto with a little bend in the plastic half way through that will act as a base (like a plexiglass temporary sign holder). the 4 holes in the corners will have 1/2″ motherboard mount screws that will keep it in place.

Obviously, this was made before I found out about the battery murder

Summing it up

That was pretty much it. This project has been extremely informative and helpful for me and I hope that maybe I conveyed this information in a helpful manner to someone. I am super stoked at how much I learned with such a simple project and how truly complex even the most simple of things can be. Please feel free to leave a comment with any questions or comments on the design.

ExpressPCB File

In the spirit of open source, I have uploaded the pcb file so you guys can order your own if you like.

arduino_clock_wseconds.zip

You can order these at http://www.expresspcb.com/. Alternatively, they were kind enough to make the software for free use and you can open the file in it, make changes and print out the machine file to make one manually (warning: there are alot of tiny wires very close together, so it may prove difficult to print one out).

This allows the students to interact with the advertising and will potentially bring alot of attention to them. We’ll see soon enough!

Let me know what you think!