iowa-timer/segments.ino

////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////


 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



}