update game and rfid

FW/leo_muziekdoos_esp32/lib/CR95HF-master/examples/ReadTag/ReadTag.ino

@@ -0,0 +1,21 @@
+#include "CR95HF.h"
+
+CR95HF reader(4, 2, 3, 5);
+
+void setup() {
+
+  Serial.begin(115200);
+  while (!Serial) {}
+  reader.begin();
+  Serial.println(reader.readSerial());
+}
+
+
+void loop() {
+
+  String id = reader.getID();
+  if (id != "") {
+    Serial.println(id);
+  }
+
+}

FW/leo_muziekdoos_esp32/lib/CR95HF-master/keywords.txt

@@ -0,0 +1,20 @@
+#######################################
+# Syntax Coloring Map HID
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+CR95HF	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+begin	KEYWORD2
+readSerial	KEYWORD2
+getID	KEYWORD2
+
+#######################################
+# Constants (LITERAL1)
+#######################################

FW/leo_muziekdoos_esp32/lib/CR95HF-master/library.properties

@@ -0,0 +1,9 @@
+name=CR95HF
+version=1.0
+author=Martino Facchin
+maintainer=Martino Facchin <m.facchin@arduino.cc>
+sentence=Library to talk with ST Microelectronics CR95HF RFID/NFC reader
+paragraph=Porting of mikroElektronika RFid click example code. Only SPI bus supported at the moment.
+category=Communication
+url=http://www.github.com/facchinm/CR95HF
+architectures=*

FW/leo_muziekdoos_esp32/lib/CR95HF-master/src/CR95HF.cpp

