Split up files

.vscode/arduino.json

@@ -3,5 +3,5 @@
     "configuration": "cpu=16MHzatmega328",
     "programmer": "AVRISP mkII",
     "port": "COM5",
-    "sketch": "IOWA_TIMER_with_lap_counterV1.ino"
+    "sketch": "main.ino"
 }

IOWA_TIMER_with_lap_counterV1.ino

@@ -1,157 +0,0 @@
-/*
-
- * This is the Arduino code for an: 
- * Infrared Obstacle Sensor and displaying the time on 6 digital display and serial monitor.
- * Uses preprogrammed distance and converting it into mph.
-
-***Still needs to count and store laps for average #of laps once button press
-***Still needs to use 2 digit separate display the lap count for the above laps once button press
-
-
-IR Sensor Wiring:
-Brown: 5V DC
-Blue:  GNG
-Black: Signal, to PIN 2
-
-Arduino pins to the Large Digit Driver IN
-
-Arduino pin for SPEED DISPLAY
- 6 -> CLK (GREEN)
- 5 -> LAT (BLUE)
- 7 -> SER on the IN side (YELLOW)
- 5V -> 5V (ORANGE)
- Power Arduino with 12V and connect to Vin -> 12V (RED)
- GND -> GND (PURPLE)
- 9 -> Push Button
- START Input 
-
-Arduino pin for LAP DISPLAY
- 11 -> CLK (GREEN)
- 10 -> LAT (BLUE)
- 12 -> SER on the IN side (YELLOW)
- 5V -> 5V (ORANGE)
- Power Arduino with 12V and connect to Vin -> 12V (RED)
- GND -> GND (PURPLE)
-
-
-*/
-//GPIO declarations
-//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-byte segmentClock = 6;
-byte segmentLatch = 5;
-byte segmentData = 7;
-
-byte segmentClockLAP = 11;
-byte segmentLatchLAP = 10;
-byte segmentDataLAP = 12;
-
-
-
-//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-#define SENSOR 3 // define pint 3 for sensor
-#define ACTION 9 // define pin 9 as for ACTION
-
-float startTime;
-float endTime;
-float duration;
-byte timerRunning;
-unsigned long time;
-
-float distance;
-float seconds;
-// float minutes;
-float hours;
-float mph;
-int laps = 0;
-int avglaps= 0; // AVERAGE LAP COUNTER
-
-
-
-//LAP COUNTER SETUP ///////////////////////////////////////////////////
-const int dlen = 4;     //number of samples averaged 
-double d[dlen] = {0};    // need a 0 for every sample to average
-
-void pushd(double val) {
-  for (int i = 1; i < dlen; i++) {
-    d[i-1] = d[i]; 
-  }
-  d[dlen - 1] = val;
-//Serial.print ("val: "); /// same as ad
-//Serial.println (val,3);
-  
-}
-
-double avgd() {
-  double sum = 0;
-  for (int i = 0; i < dlen; i++) {
- 
-    sum = sum + d[i]; //  adds previous lap to sum
-    
-//Serial.print ("d[i]: ");
-//Serial.println (d[i],3);
-//Serial.print ("sum: ");
-//Serial.println (sum,3);
-
-    
-  }
-  double average = sum / (double)dlen;
-  return average;
-
-  
-}
-
-
-void loop(){
-  
-  if (timerRunning == 0 && digitalRead(SENSOR) == HIGH){ // stop counting
-  startTime = millis();
-  timerRunning = 1;
-  }
-  if (timerRunning == 1 && digitalRead(SENSOR) == LOW){ // start counting
-      endTime = millis();
-      timerRunning = 0;
-      laps++;
-      avglaps++;
-      duration = endTime - startTime;
-      seconds = (duration/1000);
-      hours= (duration/3600000);
-      mph= (distance/hours);
-      Serial.print ("Lap:   ");
-      Serial.print (laps);
-      Serial.print (" \t");
-      Serial.print ("mph:   ");
-      Serial.print (mph,3);
-      Serial.print (" \t");
-      Serial.print ("sec: ");
-      Serial.println (seconds,3);
-      Serial.print ("avgLap:   ");
-      Serial.println (avglaps);
-      delay(5); // added this delay to stop reading rear wheels error before was up to .003 seconds
-      showNumber(mph);
-      showNumberLAP(laps);
-
-/// LAP AVERAGE COUNTER LOOP CODE /////////////////////
-      double nd = mph;
-      //double ad= mph;
-      pushd(nd);
-      double ad = avgd();
-    
-      //  pushd(ad); // this pushs previous average back into new average
-
-      //Serial.print ("nd: ");
-      //Serial.println (nd,4);
-      Serial.print ("ad: ");
-      Serial.println (ad,4);
-      //Serial.print ("dlen: ");
-      //Serial.println (dlen,4);
-
-
-      //Serial.print ("d[dlen]: ");
-      //Serial.println (d[dlen],4);
-      //Serial.print(average);
-      }
-
-      }
-
-
-

