/* ********************************************************************** 
 * ## Ready to build ##
 * ATTiny85_7Seg_DHT22
 * 7-SegmentDisplay - v1.0
 *  Uses (2) Common cathode 7-segment display,
 *  Uses (2) 74HC595 shift register IC
 *  Uses ATTiny85
 *
 * Description:
 *  This sketch illustrates the controlling of two 7-segment displays with
 *  two 74HC595 shift register. Charlieplexing is not used. Daisychained
 *  shift registers push 8 bits at a time from one display to the next.
 *  For a two digit display this is quite easy to code.
 
 *  Sketch uses 5236 bytes (63%) of program storage space. Maximum is 8192 bytes.
 *  Global variables use 80 bytes (15%) of dynamic memory, leaving 432 bytes for local variables. Maximum is 512 bytes.
 *   
 * See spreadsheet file 74HC595_SegmentDisplay.ods
 * Define the LED digit patterns, from 0 - 9
 * 1 = LED on, 0 = LED off, common cathode, in this order:
 *  74HC595 pin   Q7, Q6, Q5, Q4, Q3, Q2, Q1, Q0 
 *  Mapping to    g,  f,  e,  d,  c,  b,  a,  dp   of Seven-Segment LED
 * ********************************************************* */

#include <TinyDebug.h>
#include "dht.h"

#define DHTPIN PB3

dht DHT;

/********** Hardware Definitions **********/
int latchPin = PB0; // connect to the ST_CP of 74HC595 (pin 12,latch pin)
int dataPin = PB1; // connect to the DS of 74HC595 (pin 14, data pin)
int clockPin = PB2; // connect to the SH_CP of 74HC595 (pin 11, clock pin)


byte digits[10] = { B01111110,  // = 0
                    B00001100,  // = 1
                    B10110110,  // = 2
                    B10011110,  // = 3
                    B11001100,  // = 4
                    B11011010,  // = 5
                    B11111000,  // = 6
                    B00001110,  // = 7
                    B11111110,  // = 8
                    B11001110   // = 9
};

uint8_t blink[2] = {B11000110,
                    B10000000
};

byte sevenSegDP = B00000001;  // = DP

uint8_t temp[2] = {0, 0};
uint8_t humid[2] = {0, 0};

int tempF = 0;
int hum = 0;
long randNumber;
long randBlink;

/*---------- Function Declaration ----------*/
void updateTemperatureDigits();
void updateHumidityDigits();
void writeDigits(byte r1, byte r2);
void writeBlink(byte r1, byte r2);
void writeSegment(byte segment);
void writeBlank();


void setup() {
  Debug.begin();

  // Set latchPin, clockPin, dataPin as output
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  randomSeed(analogRead(A2));
}