@@ -0,0 +1,411 @@
+#include "CR95HF.h"
+#include "SPI.h"
+
+// Write command to the CR95HF
+void CR95HF::writeCmd(unsigned short cmd, unsigned short dataLen) {
+  unsigned short i = 0;
+
+  digitalWrite(CS, LOW);
+  SPI.beginTransaction(SETTINGS);
+  SPI.transfer(0x00);  // Send cmd to CR95HF
+  SPI.transfer(cmd);
+  SPI.transfer(dataLen);
+  while (dataLen == 0) {
+    digitalWrite(CS, HIGH);
+    break;
+  }
+  for (i = 0; i < dataLen; i++) {
+    SPI.transfer(sdata[i]);
+  }
+  SPI.endTransaction();
+  digitalWrite(CS, HIGH);
+}
+
+// Poll the CR95HF
+void CR95HF::readCmd() {
+  unsigned short i = 0;
+
+  while (1) {
+    digitalWrite(CS, LOW);
+    SPI.beginTransaction(SETTINGS);
+    SPI.transfer(0x03);
+    res = SPI.transfer(0);
+    SPI.endTransaction();
+    digitalWrite(CS, HIGH);
+
+    if ((res & 0x08) >> 3) {
+      digitalWrite(CS, LOW);
+      SPI.beginTransaction(SETTINGS);
+      SPI.transfer(0x02);
+      res = SPI.transfer(0);
+      dataNum = SPI.transfer(0);
+      for (i = 0; i < dataNum; i++)
+        rdata[i] = SPI.transfer(0);
+      SPI.endTransaction();
+      digitalWrite(CS, HIGH);
+      break;
+    }
+    SPI.endTransaction();
+    digitalWrite(CS, HIGH);
+    delay(10);
+  }
+}
+
+// Initialize MCU and peripherals
+void CR95HF::begin() {
+  // Configure GPIO pins
+  // if (SSI_0 != -1)
+  //   pinMode(SSI_0, OUTPUT);
+  // if (SSI_1 != -1)
+  //   pinMode(SSI_1, OUTPUT);
+  if (IRQ_IN != -1)
+    pinMode(IRQ_IN, OUTPUT);
+
+  pinMode(CS, OUTPUT);
+
+  // Set in SPI mode
+  // if (SSI_0 != -1)
+  //   digitalWrite(SSI_0, HIGH);
+  // if (SSI_1 != -1)
+  //   digitalWrite(SSI_1, LOW);
+  if (IRQ_IN != -1)
+    digitalWrite(IRQ_IN, HIGH);
+  delay(1);
+
+  if (IRQ_IN != -1)
+    digitalWrite(IRQ_IN, LOW);
+  delay(1);
+  if (IRQ_IN != -1)
+    digitalWrite(IRQ_IN, HIGH);
+  delay(1);
+
+  Serial.println("RFID init: init SPI");
+  SPI.begin(SCK,MISO, MOSI);
+
+  Serial.print("RFID init: Wait for response");
+  while (!EchoResponse()) {   // Until CR95HF is detected
+    if (IRQ_IN != -1)
+      digitalWrite(IRQ_IN, HIGH);
+    delay(10);
+    if (IRQ_IN != -1)
+      digitalWrite(IRQ_IN, LOW);
+    delay(10);
+    Serial.print(".");
+  }
+  Serial.println("ok");
+  
+  Serial.printf("RFID init: Serial=%s\n", readSerial());
+  Calibration();
+  IndexMod_Gain();
+  AutoFDet();
+  Select_ISO_IEC_18092_Protocol();
+}
+
+// Get Echo reponse from CR95HF
+char CR95HF::EchoResponse() {
+
+  digitalWrite(CS, LOW);
+  SPI.beginTransaction(SETTINGS);
+  SPI.transfer(0x00);  // Send cmd to CR95HF
+  SPI.transfer(ECHO);
+  SPI.endTransaction();
+  digitalWrite(CS, HIGH);
+
+  while (1) {
+    digitalWrite(CS, LOW);
+    SPI.beginTransaction(SETTINGS);
+    SPI.transfer(0x03);
+    tmp = SPI.transfer(0);
+    SPI.endTransaction();
+    digitalWrite(CS, HIGH);
+
+    if ((tmp & 0x08) >> 3) {
+      digitalWrite(CS, LOW);
+      SPI.beginTransaction(SETTINGS);
+      SPI.transfer(0x02);
+      tmp = SPI.transfer(0);
+      SPI.endTransaction();
+      digitalWrite(CS, HIGH);
+      if (tmp == ECHO) {
+        return 1;
+      }
+      return 0;
+    }
+  }
+}
+
+// Calibrate CR95HF device
+void CR95HF::Calibration() {
+  sdata[0] = 0x03;
+  sdata[1] = 0xA1;
+  sdata[2] = 0x00;
+  sdata[3] = 0xF8;
+  sdata[4] = 0x01;
+  sdata[5] = 0x18;
+  sdata[6] = 0x00;
+  sdata[7] = 0x20;
+  sdata[8] = 0x60;
+  sdata[9] = 0x60;
+  sdata[10] = 0x00;
+  sdata[11] = 0x00;
+  sdata[12] = 0x3F;
+  sdata[13] = 0x01;
+  writeCmd(Idle, 0x0E);
+  readCmd();
+
+  sdata[0] = 0x03;
+  sdata[1] = 0xA1;
+  sdata[2] = 0x00;
+  sdata[3] = 0xF8;
+  sdata[4] = 0x01;
+  sdata[5] = 0x18;
+  sdata[6] = 0x00;
+  sdata[7] = 0x20;
+  sdata[8] = 0x60;
+  sdata[9] = 0x60;
+  sdata[10] = 0x00;
+  sdata[11] = 0xFC;
+  sdata[12] = 0x3F;
+  sdata[13] = 0x01;
+  writeCmd(Idle, 0x0E);
+  readCmd();
+
+  sdata[0] = 0x03;
+  sdata[1] = 0xA1;
+  sdata[2] = 0x00;
+  sdata[3] = 0xF8;
+  sdata[4] = 0x01;
+  sdata[5] = 0x18;
+  sdata[6] = 0x00;
+  sdata[7] = 0x20;
+  sdata[8] = 0x60;
+  sdata[9] = 0x60;
+  sdata[10] = 0x00;
+  sdata[11] = 0x7C;
+  sdata[12] = 0x3F;
+  sdata[13] = 0x01;
+  writeCmd(Idle, 0x0E);
+  readCmd();
+
+  sdata[0] = 0x03;
+  sdata[1] = 0xA1;
+  sdata[2] = 0x00;
+  sdata[3] = 0xF8;
+  sdata[4] = 0x01;
+  sdata[5] = 0x18;
+  sdata[6] = 0x00;
+  sdata[7] = 0x20;
+  sdata[8] = 0x60;
+  sdata[9] = 0x60;
+  sdata[10] = 0x00;
+  sdata[11] = 0x3C;
+  sdata[12] = 0x3F;
+  sdata[13] = 0x01;
+  writeCmd(Idle, 0x0E);
+  readCmd();
+
+  sdata[0] = 0x03;
+  sdata[1] = 0xA1;
+  sdata[2] = 0x00;
+  sdata[3] = 0xF8;
+  sdata[4] = 0x01;
+  sdata[5] = 0x18;
+  sdata[6] = 0x00;
+  sdata[7] = 0x20;
+  sdata[8] = 0x60;
+  sdata[9] = 0x60;
+  sdata[10] = 0x00;
+  sdata[11] = 0x5C;
+  sdata[12] = 0x3F;
+  sdata[13] = 0x01;
+  writeCmd(Idle, 0x0E);
+  readCmd();
+
+  sdata[0] = 0x03;
+  sdata[1] = 0xA1;
+  sdata[2] = 0x00;
+  sdata[3] = 0xF8;
+  sdata[4] = 0x01;
+  sdata[5] = 0x18;
+  sdata[6] = 0x00;
+  sdata[7] = 0x20;
+  sdata[8] = 0x60;
+  sdata[9] = 0x60;
+  sdata[10] = 0x00;
+  sdata[11] = 0x6C;
+  sdata[12] = 0x3F;
+  sdata[13] = 0x01;
+  writeCmd(Idle, 0x0E);
+  readCmd();
+
+  sdata[0] = 0x03;
+  sdata[1] = 0xA1;
+  sdata[2] = 0x00;
+  sdata[3] = 0xF8;
+  sdata[4] = 0x01;
+  sdata[5] = 0x18;
+  sdata[6] = 0x00;
+  sdata[7] = 0x20;
+  sdata[8] = 0x60;
+  sdata[9] = 0x60;
+  sdata[10] = 0x00;
+  sdata[11] = 0x74;
+  sdata[12] = 0x3F;
+  sdata[13] = 0x01;
+  writeCmd(Idle, 0x0E);
+  readCmd();
+
+  sdata[0] = 0x03;
+  sdata[1] = 0xA1;
+  sdata[2] = 0x00;
+  sdata[3] = 0xF8;
+  sdata[4] = 0x01;
+  sdata[5] = 0x18;
+  sdata[6] = 0x00;
+  sdata[7] = 0x20;
+  sdata[8] = 0x60;
+  sdata[9] = 0x60;
+  sdata[10] = 0x00;
+  sdata[11] = 0x70;
+  sdata[12] = 0x3F;
+  sdata[13] = 0x01;
+  writeCmd(Idle, 0x0E);
+  readCmd();
+}
+
+// Get CR95HF chip ID
+char* CR95HF::readSerial() {
+  writeCmd(IDN, 0);
+  readCmd();
+  for (j = 0; j < dataNum; j++) {
+    CR95HF_ID[j] = rdata[j];
+  }
+  return CR95HF_ID;
+}
+
+// Select the RF communication protocol (ISO/IEC 14443-A)
+void CR95HF::Select_ISO_IEC_14443_A_Protocol() {
+  sdata[0] = 0x02;
+  sdata[1] = 0x00;
+  writeCmd(ProtocolSelect, 2);
+  readCmd();
+
+  // Clear read and write buffers
+  for (j = 0; j < 18; j++ ) {
+    rdata[j] = 0;
+    sdata[j] = 0;
+  }
+}
+
+// Select the RF communication protocol (ISO/IEC 18092)
+void CR95HF::Select_ISO_IEC_18092_Protocol() {
+  sdata[0] = 0x04;
+  sdata[1] = 0x51;
+  writeCmd(ProtocolSelect, 2);
+  readCmd();
+
+  // Clear read and write buffers
+  for (j = 0; j < 18; j++ ) {
+    rdata[j] = 0;
+    sdata[j] = 0;
+  }
+}
+
+// Configure IndexMod & Gain
+void CR95HF::IndexMod_Gain() {
+  sdata[0] = 0x09;
+  sdata[1] = 0x04;
+  sdata[2] = 0x68;
+  sdata[3] = 0x01;
+  sdata[4] = 0x01;
+  sdata[5] = 0x50;
+  writeCmd(WrReg, 6);
+  readCmd();
+}
+
+// Configure Auto FDet
+void CR95HF::AutoFDet() {
+  sdata[0] = 0x09;
+  sdata[1] = 0x04;
+  sdata[2] = 0x0A;
+  sdata[3] = 0x01;
+  sdata[4] = 0x02;
+  sdata[5] = 0xA1;
+  writeCmd(WrReg, 6);
+  readCmd();
+}
+
+// Read the tag ID
+void CR95HF::GetTagID() {
+  sdata[0] = 0x26;
+  sdata[1] = 0x07;
+  writeCmd(SendRecv , 2);
+  readCmd();
+
+  sdata[0] = 0x93;
+  sdata[1] = 0x20;
+  sdata[2] = 0x08;
+  writeCmd(SendRecv , 3);
+  readCmd();
+
+  if (res == 0x80) {
+    for (j = 1; j < dataNum - 3; j++) {
+      ID += String(rdata[j], HEX);
+    }
+    TAG_flag = 1;
+  }
+  else {
+    TAG_flag = 0;
+    Select_ISO_IEC_18092_Protocol();
+  }
+}
+
+// Read the NFC Forum tags
+void CR95HF::GetNFCTag() {
+  sdata[0] = 0x00;
+  sdata[1] = 0xFF;
+  sdata[2] = 0xFF;
+  sdata[3] = 0x00;
+  sdata[4] = 0x00;
+  writeCmd(SendRecv, 5);
+  readCmd();
+
+  if (res == 0x80) {
+    for (j = 0; j < dataNum; j++) {
+      ID += String(rdata[j], HEX);
+    }
+    NFC_flag = 1;
+  }
+  else {
+    NFC_flag = 0;
+    Select_ISO_IEC_14443_A_Protocol();
+  }
+}
+
+String CR95HF::getID() {
+
+  String id = "";
+
+  if (!TAG_flag)
+    GetNFCTag();                                               // Get NFC ID
+
+  if (!NFC_flag)
+    GetTagID();                                                // Get Tag ID
+
+  if (ID.c_str()[0] == 0) {                                    // If there is no tag present
+    flag++;                                                    // Increment counter flag
+  }
+  else {                                                       // If tag is present
+    flag = 0;                                                  // Reset counter flag
+    id = ID;                                                   // Set current ID as previous ID
+  }
+  ID = "";                                                     // Terminate the ID string
+
+  // Clear read and write buffers
+  for (j = 0; j < 18; j++) {
+    rdata[j] = 0;
+    sdata[j] = 0;
+  }
+
+  return id;
+}

