/*
 * Example on how to use the Wiegand reader library with interruptions.
 */

#include <Wiegand.h>
#include <PinChangeInterrupt.h>

// These are the pins connected to the Wiegand D0 and D1 signals.
// Ensure your board supports external Interruptions on these pins
#define PIN_D0_I 4
#define PIN_D1_I 5

#define PIN_D0_O 6
#define PIN_D1_O 7

// The object that handles the wiegand protocol
Wiegand wiegand;
Wiegand wiegand2;

// Initialize Wiegand reader
void setup() {
  Serial.begin(9600);
  Serial.println("xd");

  //Install listeners and initialize Wiegand reader
  wiegand.onReceive(receivedData, "Card readed: ");
  wiegand.onReceiveError(receivedDataError, "Card read error: ");
  wiegand.onStateChange(stateChanged, "State changed: ");
  wiegand.begin(Wiegand::LENGTH_ANY, true);

  wiegand2.onReceive(receivedData, "Card readed: ");
  wiegand2.onReceiveError(receivedDataError, "Card read error: ");
  wiegand2.onStateChange(stateChanged, "State changed: ");
  wiegand2.begin(Wiegand::LENGTH_ANY, true);


  //initialize pins as INPUT and attaches interruptions
  pinMode(PIN_D0_I, INPUT);
  pinMode(PIN_D1_I, INPUT);
  attachPinChangeInterrupt(digitalPinToPinChangeInterrupt(PIN_D0_I), pinStateChanged_I, CHANGE);
  attachPinChangeInterrupt(digitalPinToPinChangeInterrupt(PIN_D1_I), pinStateChanged_I, CHANGE);
  
  pinMode(PIN_D0_O, INPUT);
  pinMode(PIN_D1_O, INPUT);
  attachPinChangeInterrupt(digitalPinToPinChangeInterrupt(PIN_D0_O), pinStateChanged_O, CHANGE);
  attachPinChangeInterrupt(digitalPinToPinChangeInterrupt(PIN_D1_O), pinStateChanged_O, CHANGE);


  //Sends the initial pin state to the Wiegand library
  pinStateChanged_I();
  pinStateChanged_O();
}

// Every few milliseconds, check for pending messages on the wiegand reader
// This executes with interruptions disabled, since the Wiegand library is not thread-safe
void loop() {
  //noInterrupts();
  wiegand.flush();
  wiegand2.flush();
  //interrupts();
  //Sleep a little -- this doesn't have to run very often.
  delay(100);
}

// When any of the pins have changed, update the state of the wiegand library
void pinStateChanged_I() {
  wiegand.setPin0State(digitalRead(PIN_D0_I));
  wiegand.setPin1State(digitalRead(PIN_D1_I));
}
void pinStateChanged_O() {
  wiegand.setPin0State(digitalRead(PIN_D0_O));
  wiegand.setPin1State(digitalRead(PIN_D1_O));
}

// Notifies when a reader has been connected or disconnected.
// Instead of a message, the seconds parameter can be anything you want -- Whatever you specify on `wiegand.onStateChange()`
void stateChanged(bool plugged, const char* message) {
    Serial.print(message);
    Serial.println(plugged ? "CONNECTED\n" : "DISCONNECTED\n");
}

// Notifies when a card was read.
// Instead of a message, the seconds parameter can be anything you want -- Whatever you specify on `wiegand.onReceive()`
void receivedData(uint8_t* data, uint8_t bits, const char* message) {
    Serial.print(message);
    Serial.print(bits);
    Serial.print("bits / ");
    //Print value in HEX
    uint8_t bytes = (bits+7)/8;
    for (int i=0; i<bytes; i++) {
        Serial.print(data[i] >> 4, 16);
        Serial.print(data[i] & 0xF, 16);
    }
    Serial.println();
}

// Notifies when an invalid transmission is detected
void receivedDataError(Wiegand::DataError error, uint8_t* rawData, uint8_t rawBits, const char* message) {
    Serial.print(message);
    Serial.print(Wiegand::DataErrorStr(error));
    Serial.print(" - Raw data: ");
    Serial.print(rawBits);
    Serial.print("bits / ");

    //Print value in HEX
    uint8_t bytes = (rawBits+7)/8;
    for (int i=0; i<bytes; i++) {
        Serial.print(rawData[i] >> 4, 16);
        Serial.print(rawData[i] & 0xF, 16);
    }
    Serial.println();
}