Форум РадиоКот

Код: Выделить всё

/*
 * MadDogMayCry aka ~O8o
 * General Public Licence (GNU)
 * Education Desfire EV1 lib for MFRC522 over i2c
 * http://radiokot.ru/forum/viewtopic.php?p=3216806#p3216806
 */

#include <Wire.h>
#define address 0x28
byte crc[2];

void setup() {
  Wire.begin();
  Serial.begin(9600);
}

//Отправить байт
void Write(byte reg, byte value)
{
  Wire.beginTransmission(address);
  Wire.write(reg);
  Wire.write(value);
  Wire.endTransmission();
}

//Получить байт
unsigned char Read(unsigned char res){
  byte ucResult = 0;

  Wire.beginTransmission(address);
  Wire.write(res);
  Wire.endTransmission();
  
  Wire.beginTransmission(address);
  Wire.requestFrom(address, 1);
  while (Wire.available()){
    ucResult = Wire.read();
  }
  Wire.endTransmission();
  return ucResult;
}

//Калькуляция CRC при помощи сопроцессора MFRC522
void GetCrc(byte *value, int *cnt){
  crc[0]=NULL;
  crc[1]=NULL;
  Write(0x0a,0x80);
  int i = 0;
  while (i<cnt){
    Write(0x09,value[i]);
    i++;
  }
  Write(0x01,0x03);
  crc[0]=Read(0xA2);
  crc[1]=Read(0xA1);
  Write(0x01,0x00);
}

//Аналог функции Serial.print() у которой 00,01,02... выводится как 0,1,2...
//Добавляет ведущий 0 к HEX значениям у которых он отсутсвует.
void Echo(byte value){
  if (value<0x10){
    Serial.print("0");
  }
  Serial.print(value,HEX);
  Serial.print(" ");
}

void loop() {
//Софтверный ресет
Write(0x01,0x0F);

//Конфигурируем mfrc522
Write(0x11,0x3D);
Write(0x2D,0x30);
Write(0x2C,0x00);
Write(0x2A,0x8D);
Write(0x2B,0x3E);
Write(0x14,0x83);
Write(0x15,0x40);

//Настройка усиления антенны 0x30, 0x40, 0x50, 0x60, 0x70 - максимум
Write(0x26,0x40);

//Отправляем REQA
Write(0x09,0x52);
Write(0x01,0x0C);
Write(0x0d,0x87);

//Карте нужно время на обмен данными
delay(1);

//Проверяем ATQA
//Desfire = 0x4403 и еще проверим есть ли в буффере 2 байта
if (Read(0x8a)==0x02 && Read(0x89)==0x44 && Read(0x89)==0x03){
  Serial.print("Карта Desfire / Desfire EV1");
  Serial.println();
  //Очищаем буффер
  Write(0x0a,0x80);

  //Каскадный уровень 1
  Write(0x09,0x93);
  Write(0x09,0x20);
  Write(0x01,0x0c);
  Write(0x0d,0x80);
  
  //1мс на передачу
  delay(1);

  //Читаем CT UID0 UID1 UID2 BCC (Первый SAK = 24)
  byte uid[] = {Read(0x89),Read(0x89),Read(0x89),Read(0x89),Read(0x89)};
  
  Serial.println("Каскадный уровень 1"); 
  Echo(uid[0]);Echo(uid[1]);Echo(uid[2]);Echo(uid[3]);Echo(uid[4]);
  Serial.println();

  //Расчитываем CRC сопроцессором mfrc522 - на выходе crc[0] и crc[1]
  byte crc_1[]={0x93,0x70,uid[0],uid[1],uid[2],uid[3],uid[4]};
  GetCrc(crc_1,7);
  
  //Очищаем буффер
  Write(0x0a,0x80);
  
  //Отправляем селект 1
  Write(0x09,0x93);
  Write(0x09,0x70);
  //Добавляем к строке первую часть UID
  Write(0x09,uid[0]);
  Write(0x09,uid[1]);
  Write(0x09,uid[2]);
  Write(0x09,uid[3]);
  Write(0x09,uid[4]);
  //Добавляем к строке CRC
  Write(0x09,crc[0]);
  Write(0x09,crc[1]);
  
  //Отправляем карте
  Write(0x01,0x0c);
  Write(0x0d,0x80);
  
  //1мс на передачу
  delay(1);

  //Читаем ответ
  Echo(Read(0x89));
  Echo(Read(0x89));
  Echo(Read(0x89));
  Serial.println();
  
  //Очищаем буффер на всякий случай
  Write(0x0a,0x80);

  Serial.println("Каскадный уровень 2"); 
  //Каскадный уровень 2
  Write(0x09,0x95);
  Write(0x09,0x20);
  Write(0x01,0x0c);
  Write(0x0d,0x80);
  
  //1мс на передачу
  delay(1);

  //Читаем UID3 UID4 UID5 UID6 BCC
  uid[5]=Read(0x89);
  uid[6]=Read(0x89);
  uid[7]=Read(0x89);
  uid[8]=Read(0x89);
  uid[9]=Read(0x89);

  Echo(uid[5]);Echo(uid[6]);Echo(uid[7]);Echo(uid[8]);Echo(uid[9]);
  Serial.println();
  
  //На всякий очищаем буффер
  Write(0x0a,0x80);

  //Расчитываем CRC сопроцессором mfrc522 - на выходе crc[0] и crc[1]
  byte crc_2[]={0x95,0x70,uid[5],uid[6],uid[7],uid[8],uid[9]};
  GetCrc(crc_2,7);
  
  //Отправляем селект 2
  Write(0x09,0x95);
  Write(0x09,0x70);
  //Добавляем к строке вторую часть UID
  Write(0x09,uid[5]);
  Write(0x09,uid[6]);
  Write(0x09,uid[7]);
  Write(0x09,uid[8]);
  Write(0x09,uid[9]);
  //Добавляем к строке CRC
  Write(0x09,crc[0]);
  Write(0x09,crc[1]);
  //Отправка
  Write(0x01,0x0c);
  Write(0x0d,0x80);
  
  delay(1);

  //Читаем ответ
  Echo(Read(0x89));
  Echo(Read(0x89));
  Echo(Read(0x89));
  Serial.println();
  
  //Выводим UID карты
  Serial.println("UID Карты");
  Echo(uid[1]);Echo(uid[2]);Echo(uid[3]);Echo(uid[5]);Echo(uid[6]);Echo(uid[7]);Echo(uid[8]);
  Serial.println();
  
  //На всякий очищаем буффер
  Write(0x0a,0x80);
  
  //Отправка RATS
  Write(0x09,0xE0);
  Write(0x09,0x20);
  //Нет смысла напрягать сопроцессор,- для 0xE0 0x20 CRC калькулировался заранее)
  Write(0x09,0x3b);
  Write(0x09,0xd6);
  //Отправка
  Write(0x01,0x0c);
  Write(0x0d,0x80);

  delay(1);
  Serial.println("ATS ответ");
  //Читаем ответ
  Echo(Read(0x89));
  Echo(Read(0x89));
  Echo(Read(0x89));
  Echo(Read(0x89));
  Echo(Read(0x89));
  Echo(Read(0x89));
  Echo(Read(0x89));
  Echo(Read(0x89));
  Serial.println();
  Serial.println();
}
delay(500);
}