FW/leo_muziekdoos_esp32/lib/CR95HF-master/src/CR95HF.h

@@ -0,0 +1,56 @@
+#include "SPI.h"
+#include "Arduino.h"
+
+// CR95HF Commands Definition
+#define IDN 0x01
+#define ProtocolSelect 0x02
+#define SendRecv 0x04
+#define Idle 0x07
+#define RdReg 0x08
+#define WrReg 0x09
+#define BaudRate 0x0A
+#define ECHO 0x55
+
+class CR95HF
+{
+
+public:
+  CR95HF(int cs, int sck, int mosi, int miso, int irq_in = -1, int ssi_o = -1, int ssi_i = -1) : CS(cs), SCK(sck), MOSI(mosi), MISO(miso), IRQ_IN(irq_in), SSI_0(ssi_o), SSI_1(ssi_i) {}
+  void begin();
+  char *readSerial();
+  String getID();
+
+private:
+  void writeCmd(unsigned short cmd, unsigned short dataLen);
+  void readCmd();
+  char EchoResponse();
+  void Calibration();
+  void GetNFCTag();
+  void GetTagID();
+  void AutoFDet();
+  void IndexMod_Gain();
+  void Select_ISO_IEC_18092_Protocol();
+  void Select_ISO_IEC_14443_A_Protocol();
+
+private:
+  const SPISettings SETTINGS = SPISettings(1000000, MSBFIRST, SPI_MODE0);
+  unsigned short sdata[18];
+  unsigned short rdata[18];
+  unsigned short res = 0, dataNum = 0;
+  unsigned short j = 0, tmp = 0;
+  int x_pos = 0;
+  int x_pos_old = 0;
+  char CR95HF_ID[13];
+  String ID;
+  String ID_old;
+  char flag = 0;
+  unsigned char NFC_flag = 0;
+  unsigned char TAG_flag = 1;
+  const unsigned int CS; 
+  const unsigned int SCK;
+  const unsigned int MOSI;
+  const unsigned int MISO;
+  const unsigned int IRQ_IN; 
+  const unsigned int SSI_0;  
+  const unsigned int SSI_1; 
+};

