almost read command

SoftwareSerial8e1.cpp

@@ -0,0 +1,476 @@
+//
+// Created by robin on 2/24/17.
+//
+
+// When set, _DEBUG co-opts pins 11 and 13 for debugging with an
+// oscilloscope or logic analyzer.  Beware: it also slightly modifies
+// the bit times, so don't rely on it too much at high baud rates
+#define _DEBUG 0
+#define _DEBUG_PIN1 11
+#define _DEBUG_PIN2 13
+//
+// Includes
+//
+#include <avr/interrupt.h>
+#include <avr/pgmspace.h>
+#include <Arduino.h>
+#include "SoftwareSerial8e1.h"
+#include <util/delay_basic.h>
+
+//
+// Statics
+//
+SoftwareSerial8e1 *SoftwareSerial8e1::active_object = 0;
+uint8_t SoftwareSerial8e1::_receive_buffer[_SS_MAX_RX_BUFF];
+volatile uint8_t SoftwareSerial8e1::_receive_buffer_tail = 0;
+volatile uint8_t SoftwareSerial8e1::_receive_buffer_head = 0;
+
+//
+// Debugging
+//
+// This function generates a brief pulse
+// for debugging or measuring on an oscilloscope.
+#if _DEBUG
+inline void DebugPulse(uint8_t pin, uint8_t count)
+{
+  volatile uint8_t *pport = portOutputRegister(digitalPinToPort(pin));
+
+  uint8_t val = *pport;
+  while (count--)
+  {
+    *pport = val | digitalPinToBitMask(pin);
+    *pport = val;
+  }
+}
+#else
+inline void DebugPulse(uint8_t, uint8_t) {}
+#endif
+
+//
+// Private methods
+//
+
+/* static */
+inline void SoftwareSerial8e1::tunedDelay(uint16_t delay) {
+    _delay_loop_2(delay);
+}
+
+// This function sets the current object as the "listening"
+// one and returns true if it replaces another
+bool SoftwareSerial8e1::listen()
+{
+    if (!_rx_delay_stopbit)
+        return false;
+
+    if (active_object != this)
+    {
+        if (active_object)
+            active_object->stopListening();
+
+        _buffer_overflow = false;
+        _receive_buffer_head = _receive_buffer_tail = 0;
+        active_object = this;
+
+        setRxIntMsk(true);
+        return true;
+    }
+
+    return false;
+}
+
+// Stop listening. Returns true if we were actually listening.
+bool SoftwareSerial8e1::stopListening()
+{
+    if (active_object == this)
+    {
+        setRxIntMsk(false);
+        active_object = NULL;
+        return true;
+    }
+    return false;
+}
+
+//
+// The receive routine called by the interrupt handler
+//
+void SoftwareSerial8e1::recv()
+{
+
+#if GCC_VERSION < 40302
+// Work-around for avr-gcc 4.3.0 OSX version bug
+// Preserve the registers that the compiler misses
+// (courtesy of Arduino forum user *etracer*)
+    asm volatile(
+    "push r18 \n\t"
+            "push r19 \n\t"
+            "push r20 \n\t"
+            "push r21 \n\t"
+            "push r22 \n\t"
+            "push r23 \n\t"
+            "push r26 \n\t"
+            "push r27 \n\t"
+    ::);
+#endif
+
+    uint8_t d = 0;
+
+    // If RX line is high, then we don't see any start bit
+    // so interrupt is probably not for us
+    if (_inverse_logic ? rx_pin_read() : !rx_pin_read())
+    {
+        // Disable further interrupts during reception, this prevents
+        // triggering another interrupt directly after we return, which can
+        // cause problems at higher baudrates.
+        setRxIntMsk(false);
+
+        // Wait approximately 1/2 of a bit width to "center" the sample
+        tunedDelay(_rx_delay_centering);
+        DebugPulse(_DEBUG_PIN2, 1);
+
+        // Read each of the 8 bits
+        for (uint8_t i=8; i > 0; --i)
+        {
+            tunedDelay(_rx_delay_intrabit);
+            d >>= 1;
+            DebugPulse(_DEBUG_PIN2, 1);
+            if (rx_pin_read())
+                d |= 0x80;
+        }
+
+        if (_inverse_logic)
+            d = ~d;
+
+        // if buffer full, set the overflow flag and return
+        uint8_t next = (_receive_buffer_tail + 1) % _SS_MAX_RX_BUFF;
+        if (next != _receive_buffer_head)
+        {
+            // save new data in buffer: tail points to where byte goes
+            _receive_buffer[_receive_buffer_tail] = d; // save new byte
+            _receive_buffer_tail = next;
+        }
+        else
+        {
+            DebugPulse(_DEBUG_PIN1, 1);
+            _buffer_overflow = true;
+        }
+
+        // skip the parity bit
+        tunedDelay(_rx_delay_stopbit);
+        DebugPulse(_DEBUG_PIN1, 1);
+
+        // skip the stop bit
+        tunedDelay(_rx_delay_stopbit);
+        DebugPulse(_DEBUG_PIN1, 1);
+
+        // Re-enable interrupts when we're sure to be inside the stop bit
+        setRxIntMsk(true);
+
+    }
+
+#if GCC_VERSION < 40302
+// Work-around for avr-gcc 4.3.0 OSX version bug
+// Restore the registers that the compiler misses
+    asm volatile(
+    "pop r27 \n\t"
+            "pop r26 \n\t"
+            "pop r23 \n\t"
+            "pop r22 \n\t"
+            "pop r21 \n\t"
+            "pop r20 \n\t"
+            "pop r19 \n\t"
+            "pop r18 \n\t"
+    ::);
+#endif
+}
+
+uint8_t SoftwareSerial8e1::rx_pin_read()
+{
+    return *_receivePortRegister & _receiveBitMask;
+}
+
+//
+// Interrupt handling
+//
+
+/* static */
+inline void SoftwareSerial8e1::handle_interrupt()
+{
+    if (active_object)
+    {
+        active_object->recv();
+    }
+}
+
+#if defined(PCINT0_vect)
+ISR(PCINT0_vect)
+{
+  SoftwareSerial8e1::handle_interrupt();
+}
+#endif
+
+#if defined(PCINT1_vect)
+ISR(PCINT1_vect, ISR_ALIASOF(PCINT0_vect));
+#endif
+
+#if defined(PCINT2_vect)
+ISR(PCINT2_vect, ISR_ALIASOF(PCINT0_vect));
+#endif
+
+#if defined(PCINT3_vect)
+ISR(PCINT3_vect, ISR_ALIASOF(PCINT0_vect));
+#endif
+
+//
+// Constructor
+//
+SoftwareSerial8e1::SoftwareSerial8e1(uint8_t receivePin, uint8_t transmitPin, bool inverse_logic /* = false */) :
+        _rx_delay_centering(0),
+        _rx_delay_intrabit(0),
+        _rx_delay_stopbit(0),
+        _tx_delay(0),
+        _buffer_overflow(false),
+        _inverse_logic(inverse_logic)
+{
+    setTX(transmitPin);
+    setRX(receivePin);
+}
+
+//
+// Destructor
+//
+SoftwareSerial8e1::~SoftwareSerial8e1()
+{
+    end();
+}
+
+void SoftwareSerial8e1::setTX(uint8_t tx)
+{
+    // First write, then set output. If we do this the other way around,
+    // the pin would be output low for a short while before switching to
+    // output high. Now, it is input with pullup for a short while, which
+    // is fine. With inverse logic, either order is fine.
+    digitalWrite(tx, _inverse_logic ? LOW : HIGH);
+    pinMode(tx, OUTPUT);
+    _transmitBitMask = digitalPinToBitMask(tx);
+    uint8_t port = digitalPinToPort(tx);
+    _transmitPortRegister = portOutputRegister(port);
+}
+
+void SoftwareSerial8e1::setRX(uint8_t rx)
+{
+    pinMode(rx, INPUT);
+    if (!_inverse_logic)
+        digitalWrite(rx, HIGH);  // pullup for normal logic!
+    _receivePin = rx;
+    _receiveBitMask = digitalPinToBitMask(rx);
+    uint8_t port = digitalPinToPort(rx);
+    _receivePortRegister = portInputRegister(port);
+}
+
+uint16_t SoftwareSerial8e1::subtract_cap(uint16_t num, uint16_t sub) {
+    if (num > sub)
+        return num - sub;
+    else
+        return 1;
+}
+
+//
+// Public methods
+//
+
+void SoftwareSerial8e1::begin(long speed)
+{
+    _rx_delay_centering = _rx_delay_intrabit = _rx_delay_stopbit = _tx_delay = 0;
+
+    // Precalculate the various delays, in number of 4-cycle delays
+    uint16_t bit_delay = (F_CPU / speed) / 4;
+
+    // 12 (gcc 4.8.2) or 13 (gcc 4.3.2) cycles from start bit to first bit,
+    // 15 (gcc 4.8.2) or 16 (gcc 4.3.2) cycles between bits,
+    // 12 (gcc 4.8.2) or 14 (gcc 4.3.2) cycles from last bit to stop bit
+    // These are all close enough to just use 15 cycles, since the inter-bit
+    // timings are the most critical (deviations stack 8 times)
+    _tx_delay = subtract_cap(bit_delay, 15 / 4);
+
+    // Only setup rx when we have a valid PCINT for this pin
+    if (digitalPinToPCICR(_receivePin)) {
+#if GCC_VERSION > 40800
+        // Timings counted from gcc 4.8.2 output. This works up to 115200 on
+    // 16Mhz and 57600 on 8Mhz.
+    //
+    // When the start bit occurs, there are 3 or 4 cycles before the
+    // interrupt flag is set, 4 cycles before the PC is set to the right
+    // interrupt vector address and the old PC is pushed on the stack,
+    // and then 75 cycles of instructions (including the RJMP in the
+    // ISR vector table) until the first delay. After the delay, there
+    // are 17 more cycles until the pin value is read (excluding the
+    // delay in the loop).
+    // We want to have a total delay of 1.5 bit time. Inside the loop,
+    // we already wait for 1 bit time - 23 cycles, so here we wait for
+    // 0.5 bit time - (71 + 18 - 22) cycles.
+    _rx_delay_centering = subtract_cap(bit_delay / 2, (4 + 4 + 75 + 17 - 23) / 4);
+
+    // There are 23 cycles in each loop iteration (excluding the delay)
+    _rx_delay_intrabit = subtract_cap(bit_delay, 23 / 4);
+
+    // There are 37 cycles from the last bit read to the start of
+    // stopbit delay and 11 cycles from the delay until the interrupt
+    // mask is enabled again (which _must_ happen during the stopbit).
+    // This delay aims at 3/4 of a bit time, meaning the end of the
+    // delay will be at 1/4th of the stopbit. This allows some extra
+    // time for ISR cleanup, which makes 115200 baud at 16Mhz work more
+    // reliably
+    _rx_delay_stopbit = subtract_cap(bit_delay * 3 / 4, (37 + 11) / 4);
+#else // Timings counted from gcc 4.3.2 output
+        // Note that this code is a _lot_ slower, mostly due to bad register
+        // allocation choices of gcc. This works up to 57600 on 16Mhz and
+        // 38400 on 8Mhz.
+        _rx_delay_centering = subtract_cap(bit_delay / 2, (4 + 4 + 97 + 29 - 11) / 4);
+        _rx_delay_intrabit = subtract_cap(bit_delay, 11 / 4);
+        _rx_delay_stopbit = subtract_cap(bit_delay * 3 / 4, (44 + 17) / 4);
+#endif
+
+
+        // Enable the PCINT for the entire port here, but never disable it
+        // (others might also need it, so we disable the interrupt by using
+        // the per-pin PCMSK register).
+        *digitalPinToPCICR(_receivePin) |= _BV(digitalPinToPCICRbit(_receivePin));
+        // Precalculate the pcint mask register and value, so setRxIntMask
+        // can be used inside the ISR without costing too much time.
+        _pcint_maskreg = digitalPinToPCMSK(_receivePin);
+        _pcint_maskvalue = _BV(digitalPinToPCMSKbit(_receivePin));
+
+        tunedDelay(_tx_delay); // if we were low this establishes the end
+    }
+
+#if _DEBUG
+    pinMode(_DEBUG_PIN1, OUTPUT);
+  pinMode(_DEBUG_PIN2, OUTPUT);
+#endif
+
+    listen();
+}
+
+void SoftwareSerial8e1::setRxIntMsk(bool enable)
+{
+    if (enable)
+        *_pcint_maskreg |= _pcint_maskvalue;
+    else
+        *_pcint_maskreg &= ~_pcint_maskvalue;
+}
+
+void SoftwareSerial8e1::end()
+{
+    stopListening();
+}
+
+
+// Read data from buffer
+int SoftwareSerial8e1::read()
+{
+    if (!isListening())
+        return -1;
+
+    // Empty buffer?
+    if (_receive_buffer_head == _receive_buffer_tail)
+        return -1;
+
+    // Read from "head"
+    uint8_t d = _receive_buffer[_receive_buffer_head]; // grab next byte
+    _receive_buffer_head = (_receive_buffer_head + 1) % _SS_MAX_RX_BUFF;
+    return d;
+}
+
+int SoftwareSerial8e1::available()
+{
+    if (!isListening())
+        return 0;
+
+    return (_receive_buffer_tail + _SS_MAX_RX_BUFF - _receive_buffer_head) % _SS_MAX_RX_BUFF;
+}
+
+size_t SoftwareSerial8e1::write(uint8_t b)
+{
+    if (_tx_delay == 0) {
+        setWriteError();
+        return 0;
+    }
+//    setTX(_receivePin);
+
+    // By declaring these as local variables, the compiler will put them
+    // in registers _before_ disabling interrupts and entering the
+    // critical timing sections below, which makes it a lot easier to
+    // verify the cycle timings
+    volatile uint8_t *reg = _transmitPortRegister;
+    uint8_t reg_mask = _transmitBitMask;
+    uint8_t inv_mask = ~_transmitBitMask;
+    uint8_t oldSREG = SREG;
+    bool inv = _inverse_logic;
+    uint16_t delay = _tx_delay;
+    uint8_t p = 0;
+    for (uint8_t t = 0x80; t; t >>= 1)
+        if (b & t) p++;
+
+    if (inv)
+        b = ~b;
+
+    cli();  // turn off interrupts for a clean txmit
+
+    // Write the start bit
+    if (inv)
+        *reg |= reg_mask;
+    else
+        *reg &= inv_mask;
+
+    tunedDelay(delay);
+
+    // Write each of the 8 bits
+    for (uint8_t i = 8; i > 0; --i)
+    {
+        if (b & 1) // choose bit
+            *reg |= reg_mask; // send 1
+        else
+            *reg &= inv_mask; // send 0
+
+        tunedDelay(delay);
+        b >>= 1;
+    }
+
+    if (p & 0x01)
+        *reg |= reg_mask; // send 1
+    else
+        *reg &= inv_mask; // send 0
+    tunedDelay(_tx_delay);
+
+    // restore pin to natural state
+    if (inv)
+        *reg &= inv_mask;
+    else
+        *reg |= reg_mask;
+
+    SREG = oldSREG; // turn interrupts back on
+    tunedDelay(_tx_delay);
+
+//    setRX(_receivePin);
+//    pinMode(_receivePin, INPUT);
+
+    return 1;
+}
+
+void SoftwareSerial8e1::flush()
+{
+    // There is no tx buffering, simply return
+}
+
+int SoftwareSerial8e1::peek()
+{
+    if (!isListening())
+        return -1;
+
+    // Empty buffer?
+    if (_receive_buffer_head == _receive_buffer_tail)
+        return -1;
+
+    // Read from "head"
+    return _receive_buffer[_receive_buffer_head];
+}