lapCounter.ino

@@ -0,0 +1,34 @@
+//LAP COUNTER SETUP ///////////////////////////////////////////////////
+const int dlen = 4;     //number of samples averaged 
+double d[dlen] = {0};    // need a 0 for every sample to average
+
+void pushd(double val) {
+  for (int i = 1; i < dlen; i++) {
+    d[i-1] = d[i]; 
+  }
+  d[dlen - 1] = val;
+//Serial.print ("val: "); /// same as ad
+//Serial.println (val,3);
+  
+}
+
+double avgd() {
+  double sum = 0;
+  for (int i = 0; i < dlen; i++) {
+ 
+    sum = sum + d[i]; //  adds previous lap to sum
+    
+//Serial.print ("d[i]: ");
+//Serial.println (d[i],3);
+//Serial.print ("sum: ");
+//Serial.println (sum,3);
+
+    
+  }
+  double average = sum / (double)dlen;
+  return average;
+
+  
+}
+
+

loop.ino

@@ -0,0 +1,86 @@
+
+//GPIO declarations
+//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+byte segmentClock = 6;
+byte segmentLatch = 5;
+byte segmentData = 7;
+
+byte segmentClockLAP = 11;
+byte segmentLatchLAP = 10;
+byte segmentDataLAP = 12;
+
+
+
+//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+#define SENSOR 3 // define pint 3 for sensor
+#define ACTION 9 // define pin 9 as for ACTION
+
+float startTime;
+float endTime;
+float duration;
+byte timerRunning;
+unsigned long time;
+
+float distance;
+float seconds;
+// float minutes;
+float hours;
+float mph;
+int laps = 0;
+int avglaps= 0; // AVERAGE LAP COUNTER
+
+
+void loop() {
+  
+  if (timerRunning == 0 && digitalRead(SENSOR) == HIGH) { // stop counting
+    startTime = millis();
+    timerRunning = 1;
+  }
+  if (timerRunning == 1 && digitalRead(SENSOR) == LOW) { // start counting
+    endTime = millis();
+    timerRunning = 0;
+    laps++;
+    avglaps++;
+    duration = endTime - startTime;
+    seconds = (duration/1000);
+    hours= (duration/3600000);
+    mph= (distance/hours);
+    Serial.print ("Lap:   ");
+    Serial.print (laps);
+    Serial.print (" \t");
+    Serial.print ("mph:   ");
+    Serial.print (mph,3);
+    Serial.print (" \t");
+    Serial.print ("sec: ");
+    Serial.println (seconds,3);
+    Serial.print ("avgLap:   ");
+    Serial.println (avglaps);
+    delay(5); // added this delay to stop reading rear wheels error before was up to .003 seconds
+    showNumber(mph);
+    showNumberLAP(laps);
+
+    /// LAP AVERAGE COUNTER LOOP CODE /////////////////////
+    double nd = mph;
+    //double ad= mph;
+    pushd(nd);
+    double ad = avgd();
+
+    //  pushd(ad); // this pushs previous average back into new average
+
+    //Serial.print ("nd: ");
+    //Serial.println (nd,4);
+    Serial.print ("ad: ");
+    Serial.println (ad,4);
+    //Serial.print ("dlen: ");
+    //Serial.println (dlen,4);
+
+
+    //Serial.print ("d[dlen]: ");
+    //Serial.println (d[dlen],4);
+    //Serial.print(average);
+  }
+
+}
+
+
+

main.ino

