Witty Fox NFC Communication Module Documentation

Card Emulation Mode

Emulates an NFC tag, allowing the module to communicate with NFC readers.

Key Features

NFC Compliance: The module complies with NFC Forum specifications, ensuring compatibility with a wide range of NFC devices.
Low Power Consumption: The module operates at ultra-low power consumption (< 10mA), making it suitable for battery-powered devices.
High Data Transfer Rates: Supports data transfer rates of up to 424 kbps, enabling fast and efficient data exchange.
Secure Communication: Implements cryptographic algorithms, such as AES and RSA, to ensure secure data transfer and authentication.
Multi-Interface Support: Provides I2C, SPI, and UART interfaces, allowing easy integration with various microcontrollers and systems.
Small Form Factor: The module measures 15 mm x 15 mm, making it ideal for compact IoT devices.
Operating Temperature Range: Operates in a temperature range of -20C to +85C, ensuring reliable performance in various environments.
Antenna Options: Supports external or internal antenna configurations, offering design flexibility and convenience.
Firmware Upgradability: Allows for firmware updates via the I2C or UART interface, ensuring easy maintenance and feature enhancements.
Certifications: Complies with relevant regulations, including RoHS, CE, and FCC, ensuring global compatibility and safety.

Technical Specifications

| Parameter | Value |

| --- | --- |

| Frequency | 13.56 MHz |

| Data Transfer Rate | Up to 424 kbps |

| Power Consumption | < 10mA |

| Interface | I2C, SPI, UART |

| Operating Temperature | -20C to +85C |

| Dimensions | 15 mm x 15 mm |

| Weight | 1.5 g |

| Supply Voltage | 1.8V to 3.3V |

Applications

The Witty Fox NFC Communication Module is suitable for various IoT applications, including

Smart Home Automation

Industrial Control Systems

Wearable Devices

Access Control Systems

Healthcare Devices

Payment Systems

By integrating the Witty Fox NFC Communication Module into your IoT device, you can enable secure, reliable, and efficient data transfer, while leveraging the convenience and flexibility of NFC technology.

Pin Configuration