SoftwareSerial8e1.h

@@ -0,0 +1,98 @@
+//
+// Created by robin on 2/24/17.
+//
+
+#ifndef ARDUINOSMARTCARD_SOFTWARESERIAL8E1_H
+#define ARDUINOSMARTCARD_SOFTWARESERIAL8E1_H
+
+
+
+#include <inttypes.h>
+#include <Stream.h>
+
+/******************************************************************************
+* Definitions
+******************************************************************************/
+
+#ifndef _SS_MAX_RX_BUFF
+#define _SS_MAX_RX_BUFF 64 // RX buffer size
+#endif
+
+#ifndef GCC_VERSION
+#define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
+#endif
+
+class SoftwareSerial8e1 : public Stream
+{
+private:
+    // per object data
+    uint8_t _receivePin;
+    uint8_t _receiveBitMask;
+    volatile uint8_t *_receivePortRegister;
+    uint8_t _transmitBitMask;
+    volatile uint8_t *_transmitPortRegister;
+    volatile uint8_t *_pcint_maskreg;
+    uint8_t _pcint_maskvalue;
+
+    // Expressed as 4-cycle delays (must never be 0!)
+    uint16_t _rx_delay_centering;
+    uint16_t _rx_delay_intrabit;
+    uint16_t _rx_delay_stopbit;
+    uint16_t _tx_delay;
+
+    uint16_t _buffer_overflow:1;
+    uint16_t _inverse_logic:1;
+
+    // static data
+    static uint8_t _receive_buffer[_SS_MAX_RX_BUFF];
+    static volatile uint8_t _receive_buffer_tail;
+    static volatile uint8_t _receive_buffer_head;
+    static SoftwareSerial8e1 *active_object;
+
+    // private methods
+    inline void recv() __attribute__((__always_inline__));
+    uint8_t rx_pin_read();
+    void setTX(uint8_t transmitPin);
+    void setRX(uint8_t receivePin);
+    inline void setRxIntMsk(bool enable) __attribute__((__always_inline__));
+
+    // Return num - sub, or 1 if the result would be < 1
+    static uint16_t subtract_cap(uint16_t num, uint16_t sub);
+
+    // private static method for timing
+    static inline void tunedDelay(uint16_t delay);
+
+public:
+    // public methods
+    SoftwareSerial8e1(uint8_t receivePin, uint8_t transmitPin, bool inverse_logic = false);
+    ~SoftwareSerial8e1();
+    void begin(long speed);
+    bool listen();
+    void end();
+    bool isListening() { return this == active_object; }
+    bool stopListening();
+    bool overflow() { bool ret = _buffer_overflow; if (ret) _buffer_overflow = false; return ret; }
+    int peek();
+
+    virtual size_t write(uint8_t byte);
+    virtual int read();
+    virtual int available();
+    virtual void flush();
+    operator bool() { return true; }
+
+    using Print::write;
+
+    // public only for easy access by interrupt handlers
+    static inline void handle_interrupt() __attribute__((__always_inline__));
+};
+
+// Arduino 0012 workaround
+#undef int
+#undef char
+#undef long
+#undef byte
+#undef float
+#undef abs
+#undef round
+
+#endif //ARDUINOSMARTCARD_SOFTWARESERIAL8E1_H

