Add class SFE_ST25DV64KC_NDEF. Add writeCCFile methods

Author: PaulZC

keywords.txt

@@ -13,6 +13,8 @@ END_REGISTERS	KEYWORD1
 
 SFE_ST2525DV64KC_IO	KEYWORD1
 
+SFE_ST2525DV64KC_NDEF	KEYWORD1
+
 #######################################
 # Methods and Functions 	KEYWORD2
 #######################################
@@ -56,6 +58,9 @@ setRegisterBit	KEYWORD2
 clearRegisterBit	KEYWORD2
 isBitSet	KEYWORD2
 
+writeCCFile4Byte	KEYWORD2
+writeCCFile8Byte	KEYWORD2
+
 #######################################
 # Constants 	LITERAL1
 #######################################

src/SparkFun_ST25DV64KC_Arduino_Library.cpp

@@ -304,23 +304,28 @@ bool SFE_ST25DV64KC::getEEPROMWriteProtectionBit(uint8_t memoryArea)
   return false;
 }
 
-void SFE_ST25DV64KC::writeEEPROM(uint16_t baseAddress, uint8_t *data, uint16_t dataLength)
+bool SFE_ST25DV64KC::writeEEPROM(uint16_t baseAddress, uint8_t *data, uint16_t dataLength)
 {
   // Disable FTM temporarily if enabled
   bool ftmEnabled = st25_io.isBitSet(SF_ST25DV64KC_ADDRESS::DATA, REG_FTM, BIT_FTM_MB_MODE);
+
+  bool success = true;
+
   if (ftmEnabled)
-    st25_io.clearRegisterBit(SF_ST25DV64KC_ADDRESS::SYSTEM, REG_FTM, BIT_FTM_MB_MODE);
+    success &= st25_io.clearRegisterBit(SF_ST25DV64KC_ADDRESS::SYSTEM, REG_FTM, BIT_FTM_MB_MODE);
 
-  st25_io.writeMultipleBytes(SF_ST25DV64KC_ADDRESS::DATA, baseAddress, data, dataLength);
+  success &= st25_io.writeMultipleBytes(SF_ST25DV64KC_ADDRESS::DATA, baseAddress, data, dataLength);
 
   // Restore FTM if previously enabled
   if (ftmEnabled)
-    st25_io.setRegisterBit(SF_ST25DV64KC_ADDRESS::SYSTEM, REG_FTM, BIT_FTM_MB_MODE);
+    success &= st25_io.setRegisterBit(SF_ST25DV64KC_ADDRESS::SYSTEM, REG_FTM, BIT_FTM_MB_MODE);
+
+  return success;
 }
 
-void SFE_ST25DV64KC::readEEPROM(uint16_t baseAddress, uint8_t *data, uint16_t dataLength)
+bool SFE_ST25DV64KC::readEEPROM(uint16_t baseAddress, uint8_t *data, uint16_t dataLength)
 {
-  st25_io.readMultipleBytes(SF_ST25DV64KC_ADDRESS::DATA, baseAddress, data, dataLength);
+  return st25_io.readMultipleBytes(SF_ST25DV64KC_ADDRESS::DATA, baseAddress, data, dataLength);
 }
 
 bool SFE_ST25DV64KC::setMemoryAreaEndAddress(uint8_t memoryArea, uint8_t endAddressValue)

src/SparkFun_ST25DV64KC_Arduino_Library.h

@@ -99,10 +99,10 @@ class SFE_ST25DV64KC
   bool getEEPROMWriteProtectionBit(uint8_t memoryArea);
 
   // Reads block of data from EEPROM.
-  void readEEPROM(uint16_t baseAddress, uint8_t *data, uint16_t dataLength);
+  bool readEEPROM(uint16_t baseAddress, uint8_t *data, uint16_t dataLength);
 
   // Writes block of data to EEPROM.
-  void writeEEPROM(uint16_t baseAddress, uint8_t *data, uint16_t dataLength);
+  bool writeEEPROM(uint16_t baseAddress, uint8_t *data, uint16_t dataLength);
 
   // Sets memory area boundary. memoryNumber ranges from 1 to 4.
   // endAddressValue must comply with datasheet's area size specifications (page 14).
@@ -151,4 +151,6 @@ class SFE_ST25DV64KC
   bool getEH_CTRL_DYNBit(uint8_t bitMask);
 };
 
+#include "SparkFun_ST25DV64KC_NDEF.h"
+
 #endif

src/SparkFun_ST25DV64KC_IO.cpp