FW/leo_muziekdoos_esp32/platformio.ini

@@ -16,6 +16,5 @@ lib_deps =
 	bblanchon/ArduinoJson@^6.18.5
 	joaolopesf/SerialDebug@^0.9.82
 monitor_speed = 115200
-;upload_speed = 115200
 lib_ldf_mode = deep+
 extra_scripts = ./littlefsbuilder.py

FW/leo_muziekdoos_esp32/src/game.cpp

@@ -47,11 +47,11 @@ void handleGame(void)
         hall_idle_count--;
       }
     }
-    // debugD("HallSensor: val=%d, delta=%d, count=%d, idle=%s\n",
-    //         hall_sample,
-    //         hall_delta,
-    //         hall_idle_count,
-    //         (hall_is_Idle? "yes":"no"));
+    debugD("HallSensor: val=%d, delta=%d, count=%d, idle=%s\n",
+            hall_sample,
+            hall_delta,
+            hall_idle_count,
+            (hall_is_Idle? "yes":"no"));
     last_hall_sample = hall_sample;
     last_hall_read = timeNow;
   }

FW/leo_muziekdoos_esp32/src/game.h

@@ -4,9 +4,9 @@
 #include "board.h"
 #include "SerialDebug.h"
 
-#define HALLINTERVAL        200
-#define HALLIDLETHRESHOLD   6
-#define HALLIDLESAMPLES     2
+#define HALLINTERVAL        100
+#define HALLIDLETHRESHOLD   3
+#define HALLIDLESAMPLES     3
 
 void initGame(void);
 void handleGame(void);