@@ -0,0 +1,36 @@
+/*
+
+ * This is the Arduino code for an: 
+ * Infrared Obstacle Sensor and displaying the time on 6 digital display and serial monitor.
+ * Uses preprogrammed distance and converting it into mph.
+
+***Still needs to count and store laps for average #of laps once button press
+***Still needs to use 2 digit separate display the lap count for the above laps once button press
+
+
+IR Sensor Wiring:
+Brown: 5V DC
+Blue:  GNG
+Black: Signal, to PIN 2
+
+Arduino pins to the Large Digit Driver IN
+
+Arduino pin for SPEED DISPLAY
+ 6 -> CLK (GREEN)
+ 5 -> LAT (BLUE)
+ 7 -> SER on the IN side (YELLOW)
+ 5V -> 5V (ORANGE)
+ Power Arduino with 12V and connect to Vin -> 12V (RED)
+ GND -> GND (PURPLE)
+ 9 -> Push Button
+ START Input 
+
+Arduino pin for LAP DISPLAY
+ 11 -> CLK (GREEN)
+ 10 -> LAT (BLUE)
+ 12 -> SER on the IN side (YELLOW)
+ 5V -> 5V (ORANGE)
+ Power Arduino with 12V and connect to Vin -> 12V (RED)
+ GND -> GND (PURPLE)
+
+*/

postNumber.ino

@@ -0,0 +1,52 @@
+//Given a number, or '-', shifts it out to the display
+void postNumber(int number, boolean decimal)
+{
+  //    -  A
+  //   / / F/B
+  //    -  G
+  //   / / E/C
+  //    -. D/DP
+
+#define a  1<<0
+#define b  1<<6
+#define c  1<<5
+#define d  1<<4
+#define e  1<<3
+#define f  1<<1
+#define g  1<<2
+#define dp 1<<7
+
+  byte segments;
+
+  switch (number)
+  {
+    case 1: segments = b | c; break;
+    case 2: segments = a | b | d | e | g; break;
+    case 3: segments = a | b | c | d | g; break;
+    case 4: segments = f | g | b | c; break;
+    case 5: segments = a | f | g | c | d; break;
+    case 6: segments = a | f | g | e | c | d; break;
+    case 7: segments = a | b | c; break;
+    case 8: segments = a | b | c | d | e | f | g; break;
+    case 9: segments = a | b | c | d | f | g; break;
+    //   case 0: 
+    //    if (number > 9) {
+    //      segments = a | b | c | d | e | f; break;
+    //    } else segments = 0; break;
+      
+    case 0: segments = a | b | c | d | e | f; break;
+    case ' ': segments = 0; break;
+    case 'c': segments = g | e | d; break;
+    case '-': segments = g; break;
+  }
+
+  if (decimal) segments |= dp;
+
+  //Clock these bits out to the drivers
+  for (byte x = 0 ; x < 8 ; x++)
+  {
+    digitalWrite(segmentClock, LOW);
+    digitalWrite(segmentData, segments & 1 << (7 - x));
+    digitalWrite(segmentClock, HIGH); //Data transfers to the register on the rising edge of SRCK
+  }
+}

postNumberLap.ino

@@ -0,0 +1,52 @@
+//Given a number, or '-', shifts it out to the display
+void postNumberLAP(int number, boolean decimal)
+{
+  //    -  A
+  //   / / F/B
+  //    -  G
+  //   / / E/C
+  //    -. D/DP
+
+#define a  1<<0
+#define b  1<<6
+#define c  1<<5
+#define d  1<<4
+#define e  1<<3
+#define f  1<<1
+#define g  1<<2
+#define dp 1<<7
+
+  byte segmentsLAP;
+
+  switch (number)
+  {
+    case 1: segmentsLAP = b | c; break;
+    case 2: segmentsLAP = a | b | d | e | g; break;
+    case 3: segmentsLAP = a | b | c | d | g; break;
+    case 4: segmentsLAP = f | g | b | c; break;
+    case 5: segmentsLAP = a | f | g | c | d; break;
+    case 6: segmentsLAP = a | f | g | e | c | d; break;
+    case 7: segmentsLAP = a | b | c; break;
+    case 8: segmentsLAP = a | b | c | d | e | f | g; break;
+    case 9: segmentsLAP = a | b | c | d | f | g; break;
+ //   case 0: 
+  //    if (number > 9) {
+  //      segments = a | b | c | d | e | f; break;
+  //    } else segments = 0; break;
+      
+   case 0: segmentsLAP = a | b | c | d | e | f; break;
+    case ' ': segmentsLAP = 0; break;
+    case 'c': segmentsLAP = g | e | d; break;
+    case '-': segmentsLAP = g; break;
+  }
+
+  if (decimal) segmentsLAP |= dp;
+
+  //Clock these bits out to the drivers
+  for (byte x = 0 ; x < 8 ; x++)
+  {
+    digitalWrite(segmentClockLAP, LOW);
+    digitalWrite(segmentDataLAP, segmentsLAP & 1 << (7 - x));
+    digitalWrite(segmentClockLAP, HIGH); //Data transfers to the register on the rising edge of SRCK
+  }
+}

