/*
  74HC165 Shift register input example

  https://wokwi.com/arduino/projects/306031380875182657

  (C) 2021, Uri Shaked
*/

// Display LED
#define DATA_PIN  12  // Pin connected to DS of 74HC595
#define LATCH_PIN 14  // Pin connected to STCP of 74HC595
#define CLOCK_PIN 27 // Pin connected to SHCP of 74HC595

// How many of the shift registers
#define NUM_SHIFT_REGS 3

const uint8_t numOfRegisterPins = NUM_SHIFT_REGS * 8;

bool registers[numOfRegisterPins];

bool toggle = false;

// Input Switch
const byte dataPin = 2;        // to latch the inputs into the registers
const byte clockPin = 17;       // I choose the SCK pin
const byte latchPin = 4;        // I choose the MISO pin
uint32_t oldOptionSwitch = 0;   // previous state of all the inputs

const int pulseWidth = 10;      // pulse width in microseconds

const int numBits = 24;   /* Set to 8 * number of shift registers */

void setup() {
  /*
  Serial.begin(115200);
  pinMode(dataPin, INPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(latchPin, OUTPUT);
  */
  Serial.begin( 115200);
  Serial.println( "Turn on and off the switches");
  Serial.println( "Top row is switch 0 (right) to switch 7 (left)");
  Serial.println( "Second row is 8 to 15, and so on");

  // Input Switch
  pinMode(dataPin, INPUT);
  pinMode(clockPin, OUTPUT);   // clock signal, idle LOW
  pinMode(latchPin, OUTPUT);   // latch (copy input into registers), idle HIGH
  digitalWrite(latchPin, HIGH);

  // Display LED
  pinMode(DATA_PIN, OUTPUT);
  pinMode(CLOCK_PIN, OUTPUT);
  pinMode(LATCH_PIN, OUTPUT);
  clearRegisters();
  writeRegisters();
}

void loop ()
{
  // Give a pulse to the parallel load latch of all 74HC165
  digitalWrite( latchPin, LOW);
  delayMicroseconds( pulseWidth);
  digitalWrite( latchPin, HIGH);// Step 2: Shift
  
  // Reading one 74HC165 at a time and combining them into a 32 bit variable
  // The last 74HC165 is at the bottom, but the switches start numbering
  // at the top. So the first byte has to be shifted into the highest place.
  uint32_t optionSwitch = 0;
  for( int i=numBits-8; i>=0; i-=8)
  {
    optionSwitch |= ((uint32_t) ReadOne165()) << i;
    //Serial.println(i);
  }

  //Serial.println(optionSwitch);
  
  for( int i = 0; i<numBits; i++)
  {
    if( bitRead( optionSwitch, i) != bitRead( oldOptionSwitch,i))
    {
      Serial.print( "Switch ");
      if( i < 10)
        Serial.print( " ");
      Serial.print( i+1 );
      Serial.print( " is now ");
      Serial.println( bitRead( optionSwitch, i) == 0 ? "down ↓" : "up   ↑");

      bitRead( optionSwitch, i) == 0 ? setRegisterPin(i, 0) : setRegisterPin(i, 1);
      writeRegisters();
    }
  }
  
  oldOptionSwitch = optionSwitch;
  delay( 25);      // slow down the sketch to avoid switch bounce

  /*
  for (uint8_t i = 0; i < 16; i++) {
    if (i % 2 == 0) {
      setRegisterPin(i, toggle);
    } else {
      setRegisterPin(i, !toggle);
    }
    writeRegisters();
  }
  toggle = !toggle;
  delay(500);
  */
}

// The ReadOne165() function reads only 8 bits,
// because of the similar functions shiftIn() and SPI.transfer() 
// which both use 8 bits.
//
// The shiftIn() can not be used here, because the clock is set idle low
// and the shiftIn() makes the clock high to read a bit.
// The 74HC165 require to read the bit first and then give a clock pulse.
//
byte ReadOne165()
{
  byte ret = 0x00;

  // The first one that is read is the highest bit (input D7 of the 74HC165).
  for( int i=7; i>=0; i--)
  {
    //Serial.println(ret);
    if( digitalRead( dataPin) == HIGH) {
      bitSet( ret, i);
    }     

    digitalWrite( clockPin, HIGH);
    delayMicroseconds( pulseWidth);
    digitalWrite( clockPin, LOW);
  }

  return( ret);
}

void clearRegisters() {
  // Reset all register pins
  for (int i = numOfRegisterPins - 1; i >= 0; i--) {
    registers[i] = LOW;
  }
}

void setRegisterPin(int index, int value) {
  // Set an individual pin HIGH or LOW
  registers[index] = value;
}

void writeRegisters() {
  // Set and display registers
  digitalWrite(LATCH_PIN, LOW);

  for (int i = numOfRegisterPins - 1; i >= 0; i--) {
    digitalWrite(CLOCK_PIN, LOW);
    digitalWrite(DATA_PIN, registers[i]);
    digitalWrite(CLOCK_PIN, HIGH);
  }

  digitalWrite(LATCH_PIN, HIGH);
}