projects_leo/muziekdoos
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

update game and rfid

Browse Source
This commit is contained in:
willem
2021-10-18 17:29:11 +02:00
parent 684688da7b
commit 501e73b119
14 changed files with 2143 additions and 1621 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
FW/leo_muziekdoos_esp32/hallsensor_output.xlsx
View File

Binary file not shown.

21
FW/leo_muziekdoos_esp32/lib/CR95HF-master/examples/ReadTag/ReadTag.ino Normal file
View File

@@ -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);
}
}

20
FW/leo_muziekdoos_esp32/lib/CR95HF-master/keywords.txt Normal file
View File

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

9
FW/leo_muziekdoos_esp32/lib/CR95HF-master/library.properties Normal file
View File

@@ -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=*

411
FW/leo_muziekdoos_esp32/lib/CR95HF-master/src/CR95HF.cpp Normal file
View File

@@ -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;
}

56
FW/leo_muziekdoos_esp32/lib/CR95HF-master/src/CR95HF.h Normal file
View File

@@ -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;
};

1
FW/leo_muziekdoos_esp32/platformio.ini
View File

@@ -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

10
FW/leo_muziekdoos_esp32/src/game.cpp
View File

@@ -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;
}

6
FW/leo_muziekdoos_esp32/src/game.h
View File

@@ -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);

2
FW/leo_muziekdoos_esp32/src/main.cpp
View File

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

31
FW/leo_muziekdoos_esp32/src/rfid.cpp
View File

@@ -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;
}
}
//*****************************************************************************************//

13
FW/leo_muziekdoos_esp32/src/rfid.h
View File

@@ -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);