rc522.cpp

Go to the documentation of this file.

#include "rc522.h"
#include "esphome/core/helpers.h"
#include "esphome/core/log.h"
 
// Based on:
// - https://github.com/miguelbalboa/rfid
 
namespace esphome::rc522 {
 
static const uint8_t WAIT_I_RQ = 0x30;  // RxIRq and IdleIRq
 
ESPHOME_LOG_TAG(TAG, "rc522");
 
// Max UID size for RFID tags (4, 7, or 10 bytes)
static constexpr size_t RC522_MAX_UID_SIZE = 10;
 
static const uint8_t RESET_COUNT = 5;
 
void RC522::setup() {
  state_ = STATE_SETUP;
  // Pull device out of power down / reset state.
 
  // First set the resetPowerDownPin as digital input, to check the MFRC522 power down mode.
  if (reset_pin_ != nullptr) {
    reset_pin_->pin_mode(gpio::FLAG_INPUT);
 
    if (!reset_pin_->digital_read()) {  // The MFRC522 chip is in power down mode.
      ESP_LOGV(TAG, "Power down mode detected. Hard resetting");
      reset_pin_->pin_mode(gpio::FLAG_OUTPUT);  // Now set the resetPowerDownPin as digital output.
      reset_pin_->digital_write(false);         // Make sure we have a clean LOW state.
      delayMicroseconds(2);             // 8.8.1 Reset timing requirements says about 100ns. Let us be generous: 2μsl
      reset_pin_->digital_write(true);  // Exit power down mode. This triggers a hard reset.
      // Section 8.8.2 in the datasheet says the oscillator start-up time is the start up time of the crystal + 37,74μs.
      // Let us be generous: 50ms.
      reset_timeout_ = millis();
      return;
    }
  }
 
  // Setup a soft reset
  reset_count_ = RESET_COUNT;
  reset_timeout_ = millis();
}
 
void RC522::initialize_() {
  // Per original code, wait 50 ms
  if (millis() - reset_timeout_ < 50)
    return;
 
  // Reset baud rates
  ESP_LOGV(TAG, "Initialize");
 
  pcd_write_register(TX_MODE_REG, 0x00);
  pcd_write_register(RX_MODE_REG, 0x00);
  // Reset ModWidthReg
  pcd_write_register(MOD_WIDTH_REG, 0x26);
 
  // When communicating with a PICC we need a timeout if something goes wrong.
  // f_timer = 13.56 MHz / (2*TPreScaler+1) where TPreScaler = [TPrescaler_Hi:TPrescaler_Lo].
  // TPrescaler_Hi are the four low bits in TModeReg. TPrescaler_Lo is TPrescalerReg.
  pcd_write_register(T_MODE_REG, 0x80);  // TAuto=1; timer starts automatically at the end of the transmission in all
                                         // communication modes at all speeds
 
  // TPreScaler = TModeReg[3..0]:TPrescalerReg, ie 0x0A9 = 169 => f_timer=40kHz, ie a timer period of 25μs.
  pcd_write_register(T_PRESCALER_REG, 0xA9);
  pcd_write_register(T_RELOAD_REG_H, 0x03);  // Reload timer with 0x3E8 = 1000, ie 25ms before timeout.
  pcd_write_register(T_RELOAD_REG_L, 0xE8);
 
  // Default 0x00. Force a 100 % ASK modulation independent of the ModGsPReg register setting
  pcd_write_register(TX_ASK_REG, 0x40);
  pcd_write_register(MODE_REG, 0x3D);  // Default 0x3F. Set the preset value for the CRC coprocessor for the CalcCRC
                                       // command to 0x6363 (ISO 14443-3 part 6.2.4)
 
  state_ = STATE_INIT;
}
 
void RC522::dump_config() {
  ESP_LOGCONFIG(TAG, "RC522:");
 
  LOG_PIN("  RESET Pin: ", this->reset_pin_);
 
  LOG_UPDATE_INTERVAL(this);
 
  for (auto *child : this->binary_sensors_) {
    LOG_BINARY_SENSOR("  ", "Tag", child);
  }
}
 
void RC522::update() {
  if (state_ == STATE_INIT) {
    pcd_antenna_on_();
    pcd_clear_register_bit_mask_(COLL_REG, 0x80);  // ValuesAfterColl=1 => Bits received after collision are cleared.
    buffer_[0] = PICC_CMD_REQA;
    pcd_transceive_data_(1);
    state_ = STATE_PICC_REQUEST_A;
  } else {
    ESP_LOGW(TAG, "Communication takes longer than update interval: %d", state_);
  }
}
 
void RC522::loop() {
  // First check reset is needed
  if (reset_count_ > 0) {
    pcd_reset_();
    return;
  }
  if (state_ == STATE_SETUP) {
    initialize_();
    return;
  }
 
  StatusCode status = STATUS_ERROR;  // For lint passing. TODO: refactor this
  if (awaiting_comm_) {
    if (state_ == STATE_SELECT_SERIAL_DONE) {
      status = await_crc_();
    } else {
      status = await_transceive_();
    }
 
    if (status == STATUS_WAITING) {
      return;
    }
    awaiting_comm_ = false;
    ESP_LOGV(TAG, "finished communication status: %d, state: %d", status, state_);
  }
 
  switch (state_) {
    case STATE_PICC_REQUEST_A: {
      if (status == STATUS_TIMEOUT) {  // no tag present
        for (auto *obj : this->binary_sensors_)
          obj->on_scan_end();  // reset the binary sensors
        ESP_LOGV(TAG, "CMD_REQA -> TIMEOUT (no tag present) %d", status);
        state_ = STATE_DONE;
      } else if (status != STATUS_OK) {
        ESP_LOGW(TAG, "CMD_REQA -> Not OK %d", status);
        state_ = STATE_DONE;
      } else if (back_length_ != 2) {  // || *valid_bits_ != 0) {  // ATQA must be exactly 16 bits.
        ESP_LOGW(TAG, "CMD_REQA -> OK, but unexpected back_length_ of %d", back_length_);
        state_ = STATE_DONE;
      } else {
        state_ = STATE_READ_SERIAL;
      }
      if (state_ == STATE_DONE) {
        // Don't wait another loop cycle
        pcd_antenna_off_();
      }
      break;
    }
    case STATE_READ_SERIAL: {
      ESP_LOGV(TAG, "STATE_READ_SERIAL (%d)", status);
      switch (uid_idx_) {
        case 0:
          buffer_[0] = PICC_CMD_SEL_CL1;
          break;
        case 3:
          buffer_[0] = PICC_CMD_SEL_CL2;
          break;
        case 6:
          buffer_[0] = PICC_CMD_SEL_CL3;
          break;
        default:
          ESP_LOGE(TAG, "uid_idx_ invalid, uid_idx_ = %d", uid_idx_);
          state_ = STATE_DONE;
          return;
      }
      buffer_[1] = 32;
      pcd_transceive_data_(2);
      state_ = STATE_SELECT_SERIAL;
      break;
    }
    case STATE_SELECT_SERIAL: {
      buffer_[1] = 0x70;  // select
      // todo: set CRC
      buffer_[6] = buffer_[2] ^ buffer_[3] ^ buffer_[4] ^ buffer_[5];
      pcd_calculate_crc_(buffer_, 7);
      state_ = STATE_SELECT_SERIAL_DONE;
      break;
    }
    case STATE_SELECT_SERIAL_DONE: {
      send_len_ = 6;
      pcd_transceive_data_(9);
      state_ = STATE_READ_SERIAL_DONE;
      break;
    }
    case STATE_READ_SERIAL_DONE: {
      if (status != STATUS_OK || back_length_ != 3) {
        if (status == STATUS_TIMEOUT) {
          ESP_LOGV(TAG, "STATE_READ_SERIAL_DONE -> TIMEOUT (no tag present) %d", status);
        } else {
          char hex_buf[format_hex_pretty_size(RC522_MAX_UID_SIZE)];
          ESP_LOGW(TAG, "Unexpected response. Read status is %d. Read bytes: %d (%s)", status, back_length_,
                   format_hex_pretty_to(hex_buf, buffer_, back_length_, '-'));
        }
 
        state_ = STATE_DONE;
        uid_idx_ = 0;
 
        pcd_antenna_off_();
        return;
      }
 
      // copy the uid
      bool cascade = buffer_[2] == PICC_CMD_CT;  // todo: should be determined based on select response (buffer[6])
      for (uint8_t i = 2 + cascade; i < 6; i++)
        uid_buffer_[uid_idx_++] = buffer_[i];
      ESP_LOGVV(TAG, "copied uid to idx %d last byte is 0x%x, cascade is %d", uid_idx_, uid_buffer_[uid_idx_ - 1],
                cascade);
 
      if (cascade) {  // there is more bytes in the UID
        state_ = STATE_READ_SERIAL;
        return;
      }
 
      std::vector<uint8_t> rfid_uid(std::begin(uid_buffer_), std::begin(uid_buffer_) + uid_idx_);
      uid_idx_ = 0;
      // ESP_LOGD(TAG, "Processing '%s'", format_hex_pretty(rfid_uid, '-', false).c_str());  // NOLINT
      pcd_antenna_off_();
      state_ = STATE_INIT;  // scan again on next update
      bool report = true;
 
      for (auto *tag : this->binary_sensors_) {
        if (tag->process(rfid_uid)) {
          report = false;
        }
      }
 
      if (this->current_uid_ == rfid_uid) {
        return;
      }
 
      this->current_uid_ = rfid_uid;
 
      for (auto *trigger : this->triggers_ontag_)
        trigger->process(rfid_uid);
 
      if (report) {
        char uid_buf[format_hex_pretty_size(RC522_MAX_UID_SIZE)];
        ESP_LOGD(TAG, "Found new tag '%s'", format_hex_pretty_to(uid_buf, rfid_uid.data(), rfid_uid.size(), '-'));
      }
      break;
    }
    case STATE_DONE: {
      if (!this->current_uid_.empty()) {
#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
        char uid_buf[format_hex_pretty_size(RC522_MAX_UID_SIZE)];
        ESP_LOGV(TAG, "Tag '%s' removed",
                 format_hex_pretty_to(uid_buf, this->current_uid_.data(), this->current_uid_.size(), '-'));
#endif
        for (auto *trigger : this->triggers_ontagremoved_)
          trigger->process(this->current_uid_);
      }
      this->current_uid_ = {};
      state_ = STATE_INIT;
      break;
    }
    default:
      break;
  }
}  // namespace rc522
 
void RC522::pcd_reset_() {
  // The datasheet does not mention how long the SoftRest command takes to complete.
  // But the MFRC522 might have been in soft power-down mode (triggered by bit 4 of CommandReg)
  // Section 8.8.2 in the datasheet says the oscillator start-up time is the start up time of the crystal + 37,74μs.
  // Let us be generous: 50ms.
 
  if (millis() - reset_timeout_ < 50)
    return;
 
  if (reset_count_ == RESET_COUNT) {
    ESP_LOGI(TAG, "Soft reset");
    // Issue the SoftReset command.
    pcd_write_register(COMMAND_REG, PCD_SOFT_RESET);
  }
 
  // Expect the PowerDown bit in CommandReg to be cleared (max 3x50ms)
  if ((pcd_read_register(COMMAND_REG) & (1 << 4)) == 0) {
    reset_count_ = 0;
    ESP_LOGI(TAG, "Device online");
    // Wait for initialize
    reset_timeout_ = millis();
    return;
  }
 
  if (--reset_count_ == 0) {
    this->mark_failed(LOG_STR("Reset command failed"));
  }
}
 
void RC522::pcd_antenna_on_() {
  uint8_t value = pcd_read_register(TX_CONTROL_REG);
  if ((value & 0x03) != 0x03) {
    pcd_write_register(TX_CONTROL_REG, value | 0x03);
  }
}
 
void RC522::pcd_antenna_off_() {
  uint8_t value = pcd_read_register(TX_CONTROL_REG);
  if ((value & 0x03) != 0x00) {
    pcd_write_register(TX_CONTROL_REG, value & ~0x03);
  }
}
 
void RC522::pcd_set_register_bit_mask_(PcdRegister reg,  
                                       uint8_t mask      
) {
  uint8_t tmp = pcd_read_register(reg);
  pcd_write_register(reg, tmp | mask);  // set bit mask
}
 
void RC522::pcd_clear_register_bit_mask_(PcdRegister reg,  
                                         uint8_t mask      
) {
  uint8_t tmp = pcd_read_register(reg);
  pcd_write_register(reg, tmp & (~mask));  // clear bit mask
}
 
void RC522::pcd_transceive_data_(uint8_t send_len) {
#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
  char hex_buf[format_hex_pretty_size(RC522_MAX_UID_SIZE)];
  ESP_LOGV(TAG, "PCD TRANSCEIVE: RX: %s", format_hex_pretty_to(hex_buf, buffer_, send_len, '-'));
#endif
  delayMicroseconds(1000);  // we need 1 ms delay between antenna on and those communication commands
  send_len_ = send_len;
  // Prepare values for BitFramingReg
  // For REQA and WUPA we need the short frame format - transmit only 7 bits of the last (and only)
  // uint8_t. TxLastBits = BitFramingReg[2..0]
  uint8_t bit_framing = (buffer_[0] == PICC_CMD_REQA) ? 7 : 0;
 
  pcd_write_register(COMMAND_REG, PCD_IDLE);              // Stop any active command.
  pcd_write_register(COM_IRQ_REG, 0x7F);                  // Clear all seven interrupt request bits
  pcd_write_register(FIFO_LEVEL_REG, 0x80);               // FlushBuffer = 1, FIFO initialization
  pcd_write_register(FIFO_DATA_REG, send_len_, buffer_);  // Write sendData to the FIFO
  pcd_write_register(BIT_FRAMING_REG, bit_framing);       // Bit adjustments
  pcd_write_register(COMMAND_REG, PCD_TRANSCEIVE);        // Execute the command
  pcd_set_register_bit_mask_(BIT_FRAMING_REG, 0x80);      // StartSend=1, transmission of data starts
  awaiting_comm_ = true;
  awaiting_comm_time_ = millis();
}
 
RC522::StatusCode RC522::await_transceive_() {
  if (millis() - awaiting_comm_time_ < 2)  // wait at least 2 ms
    return STATUS_WAITING;
  uint8_t n = pcd_read_register(
      COM_IRQ_REG);  // ComIrqReg[7..0] bits are: Set1 TxIRq RxIRq IdleIRq HiAlertIRq LoAlertIRq ErrIRq TimerIRq
  if (n & 0x01) {    // Timer interrupt - nothing received in 25ms
    back_length_ = 0;
    error_counter_ = 0;  // reset the error counter
    return STATUS_TIMEOUT;
  }
  if (!(n & WAIT_I_RQ)) {  // None of the interrupts that signal success has been set.
                           // Wait for the command to complete.
    if (millis() - awaiting_comm_time_ < 40)
      return STATUS_WAITING;
    back_length_ = 0;
    ESP_LOGW(TAG, "Communication with the MFRC522 might be down, reset in %d",
             10 - error_counter_);  // todo: trigger reset?
    if (error_counter_++ >= 10) {
      setup();
      error_counter_ = 0;  // reset the error counter
    }
 
    return STATUS_TIMEOUT;
  }
  // Stop now if any errors except collisions were detected.
  uint8_t error_reg_value = pcd_read_register(
      ERROR_REG);  // ErrorReg[7..0] bits are: WrErr TempErr reserved BufferOvfl CollErr CRCErr ParityErr ProtocolErr
  if (error_reg_value & 0x13) {  // BufferOvfl ParityErr ProtocolErr
    return STATUS_ERROR;
  }
  error_counter_ = 0;  // reset the error counter
 
  n = pcd_read_register(FIFO_LEVEL_REG);  // Number of uint8_ts in the FIFO
  if (n > sizeof(buffer_))
    return STATUS_NO_ROOM;
  if (n > sizeof(buffer_) - send_len_)
    send_len_ = sizeof(buffer_) - n;                                    // simply overwrite the sent values
  back_length_ = n;                                                     // Number of uint8_ts returned
  pcd_read_register(FIFO_DATA_REG, n, buffer_ + send_len_, rx_align_);  // Get received data from FIFO
  uint8_t valid_bits_local =
      pcd_read_register(CONTROL_REG) & 0x07;  // RxLastBits[2:0] indicates the number of valid bits in the last
                                              // received uint8_t. If this value is 000b, the whole uint8_t is valid.
 
  // Tell about collisions
  if (error_reg_value & 0x08) {  // CollErr
    ESP_LOGW(TAG, "collision error, received %d bytes + %d bits (but anticollision not implemented)",
             back_length_ - (valid_bits_local > 0), valid_bits_local);
    return STATUS_COLLISION;
  }
  // Tell about collisions
  if (valid_bits_local) {
    ESP_LOGW(TAG, "only %d valid bits received, tag distance to high? Error code is 0x%x", valid_bits_local,
             error_reg_value);  // TODO: is this always due to collissions?
    return STATUS_ERROR;
  }
#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
  char hex_buf[format_hex_pretty_size(RC522_MAX_UID_SIZE)];
  ESP_LOGV(TAG, "received %d bytes: %s", back_length_,
           format_hex_pretty_to(hex_buf, buffer_ + send_len_, back_length_, '-'));
#endif
 
  return STATUS_OK;
}
 
void RC522::pcd_calculate_crc_(uint8_t *data,  
                               uint8_t length  
) {
  ESP_LOGVV(TAG, "pcd_calculate_crc_(..., %d, ...)", length);
  pcd_write_register(COMMAND_REG, PCD_IDLE);        // Stop any active command.
  pcd_write_register(DIV_IRQ_REG, 0x04);            // Clear the CRCIRq interrupt request bit
  pcd_write_register(FIFO_LEVEL_REG, 0x80);         // FlushBuffer = 1, FIFO initialization
  pcd_write_register(FIFO_DATA_REG, length, data);  // Write data to the FIFO
  pcd_write_register(COMMAND_REG, PCD_CALC_CRC);    // Start the calculation
 
  awaiting_comm_ = true;
  awaiting_comm_time_ = millis();
}
 
RC522::StatusCode RC522::await_crc_() {
  if (millis() - awaiting_comm_time_ < 2)  // wait at least 2 ms
    return STATUS_WAITING;
 
  // DivIrqReg[7..0] bits are: Set2 reserved reserved MfinActIRq reserved CRCIRq reserved reserved
  uint8_t n = pcd_read_register(DIV_IRQ_REG);
  if (n & 0x04) {                               // CRCIRq bit set - calculation done
    pcd_write_register(COMMAND_REG, PCD_IDLE);  // Stop calculating CRC for new content in the FIFO.
    // Transfer the result from the registers to the result buffer
    buffer_[7] = pcd_read_register(CRC_RESULT_REG_L);
    buffer_[8] = pcd_read_register(CRC_RESULT_REG_H);
 
    ESP_LOGVV(TAG, "pcd_calculate_crc_() STATUS_OK");
    return STATUS_OK;
  }
  if (millis() - awaiting_comm_time_ < 89)
    return STATUS_WAITING;
 
  ESP_LOGD(TAG, "pcd_calculate_crc_() TIMEOUT");
  // 89ms passed and nothing happened. Communication with the MFRC522 might be down.
  return STATUS_TIMEOUT;
}
 
bool RC522BinarySensor::process(std::vector<uint8_t> &data) {
  bool result = true;
  if (data.size() != this->uid_.size()) {
    result = false;
  } else {
    for (size_t i = 0; i < data.size(); i++) {
      if (data[i] != this->uid_[i]) {
        result = false;
        break;
      }
    }
  }
  this->publish_state(result);
  this->found_ = result;
  return result;
}
void RC522Trigger::process(std::vector<uint8_t> &data) {
  char uid_buf[format_hex_pretty_size(RC522_MAX_UID_SIZE)];
  this->trigger(format_hex_pretty_to(uid_buf, data.data(), data.size(), '-'));
}
 
}  // namespace esphome::rc522