// File : Cascade165.ino
//
// Version 1, 5 August 2021, by Koepel
//     Initial version.
// Version 2, 5 August 2021, by Koepel
//     Layout of the wiring made better.
// Version 3, 13 August 2021, by Koepel
//     Changed 'SCK' to 'clockPin'.
//
// Cascade of four 74HC165 shift-in registers.
// Only three pins are used on the Arduino board, to read 32 switches.
//
// Using the 74HC165 is safe, because a pulse to the Latch pin 
// ('PL' on the 74HC165) will make a new start every time. 
// In case of an error or a wrong clock pulse by noise, 
// it synchronizes the data when inputs are read the next time.
//
// Based on:
//   (1)
//     Demo sketch to read from a 74HC165 input shift register
//     by Nick Gammon, https://www.gammon.com.au/forum/?id=11979
//   (2)
//     74HC165 Shift register input example
//     by Uri Shaked, https://wokwi.com/arduino/projects/306031380875182657
//
//

#include <EncButton.h>

#define reg 5 // количество регистров

const byte latchPin = 9;        // to latch the inputs into the registers
const byte clockPin = 13;       // I choose the SCK pin
const byte dataPin = 12;        // I choose the MISO pin
uint64_t oldOptionSwitch = 0;   // previous state of all the inputs

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

VirtButton btn1;
VirtButton btn2;
EncButton ebs[3];



void setup ()
{
  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");

  pinMode( clockPin, OUTPUT);   // clock signal, idle LOW
  pinMode( latchPin, OUTPUT);   // latch (copy input into registers), idle HIGH
  digitalWrite( latchPin, HIGH);
  ebs[0].init(10, 11, 8);
  ebs[1].init(5, 6, 7);
  ebs[2].init(2, 3, 4);
  ebs[3].init(A2, A1, A0);

}

void loop ()
{
  // Give a pulse to the parallel load latch of all 74HC165
  digitalWrite( latchPin, LOW);    
  delayMicroseconds( pulseWidth);
  digitalWrite( latchPin, HIGH);

  for (int i = 0; i < 4; i++) ebs[i].tick();

  // 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.
  uint64_t optionSwitch = 0;
  for( int i=reg*8-8; i>=0; i-=8)
  {
    optionSwitch |= ((uint64_t) ReadOne165()) << i;
  }

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

  btn1.tick(bitRead(optionSwitch, 0));
  btn2.tick(bitRead(optionSwitch, 1));
  
 // eb1.tick(bitRead(optionSwitch, 2), bitRead(optionSwitch, 3), bitRead(optionSwitch, 4));
  //eb2.tick(bitRead(optionSwitch, 2), bitRead(optionSwitch, 3), bitRead(optionSwitch, 4));
  //eb3.tick(bitRead(optionSwitch, 2), bitRead(optionSwitch, 3), bitRead(optionSwitch, 4));
  //eb4.tick(bitRead(optionSwitch, 2), bitRead(optionSwitch, 3), bitRead(optionSwitch, 4));
  //eb1.tick(bitRead(optionSwitch, 2), bitRead(optionSwitch, 3), bitRead(optionSwitch, 4));

  if (btn1.press()) Serial.println ("Press btn1");
  if (btn2.press()) Serial.println ("Press btn2");
  if (ebs[0].press()) Serial.println ("Press eb0");
  if (ebs[0].right()) Serial.println("eb0 Right holded"); // если было удержание + поворот
  if (ebs[0].left()) Serial.println("eb0 Left holded");
  if (ebs[1].press()) Serial.println ("Press eb1");
  if (ebs[1].right()) Serial.println("eb1 Right holded"); // если было удержание + поворот
  if (ebs[1].left()) Serial.println("eb1 Left holded");
  if (ebs[2].press()) Serial.println ("Press eb2");
  if (ebs[2].right()) Serial.println("eb2 Right holded"); // если было удержание + поворот
  if (ebs[2].left()) Serial.println("eb2 Left holded");
  if (ebs[3].press()) Serial.println ("Press eb3");
  if (ebs[3].right()) Serial.println("eb3 Right holded"); // если было удержание + поворот
  if (ebs[3].left()) Serial.println("eb3 Left holded");
  

  delay(25);      // slow down the sketch to avoid switch bounce
}

// 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--)
  {
    if( digitalRead( dataPin) == HIGH)
      bitSet( ret, i);

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

  return( ret);
}