//
//
#include <I2cDiscreteIoExpander.h>    // PCF85xx library

#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 16, 2);

#define Add0 32     // PCF chip1 INToutput read

#define LEDPIN 25
#define DEBOUNCE_DELAY 50      // puvodni 200  - debouncing isr

//volatile bool interrupt = false;    // true on interrupt
volatile uint8_t interrupt = 0;    // true on interrupt
volatile bool ledState = false;
volatile uint32_t lastInterruptTime = 0;
volatile uint16_t ISRVector;
uint16_t ISR_Xvector;

uint8_t ISRdev = 6;         // ISR vector device

/*volatile */ uint8_t error, address, reg, data;
uint16_t PCF_16b;

/**********************************************************************/

// create I2cDiscreteIoExpander objects
I2cDiscreteIoExpander device[8] = {0,1,2,3,4,5,6,7};  //  [8=total number]

uint8_t PCF_addr[8] = {0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27};

/********************************** ISR *********************************/

void IRAM_ATTR doISR(){
//void ARDUINO_ISR_ATTR doISR() {
    interrupt = 1;
//    ISR_Xvector = device[ISRdev].getPorts();      // tady to simulace stihala
//    ISR_Xvector = PCF_digitalRead(0x26);          // s tim se procesor pere
}

void setup() {

  pinMode(Add0, INPUT_PULLUP);
  pinMode(34, INPUT_PULLUP);
  pinMode(LEDPIN, OUTPUT);

  Serial.begin(115200);
  Serial2.begin(9600, SERIAL_8N1, 16, 17);  // Nextion serial
//  Serial2.begin(9600);  // Nextion serial2
  Serial2.println("Serial 2 NEX");

  Wire.begin();
  
  lcd.init();
  lcd.backlight();
  lcd.clear();
  lcd.setCursor(0, 0);
//  lcd.print("    I2C scan    ");
//  lcd.setCursor(0, 1);
//  lcd.print("  > scanning >  ");

  lcd.clear();
  lcd.backlight();
  lcd.setCursor(0, 0);
//  lcd.print("Connecting to ");
//  lcd.setCursor(0, 1);
//  lcd.print("WiFi ");

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.println("Online");
  lcd.setCursor(0, 1);

/************************************************************************/

  attachInterrupt(Add0, doISR, CHANGE);      // INT signal je aktivni stavem L, vynuluje se prectenim nebo zapisem do portu
/*
  ISR_Xvector = PCF_digitalRead(0x26);

    Serial.println(PCF_digitalRead(0x20), BIN);
    Serial.println(PCF_digitalRead(0x21), BIN);
    Serial.println(PCF_digitalRead(0x22), BIN);
*/
}