segments.ino

@@ -1,37 +1,29 @@
-
-
-
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-
- void showNumber(float value)
+void showNumber(float value)
 {
 
-// changed from int to float
+  // changed from int to float
   long numberX = ((value+.0005)*1000); //Remove negative signs and any decimals
 
-//  Serial.print("number: ");
-//  Serial.println(numberX,3);
-//  Serial.print("mph: ");
-//  Serial.println(mph,3);
+  //  Serial.print("number: ");
+  //  Serial.println(numberX,3);
+  //  Serial.print("mph: ");
+  //  Serial.println(mph,3);
   for (byte x = 0 ; x < 6 ; x++)
   {
-long remainder = numberX % 10;
+    long remainder = numberX % 10;
 
-  postNumber(remainder, x==3);
+    postNumber(remainder, x==3);
 
-//Serial.print("remainder: ");
-//Serial.println (remainder,4);
-//Serial.print("value: ");
-//Serial.println (value,3);
-//Serial.print("number: ");
-//  Serial.println(number );
- numberX /= 10;
+    //Serial.print("remainder: ");
+    //Serial.println (remainder,4);
+    //Serial.print("value: ");
+    //Serial.println (value,3);
+    //Serial.print("number: ");
+    //  Serial.println(number );
+    numberX /= 10;
  
-// Serial.print("number:  ");
-//  Serial.println(numberX,3 );
+    // Serial.print("number:  ");
+    //  Serial.println(numberX,3 );
   }
 
   //Latch the current segment data
@@ -39,388 +31,3 @@ long remainder = numberX % 10;
   digitalWrite(segmentLatch, HIGH); //Register moves storage register on the rising edge of RCK
 }
 
