Added I2C interface example.

Added a really simple I2C example sketch. Cleaned up some residual stuff
in the main firmware. Moved the I2C receive event down below the main
loop because it's not really an ISR.

Author: nseidle

firmware/Serial 7-Segment Display/Arduino_Examples/S7S_Example_BasicI2C/S7S_Example_BasicI2C.ino

@@ -0,0 +1,66 @@
+/*
+ 11-2-2012
+ Spark Fun Electronics
+ Nathan Seidle
+ 
+ This code is public domain but you buy me a beer if you use this and we meet someday (Beerware license).
+
+ Serial7Segment is an open source seven segment display. 
+
+ This is example code that shows how to send data over I2C to the display.
+ 
+ Note: This code expects the display to be listening at the default I2C address. If your display is not at 0x71, you can
+ do a software or hardware reset. See the Wiki for more info: 
+ http://github.com/sparkfun/Serial7SegmentDisplay/wiki/Special-Commands
+ 
+ To get this code to work, attached an Serial7Segment to an Arduino Uno using the following pins:
+ A5 to SCL
+ A4 to SDA
+ VIN to PWR
+ GND to GND
+
+*/
+
+#include <Wire.h>
+
+#define DISPLAY_ADDRESS1 0x71 //This is the default address of the OpenSegment with both solder jumpers open
+
+int cycles = 0;
+
+void setup() 
+{
+  Wire.begin(); //Join the bus as master
+
+  Serial.begin(9600); //Start serial communication at 9600 for debug statements
+  Serial.println("OpenSegment Example Code");
+
+  //Send the reset command to the display - this forces the cursor to return to the beginning of the display
+  Wire.beginTransmission(DISPLAY_ADDRESS1);
+  Wire.write('v');
+  Wire.endTransmission();
+}
+
+void loop() 
+{
+  cycles++; //Counting cycles! Yay!
+  Serial.print("Cycle: ");
+  Serial.println(cycles);
+  
+  i2cSendValue(cycles); //Send the four characters to the display
+  
+  delay(1); //If we remove the slow debug statements, we need a very small delay to prevent flickering
+}
+
+//Given a number, i2cSendValue chops up an integer into four values and sends them out over I2C
+void i2cSendValue(int tempCycles)
+{
+  Wire.beginTransmission(DISPLAY_ADDRESS1); // transmit to device #1
+  Wire.write(tempCycles / 1000); //Send the left most digit
+  tempCycles %= 1000; //Now remove the left most digit from the number we want to display
+  Wire.write(tempCycles / 100);
+  tempCycles %= 100;
+  Wire.write(tempCycles / 10);
+  tempCycles %= 10;
+  Wire.write(tempCycles); //Send the right most digit
+  Wire.endTransmission(); //Stop I2C transmission
+}

firmware/Serial 7-Segment Display/Serial_7_Segment_Display_Firmware/Serial_7_Segment_Display_Firmware.ino

@@ -68,24 +68,6 @@ ISR(SPI_STC_vect)
   interrupts();  // Fine, you were saying?
 }
 
-// I2C byte receive interrupt routine
-// Note: this isn't an ISR. I'm using wire library (because it just works), so
-// Wire.onReceive(twiReceive); should be called
-void twiReceive(int rxCount)
-{
-  while(Wire.available() > 0)  // Do this while data is available in Wire buffer
-  {
-    unsigned int i = (buffer.head + 1) % BUFFER_SIZE;  // read buffer head position and increment
-    unsigned char c = Wire.read();  // Read data byte into c, from Wire data buffer
-
-    if (i != buffer.tail)  // As long as the buffer isn't full, we can store the data in buffer
-    {
-      buffer.data[buffer.head] = c;  // Store the data into the buffer's head
-      buffer.head = i;  // update buffer head, since we stored new data
-    }    
-  }
-}
-
 // The display data is updated on a Timer interrupt
 ISR(TIMER1_COMPA_vect)
 {
@@ -128,24 +110,36 @@ void loop()
 }
 
 // This is effectively the UART0 byte received interrupt routine
-//ISR(USART_RX_vect)
 void serialEvent()
 {
   while (Serial.available()) 
   {
-    //noInterrupts();  // We'll be quick...
-
     unsigned int i = (buffer.head + 1) % BUFFER_SIZE;  // read buffer head position and increment
-    //    unsigned char c = UDR0;  // Read data byte into c, from UART0 data register
     unsigned char c = Serial.read();  // Read data byte into c, from UART0 data register
 
     if (i != buffer.tail)  // As long as the buffer isn't full, we can store the data in buffer
     {
       buffer.data[buffer.head] = c;  // Store the data into the buffer's head
       buffer.head = i;  // update buffer head, since we stored new data
     }
+  }
+}
 
-    //interrupts();  // Okay, resume interrupts
+// I2C byte receive interrupt routine
+// Note: this isn't an ISR. I'm using wire library (because it just works), so
+// Wire.onReceive(twiReceive); should be called
+void twiReceive(int rxCount)
+{
+  while(Wire.available())  // Do this while data is available in Wire buffer
+  {
+    unsigned int i = (buffer.head + 1) % BUFFER_SIZE;  // read buffer head position and increment
+    unsigned char c = Wire.read();  // Read data byte into c, from Wire data buffer
+
+    if (i != buffer.tail)  // As long as the buffer isn't full, we can store the data in buffer
+    {
+      buffer.data[buffer.head] = c;  // Store the data into the buffer's head
+      buffer.head = i;  // update buffer head, since we stored new data
+    }    
   }
 }