main.ino

@@ -1,7 +1,7 @@
 #include <Arduino.h>
 #include <pins_arduino.h>
-#include <SoftwareSerial.h>
 #include <SCLib.h>
+#include "SoftwareSerial8e1.h"
 
 #define STATUS_LED 13
 
@@ -24,9 +24,11 @@ SmartCardReader cardReader(CARD_IO, CARD_RST, CARD_VCC, CARD_PRE, CARD_CLK, fals
 uint8_t readerAtr[MAX_ATR_BYTES];
 int readerAtrSize = 0;
 
-bool readerReset = false;
+//SoftwareSerial8e1 emulatorSerial(READER_IO, 5);
+bool isResetUp;
 int baudRate = -1;
-int etu = -1;
+int emulatorAtrEtu = -1;
+bool emulatorIoData = false;
 #ifndef digitalPinToInterrupt
 int digitalPinToInterrupt(int pin)
 {
@@ -46,10 +48,10 @@ int digitalPinToInterrupt(int pin)
 void emulatorComputeEtu()
 {
     baudRate = 9600;
-    etu = 1000000 / baudRate;
+    emulatorAtrEtu = 1000000 / baudRate;
 }
 
-void emulatorSendAtrByte(char byte)
+void emulatorSendByte(char byte, int etu)
 {
     unsigned long nextBitTime = micros() + (2 * etu);
     digitalWrite(READER_IO, HIGH);
@@ -84,14 +86,81 @@ void emulatorSendAtrByte(char byte)
     }
 }
 
-void emulatorSendAtr(const uint8_t* atr, size_t size)
+void emulatorSend(const uint8_t* atr, size_t size, int etu)
 {
+    pinMode(5, OUTPUT);
+    digitalWrite(5, HIGH);
     pinMode(READER_IO, OUTPUT);
     for (int i = 0; i < size; ++i)
     {
-        emulatorSendAtrByte(atr[i]);
+        emulatorSendByte(atr[i], etu);
         delayMicroseconds(4*etu);
     }
+    digitalWrite(READER_IO, LOW);
+    pinMode(READER_IO, INPUT);
+    digitalWrite(5, LOW);
+}
+
+uint8_t emulatorReadByte(int etu)
+{
+//    while (digitalRead(READER_IO));
+
+    unsigned long nextBitTime = micros() + (3 * etu / 2);
+    uint8_t byte = 0;
+    int bitNumber = 0;
+    int parity = 0;
+    while (bitNumber < 10)
+    {
+        if (nextBitTime <= micros())
+        {
+            if (bitNumber < 8)
+            {
+                int bit = digitalRead(READER_IO);
+                bitWrite(byte, bitNumber, bit);
+            }
+            else if (bitNumber == 8)
+            {
+                int parity = digitalRead(READER_IO);
+            }
+            else if (bitNumber == 9)
+            {
+                break;
+            }
+            nextBitTime += etu;
+            ++bitNumber;
+        }
+    }
+    return byte;
+}
+
+void emulatorReadCommand(int etu)
+{
+    pinMode(READER_IO, INPUT);
+
+    uint8_t cla = emulatorReadByte(etu);
+    uint8_t ins = emulatorReadByte(etu);
+    uint8_t p1 = emulatorReadByte(etu);
+    uint8_t p2 = emulatorReadByte(etu);
+    Serial.print((int)cla);
+    Serial.print(' ');
+    Serial.print((int)ins);
+    Serial.print(' ');
+    Serial.print((int)p1);
+    Serial.print(' ');
+    Serial.println((int)p2);
+
+//    pinMode(READER_IO, OUTPUT);
+}
+
+void emulatorSetupIoInterrupt()
+{
+    attachInterrupt(digitalPinToInterrupt(READER_IO), emulatorOnIoInterrupt, FALLING);
+}
+
+void emulatorOnIoInterrupt()
+{
+    detachInterrupt(digitalPinToInterrupt(READER_IO));
+    emulatorIoData = true;
 }
 
 void readerResetAtr()
@@ -114,6 +183,9 @@ void setup() {
 
     pinMode(STATUS_LED, OUTPUT);
     digitalWrite(STATUS_LED, LOW);
+
+    isResetUp = digitalRead(READER_RST);
+
     Serial.println("Initialized");
 
     readerResetAtr();
@@ -121,6 +193,14 @@ void setup() {
 
 void loop() {
 
+//    if (emulatorIoData)
+//    {
+//        emulatorIoData = false;
+//        uint8_t b = emulatorReadCommand(12171);
+//        emulatorSetupIoInterrupt();
+//        Serial.println()
+//    }
+
     if (readerAtrSize == 0)
     {
         if (cardReader.cardInserted())
@@ -133,26 +213,79 @@ void loop() {
     }
     else
     {
+        int resetStatus = digitalRead(READER_RST);
         if (!cardReader.cardInserted())
         {
             readerResetAtr();
             digitalWrite(STATUS_LED, LOW);
         }
-        else if (digitalRead(READER_RST))
+        else if (!isResetUp && resetStatus)
         {
-            if (!readerReset)
+            Serial.println("Reset");
+            emulatorComputeEtu();
+            emulatorSend(readerAtr, readerAtrSize, emulatorAtrEtu);
+
+            int baudRate = 12171;
+            int etu = 1000000 / baudRate;
+            size_t dataSize = 0;
+            uint8_t data[42];
+
             {
-                emulatorComputeEtu();
-                emulatorSendAtr(readerAtr, readerAtrSize);
-                readerReset = true;
+                SoftwareSerial8e1 emulatorSerial(READER_IO, 5);
+                emulatorSerial.begin(baudRate);
+                while (emulatorSerial.available() < 8);
+                dataSize = emulatorSerial.available();
+                emulatorSerial.readBytes((char *) data, dataSize);
+                emulatorSerial.end();
             }
-        }
-        else
-        {
-            if (readerReset)
+
+            delayMicroseconds(1000);
+            {
+                SoftwareSerial8e1 emulatorSerial(5, READER_IO);
+                emulatorSerial.begin(baudRate);
+                const uint8_t resp[] = {0x90, 0x00};
+                emulatorSerial.write(resp, sizeof(resp));
+                emulatorSerial.end();
+            }
+
+
+            for (int i = 0; i < dataSize; ++i)
             {
-                readerReset = false;
+                Serial.print((int) data[i]);
+                Serial.print(' ');
             }
+            Serial.println();
+//            emulatorSend(resp, sizeof(resp), etu);
+//            emulatorSetupIoInterrupt();
+//                for (size_t i = 0; i < readerAtrSize; ++i)
+//                {
+//                    emulatorSerial.write(readerAtr[i]);
+//                }
+//                while (1)
+//                {
+////                    delayMicroseconds(10000);
+//                    bool has = false;
+//                    while (emulatorSerial.available())
+//                    {
+//                        Serial.print((int) emulatorSerial.read());
+//                        Serial.print(' ');
+//                        has = true;
+//                    }
+//                    if (has)
+//                    {
+//                        Serial.println();
+//                        const uint8_t resp[] = {0x90, 0x00};
+//                        emulatorSendAtr(resp, sizeof(resp), 12171);
+//                        emulatorSerial.begin(12171);
+////                        emulatorSerial.write((uint8_t)0x90);
+////                        emulatorSerial.write((uint8_t)0x00);
+//                    }
+//                }
+//            while (true)
+//            {
+//                emulatorReadCommand(12171);
+//            }
         }
+        isResetUp = resetStatus;
     }
 }