-//Given a number, or '-', shifts it out to the display
-void postNumber(int number, boolean decimal)
-{
-  //    -  A
-  //   / / F/B
-  //    -  G
-  //   / / E/C
-  //    -. D/DP
-
-#define a  1<<0
-#define b  1<<6
-#define c  1<<5
-#define d  1<<4
-#define e  1<<3
-#define f  1<<1
-#define g  1<<2
-#define dp 1<<7
-
-  byte segments;
-
-  switch (number)
-  {
-    case 1: segments = b | c; break;
-    case 2: segments = a | b | d | e | g; break;
-    case 3: segments = a | b | c | d | g; break;
-    case 4: segments = f | g | b | c; break;
-    case 5: segments = a | f | g | c | d; break;
-    case 6: segments = a | f | g | e | c | d; break;
-    case 7: segments = a | b | c; break;
-    case 8: segments = a | b | c | d | e | f | g; break;
-    case 9: segments = a | b | c | d | f | g; break;
- //   case 0: 
-  //    if (number > 9) {
-  //      segments = a | b | c | d | e | f; break;
-  //    } else segments = 0; break;
-      
-   case 0: segments = a | b | c | d | e | f; break;
-    case ' ': segments = 0; break;
-    case 'c': segments = g | e | d; break;
-    case '-': segments = g; break;
-  }
-
-  if (decimal) segments |= dp;
-
-  //Clock these bits out to the drivers
-  for (byte x = 0 ; x < 8 ; x++)
-  {
-    digitalWrite(segmentClock, LOW);
-    digitalWrite(segmentData, segments & 1 << (7 - x));
-    digitalWrite(segmentClock, HIGH); //Data transfers to the register on the rising edge of SRCK
-  }
-}
-
-
-
-
-
-void showShape(int shape)
-{
-  //    -  A
-  //   / / F/B
-  //    -  G
-  //   / / E/C
-  //    -. D/DP
-
-#define a  1<<0
-#define b  1<<6
-#define c  1<<5
-#define d  1<<4
-#define e  1<<3
-#define f  1<<1
-#define g  1<<2
-#define dp 1<<7
-
-  byte segments1;
-  byte segments2;
-  byte segments3;
-  byte segments4;
-  byte segments5;
-  byte segments6;
-
-  switch (shape)
-  {
-    // 
-    case 0:
-      segments1 = a | f | b | e | c | d;
-      segments2 = a | f | b | e | c | d;
-      segments3 = a | f | b | e | c | d;
-      segments4 = a | f | b | e | c | d;
-      segments5 = a | f | b | e | c | d;
-      segments6 = a | f | b | e | c | d;
-     
-      break;
-    // . .
-    case 1:
-      segments1 = dp;
-      segments2 = dp;
-      segments3 = dp;
-      segments4 = dp;
-      segments5 = dp;
-      segments6 = dp;
-      break;
-    // _ _
-    case 2:
-      segments1 = d;
-      segments2 = d;
-      
-      break;
-    // Double 88
-    case 3:
-      segments1 = a | f | b | e | c | d | g;
-      segments2 = a | f | b | e | c | d | g;  
-      break;
-    // - -
-    case 4:
-      segments1 = g;
-      segments2 = g;
-      segments3 = g;
-      segments4 = g;
-      segments5 = g;
-      segments6 = g;
-      break;
-    // NOTHING
-    case 5:
-      segments1 = 0;
-      segments2 = 0;
-      break;  
-  }
-  //Clock these bits out to the drivers
-  // Segment1
-  for (byte x = 0 ; x < 8 ; x++)
-  {
-    digitalWrite(segmentClock, LOW);
-    digitalWrite(segmentData, segments1 & 1 << (7 - x));
-    digitalWrite(segmentClock, HIGH); //Data transfers to the register on the rising edge of SRCK
-  }
-
-  digitalWrite(segmentLatch, LOW);
-  digitalWrite(segmentLatch, HIGH); //Register moves storage register on the rising edge of RCK
-
-  // Segment2
-  for (byte x = 0 ; x < 8 ; x++)
-  {
-    digitalWrite(segmentClock, LOW);
-    digitalWrite(segmentData, segments2 & 1 << (7 - x));
-
-    digitalWrite(segmentClock, HIGH); //Data transfers to the register on the rising edge of SRCK
-  }
-
-  digitalWrite(segmentLatch, LOW);
-  digitalWrite(segmentLatch, HIGH); //Register moves storage register on the rising edge of RCK
-
-// Segment3
-  for (byte x = 0 ; x < 8 ; x++)
-  {
-    digitalWrite(segmentClock, LOW);
-    digitalWrite(segmentData, segments3 & 1 << (7 - x));
-
-    digitalWrite(segmentClock, HIGH); //Data transfers to the register on the rising edge of SRCK
-  }
-
-  digitalWrite(segmentLatch, LOW);
-  digitalWrite(segmentLatch, HIGH); //Register moves storage register on the rising edge of RCK
-
-// Segment4
-  for (byte x = 0 ; x < 8 ; x++)
-  {
-    digitalWrite(segmentClock, LOW);
-    digitalWrite(segmentData, segments4 & 1 << (7 - x));
-    digitalWrite(segmentClock, HIGH); //Data transfers to the register on the rising edge of SRCK
-  }
-
-  digitalWrite(segmentLatch, LOW);
-  digitalWrite(segmentLatch, HIGH); //Register moves storage register on the rising edge of RCK
-
-  // Segment5
-  for (byte x = 0 ; x < 8 ; x++)
-  {
-    digitalWrite(segmentClock, LOW);
-    digitalWrite(segmentData, segments5 & 1 << (7 - x));
-
-    digitalWrite(segmentClock, HIGH); //Data transfers to the register on the rising edge of SRCK
-  }
-
-  digitalWrite(segmentLatch, LOW);
-  digitalWrite(segmentLatch, HIGH); //Register moves storage register on the rising edge of RCK
-
-// Segment6
-  for (byte x = 0 ; x < 8 ; x++)
-  {
-    digitalWrite(segmentClock, LOW);
-    digitalWrite(segmentData, segments6 & 1 << (7 - x));
-
-    digitalWrite(segmentClock, HIGH); //Data transfers to the register on the rising edge of SRCK
-  }
-
-  digitalWrite(segmentLatch, LOW);
-  digitalWrite(segmentLatch, HIGH); //Register moves storage register on the rising edge of RCK
-
-
-}
- 
-
-/////////////////////////////////////////////////////////////////////////////////////
-/////////////////////////////////////////////////////////////////////////////////////
-//                      LAP SEGMENT CODE 
-/////////////////////////////////////////////////////////////////////////////////////
-/////////////////////////////////////////////////////////////////////////////////////
-
-
-void showNumberLAP(float valueLAP)
-{
-
-// changed from int to float
-  long numberLAP =  abs(valueLAP); //Remove negative signs and any decimals
-
-//  Serial.print("numberLAP: ");
-//  Serial.println(numberLAP,3);
-//  Serial.print("mph: ");
-//  Serial.println(mph,3);
-
-  for (byte x = 0 ; x < 2 ; x++)
-  {
-long remainderLAP = numberLAP % 10;
-
-  postNumberLAP(remainderLAP, false);
-
-//Serial.print("remainder: ");
-//Serial.println (remainder,4);
-//Serial.print("value: ");
-//Serial.println (value,3);
-//Serial.print("number: ");
-//  Serial.println(number );
- numberLAP /= 10;
- 
-// Serial.print("number:  ");
-//  Serial.println(numberX,3 );
-  }
-
-  //Latch the current segment data
-  digitalWrite(segmentLatchLAP, LOW);
-  digitalWrite(segmentLatchLAP, HIGH); //Register moves storage register on the rising edge of RCK
-}
-
-
-
-//Given a number, or '-', shifts it out to the display
-void postNumberLAP(int number, boolean decimal)
-{
-  //    -  A
-  //   / / F/B
-  //    -  G
-  //   / / E/C
-  //    -. D/DP
-
-#define a  1<<0
-#define b  1<<6
-#define c  1<<5
-#define d  1<<4
-#define e  1<<3
-#define f  1<<1
-#define g  1<<2
-#define dp 1<<7
-
-  byte segmentsLAP;
-
-  switch (number)
-  {
-    case 1: segmentsLAP = b | c; break;
-    case 2: segmentsLAP = a | b | d | e | g; break;
-    case 3: segmentsLAP = a | b | c | d | g; break;
-    case 4: segmentsLAP = f | g | b | c; break;
-    case 5: segmentsLAP = a | f | g | c | d; break;
-    case 6: segmentsLAP = a | f | g | e | c | d; break;
-    case 7: segmentsLAP = a | b | c; break;
-    case 8: segmentsLAP = a | b | c | d | e | f | g; break;
-    case 9: segmentsLAP = a | b | c | d | f | g; break;
- //   case 0: 
-  //    if (number > 9) {
-  //      segments = a | b | c | d | e | f; break;
-  //    } else segments = 0; break;
-      
-   case 0: segmentsLAP = a | b | c | d | e | f; break;
-    case ' ': segmentsLAP = 0; break;
-    case 'c': segmentsLAP = g | e | d; break;
-    case '-': segmentsLAP = g; break;
-  }
-
-  if (decimal) segmentsLAP |= dp;
-
-  //Clock these bits out to the drivers
-  for (byte x = 0 ; x < 8 ; x++)
-  {
-    digitalWrite(segmentClockLAP, LOW);
-    digitalWrite(segmentDataLAP, segmentsLAP & 1 << (7 - x));
-    digitalWrite(segmentClockLAP, HIGH); //Data transfers to the register on the rising edge of SRCK
-  }
-}
-
-
-
-
-void showShapeLAP(int shape)
-{
-  //    -  A
-  //   / / F/B
-  //    -  G
-  //   / / E/C
-  //    -. D/DP
-
-#define a  1<<0
-#define b  1<<6
-#define c  1<<5
-#define d  1<<4
-#define e  1<<3
-#define f  1<<1
-#define g  1<<2
-#define dp 1<<7
-
-  byte segmentsLAP1;
-  byte segmentsLAP2;
-  
-  switch (shape)
-  {
-    // 
-    case 0:
-      segmentsLAP1 = a | f | b | e | c | d;
-      segmentsLAP2 = a | f | b | e | c | d;
-      break;
-    // . .
-    case 1:
-      segmentsLAP1 = dp;
-      segmentsLAP2 = dp;
-      break;
-    // _ _
-    case 2:
-      segmentsLAP1 = d;
-      segmentsLAP2 = d;
-      
-      break;
-    // Double 88
-    case 3:
-      segmentsLAP1 = a | f | b | e | c | d | g;
-      segmentsLAP2 = a | f | b | e | c | d | g;  
-      break;
-    // - -
-    case 4:
-      segmentsLAP1 = g;
-      segmentsLAP2 = g;
-      break;
-    // NOTHING
-    case 5:
-      segmentsLAP1 = 0;
-      segmentsLAP2 = 0;
-      break;  
-  }
-  //Clock these bits out to the drivers
-  // SegmentLAP1
-  for (byte x = 0 ; x < 8 ; x++)
-  {
-    digitalWrite(segmentClockLAP, LOW);
-    digitalWrite(segmentDataLAP, segmentsLAP1 & 1 << (7 - x));
-    digitalWrite(segmentClockLAP, HIGH); //Data transfers to the register on the rising edge of SRCK
-  }
-
-  digitalWrite(segmentLatchLAP, LOW);
-  digitalWrite(segmentLatchLAP, HIGH); //Register moves storage register on the rising edge of RCK
-
-  // SegmentLAP2
-  for (byte x = 0 ; x < 8 ; x++)
-  {
-    digitalWrite(segmentClockLAP, LOW);
-    digitalWrite(segmentDataLAP, segmentsLAP2 & 1 << (7 - x));
-
-    digitalWrite(segmentClockLAP, HIGH); //Data transfers to the register on the rising edge of SRCK
-  }
-
-  digitalWrite(segmentLatchLAP, LOW);
-  digitalWrite(segmentLatchLAP, HIGH); //Register moves storage register on the rising edge of RCK
-
-
-
-}
- 
- 