void loop() {

  int check = DHT.read22(DHTPIN); // 0 = no errors

  if (check == DHTLIB_OK) {
    tempF = (DHT.temperature * 1.8) + 32; // Fahrenheit
    hum = DHT.humidity;
    updateHumidityDigits();
    writeDigits(humid[0], humid[1]); // write humid to 7-Segments
    delay(1000);
    updateTemperatureDigits();
    writeDigits(temp[0], temp[1]); // write temp to 7-Segments
  }

  randNumber = random(1000, 10000);
  
  Debug.print("check: "); Debug.println(check);
  Debug.print("tempF: "); Debug.println(tempF);
  Debug.print("hum: "); Debug.println(hum);

  Debug.print("temp:"); Debug.print(temp[0]); Debug.print(temp[1]);
  Debug.print(" humid:"); Debug.print(humid[0]); Debug.println(humid[1]);

  Debug.println(randNumber);

  delay(randNumber);

/*
  // count to 99
  for (int i = 0; i < 10; i++) {
    for (int j = 0; j < 10; j++) {
      // First 8 bytes 'j' goes into register 1.
      // Second 8 bytes 'i' goes into register 1 and pushes first 8 bytes into register 2.
      writeDigits(i, j);
      delay(500);
    }
  }
*/

  if (tempF > 75) {
    writeBlink(0, 0);
    randBlink = random(500, 2000);
    delay(randBlink);
    writeBlink(1, 1);
    delay(300);

    writeBlink(0, 0);
    randBlink = random(500, 2000);
    delay(randBlink);
    writeBlink(1, 1);
    delay(300);

    writeBlink(0, 0);
    randBlink = random(500, 2000);
    delay(randBlink);
    writeBlink(1, 1);
    delay(300);

    writeBlink(0, 0);
    randBlink = random(500, 2000);
    delay(randBlink);

    writeBlank();
    delay(500);
  }

  if(tempF < 69) {
    for (int i = 0; i < 6; i++) {
      byte z = 0b00000000 + (2 << i);
      writeSegment(z);
      Debug.print(z, BIN);
      Debug.print(", ");
      delay(100);
    }
    for (int i = 0; i < 6; i++) {
      byte z = 0b00000000 + (2 << i);
      writeSegment(z);
      delay(100);
    }
    for (int i = 0; i < 6; i++) {
      byte z = 0b00000000 + (2 << i);
      writeSegment(z);
      delay(100);
    }

    for (int j = 5; j >= 0; j--) {
      byte x = 0b00000000 + (2 << j);
      writeSegment(x);
      Debug.print(x, BIN);
      Debug.print(", ");
      delay(100);
    }
    for (int j = 5; j >= 0; j--) {
      byte x = 0b00000000 + (2 << j);
      writeSegment(x);
      delay(100);
    }
    for (int j = 5; j >= 0; j--) {
      byte x = 0b00000000 + (2 << j);
      writeSegment(x);
      delay(100);
    }
    writeBlank();
  }

  // Sensor readings take up to 2 seconds (its a very slow sensor)
  delay(2000); // Wait a few seconds between measurements.

/*
  writeSegment(B11111111); // write temp to 7-Segments
  delay(2000);
  writeSegment(B00000000);
  delay(2000);
*/

} // end of void loop


/*---------- Functions ----------*/

void updateTemperatureDigits() {
  temp[0] = ((int)tempF % 100) / 10;
  temp[1] = ((int)tempF % 10);
  //temp[2] = (int)(tempF * 10) % 10;
  //temp[3] = (int)(tempF * 100) % 10;
}

void updateHumidityDigits() {
  humid[0] = ((int)hum % 100) / 10;
  humid[1] = ((int)hum % 10);
  //temp[2] = (int)(tempF * 10) % 10;
  //temp[3] = (int)(tempF * 100) % 10;
}

// display a alpha, binary value, or number on the digital segment display
void writeDigits(byte r1, byte r2) {
  // r1, r2 = array pointer or binary value, as a byte 
  digitalWrite(latchPin, LOW); // set latchPin low, before sending data
  shiftOut(dataPin, clockPin, MSBFIRST, digits[r2]);
  shiftOut(dataPin, clockPin, MSBFIRST, digits[r1]);
  digitalWrite(latchPin, HIGH); // set latchPin high, after sending data
}

void writeBlink(byte r1, byte r2) {
  // r1, r2 = array pointer or binary value, as a byte 
  digitalWrite(latchPin, LOW); // set latchPin low, before sending data
  shiftOut(dataPin, clockPin, MSBFIRST, blink[r2]);
  shiftOut(dataPin, clockPin, MSBFIRST, blink[r1]);
  digitalWrite(latchPin, HIGH); // set latchPin high, after sending data
}

void writeSegment(byte segment) {
  // digit = array pointer or binary value, as a byte 
  digitalWrite(latchPin, LOW); // set latchPin low, before sending data
  // shiftOut(dataPin, clockPin, MSBFIRST, blink[r2]);
  shiftOut(dataPin, clockPin, MSBFIRST, segment);
  shiftOut(dataPin, clockPin, MSBFIRST, segment);
  digitalWrite(latchPin, HIGH); // set latchPin high, after sending data
}

void writeBlank() {
  digitalWrite(latchPin, LOW); // set latchPin low, before sending data
  shiftOut(dataPin, clockPin, MSBFIRST, B00000000);
  shiftOut(dataPin, clockPin, MSBFIRST, B00000000);
  digitalWrite(latchPin, HIGH); // set latchPin high, after sending data
}