/**************************************************************/
/**********  MAIN LOOP - MAIN LOOP - MAIN LOOP  ***************/
/**************************************************************/
void loop() {
delay(10);    //  recommended for "faster" simulation
    Serial.print("interrupt in loop : ");
    Serial.println(interrupt);

/* zpracovat flag if(interrupt=true) a pak ho vynulovat  */
  if(interrupt == 1) {
//    digitalWrite(LEDPIN, interrupt);     // POZOR - dlouhá loop - dlouhá odezva - ošetřit jinak
    Serial.print("interrupt true : ");
    Serial.println(interrupt);

//  nnásledující řádek musím ověřit zda je nutný
//    ISR_Xvector = XreadInputs(ISRdev);    // az precteni PCF s aktivnim INT schodi vystup int PCF // tohle je asi pomalejsi - cca 2 millis

    ISR_Xvector = PCF_digitalRead(0x26);

  interrupt = 0;     // s tím to funguje o.k.

    ledState = !ledState;
    digitalWrite(LEDPIN, ledState);     // POZOR - dlouhá loop - dlouhá odezva - ošetřit jinak

    Serial.print("ISR_Xvector from isr : ");
    Serial.println(ISR_Xvector, BIN);                     // ISR_Xvector je nacteni z isr

//    po následujím digitalRead nedochází k vynulování isr - že by ještě špatně fungoval interrupt==1
//    Serial.print("PCF_digitalRead(0x26), BIN  ");
//    Serial.println(PCF_digitalRead(0x26), BIN);

//  {..........................................}
  }

/*
  for(uint8_t idx = 0x20; idx<0x26; idx++){

//    Serial.print("inputs on device : ");
//    Serial.print(idx, HEX);
//    Serial.print(" bin : ");
///    Serial.println(getChangedInputValue(idx), BIN);
///    Serial.println(XreadInputs(idx), BIN);

    Serial.println(PCF_digitalRead(idx), BIN);
    }
*/
// BACHA :
// následující přečtění PCF schodí i jejich INT příznaky,
// tím se ale změní taky vstupy do PCF ISR vectoru
// a PCF(0x26) tím pádem znovu nahodí svůj INT výstup - "CHANGE"
    Serial.println(PCF_digitalRead(0x20), BIN);
    Serial.println(PCF_digitalRead(0x21), BIN);
    Serial.println(PCF_digitalRead(0x22), BIN);


//  následující digitalRead teprve schodí int PCF ISR
    PCF_16b = PCF_digitalRead(0x26);    // na zkoušku místo následujícího (a funkčního) Serial.print
              // bez toho to nějak nefunguje
/*
    Serial.print("PCF_digitalRead(0x26), BIN  ");
    Serial.println(PCF_digitalRead(0x26), BIN);
*/

///    Serial.print("interrupt false : ");
///    Serial.println(interrupt);

//    Serial.print("ISR_Xvector from loop : ");
//    Serial.println(ISR_Xvector, BIN);                     // ISR?Xvector je nacteni z isr
//    vTaskDelay(100 / portTICK_PERIOD_MS);
// delay(100);

//  detachInterrupt(Add0);

/// delay(100);
}
/***************  END OF MAIN LOOP - END OF MAIN LOOP  ***************/

uint16_t getChangedInputValue(uint8_t idx) {
    Serial.print("Get Input  ");
    Serial.println(device[idx].digitalRead(),BIN);
    return device[idx].getPorts();
}

void readInputs(uint8_t idx) {      // pouze posle na ser.port
    uint16_t newValue = getChangedInputValue(idx);
    Serial.print("Inputs read 0x");
    Serial.print(newValue, HEX);
    Serial.print(" on device ");
    Serial.println((int)idx);
//     if(newValue < 0xFFFE)
//      device[idx].digitalWrite (0xFFFE);
//      else device[idx].digitalWrite (0xFFFF);
  }

uint16_t XreadInputs(uint8_t idx) {   //  funkce, vraci stav vstupu
    uint16_t newValue = getChangedInputValue(idx);
//    Serial.print("Inputs Xread 0x");
//    Serial.print(newValue, HEX);
//    Serial.print(" on device ");
//    Serial.println((int)idx);
//     if(newValue < 0xFFFE)
//      device[idx].digitalWrite (0xFFFE);
//      else device[idx].digitalWrite (0xFFFF);
//   delay(50);
    return newValue;  
  }


uint16_t PCF_digitalRead(uint8_t idx)     // přečte 2x Byte z PCF adresa idx a vrátí uint16_t ports
{
  uint8_t hi, lo, status;
  uint16_t ports;

  Wire.beginTransmission(idx);
  status = Wire.endTransmission();

  if (TWI_SUCCESS == status)
  {
    if (Wire.requestFrom(idx, 2) == 2)
    {
      lo = Wire.read();
      hi = Wire.read();
      ports = word(hi, lo);
    }
  }

///  return status;

return ports;
}


uint16_t PCF_digitalWrite(uint8_t idx, uint16_t ports)
{
  uint8_t status;

  Wire.beginTransmission(idx);
  status = Wire.endTransmission();

  if (TWI_SUCCESS == status)
  {
    Wire.write(lowByte(ports));
    Wire.write(highByte(ports));
  }
  return Wire.endTransmission();
}