showNumberLap.ino

@@ -0,0 +1,33 @@
+void showNumberLAP(float valueLAP)
+{
+
+  // changed from int to float
+  long numberLAP =  abs(valueLAP); //Remove negative signs and any decimals
+
+  //  Serial.print("numberLAP: ");
+  //  Serial.println(numberLAP,3);
+  //  Serial.print("mph: ");
+  //  Serial.println(mph,3);
+
+  for (byte x = 0 ; x < 2 ; x++)
+  {
+    long remainderLAP = numberLAP % 10;
+
+    postNumberLAP(remainderLAP, false);
+
+    //Serial.print("remainder: ");
+    //Serial.println (remainder,4);
+    //Serial.print("value: ");
+    //Serial.println (value,3);
+    //Serial.print("number: ");
+    //  Serial.println(number );
+    numberLAP /= 10;
+ 
+    // Serial.print("number:  ");
+    //  Serial.println(numberX,3 );
+  }
+
+  //Latch the current segment data
+  digitalWrite(segmentLatchLAP, LOW);
+  digitalWrite(segmentLatchLAP, HIGH); //Register moves storage register on the rising edge of RCK
+}

showShape.ino

@@ -0,0 +1,144 @@
+void showShape(int shape)
+{
+  //    -  A
+  //   / / F/B
+  //    -  G
+  //   / / E/C
+  //    -. D/DP
+
+#define a  1<<0
+#define b  1<<6
+#define c  1<<5
+#define d  1<<4
+#define e  1<<3
+#define f  1<<1
+#define g  1<<2
+#define dp 1<<7
+
+  byte segments1;
+  byte segments2;
+  byte segments3;
+  byte segments4;
+  byte segments5;
+  byte segments6;
+
+  switch (shape)
+  {
+    // 
+    case 0:
+      segments1 = a | f | b | e | c | d;
+      segments2 = a | f | b | e | c | d;
+      segments3 = a | f | b | e | c | d;
+      segments4 = a | f | b | e | c | d;
+      segments5 = a | f | b | e | c | d;
+      segments6 = a | f | b | e | c | d;
+     
+      break;
+    // . .
+    case 1:
+      segments1 = dp;
+      segments2 = dp;
+      segments3 = dp;
+      segments4 = dp;
+      segments5 = dp;
+      segments6 = dp;
+      break;
+    // _ _
+    case 2:
+      segments1 = d;
+      segments2 = d;
+      
+      break;
+    // Double 88
+    case 3:
+      segments1 = a | f | b | e | c | d | g;
+      segments2 = a | f | b | e | c | d | g;  
+      break;
+    // - -
+    case 4:
+      segments1 = g;
+      segments2 = g;
+      segments3 = g;
+      segments4 = g;
+      segments5 = g;
+      segments6 = g;
+      break;
+    // NOTHING
+    case 5:
+      segments1 = 0;
+      segments2 = 0;
+      break;  
+  }
+  //Clock these bits out to the drivers
+  // Segment1
+  for (byte x = 0 ; x < 8 ; x++)
+  {
+    digitalWrite(segmentClock, LOW);
+    digitalWrite(segmentData, segments1 & 1 << (7 - x));
+    digitalWrite(segmentClock, HIGH); //Data transfers to the register on the rising edge of SRCK
+  }
+
+  digitalWrite(segmentLatch, LOW);
+  digitalWrite(segmentLatch, HIGH); //Register moves storage register on the rising edge of RCK
+
+  // Segment2
+  for (byte x = 0 ; x < 8 ; x++)
+  {
+    digitalWrite(segmentClock, LOW);
+    digitalWrite(segmentData, segments2 & 1 << (7 - x));
+
+    digitalWrite(segmentClock, HIGH); //Data transfers to the register on the rising edge of SRCK
+  }
+
+  digitalWrite(segmentLatch, LOW);
+  digitalWrite(segmentLatch, HIGH); //Register moves storage register on the rising edge of RCK
+
+// Segment3
+  for (byte x = 0 ; x < 8 ; x++)
+  {
+    digitalWrite(segmentClock, LOW);
+    digitalWrite(segmentData, segments3 & 1 << (7 - x));
+
+    digitalWrite(segmentClock, HIGH); //Data transfers to the register on the rising edge of SRCK
+  }
+
+  digitalWrite(segmentLatch, LOW);
+  digitalWrite(segmentLatch, HIGH); //Register moves storage register on the rising edge of RCK
+
+// Segment4
+  for (byte x = 0 ; x < 8 ; x++)
+  {
+    digitalWrite(segmentClock, LOW);
+    digitalWrite(segmentData, segments4 & 1 << (7 - x));
+    digitalWrite(segmentClock, HIGH); //Data transfers to the register on the rising edge of SRCK
+  }
+
+  digitalWrite(segmentLatch, LOW);
+  digitalWrite(segmentLatch, HIGH); //Register moves storage register on the rising edge of RCK
+
+  // Segment5
+  for (byte x = 0 ; x < 8 ; x++)
+  {
+    digitalWrite(segmentClock, LOW);
+    digitalWrite(segmentData, segments5 & 1 << (7 - x));
+
+    digitalWrite(segmentClock, HIGH); //Data transfers to the register on the rising edge of SRCK
+  }
+
+  digitalWrite(segmentLatch, LOW);
+  digitalWrite(segmentLatch, HIGH); //Register moves storage register on the rising edge of RCK
+
+// Segment6
+  for (byte x = 0 ; x < 8 ; x++)
+  {
+    digitalWrite(segmentClock, LOW);
+    digitalWrite(segmentData, segments6 & 1 << (7 - x));
+
+    digitalWrite(segmentClock, HIGH); //Data transfers to the register on the rising edge of SRCK
+  }
+
+  digitalWrite(segmentLatch, LOW);
+  digitalWrite(segmentLatch, HIGH); //Register moves storage register on the rising edge of RCK
+
+
+}