Код: Выделить всё

//Расчитываем CRC сопроцессором mfrc522 - на выходе crc[0] и crc[1]
  byte crc_3[]={0x03,0x5a,0x00,0x00,0x00};
  GetCrc(crc_3,5);
  //Выбираем приложение 00 00 00 (root)
  Write(0x09,0x03);Write(0x09,0x5a);Write(0x09,0x00);Write(0x09,0x00);Write(0x09,0x00);
  //CRC
   Write(0x09,crc[0]);
   Write(0x09,crc[1]);
  //Отправка
  Write(0x01,0x0c);Write(0x0d,0x80);
  delay(2);

  //Ответ
  Echo(Read(0x89));Echo(Read(0x89));Echo(Read(0x89));Echo(Read(0x89));
  Serial.println();
  Serial.println();

Код: Выделить всё

byte crc16[2];

void setup() {
 Serial.begin(9600);
}

unsigned short GetCrc(unsigned char *data, unsigned int len){
  unsigned int i;
  unsigned short crc= 0x6363;
  for(i= 0; i < len ; ++i){
    unsigned short n, v, tcrc = 0;
    v = (crc ^ data[i]) & 0xff;
    for (n = 0; n < 8; n++){
      tcrc = ( (tcrc ^ v) & 1 ) ? ( tcrc >> 1 ) ^ 0x8408 : tcrc >> 1;
      v >>= 1;
    }
    crc = ((crc >> 8) ^ tcrc) & 0xffff;
  }
  crc16[0] = crc & 0xff;
  crc16[1] = (crc >> 8) & 0xff;
}
void loop() {
  byte data[] = {0xe0,0x20};
  GetCrc(data,2);
  Serial.print(crc16[0],HEX);
  Serial.print(" ");
  Serial.println(crc16[1],HEX);
  delay(5000);
}

Код: Выделить всё

uint16_t CalcCrc16(const byte* u8_Data, int s32_Length){
    uint16_t u16_Crc = 0x6363;
    for (int i=0; i<s32_Length; i++){
        byte ch = u8_Data[i];
        ch = ch ^ (byte)u16_Crc;
        ch = ch ^ (ch << 4);
        u16_Crc = (u16_Crc >> 8) ^ ((uint16_t)ch << 8) ^ ((uint16_t)ch << 3) ^ ((uint16_t)ch >> 4);
    }
    crc16[0] = u16_Crc & 0xff;
    crc16[1] = (u16_Crc >> 8) & 0xff;
    //return u16_Crc;
}

Код: Выделить всё

uint32_t CalcCrc32(const byte* u8_Data, int s32_Length, uint32_t u32_Crc = 0xFFFFFFFF){
    for (int i=0; i<s32_Length; i++){
        u32_Crc ^= u8_Data[i];
        for (int b=0; b<8; b++){
            bool b_Bit = (u32_Crc & 0x01) > 0;
            u32_Crc >>= 1;
            if (b_Bit){
              u32_Crc ^= 0xEDB88320;
            }
        }
    }
    crc32[3] = u32_Crc & 0xff;
    crc32[2] = (u32_Crc >> 8) & 0xff;
    crc32[1] = (u32_Crc >> 16) & 0xff;
    crc32[0] = (u32_Crc >> 24) & 0xff;
    return u32_Crc;
}

Код: Выделить всё

int GetBufferSize(){
      return Read(0x8a);
}