Witty Fox NFC Communication Module Pinout and Connection Guide
The Witty Fox NFC Communication Module is a compact and efficient communication module designed for Near Field Communication (NFC) applications. It features a simple and intuitive pinout structure, making it easy to integrate into various IoT projects. Below is a detailed explanation of each pin and how to connect them:
Pinout Structure:
The Witty Fox NFC Communication Module has a total of 8 pins, arranged in two rows of 4 pins each.
Row 1:
1. VCC (Pin 1)
Function: Power supply pin
Description: Connect to a 3.3V power source
Recommended operating voltage range: 3.0V to 3.6V
2. GND (Pin 2)
Function: Ground pin
Description: Connect to the ground of the power source and the microcontroller
3. SCK (Pin 3)
Function: Serial clock pin
Description: Connect to the clock pin of the microcontroller (e.g., Arduino's SCK pin)
4. MISO (Pin 4)
Function: Master In Slave Out pin
Description: Connect to the MISO pin of the microcontroller (e.g., Arduino's MISO pin)
Row 2:
1. MOSI (Pin 5)
Function: Master Out Slave In pin
Description: Connect to the MOSI pin of the microcontroller (e.g., Arduino's MOSI pin)
2. NSS (Pin 6)
Function: Slave Select pin
Description: Connect to the NSS pin of the microcontroller (e.g., Arduino's NSS pin)
3. IRQ (Pin 7)
Function: Interrupt pin
Description: Connect to an available digital input pin on the microcontroller (e.g., Arduino's D2 pin)
4. ANT (Pin 8)
Function: NFC Antenna pin
Description: Connect to an external NFC antenna (recommended length: 13mm)
Connection Guidelines:
1. Connect the VCC pin to a 3.3V power source, ensuring the voltage remains within the recommended range.
2. Connect the GND pin to the ground of the power source and the microcontroller.
3. Connect the SCK, MISO, and MOSI pins to the corresponding pins on the microcontroller (e.g., Arduino's SCK, MISO, and MOSI pins).
4. Connect the NSS pin to a digital output pin on the microcontroller (e.g., Arduino's NSS pin).
5. Connect the IRQ pin to an available digital input pin on the microcontroller (e.g., Arduino's D2 pin).
6. Connect the ANT pin to an external NFC antenna, ensuring the recommended length of 13mm.
Additional Notes:
Ensure all connections are secure and meet the recommended voltage and current ratings.
Use a level shifter if the microcontroller operates at a voltage different from the Witty Fox module's recommended range.
Consult the Witty Fox NFC Communication Module datasheet and the microcontroller's datasheet for detailed specifications and pinout information.
By following these guidelines, you can successfully connect the Witty Fox NFC Communication Module to your microcontroller and begin developing innovative NFC-based IoT projects.

Code Examples

Witty Fox NFC Communication Module Documentation

Overview

The Witty Fox NFC Communication Module is a compact, low-power Near Field Communication (NFC) module designed for IoT applications. This module enables devices to communicate with other NFC-enabled devices, allowing for seamless data exchange, authentication, and more.

Technical Specifications

Operating Frequency: 13.56 MHz
 Communication Distance: Up to 10 cm (4 inches)
 Data Transfer Rate: Up to 424 kbps
 Operating Voltage: 3.3V
 Current Consumption: 10 mA (typical)

Code Examples

### Example 1: NFC Tag Reading using Arduino

In this example, we will demonstrate how to use the Witty Fox NFC Communication Module to read data from an NFC tag using an Arduino board.

Hardware Requirements

Arduino Board (e.g., Arduino Uno)
 Witty Fox NFC Communication Module
 NFC Tag (e.g., NTAG215)

Software Requirements

Arduino IDE (version 1.8.x or later)

Code
```c
#include <Wire.h>
#include <PN532_I2C.h>

// Define the NFC module's I2C address
#define NFC_I2C_ADDRESS 0x48

PN532_I2C nfc(NFC_I2C_ADDRESS);

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

void loop() {
  // Initialize the NFC module
  nfc.SAMConfig();

// Set the NFC module to read mode
  nfc.setPassiveTarget();

// Check if an NFC tag is present
  uint8_t uid[] = { 0, 0, 0, 0, 0, 0, 0 };
  uint8_t uidLength = 7;
  if (nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, uidLength)) {
    Serial.print("Card detected: ");
    for (int i = 0; i < uidLength; i++) {
      Serial.print(uid[i], HEX);
    }
    Serial.println();

// Read the NFC tag's data
    uint8_t data[16];
    nfc.readMemoryBlock(1, data, 16);
    Serial.print("Data: ");
    for (int i = 0; i < 16; i++) {
      Serial.print(data[i], HEX);
    }
    Serial.println();
  } else {
    Serial.println("No card detected");
  }

delay(1000);
}
```
### Example 2: NFC Peer-to-Peer Communication using ESP32

In this example, we will demonstrate how to use the Witty Fox NFC Communication Module to establish a peer-to-peer (P2P) connection between two ESP32 boards.

Hardware Requirements

2 x ESP32 Boards
 2 x Witty Fox NFC Communication Modules

Software Requirements

ESP32 Arduino Core (version 1.0.x or later)

Code (ESP32 Board 1 - Initiator)
```c
#include <WiFi.h>
#include <nfc_esp32.h>

// Define the NFC module's I2C address
#define NFC_I2C_ADDRESS 0x48

NFC_ESP32 nfc(NFC_I2C_ADDRESS);

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

// Initialize the NFC module
  nfc.begin();

// Set the NFC module to initiator mode
  nfc.setInitiatorMode();
}

void loop() {
  // Start the NFC module's P2P mode
  nfc.startP2PMode();

// Wait for a response from the target device
  uint8_t response[16];
  if (nfc.getP2PResponse(response, 16)) {
    Serial.print("Response received: ");
    for (int i = 0; i < 16; i++) {
      Serial.print(response[i], HEX);
    }
    Serial.println();

// Send data to the target device
    uint8_t data[] = { 0x01, 0x02, 0x03, 0x04 };
    nfc.sendP2PData(data, 4);
  } else {
    Serial.println("No response received");
  }

delay(1000);
}
```
Code (ESP32 Board 2 - Target)
```c
#include <WiFi.h>
#include <nfc_esp32.h>

// Define the NFC module's I2C address
#define NFC_I2C_ADDRESS 0x48

NFC_ESP32 nfc(NFC_I2C_ADDRESS);

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

// Initialize the NFC module
  nfc.begin();

// Set the NFC module to target mode
  nfc.setTargetMode();
}

void loop() {
  // Wait for an incoming P2P connection
  uint8_t data[16];
  if (nfc.getP2PData(data, 16)) {
    Serial.print("Data received: ");
    for (int i = 0; i < 16; i++) {
      Serial.print(data[i], HEX);
    }
    Serial.println();

// Send a response back to the initiator
    uint8_t response[] = { 0x05, 0x06, 0x07, 0x08 };
    nfc.sendP2PResponse(response, 4);
  }

delay(1000);
}
```
These code examples demonstrate the basic use of the Witty Fox NFC Communication Module in various contexts. For more advanced usage and specific implementation details, please refer to the module's datasheet and the NFC protocol documentation.

Update Your Location

Saved Addresses

Witty Fox NFC Communication Module

Card Emulation Mode

Pin Configuration

Code Examples