Initial Commit

.vscode/arduino.json

@@ -0,0 +1,7 @@
+{
+    "board": "arduino:avr:pro",
+    "configuration": "cpu=16MHzatmega328",
+    "programmer": "AVRISP mkII",
+    "port": "COM5",
+    "sketch": "IOWA_TIMER_with_lap_counterV1.ino"
+}

.vscode/c_cpp_properties.json

@@ -0,0 +1,16 @@
+{
+    "configurations": [
+        {
+            "name": "Win32",
+            "includePath": [
+                "C:\\Program Files (x86)\\Arduino\\tools\\**",
+                "C:\\Program Files (x86)\\Arduino\\hardware\\arduino\\avr\\**"
+            ],
+            "forcedInclude": [
+                "C:\\Program Files (x86)\\Arduino\\hardware\\arduino\\avr\\cores\\arduino\\Arduino.h"
+            ],
+            "intelliSenseMode": "msvc-x64"
+        }
+    ],
+    "version": 4
+}

IOWA_TIMER_with_lap_counterV1.ino

@@ -0,0 +1,157 @@
+/*
+
+ * 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);
+      }
+
+      }
+
+
+

segments.ino

@@ -0,0 +1,426 @@
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+ void showNumber(float value)
+{
+
+// 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);
+  for (byte x = 0 ; x < 6 ; x++)
+  {
+long remainder = numberX % 10;
+
+  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("number:  ");
+//  Serial.println(numberX,3 );
+  }
+
+  //Latch the current segment data
+  digitalWrite(segmentLatch, LOW);
+  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
+
+
+
+}
+ 
+ 

setup.ino

@@ -0,0 +1,51 @@
+void setup() {
+  Serial.begin(9600);// setup Serial Monitor to display information
+  pinMode(SENSOR, INPUT_PULLUP);// define pin as Input  sensor
+  pinMode(ACTION, OUTPUT);// define pin as OUTPUT for ACTION
+  pinMode(segmentClock, OUTPUT);
+  pinMode(segmentData, OUTPUT);
+  pinMode(segmentLatch, OUTPUT);
+  pinMode(segmentClockLAP, OUTPUT);
+  pinMode(segmentDataLAP, OUTPUT);
+  pinMode(segmentLatchLAP, OUTPUT);
+
+  
+  pinMode(13,OUTPUT); // blink tester
+  digitalWrite(segmentClock, LOW);
+  digitalWrite(segmentData, LOW);
+  digitalWrite(segmentLatch, LOW);
+  digitalWrite(segmentClockLAP, LOW);
+  digitalWrite(segmentDataLAP, LOW);
+  digitalWrite(segmentLatchLAP, LOW);
+
+  
+  
+
+// whittier track circumference equals 205.08 feet or 0.0388409091 miles per lap USED 0.0384
+// Sabatatini test track circumference equals 100.531 feet or 0.01903996212 miles per lap USED 0.01903   
+// Iowa track = 0.02083333333 miles per lap
+   distance= 0.02083333333; 
+   Serial.println("Iowa Lap Timer");
+   Serial.print(distance, 4);
+   Serial.println (" = circumference in miles");
+   Serial.print(.250/distance, 4);
+   Serial.println(" = laps per quarter mile");
+   Serial.print(.310686/distance, 4);
+   Serial.println(" =laps per 500 meters");
+   Serial.println ("READY!");
+   showShape(0);
+   showShapeLAP(0);
+   delay(500);
+   showShape(4);
+   showShapeLAP(4);
+   delay(500);
+   showShape(0);
+   showShapeLAP(0);
+   delay(500);
+   showShape(4);
+   showShapeLAP(4);
+   delay(500);
+   showShapeLAP(2);
+   
+
+}