showShapeLap.ino

@@ -0,0 +1,79 @@
+void showShapeLAP(int shape)
+{
+  //    -  A
+  //   / / F/B
+  //    -  G
+  //   / / E/C
+  //    -. D/DP
+
+#define a  1<<0
+#define b  1<<6
+#define c  1<<5
+#define d  1<<4
+#define e  1<<3
+#define f  1<<1
+#define g  1<<2
+#define dp 1<<7
+
+  byte segmentsLAP1;
+  byte segmentsLAP2;
+  
+  switch (shape)
+  {
+    // 
+    case 0:
+      segmentsLAP1 = a | f | b | e | c | d;
+      segmentsLAP2 = a | f | b | e | c | d;
+      break;
+    // . .
+    case 1:
+      segmentsLAP1 = dp;
+      segmentsLAP2 = dp;
+      break;
+    // _ _
+    case 2:
+      segmentsLAP1 = d;
+      segmentsLAP2 = d;
+      
+      break;
+    // Double 88
+    case 3:
+      segmentsLAP1 = a | f | b | e | c | d | g;
+      segmentsLAP2 = a | f | b | e | c | d | g;  
+      break;
+    // - -
+    case 4:
+      segmentsLAP1 = g;
+      segmentsLAP2 = g;
+      break;
+    // NOTHING
+    case 5:
+      segmentsLAP1 = 0;
+      segmentsLAP2 = 0;
+      break;  
+  }
+  //Clock these bits out to the drivers
+  // SegmentLAP1
+  for (byte x = 0 ; x < 8 ; x++)
+  {
+    digitalWrite(segmentClockLAP, LOW);
+    digitalWrite(segmentDataLAP, segmentsLAP1 & 1 << (7 - x));
+    digitalWrite(segmentClockLAP, HIGH); //Data transfers to the register on the rising edge of SRCK
+  }
+
+  digitalWrite(segmentLatchLAP, LOW);
+  digitalWrite(segmentLatchLAP, HIGH); //Register moves storage register on the rising edge of RCK
+
+  // SegmentLAP2
+  for (byte x = 0 ; x < 8 ; x++)
+  {
+    digitalWrite(segmentClockLAP, LOW);
+    digitalWrite(segmentDataLAP, segmentsLAP2 & 1 << (7 - x));
+
+    digitalWrite(segmentClockLAP, HIGH); //Data transfers to the register on the rising edge of SRCK
+  }
+
+  digitalWrite(segmentLatchLAP, LOW);
+  digitalWrite(segmentLatchLAP, HIGH); //Register moves storage register on the rising edge of RCK
+
+}