FW/leo_muziekdoos_esp32/src/main.cpp

@@ -19,7 +19,7 @@ void setup()
   initStorage();
   initConfig();
   initAudio();
-  initRfid();
+  //initRfid();
   
   initGame();
 

FW/leo_muziekdoos_esp32/src/rfid.cpp

@@ -1,31 +1,44 @@
 #include "rfid.h"
 
+// uint8_t cardsToCheck[] = {TRACK_NFCTYPE1,
+//                           TRACK_NFCTYPE2,
+//                           TRACK_NFCTYPE3,
+//                           TRACK_NFCTYPE4A,
+//                           TRACK_NFCTYPE4B,
+//                           TRACK_NFCTYPE5};
+
+// uint8_t currentCardIdx = 0;
+// uint8_t maxCardIdx = sizeof(cardsToCheck);
 
 uint32_t last_rfid_update = 0;
+CR95HF reader(NFC_SS, NFC_SCK, NFC_MOSI, NFC_MISO, NFC_IRQ);
 
 //*****************************************************************************************//
 void initRfid()
 {
-  printlnI(F("rfid init")); //shows in serial that it is ready to read
+  Serial.println(F("rfid init")); //shows in serial that it is ready to read
 
   //int8_t sck=-1, int8_t miso=-1, int8_t mosi=-1, int8_t ss=-1);
-  ConfigManager_HWInit(NFC_SCK, NFC_MISO, NFC_MOSI, NFC_SS, NFC_IRQ);
-  printlnI(F("rfid init done")); //shows in serial that it is ready to read
+  //ConfigManager_HWInit(NFC_SCK, NFC_MISO, NFC_MOSI, NFC_SS, NFC_IRQ);
+  reader.begin();
+  Serial.println(F("rfid init done")); //shows in serial that it is ready to read
 }
 
 //*****************************************************************************************//
 void handleRfid()
 {
   uint32_t timeNow = millis();
-  int8_t TagType = TRACK_NOTHING;
+  //int8_t TagType = TRACK_NOTHING;
 
-  if(timeNow - last_rfid_update > RFIDINTERVAL)
+  if (timeNow - last_rfid_update > RFIDINTERVAL)
   {
-    Serial.printf("rfid: tagreader start\n");
-    TagType = ConfigManager_TagHunting(TRACK_ALL);
-    Serial.printf("rfid: tagreader done: %d\n",TagType);
+
+    String id = reader.getID();
+    if (id != "")
+    {
+      Serial.println(id);
+    }
     last_rfid_update = timeNow;
   }
 }
 //*****************************************************************************************//
-

FW/leo_muziekdoos_esp32/src/rfid.h

@@ -4,13 +4,16 @@
 #include "Arduino.h"
 #include "SerialDebug.h"
 
-#include <SPI.h>
-#include "lib_95HFConfigManager.h"
-#include "drv_spi.h"
-#include "lib_wrapper.h"
-#include "miscellaneous.h"
+// #include <SPI.h>
+// #include "lib_95HFConfigManager.h"
+// #include "drv_spi.h"
+// #include "lib_wrapper.h"
+// #include "miscellaneous.h"
+
+#include "CR95HF.h"
 
 #define RFIDINTERVAL 200
 
+
 void initRfid(void);
 void handleRfid(void);