@@ -45,7 +45,7 @@ bool SFE_ST2525DV64KC_IO::writeMultipleBytes(const SF_ST25DV64KC_ADDRESS address
   {
     uint8_t bytesToWrite; // Write the data in chunks of readWriteChunkSize max
     if ((packetLength - bytesWritten) > ((uint16_t)readWriteChunkSize))
-      bytesToWrite = readWriteChunkSize;
+      bytesToWrite = readWriteChunkSize - 2; // Write a maximum of readWriteChunkSize bytes total - including the register address
     else
       bytesToWrite = packetLength - bytesWritten;
 

src/SparkFun_ST25DV64KC_NDEF.cpp

@@ -0,0 +1,74 @@
+/*
+  This is a library written for the ST25DV64KC Dynamic RFID Tag.
+  SparkFun sells these at its website:
+  https://www.sparkfun.com/products/
+
+  Do you like this library? Help support open source hardware. Buy a board!
+
+  Written by Paul CLark  @ SparkFun Electronics, August 5th, 2021
+  This file declares the additional functions used to read/write NDEF 
+  records from/to the ST25DV64KC Dynamic RFID Tag.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+  GNU General Public License for more details.
+  You should have received a copy of the GNU General Public License
+  along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "SparkFun_ST25DV64KC_NDEF.h"
+
+bool SFE_ST25DV64KC_NDEF::writeCCFile4Byte(uint32_t val)
+{
+  uint8_t CCFile[4];
+  CCFile[0] = val >> 24;
+  CCFile[1] = (val >> 16) & 0xFF;
+  CCFile[2] = (val >> 8) & 0xFF;
+  CCFile[3] = val & 0xFF;
+
+  return writeEEPROM(0x0, CCFile, 0x4);
+}
+
+/*
+  The Capacity Container File is written to the first eight bytes of user memory:
+
+  0xE2 0x40 0x00 0x01 0x00 0x00 0x03 0xFF
+
+  Byte 0: Magic Number
+          The ST25DV64KC has 8kBytes of user memory so we need to select 0xE2 to select two-byte addressing
+  Byte 1: Version and Access Condition
+          b7 b6 = 0b01 Major Version
+          b5 b4 = 0b00 Minor Version
+          b3 b2 = 0x00 Read Access: Always
+          b1 b0 = 0x00 Write Access: Always
+  Byte 2: 0x00
+  Byte 3: Additional Feature Information
+          b7 b6 b5 = 0b000 RFU (Reserved Future Use)
+          b4 = 0b0 Special Frame
+          b3 = 0b0 Lock Block
+          b2 b1 = 0b00 RFU
+          b0 = 0b1 MBREAD: Read Multiple Block is supported
+  Byte 4: 0x00 RFU (Reserved Future Use)
+  Byte 5: 0x00 RFU (Reserved Future Use)
+  Byte 6 + Byte 7: MLEN Encoded Memory Length
+          MLEN = T5T_Area / 8
+          MLEN encoding for a ST25DV64K (8192 bytes memory size) and 8 bytes capability container (CC):
+          If the entire user memory full, user memory is used to store NDEF, T5T_Area=8192-8
+          MLEN = (8192 – 8) / 8 = 1023 (0x03FF)
+*/
+
+bool SFE_ST25DV64KC_NDEF::writeCCFile8Byte(uint32_t val1, uint32_t val2)
+{
+  uint8_t CCFile[8];
+  CCFile[0] = val1 >> 24;
+  CCFile[1] = (val1 >> 16) & 0xFF;
+  CCFile[2] = (val1 >> 8) & 0xFF;
+  CCFile[3] = val1 & 0xFF;
+  CCFile[4] = val2 >> 24;
+  CCFile[5] = (val2 >> 16) & 0xFF;
+  CCFile[6] = (val2 >> 8) & 0xFF;
+  CCFile[7] = val2 & 0xFF;
+
+  return writeEEPROM(0x0, CCFile, 0x8);
+}

src/SparkFun_ST25DV64KC_NDEF.h

@@ -0,0 +1,41 @@
+/*
+  This is a library written for the ST25DV64KC Dynamic RFID Tag.
+  SparkFun sells these at its website:
+  https://www.sparkfun.com/products/
+
+  Do you like this library? Help support open source hardware. Buy a board!
+
+  Written by Ricardo Ramos  @ SparkFun Electronics, January 6th, 2021
+  This file declares all functions used in the ST25DV64KC Dynamic RFID Tag Arduino Library.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+  GNU General Public License for more details.
+  You should have received a copy of the GNU General Public License
+  along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _SPARKFUN_ST25DV64KC_NDEF_
+#define _SPARKFUN_ST25DV64KC_NDEF_
+
+#include "SparkFun_ST25DV64KC_Arduino_Library.h"
+
+class SFE_ST25DV64KC_NDEF : public SFE_ST25DV64KC
+{
+public:
+  // Default constructor.
+  SFE_ST25DV64KC_NDEF(){};
+
+  // Default destructor.
+  ~SFE_ST25DV64KC_NDEF(){};
+
+  // Write a 4-byte CC File to user memory (e.g. ST25DV04K)
+  bool writeCCFile4Byte(uint32_t val = 0xE1403F00);
+  
+  // Write an 8-byte CC File to user memory (ST25DV64K)
+  bool writeCCFile8Byte(uint32_t val1 = 0xE2400001, uint32_t val2 = 0x000003FF);
+  
+};
+
+#endif