From c1c397b5555786bd27cac8ac9909d233671a67e8 Mon Sep 17 00:00:00 2001 From: krolyxon Date: Thu, 14 May 2026 23:47:43 +0530 Subject: move src/libs to libs --- lib/Adafruit_PN532/Adafruit_PN532.cpp | 1832 +++++++++++++++++++++ lib/Adafruit_PN532/Adafruit_PN532.h | 225 +++ lib/BleMouse/BleConnectionStatus.cpp | 17 + lib/BleMouse/BleConnectionStatus.h | 20 + lib/BleMouse/BleMouse.cpp | 165 ++ lib/BleMouse/BleMouse.h | 52 + lib/ELECHOUSE_CC1101/ELECHOUSE_CC1101_SRC_DRV.cpp | 1482 +++++++++++++++++ lib/ELECHOUSE_CC1101/ELECHOUSE_CC1101_SRC_DRV.h | 203 +++ src/bluetooth/ble_mouse.cpp | 4 +- src/libs/Adafruit_PN532.cpp | 1832 --------------------- src/libs/Adafruit_PN532.h | 225 --- src/libs/BleConnectionStatus.cpp | 17 - src/libs/BleConnectionStatus.h | 20 - src/libs/BleMouse.cpp | 165 -- src/libs/BleMouse.h | 52 - src/libs/ELECHOUSE_CC1101_SRC_DRV.cpp | 1482 ----------------- src/libs/ELECHOUSE_CC1101_SRC_DRV.h | 203 --- src/main.cpp | 4 +- src/rf/cc1101.cpp | 2 +- src/utils/device_check.cpp | 2 +- 20 files changed, 4002 insertions(+), 4002 deletions(-) create mode 100644 lib/Adafruit_PN532/Adafruit_PN532.cpp create mode 100644 lib/Adafruit_PN532/Adafruit_PN532.h create mode 100644 lib/BleMouse/BleConnectionStatus.cpp create mode 100644 lib/BleMouse/BleConnectionStatus.h create mode 100644 lib/BleMouse/BleMouse.cpp create mode 100644 lib/BleMouse/BleMouse.h create mode 100644 lib/ELECHOUSE_CC1101/ELECHOUSE_CC1101_SRC_DRV.cpp create mode 100644 lib/ELECHOUSE_CC1101/ELECHOUSE_CC1101_SRC_DRV.h delete mode 100644 src/libs/Adafruit_PN532.cpp delete mode 100644 src/libs/Adafruit_PN532.h delete mode 100644 src/libs/BleConnectionStatus.cpp delete mode 100644 src/libs/BleConnectionStatus.h delete mode 100644 src/libs/BleMouse.cpp delete mode 100644 src/libs/BleMouse.h delete mode 100644 src/libs/ELECHOUSE_CC1101_SRC_DRV.cpp delete mode 100644 src/libs/ELECHOUSE_CC1101_SRC_DRV.h diff --git a/lib/Adafruit_PN532/Adafruit_PN532.cpp b/lib/Adafruit_PN532/Adafruit_PN532.cpp new file mode 100644 index 0000000..0a547b7 --- /dev/null +++ b/lib/Adafruit_PN532/Adafruit_PN532.cpp @@ -0,0 +1,1832 @@ +/**************************************************************************/ +/*! + @file Adafruit_PN532.cpp + + @section intro_sec Introduction + + Driver for NXP's PN532 NFC/13.56MHz RFID Transceiver + + This is a library for the Adafruit PN532 NFC/RFID breakout boards + This library works with the Adafruit NFC breakout + ----> https://www.adafruit.com/products/364 + + Check out the links above for our tutorials and wiring diagrams + These chips use SPI or I2C to communicate. + + Adafruit invests time and resources providing this open source code, + please support Adafruit and open-source hardware by purchasing + products from Adafruit! + + @section author Author + + Adafruit Industries + + @section license License + + BSD (see license.txt) + + @section HISTORY + + v2.2 - Added startPassiveTargetIDDetection() to start card detection and + readDetectedPassiveTargetID() to read it, useful when using the + IRQ pin. + + v2.1 - Added NTAG2xx helper functions + + v2.0 - Refactored to add I2C support from Adafruit_NFCShield_I2C library. + + v1.4 - Added setPassiveActivationRetries() + + v1.2 - Added writeGPIO() + - Added readGPIO() + + v1.1 - Changed readPassiveTargetID() to handle multiple UID sizes + - Added the following helper functions for text display + static void PrintHex(const byte * data, const uint32_t numBytes) + static void PrintHexChar(const byte * pbtData, const uint32_t + numBytes) + - Added the following Mifare Classic functions: + bool mifareclassic_IsFirstBlock (uint32_t uiBlock) + bool mifareclassic_IsTrailerBlock (uint32_t uiBlock) + uint8_t mifareclassic_AuthenticateBlock (uint8_t * uid, uint8_t + uidLen, uint32_t blockNumber, uint8_t keyNumber, uint8_t * keyData) uint8_t + mifareclassic_ReadDataBlock (uint8_t blockNumber, uint8_t * data) uint8_t + mifareclassic_WriteDataBlock (uint8_t blockNumber, uint8_t * data) + - Added the following Mifare Ultalight functions: + uint8_t mifareultralight_ReadPage (uint8_t page, uint8_t * buffer) +*/ +/**************************************************************************/ + +#include "Adafruit_PN532.h" + +byte pn532ack[] = {0x00, 0x00, 0xFF, + 0x00, 0xFF, 0x00}; ///< ACK message from PN532 +byte pn532response_firmwarevers[] = { + 0x00, 0x00, 0xFF, + 0x06, 0xFA, 0xD5}; ///< Expected firmware version message from PN532 + +// Uncomment these lines to enable debug output for PN532(SPI) and/or MIFARE +// related code + +// #define PN532DEBUG +// #define MIFAREDEBUG + +// If using Native Port on Arduino Zero or Due define as SerialUSB +#define PN532DEBUGPRINT Serial ///< Fixed name for debug Serial instance +// #define PN532DEBUGPRINT SerialUSB ///< Fixed name for debug Serial instance + +#define PN532_PACKBUFFSIZ 64 ///< Packet buffer size in bytes +byte pn532_packetbuffer[PN532_PACKBUFFSIZ]; ///< Packet buffer used in various + ///< transactions + +/**************************************************************************/ +/*! + @brief Instantiates a new PN532 class using software SPI. + + @param clk SPI clock pin (SCK) + @param miso SPI MISO pin + @param mosi SPI MOSI pin + @param ss SPI chip select pin (CS/SSEL) +*/ +/**************************************************************************/ +Adafruit_PN532::Adafruit_PN532(uint8_t clk, uint8_t miso, uint8_t mosi, + uint8_t ss) { + _cs = ss; + spi_dev = new Adafruit_SPIDevice(ss, clk, miso, mosi, 1000000, + SPI_BITORDER_LSBFIRST, SPI_MODE0); +} + +/**************************************************************************/ +/*! + @brief Instantiates a new PN532 class using I2C. + + @param irq Location of the IRQ pin + @param reset Location of the RSTPD_N pin + @param theWire pointer to I2C bus to use +*/ +/**************************************************************************/ +Adafruit_PN532::Adafruit_PN532(uint8_t irq, uint8_t reset, TwoWire *theWire) + : _irq(irq), _reset(reset) { + pinMode(_irq, INPUT); + pinMode(_reset, OUTPUT); + i2c_dev = new Adafruit_I2CDevice(PN532_I2C_ADDRESS, theWire); +} + +/**************************************************************************/ +/*! + @brief Instantiates a new PN532 class using hardware SPI. + + @param ss SPI chip select pin (CS/SSEL) + @param theSPI pointer to the SPI bus to use +*/ +/**************************************************************************/ +Adafruit_PN532::Adafruit_PN532(uint8_t ss, SPIClass *theSPI) { + _cs = ss; + spi_dev = new Adafruit_SPIDevice(ss, 1000000, SPI_BITORDER_LSBFIRST, + SPI_MODE0, theSPI); +} + +/**************************************************************************/ +/*! + @brief Instantiates a new PN532 class using hardware UART (HSU). + + @param reset Location of the RSTPD_N pin + @param theSer pointer to HardWare Serial bus to use +*/ +/**************************************************************************/ +Adafruit_PN532::Adafruit_PN532(uint8_t reset, HardwareSerial *theSer) + : _reset(reset) { + pinMode(_reset, OUTPUT); + ser_dev = theSer; +} + +/**************************************************************************/ +/*! + @brief Setups the HW + + @returns true if successful, otherwise false +*/ +/**************************************************************************/ +bool Adafruit_PN532::begin() { + if (spi_dev) { + // SPI initialization + if (!spi_dev->begin()) { + return false; + } + } else if (i2c_dev) { + // I2C initialization + // PN532 will fail address check since its asleep, so suppress + if (!i2c_dev->begin(false)) { + return false; + } + } else if (ser_dev) { + ser_dev->begin(115200); + // clear out anything in read buffer + while (ser_dev->available()) + ser_dev->read(); + } else { + // no interface specified + return false; + } + reset(); // HW reset - put in known state + delay(10); + wakeup(); // hey! wakeup! + return true; +} + +/**************************************************************************/ +/*! + @brief Perform a hardware reset. Requires reset pin to have been provided. +*/ +/**************************************************************************/ +void Adafruit_PN532::reset(void) { + // see Datasheet p.209, Fig.48 for timings + if (_reset != -1) { + digitalWrite(_reset, LOW); + delay(1); // min 20ns + digitalWrite(_reset, HIGH); + delay(2); // max 2ms + } +} + +/**************************************************************************/ +/*! + @brief Wakeup from LowVbat mode into Normal Mode. +*/ +/**************************************************************************/ +void Adafruit_PN532::wakeup(void) { + // interface specific wakeups - each one is unique! + if (spi_dev) { + // hold CS low for 2ms + digitalWrite(_cs, LOW); + delay(2); + } else if (ser_dev) { + uint8_t w[3] = {0x55, 0x00, 0x00}; + ser_dev->write(w, 3); + delay(2); + } + + // PN532 will clock stretch I2C during SAMConfig as a "wakeup" + + // need to config SAM to stay in Normal Mode + SAMConfig(); +} + +/**************************************************************************/ +/*! + @brief Prints a hexadecimal value in plain characters + + @param data Pointer to the byte data + @param numBytes Data length in bytes +*/ +/**************************************************************************/ +void Adafruit_PN532::PrintHex(const byte *data, const uint32_t numBytes) { + uint32_t szPos; + for (szPos = 0; szPos < numBytes; szPos++) { + PN532DEBUGPRINT.print(F("0x")); + // Append leading 0 for small values + if (data[szPos] <= 0xF) + PN532DEBUGPRINT.print(F("0")); + PN532DEBUGPRINT.print(data[szPos] & 0xff, HEX); + if ((numBytes > 1) && (szPos != numBytes - 1)) { + PN532DEBUGPRINT.print(F(" ")); + } + } + PN532DEBUGPRINT.println(); +} + +/**************************************************************************/ +/*! + @brief Prints a hexadecimal value in plain characters, along with + the char equivalents in the following format + + 00 00 00 00 00 00 ...... + + @param data Pointer to the byte data + @param numBytes Data length in bytes +*/ +/**************************************************************************/ +void Adafruit_PN532::PrintHexChar(const byte *data, const uint32_t numBytes) { + uint32_t szPos; + for (szPos = 0; szPos < numBytes; szPos++) { + // Append leading 0 for small values + if (data[szPos] <= 0xF) + PN532DEBUGPRINT.print(F("0")); + PN532DEBUGPRINT.print(data[szPos], HEX); + if ((numBytes > 1) && (szPos != numBytes - 1)) { + PN532DEBUGPRINT.print(F(" ")); + } + } + PN532DEBUGPRINT.print(F(" ")); + for (szPos = 0; szPos < numBytes; szPos++) { + if (data[szPos] <= 0x1F) + PN532DEBUGPRINT.print(F(".")); + else + PN532DEBUGPRINT.print((char)data[szPos]); + } + PN532DEBUGPRINT.println(); +} + +/**************************************************************************/ +/*! + @brief Checks the firmware version of the PN5xx chip + + @returns The chip's firmware version and ID +*/ +/**************************************************************************/ +uint32_t Adafruit_PN532::getFirmwareVersion(void) { + uint32_t response; + + pn532_packetbuffer[0] = PN532_COMMAND_GETFIRMWAREVERSION; + + if (!sendCommandCheckAck(pn532_packetbuffer, 1)) { + return 0; + } + + // read data packet + readdata(pn532_packetbuffer, 13); + + // check some basic stuff + if (0 != memcmp((char *)pn532_packetbuffer, + (char *)pn532response_firmwarevers, 6)) { +#ifdef PN532DEBUG + PN532DEBUGPRINT.println(F("Firmware doesn't match!")); +#endif + return 0; + } + + int offset = 7; + response = pn532_packetbuffer[offset++]; + response <<= 8; + response |= pn532_packetbuffer[offset++]; + response <<= 8; + response |= pn532_packetbuffer[offset++]; + response <<= 8; + response |= pn532_packetbuffer[offset++]; + + return response; +} + +/**************************************************************************/ +/*! + @brief Sends a command and waits a specified period for the ACK + + @param cmd Pointer to the command buffer + @param cmdlen The size of the command in bytes + @param timeout timeout before giving up + + @returns 1 if everything is OK, 0 if timeout occured before an + ACK was recieved +*/ +/**************************************************************************/ +// default timeout of one second +bool Adafruit_PN532::sendCommandCheckAck(uint8_t *cmd, uint8_t cmdlen, + uint16_t timeout) { + + // I2C works without using IRQ pin by polling for RDY byte + // seems to work best with some delays between transactions + uint8_t SLOWDOWN = 0; + if (i2c_dev || spi_dev) // SPI and I2C need 1ms slow for page reads + SLOWDOWN = 1; + + // write the command + writecommand(cmd, cmdlen); + + // I2C TUNING + delay(SLOWDOWN); + + // Wait for chip to say its ready! + if (!waitready(timeout)) { + return false; + } + +#ifdef PN532DEBUG + if (spi_dev == NULL) { + PN532DEBUGPRINT.println(F("IRQ received")); + } +#endif + + // read acknowledgement + if (!readack()) { +#ifdef PN532DEBUG + PN532DEBUGPRINT.println(F("No ACK frame received!")); +#endif + return false; + } + + // I2C TUNING + delay(SLOWDOWN); + + // Wait for chip to say its ready! + if (!waitready(timeout)) { + return false; + } + + return true; // ack'd command +} + +/**************************************************************************/ +/*! + @brief Writes an 8-bit value that sets the state of the PN532's GPIO + pins. + @param pinstate P3 pins state. + + @warning This function is provided exclusively for board testing and + is dangerous since it will throw an error if any pin other + than the ones marked "Can be used as GPIO" are modified! All + pins that can not be used as GPIO should ALWAYS be left high + (value = 1) or the system will become unstable and a HW reset + will be required to recover the PN532. + + pinState[0] = P30 Can be used as GPIO + pinState[1] = P31 Can be used as GPIO + pinState[2] = P32 *** RESERVED (Must be 1!) *** + pinState[3] = P33 Can be used as GPIO + pinState[4] = P34 *** RESERVED (Must be 1!) *** + pinState[5] = P35 Can be used as GPIO + + @return 1 if everything executed properly, 0 for an error +*/ +/**************************************************************************/ +bool Adafruit_PN532::writeGPIO(uint8_t pinstate) { + // uint8_t errorbit; + + // Make sure pinstate does not try to toggle P32 or P34 + pinstate |= (1 << PN532_GPIO_P32) | (1 << PN532_GPIO_P34); + + // Fill command buffer + pn532_packetbuffer[0] = PN532_COMMAND_WRITEGPIO; + pn532_packetbuffer[1] = PN532_GPIO_VALIDATIONBIT | pinstate; // P3 Pins + pn532_packetbuffer[2] = 0x00; // P7 GPIO Pins (not used ... taken by SPI) + +#ifdef PN532DEBUG + PN532DEBUGPRINT.print(F("Writing P3 GPIO: ")); + PN532DEBUGPRINT.println(pn532_packetbuffer[1], HEX); +#endif + + // Send the WRITEGPIO command (0x0E) + if (!sendCommandCheckAck(pn532_packetbuffer, 3)) + return 0x0; + + // Read response packet (00 FF PLEN PLENCHECKSUM D5 CMD+1(0x0F) DATACHECKSUM + // 00) + readdata(pn532_packetbuffer, 8); + +#ifdef PN532DEBUG + PN532DEBUGPRINT.print(F("Received: ")); + PrintHex(pn532_packetbuffer, 8); + PN532DEBUGPRINT.println(); +#endif + + int offset = 6; + return (pn532_packetbuffer[offset] == 0x0F); +} + +/**************************************************************************/ +/*! + Reads the state of the PN532's GPIO pins + + @returns An 8-bit value containing the pin state where: + + pinState[0] = P30 + pinState[1] = P31 + pinState[2] = P32 + pinState[3] = P33 + pinState[4] = P34 + pinState[5] = P35 +*/ +/**************************************************************************/ +uint8_t Adafruit_PN532::readGPIO(void) { + pn532_packetbuffer[0] = PN532_COMMAND_READGPIO; + + // Send the READGPIO command (0x0C) + if (!sendCommandCheckAck(pn532_packetbuffer, 1)) + return 0x0; + + // Read response packet (00 FF PLEN PLENCHECKSUM D5 CMD+1(0x0D) P3 P7 IO1 + // DATACHECKSUM 00) + readdata(pn532_packetbuffer, 11); + + /* READGPIO response should be in the following format: + + byte Description + ------------- ------------------------------------------ + b0..5 Frame header and preamble (with I2C there is an extra + 0x00) b6 P3 GPIO Pins b7 P7 GPIO Pins (not used + ... taken by SPI) b8 Interface Mode Pins (not used ... bus + select pins) b9..10 checksum */ + + int p3offset = 7; + +#ifdef PN532DEBUG + PN532DEBUGPRINT.print(F("Received: ")); + PrintHex(pn532_packetbuffer, 11); + PN532DEBUGPRINT.println(); + PN532DEBUGPRINT.print(F("P3 GPIO: 0x")); + PN532DEBUGPRINT.println(pn532_packetbuffer[p3offset], HEX); + PN532DEBUGPRINT.print(F("P7 GPIO: 0x")); + PN532DEBUGPRINT.println(pn532_packetbuffer[p3offset + 1], HEX); + PN532DEBUGPRINT.print(F("IO GPIO: 0x")); + PN532DEBUGPRINT.println(pn532_packetbuffer[p3offset + 2], HEX); + // Note: You can use the IO GPIO value to detect the serial bus being used + switch (pn532_packetbuffer[p3offset + 2]) { + case 0x00: // Using UART + PN532DEBUGPRINT.println(F("Using UART (IO = 0x00)")); + break; + case 0x01: // Using I2C + PN532DEBUGPRINT.println(F("Using I2C (IO = 0x01)")); + break; + case 0x02: // Using SPI + PN532DEBUGPRINT.println(F("Using SPI (IO = 0x02)")); + break; + } +#endif + + return pn532_packetbuffer[p3offset]; +} + +/**************************************************************************/ +/*! + @brief Configures the SAM (Secure Access Module) + @return true on success, false otherwise. +*/ +/**************************************************************************/ +bool Adafruit_PN532::SAMConfig(void) { + pn532_packetbuffer[0] = PN532_COMMAND_SAMCONFIGURATION; + pn532_packetbuffer[1] = 0x01; // normal mode; + pn532_packetbuffer[2] = 0x14; // timeout 50ms * 20 = 1 second + pn532_packetbuffer[3] = 0x01; // use IRQ pin! + + if (!sendCommandCheckAck(pn532_packetbuffer, 4)) + return false; + + // read data packet + readdata(pn532_packetbuffer, 9); + + int offset = 6; + return (pn532_packetbuffer[offset] == 0x15); +} + +/**************************************************************************/ +/*! + Sets the MxRtyPassiveActivation byte of the RFConfiguration register + + @param maxRetries 0xFF to wait forever, 0x00..0xFE to timeout + after mxRetries + + @returns 1 if everything executed properly, 0 for an error +*/ +/**************************************************************************/ +bool Adafruit_PN532::setPassiveActivationRetries(uint8_t maxRetries) { + pn532_packetbuffer[0] = PN532_COMMAND_RFCONFIGURATION; + pn532_packetbuffer[1] = 5; // Config item 5 (MaxRetries) + pn532_packetbuffer[2] = 0xFF; // MxRtyATR (default = 0xFF) + pn532_packetbuffer[3] = 0x01; // MxRtyPSL (default = 0x01) + pn532_packetbuffer[4] = maxRetries; + +#ifdef MIFAREDEBUG + PN532DEBUGPRINT.print(F("Setting MxRtyPassiveActivation to ")); + PN532DEBUGPRINT.print(maxRetries, DEC); + PN532DEBUGPRINT.println(F(" ")); +#endif + + if (!sendCommandCheckAck(pn532_packetbuffer, 5)) + return 0x0; // no ACK + + return 1; +} + +/***** ISO14443A Commands ******/ + +/**************************************************************************/ +/*! + @brief Waits for an ISO14443A target to enter the field and reads + its ID. + + @param cardbaudrate Baud rate of the card + @param uid Pointer to the array that will be populated + with the card's UID (up to 7 bytes) + @param uidLength Pointer to the variable that will hold the + length of the card's UID. + @param timeout Timeout in milliseconds. + + @return 1 if everything executed properly, 0 for an error +*/ +/**************************************************************************/ +bool Adafruit_PN532::readPassiveTargetID(uint8_t cardbaudrate, uint8_t *uid, + uint8_t *uidLength, uint16_t timeout) { + pn532_packetbuffer[0] = PN532_COMMAND_INLISTPASSIVETARGET; + pn532_packetbuffer[1] = + 1; // max 1 cards at once (we can set this to 2 later) + pn532_packetbuffer[2] = cardbaudrate; + + if (!sendCommandCheckAck(pn532_packetbuffer, 3, timeout)) { +#ifdef PN532DEBUG + PN532DEBUGPRINT.println(F("No card(s) read")); +#endif + return 0x0; // no cards read + } + + return readDetectedPassiveTargetID(uid, uidLength); +} + +/**************************************************************************/ +/*! + @brief Put the reader in detection mode, non blocking so interrupts + must be enabled. + @param cardbaudrate Baud rate of the card + @return 1 if everything executed properly, 0 for an error +*/ +/**************************************************************************/ +bool Adafruit_PN532::startPassiveTargetIDDetection(uint8_t cardbaudrate) { + pn532_packetbuffer[0] = PN532_COMMAND_INLISTPASSIVETARGET; + pn532_packetbuffer[1] = + 1; // max 1 cards at once (we can set this to 2 later) + pn532_packetbuffer[2] = cardbaudrate; + + return sendCommandCheckAck(pn532_packetbuffer, 3); +} + +/**************************************************************************/ +/*! + Reads the ID of the passive target the reader has deteceted. + + @param uid Pointer to the array that will be populated + with the card's UID (up to 7 bytes) + @param uidLength Pointer to the variable that will hold the + length of the card's UID. + + @returns 1 if everything executed properly, 0 for an error +*/ +/**************************************************************************/ +bool Adafruit_PN532::readDetectedPassiveTargetID(uint8_t *uid, + uint8_t *uidLength) { + // read data packet + readdata(pn532_packetbuffer, 20); + // check some basic stuff + + /* ISO14443A card response should be in the following format: + + byte Description + ------------- ------------------------------------------ + b0..6 Frame header and preamble + b7 Tags Found + b8 Tag Number (only one used in this example) + b9..10 SENS_RES + b11 SEL_RES + b12 NFCID Length + b13..NFCIDLen NFCID */ + +#ifdef MIFAREDEBUG + PN532DEBUGPRINT.print(F("Found ")); + PN532DEBUGPRINT.print(pn532_packetbuffer[7], DEC); + PN532DEBUGPRINT.println(F(" tags")); +#endif + if (pn532_packetbuffer[7] != 1) + return 0; + + uint16_t sens_res = pn532_packetbuffer[9]; + sens_res <<= 8; + sens_res |= pn532_packetbuffer[10]; +#ifdef MIFAREDEBUG + PN532DEBUGPRINT.print(F("ATQA: 0x")); + PN532DEBUGPRINT.println(sens_res, HEX); + PN532DEBUGPRINT.print(F("SAK: 0x")); + PN532DEBUGPRINT.println(pn532_packetbuffer[11], HEX); +#endif + + /* Card appears to be Mifare Classic */ + *uidLength = pn532_packetbuffer[12]; +#ifdef MIFAREDEBUG + PN532DEBUGPRINT.print(F("UID:")); +#endif + for (uint8_t i = 0; i < pn532_packetbuffer[12]; i++) { + uid[i] = pn532_packetbuffer[13 + i]; +#ifdef MIFAREDEBUG + PN532DEBUGPRINT.print(F(" 0x")); + PN532DEBUGPRINT.print(uid[i], HEX); +#endif + } +#ifdef MIFAREDEBUG + PN532DEBUGPRINT.println(); +#endif + + return 1; +} + +/**************************************************************************/ +/*! + @brief Exchanges an APDU with the currently inlisted peer + + @param send Pointer to data to send + @param sendLength Length of the data to send + @param response Pointer to response data + @param responseLength Pointer to the response data length + @return true on success, false otherwise. +*/ +/**************************************************************************/ +bool Adafruit_PN532::inDataExchange(uint8_t *send, uint8_t sendLength, + uint8_t *response, + uint8_t *responseLength) { + if (sendLength > PN532_PACKBUFFSIZ - 2) { +#ifdef PN532DEBUG + PN532DEBUGPRINT.println(F("APDU length too long for packet buffer")); +#endif + return false; + } + uint8_t i; + + pn532_packetbuffer[0] = 0x40; // PN532_COMMAND_INDATAEXCHANGE; + pn532_packetbuffer[1] = _inListedTag; + for (i = 0; i < sendLength; ++i) { + pn532_packetbuffer[i + 2] = send[i]; + } + + if (!sendCommandCheckAck(pn532_packetbuffer, sendLength + 2, 1000)) { +#ifdef PN532DEBUG + PN532DEBUGPRINT.println(F("Could not send APDU")); +#endif + return false; + } + + if (!waitready(1000)) { +#ifdef PN532DEBUG + PN532DEBUGPRINT.println(F("Response never received for APDU...")); +#endif + return false; + } + + readdata(pn532_packetbuffer, sizeof(pn532_packetbuffer)); + + if (pn532_packetbuffer[0] == 0 && pn532_packetbuffer[1] == 0 && + pn532_packetbuffer[2] == 0xff) { + uint8_t length = pn532_packetbuffer[3]; + if (pn532_packetbuffer[4] != (uint8_t)(~length + 1)) { +#ifdef PN532DEBUG + PN532DEBUGPRINT.println(F("Length check invalid")); + PN532DEBUGPRINT.println(length, HEX); + PN532DEBUGPRINT.println((~length) + 1, HEX); +#endif + return false; + } + if (pn532_packetbuffer[5] == PN532_PN532TOHOST && + pn532_packetbuffer[6] == PN532_RESPONSE_INDATAEXCHANGE) { + if ((pn532_packetbuffer[7] & 0x3f) != 0) { +#ifdef PN532DEBUG + PN532DEBUGPRINT.println(F("Status code indicates an error")); +#endif + return false; + } + + length -= 3; + + if (length > *responseLength) { + length = *responseLength; // silent truncation... + } + + for (i = 0; i < length; ++i) { + response[i] = pn532_packetbuffer[8 + i]; + } + *responseLength = length; + + return true; + } else { + PN532DEBUGPRINT.print(F("Don't know how to handle this command: ")); + PN532DEBUGPRINT.println(pn532_packetbuffer[6], HEX); + return false; + } + } else { + PN532DEBUGPRINT.println(F("Preamble missing")); + return false; + } +} + +/**************************************************************************/ +/*! + @brief 'InLists' a passive target. PN532 acting as reader/initiator, + peer acting as card/responder. + @return true on success, false otherwise. +*/ +/**************************************************************************/ +bool Adafruit_PN532::inListPassiveTarget() { + pn532_packetbuffer[0] = PN532_COMMAND_INLISTPASSIVETARGET; + pn532_packetbuffer[1] = 1; + pn532_packetbuffer[2] = 0; + +#ifdef PN532DEBUG + PN532DEBUGPRINT.print(F("About to inList passive target")); +#endif + + if (!sendCommandCheckAck(pn532_packetbuffer, 3, 1000)) { +#ifdef PN532DEBUG + PN532DEBUGPRINT.println(F("Could not send inlist message")); +#endif + return false; + } + + if (!waitready(30000)) { + return false; + } + + readdata(pn532_packetbuffer, sizeof(pn532_packetbuffer)); + + if (pn532_packetbuffer[0] == 0 && pn532_packetbuffer[1] == 0 && + pn532_packetbuffer[2] == 0xff) { + uint8_t length = pn532_packetbuffer[3]; + if (pn532_packetbuffer[4] != (uint8_t)(~length + 1)) { +#ifdef PN532DEBUG + PN532DEBUGPRINT.println(F("Length check invalid")); + PN532DEBUGPRINT.println(length, HEX); + PN532DEBUGPRINT.println((~length) + 1, HEX); +#endif + return false; + } + if (pn532_packetbuffer[5] == PN532_PN532TOHOST && + pn532_packetbuffer[6] == PN532_RESPONSE_INLISTPASSIVETARGET) { + if (pn532_packetbuffer[7] != 1) { +#ifdef PN532DEBUG + PN532DEBUGPRINT.println( + F("Unhandled number of targets inlisted")); +#endif + PN532DEBUGPRINT.println(F("Number of tags inlisted:")); + PN532DEBUGPRINT.println(pn532_packetbuffer[7]); + return false; + } + + _inListedTag = pn532_packetbuffer[8]; + PN532DEBUGPRINT.print(F("Tag number: ")); + PN532DEBUGPRINT.println(_inListedTag); + + return true; + } else { +#ifdef PN532DEBUG + PN532DEBUGPRINT.print( + F("Unexpected response to inlist passive host")); +#endif + return false; + } + } else { +#ifdef PN532DEBUG + PN532DEBUGPRINT.println(F("Preamble missing")); +#endif + return false; + } + + return true; +} + +/***** Mifare Classic Functions ******/ + +/**************************************************************************/ +/*! + @brief Indicates whether the specified block number is the first block + in the sector (block 0 relative to the current sector) + @param uiBlock Block number to test. + @return true if first block, false otherwise. +*/ +/**************************************************************************/ +bool Adafruit_PN532::mifareclassic_IsFirstBlock(uint32_t uiBlock) { + // Test if we are in the small or big sectors + if (uiBlock < 128) + return ((uiBlock) % 4 == 0); + else + return ((uiBlock) % 16 == 0); +} + +/**************************************************************************/ +/*! + @brief Indicates whether the specified block number is the sector + trailer. + @param uiBlock Block number to test. + @return true if sector trailer, false otherwise. +*/ +/**************************************************************************/ +bool Adafruit_PN532::mifareclassic_IsTrailerBlock(uint32_t uiBlock) { + // Test if we are in the small or big sectors + if (uiBlock < 128) + return ((uiBlock + 1) % 4 == 0); + else + return ((uiBlock + 1) % 16 == 0); +} + +/**************************************************************************/ +/*! + Tries to authenticate a block of memory on a MIFARE card using the + INDATAEXCHANGE command. See section 7.3.8 of the PN532 User Manual + for more information on sending MIFARE and other commands. + + @param uid Pointer to a byte array containing the card UID + @param uidLen The length (in bytes) of the card's UID (Should + be 4 for MIFARE Classic) + @param blockNumber The block number to authenticate. (0..63 for + 1KB cards, and 0..255 for 4KB cards). + @param keyNumber Which key type to use during authentication + (0 = MIFARE_CMD_AUTH_A, 1 = MIFARE_CMD_AUTH_B) + @param keyData Pointer to a byte array containing the 6 byte + key value + + @returns 1 if everything executed properly, 0 for an error +*/ +/**************************************************************************/ +uint8_t Adafruit_PN532::mifareclassic_AuthenticateBlock(uint8_t *uid, + uint8_t uidLen, + uint32_t blockNumber, + uint8_t keyNumber, + uint8_t *keyData) { + // uint8_t len; + uint8_t i; + + // Hang on to the key and uid data + memcpy(_key, keyData, 6); + memcpy(_uid, uid, uidLen); + _uidLen = uidLen; + +#ifdef MIFAREDEBUG + PN532DEBUGPRINT.print(F("Trying to authenticate card ")); + Adafruit_PN532::PrintHex(_uid, _uidLen); + PN532DEBUGPRINT.print(F("Using authentication KEY ")); + PN532DEBUGPRINT.print(keyNumber ? 'B' : 'A'); + PN532DEBUGPRINT.print(F(": ")); + Adafruit_PN532::PrintHex(_key, 6); +#endif + + // Prepare the authentication command // + pn532_packetbuffer[0] = + PN532_COMMAND_INDATAEXCHANGE; /* Data Exchange Header */ + pn532_packetbuffer[1] = 1; /* Max card numbers */ + pn532_packetbuffer[2] = (keyNumber) ? MIFARE_CMD_AUTH_B : MIFARE_CMD_AUTH_A; + pn532_packetbuffer[3] = + blockNumber; /* Block Number (1K = 0..63, 4K = 0..255 */ + memcpy(pn532_packetbuffer + 4, _key, 6); + for (i = 0; i < _uidLen; i++) { + pn532_packetbuffer[10 + i] = _uid[i]; /* 4 byte card ID */ + } + + if (!sendCommandCheckAck(pn532_packetbuffer, 10 + _uidLen)) + return 0; + + // Read the response packet + readdata(pn532_packetbuffer, 12); + + // check if the response is valid and we are authenticated??? + // for an auth success it should be bytes 5-7: 0xD5 0x41 0x00 + // Mifare auth error is technically byte 7: 0x14 but anything other and 0x00 + // is not good + if (pn532_packetbuffer[7] != 0x00) { +#ifdef PN532DEBUG + PN532DEBUGPRINT.print(F("Authentification failed: ")); + Adafruit_PN532::PrintHexChar(pn532_packetbuffer, 12); +#endif + return 0; + } + + return 1; +} + +/**************************************************************************/ +/*! + Tries to read an entire 16-byte data block at the specified block + address. + + @param blockNumber The block number to authenticate. (0..63 for + 1KB cards, and 0..255 for 4KB cards). + @param data Pointer to the byte array that will hold the + retrieved data (if any) + + @returns 1 if everything executed properly, 0 for an error +*/ +/**************************************************************************/ +uint8_t Adafruit_PN532::mifareclassic_ReadDataBlock(uint8_t blockNumber, + uint8_t *data) { +#ifdef MIFAREDEBUG + PN532DEBUGPRINT.print(F("Trying to read 16 bytes from block ")); + PN532DEBUGPRINT.println(blockNumber); +#endif + + /* Prepare the command */ + pn532_packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE; + pn532_packetbuffer[1] = 1; /* Card number */ + pn532_packetbuffer[2] = MIFARE_CMD_READ; /* Mifare Read command = 0x30 */ + pn532_packetbuffer[3] = + blockNumber; /* Block Number (0..63 for 1K, 0..255 for 4K) */ + + /* Send the command */ + if (!sendCommandCheckAck(pn532_packetbuffer, 4)) { +#ifdef MIFAREDEBUG + PN532DEBUGPRINT.println(F("Failed to receive ACK for read command")); +#endif + return 0; + } + + /* Read the response packet */ + readdata(pn532_packetbuffer, 26); + + /* If byte 8 isn't 0x00 we probably have an error */ + if (pn532_packetbuffer[7] != 0x00) { +#ifdef MIFAREDEBUG + PN532DEBUGPRINT.println(F("Unexpected response")); + Adafruit_PN532::PrintHexChar(pn532_packetbuffer, 26); +#endif + return 0; + } + + /* Copy the 16 data bytes to the output buffer */ + /* Block content starts at byte 9 of a valid response */ + memcpy(data, pn532_packetbuffer + 8, 16); + +/* Display data for debug if requested */ +#ifdef MIFAREDEBUG + PN532DEBUGPRINT.print(F("Block ")); + PN532DEBUGPRINT.println(blockNumber); + Adafruit_PN532::PrintHexChar(data, 16); +#endif + + return 1; +} + +/**************************************************************************/ +/*! + Tries to write an entire 16-byte data block at the specified block + address. + + @param blockNumber The block number to authenticate. (0..63 for + 1KB cards, and 0..255 for 4KB cards). + @param data The byte array that contains the data to write. + + @returns 1 if everything executed properly, 0 for an error +*/ +/**************************************************************************/ +uint8_t Adafruit_PN532::mifareclassic_WriteDataBlock(uint8_t blockNumber, + uint8_t *data) { +#ifdef MIFAREDEBUG + PN532DEBUGPRINT.print(F("Trying to write 16 bytes to block ")); + PN532DEBUGPRINT.println(blockNumber); +#endif + + /* Prepare the first command */ + pn532_packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE; + pn532_packetbuffer[1] = 1; /* Card number */ + pn532_packetbuffer[2] = MIFARE_CMD_WRITE; /* Mifare Write command = 0xA0 */ + pn532_packetbuffer[3] = + blockNumber; /* Block Number (0..63 for 1K, 0..255 for 4K) */ + memcpy(pn532_packetbuffer + 4, data, 16); /* Data Payload */ + + /* Send the command */ + if (!sendCommandCheckAck(pn532_packetbuffer, 20)) { +#ifdef MIFAREDEBUG + PN532DEBUGPRINT.println(F("Failed to receive ACK for write command")); +#endif + return 0; + } + delay(10); + + /* Read the response packet */ + readdata(pn532_packetbuffer, 26); + + return 1; +} + +/**************************************************************************/ +/*! + Formats a Mifare Classic card to store NDEF Records + + @returns 1 if everything executed properly, 0 for an error +*/ +/**************************************************************************/ +uint8_t Adafruit_PN532::mifareclassic_FormatNDEF(void) { + uint8_t sectorbuffer1[16] = {0x14, 0x01, 0x03, 0xE1, 0x03, 0xE1, + 0x03, 0xE1, 0x03, 0xE1, 0x03, 0xE1, + 0x03, 0xE1, 0x03, 0xE1}; + uint8_t sectorbuffer2[16] = {0x03, 0xE1, 0x03, 0xE1, 0x03, 0xE1, + 0x03, 0xE1, 0x03, 0xE1, 0x03, 0xE1, + 0x03, 0xE1, 0x03, 0xE1}; + uint8_t sectorbuffer3[16] = {0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, + 0x78, 0x77, 0x88, 0xC1, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF}; + + // Note 0xA0 0xA1 0xA2 0xA3 0xA4 0xA5 must be used for key A + // for the MAD sector in NDEF records (sector 0) + + // Write block 1 and 2 to the card + if (!(mifareclassic_WriteDataBlock(1, sectorbuffer1))) + return 0; + if (!(mifareclassic_WriteDataBlock(2, sectorbuffer2))) + return 0; + // Write key A and access rights card + if (!(mifareclassic_WriteDataBlock(3, sectorbuffer3))) + return 0; + + // Seems that everything was OK (?!) + return 1; +} + +/**************************************************************************/ +/*! + Writes an NDEF URI Record to the specified sector (1..15) + + Note that this function assumes that the Mifare Classic card is + already formatted to work as an "NFC Forum Tag" and uses a MAD1 + file system. You can use the NXP TagWriter app on Android to + properly format cards for this. + + @param sectorNumber The sector that the URI record should be written + to (can be 1..15 for a 1K card) + @param uriIdentifier The uri identifier code (0 = none, 0x01 = + "http://www.", etc.) + @param url The uri text to write (max 38 characters). + + @returns 1 if everything executed properly, 0 for an error +*/ +/**************************************************************************/ +uint8_t Adafruit_PN532::mifareclassic_WriteNDEFURI(uint8_t sectorNumber, + uint8_t uriIdentifier, + const char *url) { + // Figure out how long the string is + uint8_t len = strlen(url); + + // Make sure we're within a 1K limit for the sector number + if ((sectorNumber < 1) || (sectorNumber > 15)) + return 0; + + // Make sure the URI payload is between 1 and 38 chars + if ((len < 1) || (len > 38)) + return 0; + + // Note 0xD3 0xF7 0xD3 0xF7 0xD3 0xF7 must be used for key A + // in NDEF records + + // Setup the sector buffer (w/pre-formatted TLV wrapper and NDEF message) + uint8_t sectorbuffer1[16] = {0x00, + 0x00, + 0x03, + (uint8_t)(len + 5), + 0xD1, + 0x01, + (uint8_t)(len + 1), + 0x55, + uriIdentifier, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00}; + uint8_t sectorbuffer2[16] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}; + uint8_t sectorbuffer3[16] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}; + uint8_t sectorbuffer4[16] = {0xD3, 0xF7, 0xD3, 0xF7, 0xD3, 0xF7, + 0x7F, 0x07, 0x88, 0x40, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF}; + if (len <= 6) { + // Unlikely we'll get a url this short, but why not ... + memcpy(sectorbuffer1 + 9, url, len); + sectorbuffer1[len + 9] = 0xFE; + } else if (len == 7) { + // 0xFE needs to be wrapped around to next block + memcpy(sectorbuffer1 + 9, url, len); + sectorbuffer2[0] = 0xFE; + } else if ((len > 7) && (len <= 22)) { + // Url fits in two blocks + memcpy(sectorbuffer1 + 9, url, 7); + memcpy(sectorbuffer2, url + 7, len - 7); + sectorbuffer2[len - 7] = 0xFE; + } else if (len == 23) { + // 0xFE needs to be wrapped around to final block + memcpy(sectorbuffer1 + 9, url, 7); + memcpy(sectorbuffer2, url + 7, len - 7); + sectorbuffer3[0] = 0xFE; + } else { + // Url fits in three blocks + memcpy(sectorbuffer1 + 9, url, 7); + memcpy(sectorbuffer2, url + 7, 16); + memcpy(sectorbuffer3, url + 23, len - 24); + sectorbuffer3[len - 22] = 0xFE; + } + + // Now write all three blocks back to the card + if (!(mifareclassic_WriteDataBlock(sectorNumber * 4, sectorbuffer1))) + return 0; + if (!(mifareclassic_WriteDataBlock((sectorNumber * 4) + 1, sectorbuffer2))) + return 0; + if (!(mifareclassic_WriteDataBlock((sectorNumber * 4) + 2, sectorbuffer3))) + return 0; + if (!(mifareclassic_WriteDataBlock((sectorNumber * 4) + 3, sectorbuffer4))) + return 0; + + // Seems that everything was OK (?!) + return 1; +} + +/***** Mifare Ultralight Functions ******/ + +/**************************************************************************/ +/*! + @brief Tries to read an entire 4-byte page at the specified address. + + @param page The page number (0..63 in most cases) + @param buffer Pointer to the byte array that will hold the + retrieved data (if any) + @return 1 on success, 0 on error. +*/ +/**************************************************************************/ +uint8_t Adafruit_PN532::mifareultralight_ReadPage(uint8_t page, + uint8_t *buffer) { + if (page >= 64) { +#ifdef MIFAREDEBUG + PN532DEBUGPRINT.println(F("Page value out of range")); +#endif + return 0; + } + +#ifdef MIFAREDEBUG + PN532DEBUGPRINT.print(F("Reading page ")); + PN532DEBUGPRINT.println(page); +#endif + + /* Prepare the command */ + pn532_packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE; + pn532_packetbuffer[1] = 1; /* Card number */ + pn532_packetbuffer[2] = MIFARE_CMD_READ; /* Mifare Read command = 0x30 */ + pn532_packetbuffer[3] = page; /* Page Number (0..63 in most cases) */ + + /* Send the command */ + if (!sendCommandCheckAck(pn532_packetbuffer, 4)) { +#ifdef MIFAREDEBUG + PN532DEBUGPRINT.println(F("Failed to receive ACK for write command")); +#endif + return 0; + } + + /* Read the response packet */ + readdata(pn532_packetbuffer, 26); +#ifdef MIFAREDEBUG + PN532DEBUGPRINT.println(F("Received: ")); + Adafruit_PN532::PrintHexChar(pn532_packetbuffer, 26); +#endif + + /* If byte 8 isn't 0x00 we probably have an error */ + if (pn532_packetbuffer[7] == 0x00) { + /* Copy the 4 data bytes to the output buffer */ + /* Block content starts at byte 9 of a valid response */ + /* Note that the command actually reads 16 byte or 4 */ + /* pages at a time ... we simply discard the last 12 */ + /* bytes */ + memcpy(buffer, pn532_packetbuffer + 8, 4); + } else { +#ifdef MIFAREDEBUG + PN532DEBUGPRINT.println(F("Unexpected response reading block: ")); + Adafruit_PN532::PrintHexChar(pn532_packetbuffer, 26); +#endif + return 0; + } + +/* Display data for debug if requested */ +#ifdef MIFAREDEBUG + PN532DEBUGPRINT.print(F("Page ")); + PN532DEBUGPRINT.print(page); + PN532DEBUGPRINT.println(F(":")); + Adafruit_PN532::PrintHexChar(buffer, 4); +#endif + + // Return OK signal + return 1; +} + +/**************************************************************************/ +/*! + Tries to write an entire 4-byte page at the specified block + address. + + @param page The page number to write. (0..63 for most cases) + @param data The byte array that contains the data to write. + Should be exactly 4 bytes long. + + @returns 1 if everything executed properly, 0 for an error +*/ +/**************************************************************************/ +uint8_t Adafruit_PN532::mifareultralight_WritePage(uint8_t page, + uint8_t *data) { + + if (page >= 64) { +#ifdef MIFAREDEBUG + PN532DEBUGPRINT.println(F("Page value out of range")); +#endif + // Return Failed Signal + return 0; + } + +#ifdef MIFAREDEBUG + PN532DEBUGPRINT.print(F("Trying to write 4 byte page")); + PN532DEBUGPRINT.println(page); +#endif + + /* Prepare the first command */ + pn532_packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE; + pn532_packetbuffer[1] = 1; /* Card number */ + pn532_packetbuffer[2] = + MIFARE_ULTRALIGHT_CMD_WRITE; /* Mifare Ultralight Write command = 0xA2 + */ + pn532_packetbuffer[3] = page; /* Page Number (0..63 for most cases) */ + memcpy(pn532_packetbuffer + 4, data, 4); /* Data Payload */ + + /* Send the command */ + if (!sendCommandCheckAck(pn532_packetbuffer, 8)) { +#ifdef MIFAREDEBUG + PN532DEBUGPRINT.println(F("Failed to receive ACK for write command")); +#endif + + // Return Failed Signal + return 0; + } + delay(10); + + /* Read the response packet */ + readdata(pn532_packetbuffer, 26); + + // Return OK Signal + return 1; +} + +/***** NTAG2xx Functions ******/ + +/**************************************************************************/ +/*! + @brief Tries to read an entire 4-byte page at the specified address. + + @param page The page number (0..63 in most cases) + @param buffer Pointer to the byte array that will hold the + retrieved data (if any) + @return 1 on success, 0 on error. +*/ +/**************************************************************************/ +uint8_t Adafruit_PN532::ntag2xx_ReadPage(uint8_t page, uint8_t *buffer) { + // TAG Type PAGES USER START USER STOP + // -------- ----- ---------- --------- + // NTAG 203 42 4 39 + // NTAG 213 45 4 39 + // NTAG 215 135 4 129 + // NTAG 216 231 4 225 + + if (page >= 231) { +#ifdef MIFAREDEBUG + PN532DEBUGPRINT.println(F("Page value out of range")); +#endif + return 0; + } + +#ifdef MIFAREDEBUG + PN532DEBUGPRINT.print(F("Reading page ")); + PN532DEBUGPRINT.println(page); +#endif + + /* Prepare the command */ + pn532_packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE; + pn532_packetbuffer[1] = 1; /* Card number */ + pn532_packetbuffer[2] = MIFARE_CMD_READ; /* Mifare Read command = 0x30 */ + pn532_packetbuffer[3] = page; /* Page Number (0..63 in most cases) */ + + /* Send the command */ + if (!sendCommandCheckAck(pn532_packetbuffer, 4)) { +#ifdef MIFAREDEBUG + PN532DEBUGPRINT.println(F("Failed to receive ACK for write command")); +#endif + return 0; + } + + /* Read the response packet */ + readdata(pn532_packetbuffer, 26); +#ifdef MIFAREDEBUG + PN532DEBUGPRINT.println(F("Received: ")); + Adafruit_PN532::PrintHexChar(pn532_packetbuffer, 26); +#endif + + /* If byte 8 isn't 0x00 we probably have an error */ + if (pn532_packetbuffer[7] == 0x00) { + /* Copy the 4 data bytes to the output buffer */ + /* Block content starts at byte 9 of a valid response */ + /* Note that the command actually reads 16 byte or 4 */ + /* pages at a time ... we simply discard the last 12 */ + /* bytes */ + memcpy(buffer, pn532_packetbuffer + 8, 4); + } else { +#ifdef MIFAREDEBUG + PN532DEBUGPRINT.println(F("Unexpected response reading block: ")); + Adafruit_PN532::PrintHexChar(pn532_packetbuffer, 26); +#endif + return 0; + } + +/* Display data for debug if requested */ +#ifdef MIFAREDEBUG + PN532DEBUGPRINT.print(F("Page ")); + PN532DEBUGPRINT.print(page); + PN532DEBUGPRINT.println(F(":")); + Adafruit_PN532::PrintHexChar(buffer, 4); +#endif + + // Return OK signal + return 1; +} + +/**************************************************************************/ +/*! + Tries to write an entire 4-byte page at the specified block + address. + + @param page The page number to write. (0..63 for most cases) + @param data The byte array that contains the data to write. + Should be exactly 4 bytes long. + + @returns 1 if everything executed properly, 0 for an error +*/ +/**************************************************************************/ +uint8_t Adafruit_PN532::ntag2xx_WritePage(uint8_t page, uint8_t *data) { + // TAG Type PAGES USER START USER STOP + // -------- ----- ---------- --------- + // NTAG 203 42 4 39 + // NTAG 213 45 4 39 + // NTAG 215 135 4 129 + // NTAG 216 231 4 225 + + if ((page < 4) || (page > 225)) { +#ifdef MIFAREDEBUG + PN532DEBUGPRINT.println(F("Page value out of range")); +#endif + // Return Failed Signal + return 0; + } + +#ifdef MIFAREDEBUG + PN532DEBUGPRINT.print(F("Trying to write 4 byte page")); + PN532DEBUGPRINT.println(page); +#endif + + /* Prepare the first command */ + pn532_packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE; + pn532_packetbuffer[1] = 1; /* Card number */ + pn532_packetbuffer[2] = + MIFARE_ULTRALIGHT_CMD_WRITE; /* Mifare Ultralight Write command = 0xA2 + */ + pn532_packetbuffer[3] = page; /* Page Number (0..63 for most cases) */ + memcpy(pn532_packetbuffer + 4, data, 4); /* Data Payload */ + + /* Send the command */ + if (!sendCommandCheckAck(pn532_packetbuffer, 8)) { +#ifdef MIFAREDEBUG + PN532DEBUGPRINT.println(F("Failed to receive ACK for write command")); +#endif + + // Return Failed Signal + return 0; + } + delay(10); + + /* Read the response packet */ + readdata(pn532_packetbuffer, 26); + + // Return OK Signal + return 1; +} + +/**************************************************************************/ +/*! + Writes an NDEF URI Record starting at the specified page (4..nn) + + Note that this function assumes that the NTAG2xx card is + already formatted to work as an "NFC Forum Tag". + + @param uriIdentifier The uri identifier code (0 = none, 0x01 = + "http://www.", etc.) + @param url The uri text to write (null-terminated string). + @param dataLen The size of the data area for overflow checks. + + @returns 1 if everything executed properly, 0 for an error +*/ +/**************************************************************************/ +uint8_t Adafruit_PN532::ntag2xx_WriteNDEFURI(uint8_t uriIdentifier, char *url, + uint8_t dataLen) { + uint8_t pageBuffer[4] = {0, 0, 0, 0}; + + // Remove NDEF record overhead from the URI data (pageHeader below) + uint8_t wrapperSize = 12; + + // Figure out how long the string is + uint8_t len = strlen(url); + + // Make sure the URI payload will fit in dataLen (include 0xFE trailer) + if ((len < 1) || (len + 1 > (dataLen - wrapperSize))) + return 0; + + // Setup the record header + // See NFCForum-TS-Type-2-Tag_1.1.pdf for details + uint8_t pageHeader[12] = { + /* NDEF Lock Control TLV (must be first and always present) */ + 0x01, /* Tag Field (0x01 = Lock Control TLV) */ + 0x03, /* Payload Length (always 3) */ + 0xA0, /* The position inside the tag of the lock bytes (upper 4 = page + address, lower 4 = byte offset) */ + 0x10, /* Size in bits of the lock area */ + 0x44, /* Size in bytes of a page and the number of bytes each lock bit + can lock (4 bit + 4 bits) */ + /* NDEF Message TLV - URI Record */ + 0x03, /* Tag Field (0x03 = NDEF Message) */ + (uint8_t)(len + 5), /* Payload Length (not including 0xFE trailer) */ + 0xD1, /* NDEF Record Header (TNF=0x1:Well known record + SR + ME + MB) + */ + 0x01, /* Type Length for the record type indicator */ + (uint8_t)(len + 1), /* Payload len */ + 0x55, /* Record Type Indicator (0x55 or 'U' = URI Record) */ + uriIdentifier /* URI Prefix (ex. 0x01 = "http://www.") */ + }; + + // Write 12 byte header (three pages of data starting at page 4) + memcpy(pageBuffer, pageHeader, 4); + if (!(ntag2xx_WritePage(4, pageBuffer))) + return 0; + memcpy(pageBuffer, pageHeader + 4, 4); + if (!(ntag2xx_WritePage(5, pageBuffer))) + return 0; + memcpy(pageBuffer, pageHeader + 8, 4); + if (!(ntag2xx_WritePage(6, pageBuffer))) + return 0; + + // Write URI (starting at page 7) + uint8_t currentPage = 7; + char *urlcopy = url; + while (len) { + if (len < 4) { + memset(pageBuffer, 0, 4); + memcpy(pageBuffer, urlcopy, len); + pageBuffer[len] = 0xFE; // NDEF record footer + if (!(ntag2xx_WritePage(currentPage, pageBuffer))) + return 0; + // DONE! + return 1; + } else if (len == 4) { + memcpy(pageBuffer, urlcopy, len); + if (!(ntag2xx_WritePage(currentPage, pageBuffer))) + return 0; + memset(pageBuffer, 0, 4); + pageBuffer[0] = 0xFE; // NDEF record footer + currentPage++; + if (!(ntag2xx_WritePage(currentPage, pageBuffer))) + return 0; + // DONE! + return 1; + } else { + // More than one page of data left + memcpy(pageBuffer, urlcopy, 4); + if (!(ntag2xx_WritePage(currentPage, pageBuffer))) + return 0; + currentPage++; + urlcopy += 4; + len -= 4; + } + } + + // Seems that everything was OK (?!) + return 1; +} + +/************** high level communication functions (handles both I2C and SPI) */ + +/**************************************************************************/ +/*! + @brief Tries to read the SPI or I2C ACK signal +*/ +/**************************************************************************/ +bool Adafruit_PN532::readack() { + uint8_t ackbuff[6]; + + if (spi_dev) { + uint8_t cmd = PN532_SPI_DATAREAD; + spi_dev->write_then_read(&cmd, 1, ackbuff, 6); + } else if (i2c_dev || ser_dev) { + readdata(ackbuff, 6); + } + + return (0 == memcmp((char *)ackbuff, (char *)pn532ack, 6)); +} + +/**************************************************************************/ +/*! + @brief Return true if the PN532 is ready with a response. +*/ +/**************************************************************************/ +bool Adafruit_PN532::isready() { + if (spi_dev) { + // SPI ready check via Status Request + uint8_t cmd = PN532_SPI_STATREAD; + uint8_t reply; + spi_dev->write_then_read(&cmd, 1, &reply, 1); + return reply == PN532_SPI_READY; + } else if (i2c_dev) { + // I2C ready check via reading RDY byte + uint8_t rdy[1]; + i2c_dev->read(rdy, 1); + return rdy[0] == PN532_I2C_READY; + } else if (ser_dev) { + // Serial ready check based on non-zero read buffer + return (ser_dev->available() != 0); + } else if (_irq != -1) { + uint8_t x = digitalRead(_irq); + return x == 0; + } + return false; +} + +/**************************************************************************/ +/*! + @brief Waits until the PN532 is ready. + + @param timeout Timeout before giving up +*/ +/**************************************************************************/ +bool Adafruit_PN532::waitready(uint16_t timeout) { + uint16_t timer = 0; + while (!isready()) { + if (timeout != 0) { + timer += 10; + if (timer > timeout) { +#ifdef PN532DEBUG + PN532DEBUGPRINT.println("TIMEOUT!"); +#endif + return false; + } + } + delay(10); + } + return true; +} + +/**************************************************************************/ +/*! + @brief Reads n bytes of data from the PN532 via SPI or I2C. + + @param buff Pointer to the buffer where data will be written + @param n Number of bytes to be read +*/ +/**************************************************************************/ +void Adafruit_PN532::readdata(uint8_t *buff, uint8_t n) { + if (spi_dev) { + // SPI read + uint8_t cmd = PN532_SPI_DATAREAD; + spi_dev->write_then_read(&cmd, 1, buff, n); + } else if (i2c_dev) { + // I2C read + uint8_t rbuff[n + 1]; // +1 for leading RDY byte + i2c_dev->read(rbuff, n + 1); + for (uint8_t i = 0; i < n; i++) { + buff[i] = rbuff[i + 1]; + } + } else if (ser_dev) { + // Serial read + ser_dev->readBytes(buff, n); + } +#ifdef PN532DEBUG + PN532DEBUGPRINT.print(F("Reading: ")); + for (uint8_t i = 0; i < n; i++) { + PN532DEBUGPRINT.print(F(" 0x")); + PN532DEBUGPRINT.print(buff[i], HEX); + } + PN532DEBUGPRINT.println(); +#endif +} + +/**************************************************************************/ +/*! + @brief set the PN532 as iso14443a Target behaving as a SmartCard + @return true on success, false otherwise. + @note Author: Salvador Mendoza (salmg.net) new functions: + -AsTarget + -getDataTarget + -setDataTarget +*/ +/**************************************************************************/ +uint8_t Adafruit_PN532::AsTarget() { + pn532_packetbuffer[0] = 0x8C; + uint8_t target[] = { + 0x8C, // INIT AS TARGET + 0x00, // MODE -> BITFIELD + 0x08, 0x00, // SENS_RES - MIFARE PARAMS + 0xdc, 0x44, 0x20, // NFCID1T + 0x60, // SEL_RES + 0x01, 0xfe, // NFCID2T MUST START WITH 01fe - FELICA PARAMS - POL_RES + 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xc0, + 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, // PAD + 0xff, 0xff, // SYSTEM CODE + 0xaa, 0x99, 0x88, 0x77, 0x66, 0x55, 0x44, + 0x33, 0x22, 0x11, 0x01, 0x00, // NFCID3t MAX 47 BYTES ATR_RES + 0x0d, 0x52, 0x46, 0x49, 0x44, 0x49, 0x4f, + 0x74, 0x20, 0x50, 0x4e, 0x35, 0x33, 0x32 // HISTORICAL BYTES + }; + if (!sendCommandCheckAck(target, sizeof(target))) + return false; + + // read data packet + readdata(pn532_packetbuffer, 8); + + int offset = 6; + return (pn532_packetbuffer[offset] == 0x15); +} +/**************************************************************************/ +/*! + @brief Retrieve response from the emulation mode + + @param cmd = data + @param cmdlen = data length + @return true on success, false otherwise. +*/ +/**************************************************************************/ +uint8_t Adafruit_PN532::getDataTarget(uint8_t *cmd, uint8_t *cmdlen) { + uint8_t length; + pn532_packetbuffer[0] = 0x86; + if (!sendCommandCheckAck(pn532_packetbuffer, 1, 1000)) { + PN532DEBUGPRINT.println(F("Error en ack")); + return false; + } + + // read data packet + readdata(pn532_packetbuffer, 64); + length = pn532_packetbuffer[3] - 3; + + // if (length > *responseLength) {// Bug, should avoid it in the reading + // target data + // length = *responseLength; // silent truncation... + //} + + for (int i = 0; i < length; ++i) { + cmd[i] = pn532_packetbuffer[8 + i]; + } + *cmdlen = length; + return true; +} + +/**************************************************************************/ +/*! + @brief Set data in PN532 in the emulation mode + + @param cmd = data + @param cmdlen = data length + @return true on success, false otherwise. +*/ +/**************************************************************************/ +uint8_t Adafruit_PN532::setDataTarget(uint8_t *cmd, uint8_t cmdlen) { + uint8_t length; + // cmd1[0] = 0x8E; Must! + + if (!sendCommandCheckAck(cmd, cmdlen)) + return false; + + // read data packet + readdata(pn532_packetbuffer, 8); + length = pn532_packetbuffer[3] - 3; + for (int i = 0; i < length; ++i) { + cmd[i] = pn532_packetbuffer[8 + i]; + } + // cmdl = 0 + cmdlen = length; + + int offset = 6; + return (pn532_packetbuffer[offset] == 0x15); +} + +/**************************************************************************/ +/*! + @brief Writes a command to the PN532, automatically inserting the + preamble and required frame details (checksum, len, etc.) + + @param cmd Pointer to the command buffer + @param cmdlen Command length in bytes +*/ +/**************************************************************************/ +void Adafruit_PN532::writecommand(uint8_t *cmd, uint8_t cmdlen) { + if (spi_dev) { + // SPI command write. + uint8_t checksum; + uint8_t packet[9 + cmdlen]; + uint8_t *p = packet; + cmdlen++; + + p[0] = PN532_SPI_DATAWRITE; + p++; + + p[0] = PN532_PREAMBLE; + p++; + p[0] = PN532_STARTCODE1; + p++; + p[0] = PN532_STARTCODE2; + p++; + checksum = PN532_PREAMBLE + PN532_STARTCODE1 + PN532_STARTCODE2; + + p[0] = cmdlen; + p++; + p[0] = ~cmdlen + 1; + p++; + + p[0] = PN532_HOSTTOPN532; + p++; + checksum += PN532_HOSTTOPN532; + + for (uint8_t i = 0; i < cmdlen - 1; i++) { + p[0] = cmd[i]; + p++; + checksum += cmd[i]; + } + + p[0] = ~checksum; + p++; + p[0] = PN532_POSTAMBLE; + p++; + +#ifdef PN532DEBUG + Serial.print("Sending : "); + for (int i = 1; i < 8 + cmdlen; i++) { + Serial.print("0x"); + Serial.print(packet[i], HEX); + Serial.print(", "); + } + Serial.println(); +#endif + + spi_dev->write(packet, 8 + cmdlen); + } else if (i2c_dev || ser_dev) { + // I2C or Serial command write. + uint8_t packet[8 + cmdlen]; + uint8_t LEN = cmdlen + 1; + + packet[0] = PN532_PREAMBLE; + packet[1] = PN532_STARTCODE1; + packet[2] = PN532_STARTCODE2; + packet[3] = LEN; + packet[4] = ~LEN + 1; + packet[5] = PN532_HOSTTOPN532; + uint8_t sum = 0; + for (uint8_t i = 0; i < cmdlen; i++) { + packet[6 + i] = cmd[i]; + sum += cmd[i]; + } + packet[6 + cmdlen] = ~(PN532_HOSTTOPN532 + sum) + 1; + packet[7 + cmdlen] = PN532_POSTAMBLE; + +#ifdef PN532DEBUG + Serial.print("Sending : "); + for (int i = 1; i < 8 + cmdlen; i++) { + Serial.print("0x"); + Serial.print(packet[i], HEX); + Serial.print(", "); + } + Serial.println(); +#endif + + if (i2c_dev) { + i2c_dev->write(packet, 8 + cmdlen); + } else { + ser_dev->write(packet, 8 + cmdlen); + } + } +} diff --git a/lib/Adafruit_PN532/Adafruit_PN532.h b/lib/Adafruit_PN532/Adafruit_PN532.h new file mode 100644 index 0000000..c33db5c --- /dev/null +++ b/lib/Adafruit_PN532/Adafruit_PN532.h @@ -0,0 +1,225 @@ +/**************************************************************************/ +/*! + @file Adafruit_PN532.h + + v2.0 - Refactored to add I2C support from Adafruit_NFCShield_I2C library. + + v1.1 - Added full command list + - Added 'verbose' mode flag to constructor to toggle debug output + - Changed readPassiveTargetID() to return variable length values +*/ +/**************************************************************************/ + +#ifndef ADAFRUIT_PN532_H +#define ADAFRUIT_PN532_H + +#include "Arduino.h" + +#include +#include + +#define PN532_PREAMBLE (0x00) ///< Command sequence start, byte 1/3 +#define PN532_STARTCODE1 (0x00) ///< Command sequence start, byte 2/3 +#define PN532_STARTCODE2 (0xFF) ///< Command sequence start, byte 3/3 +#define PN532_POSTAMBLE (0x00) ///< EOD + +#define PN532_HOSTTOPN532 (0xD4) ///< Host-to-PN532 +#define PN532_PN532TOHOST (0xD5) ///< PN532-to-host + +// PN532 Commands +#define PN532_COMMAND_DIAGNOSE (0x00) ///< Diagnose +#define PN532_COMMAND_GETFIRMWAREVERSION (0x02) ///< Get firmware version +#define PN532_COMMAND_GETGENERALSTATUS (0x04) ///< Get general status +#define PN532_COMMAND_READREGISTER (0x06) ///< Read register +#define PN532_COMMAND_WRITEREGISTER (0x08) ///< Write register +#define PN532_COMMAND_READGPIO (0x0C) ///< Read GPIO +#define PN532_COMMAND_WRITEGPIO (0x0E) ///< Write GPIO +#define PN532_COMMAND_SETSERIALBAUDRATE (0x10) ///< Set serial baud rate +#define PN532_COMMAND_SETPARAMETERS (0x12) ///< Set parameters +#define PN532_COMMAND_SAMCONFIGURATION (0x14) ///< SAM configuration +#define PN532_COMMAND_POWERDOWN (0x16) ///< Power down +#define PN532_COMMAND_RFCONFIGURATION (0x32) ///< RF config +#define PN532_COMMAND_RFREGULATIONTEST (0x58) ///< RF regulation test +#define PN532_COMMAND_INJUMPFORDEP (0x56) ///< Jump for DEP +#define PN532_COMMAND_INJUMPFORPSL (0x46) ///< Jump for PSL +#define PN532_COMMAND_INLISTPASSIVETARGET (0x4A) ///< List passive target +#define PN532_COMMAND_INATR (0x50) ///< ATR +#define PN532_COMMAND_INPSL (0x4E) ///< PSL +#define PN532_COMMAND_INDATAEXCHANGE (0x40) ///< Data exchange +#define PN532_COMMAND_INCOMMUNICATETHRU (0x42) ///< Communicate through +#define PN532_COMMAND_INDESELECT (0x44) ///< Deselect +#define PN532_COMMAND_INRELEASE (0x52) ///< Release +#define PN532_COMMAND_INSELECT (0x54) ///< Select +#define PN532_COMMAND_INAUTOPOLL (0x60) ///< Auto poll +#define PN532_COMMAND_TGINITASTARGET (0x8C) ///< Init as target +#define PN532_COMMAND_TGSETGENERALBYTES (0x92) ///< Set general bytes +#define PN532_COMMAND_TGGETDATA (0x86) ///< Get data +#define PN532_COMMAND_TGSETDATA (0x8E) ///< Set data +#define PN532_COMMAND_TGSETMETADATA (0x94) ///< Set metadata +#define PN532_COMMAND_TGGETINITIATORCOMMAND (0x88) ///< Get initiator command +#define PN532_COMMAND_TGRESPONSETOINITIATOR (0x90) ///< Response to initiator +#define PN532_COMMAND_TGGETTARGETSTATUS (0x8A) ///< Get target status + +#define PN532_RESPONSE_INDATAEXCHANGE (0x41) ///< Data exchange +#define PN532_RESPONSE_INLISTPASSIVETARGET (0x4B) ///< List passive target + +#define PN532_WAKEUP (0x55) ///< Wake + +#define PN532_SPI_STATREAD (0x02) ///< Stat read +#define PN532_SPI_DATAWRITE (0x01) ///< Data write +#define PN532_SPI_DATAREAD (0x03) ///< Data read +#define PN532_SPI_READY (0x01) ///< Ready + +// #define PN532_I2C_ADDRESS (0x48 >> 1) ///< Default I2C address +// My fucking clone board for some goddamn reason uses the address 0x28 +#define PN532_I2C_ADDRESS (0x28) +#define PN532_I2C_READBIT (0x01) ///< Read bit +#define PN532_I2C_BUSY (0x00) ///< Busy +#define PN532_I2C_READY (0x01) ///< Ready +#define PN532_I2C_READYTIMEOUT (20) ///< Ready timeout + +#define PN532_MIFARE_ISO14443A (0x00) ///< MiFare + +// Mifare Commands +#define MIFARE_CMD_AUTH_A (0x60) ///< Auth A +#define MIFARE_CMD_AUTH_B (0x61) ///< Auth B +#define MIFARE_CMD_READ (0x30) ///< Read +#define MIFARE_CMD_WRITE (0xA0) ///< Write +#define MIFARE_CMD_TRANSFER (0xB0) ///< Transfer +#define MIFARE_CMD_DECREMENT (0xC0) ///< Decrement +#define MIFARE_CMD_INCREMENT (0xC1) ///< Increment +#define MIFARE_CMD_STORE (0xC2) ///< Store +#define MIFARE_ULTRALIGHT_CMD_WRITE (0xA2) ///< Write (MiFare Ultralight) + +// Prefixes for NDEF Records (to identify record type) +#define NDEF_URIPREFIX_NONE (0x00) ///< No prefix +#define NDEF_URIPREFIX_HTTP_WWWDOT (0x01) ///< HTTP www. prefix +#define NDEF_URIPREFIX_HTTPS_WWWDOT (0x02) ///< HTTPS www. prefix +#define NDEF_URIPREFIX_HTTP (0x03) ///< HTTP prefix +#define NDEF_URIPREFIX_HTTPS (0x04) ///< HTTPS prefix +#define NDEF_URIPREFIX_TEL (0x05) ///< Tel prefix +#define NDEF_URIPREFIX_MAILTO (0x06) ///< Mailto prefix +#define NDEF_URIPREFIX_FTP_ANONAT (0x07) ///< FTP +#define NDEF_URIPREFIX_FTP_FTPDOT (0x08) ///< FTP dot +#define NDEF_URIPREFIX_FTPS (0x09) ///< FTPS +#define NDEF_URIPREFIX_SFTP (0x0A) ///< SFTP +#define NDEF_URIPREFIX_SMB (0x0B) ///< SMB +#define NDEF_URIPREFIX_NFS (0x0C) ///< NFS +#define NDEF_URIPREFIX_FTP (0x0D) ///< FTP +#define NDEF_URIPREFIX_DAV (0x0E) ///< DAV +#define NDEF_URIPREFIX_NEWS (0x0F) ///< NEWS +#define NDEF_URIPREFIX_TELNET (0x10) ///< Telnet prefix +#define NDEF_URIPREFIX_IMAP (0x11) ///< IMAP prefix +#define NDEF_URIPREFIX_RTSP (0x12) ///< RTSP +#define NDEF_URIPREFIX_URN (0x13) ///< URN +#define NDEF_URIPREFIX_POP (0x14) ///< POP +#define NDEF_URIPREFIX_SIP (0x15) ///< SIP +#define NDEF_URIPREFIX_SIPS (0x16) ///< SIPS +#define NDEF_URIPREFIX_TFTP (0x17) ///< TFPT +#define NDEF_URIPREFIX_BTSPP (0x18) ///< BTSPP +#define NDEF_URIPREFIX_BTL2CAP (0x19) ///< BTL2CAP +#define NDEF_URIPREFIX_BTGOEP (0x1A) ///< BTGOEP +#define NDEF_URIPREFIX_TCPOBEX (0x1B) ///< TCPOBEX +#define NDEF_URIPREFIX_IRDAOBEX (0x1C) ///< IRDAOBEX +#define NDEF_URIPREFIX_FILE (0x1D) ///< File +#define NDEF_URIPREFIX_URN_EPC_ID (0x1E) ///< URN EPC ID +#define NDEF_URIPREFIX_URN_EPC_TAG (0x1F) ///< URN EPC tag +#define NDEF_URIPREFIX_URN_EPC_PAT (0x20) ///< URN EPC pat +#define NDEF_URIPREFIX_URN_EPC_RAW (0x21) ///< URN EPC raw +#define NDEF_URIPREFIX_URN_EPC (0x22) ///< URN EPC +#define NDEF_URIPREFIX_URN_NFC (0x23) ///< URN NFC + +#define PN532_GPIO_VALIDATIONBIT (0x80) ///< GPIO validation bit +#define PN532_GPIO_P30 (0) ///< GPIO 30 +#define PN532_GPIO_P31 (1) ///< GPIO 31 +#define PN532_GPIO_P32 (2) ///< GPIO 32 +#define PN532_GPIO_P33 (3) ///< GPIO 33 +#define PN532_GPIO_P34 (4) ///< GPIO 34 +#define PN532_GPIO_P35 (5) ///< GPIO 35 + +/** + * @brief Class for working with Adafruit PN532 NFC/RFID breakout boards. + */ +class Adafruit_PN532 { + public: + Adafruit_PN532(uint8_t clk, uint8_t miso, uint8_t mosi, + uint8_t ss); // Software SPI + Adafruit_PN532(uint8_t ss, SPIClass *theSPI = &SPI); // Hardware SPI + Adafruit_PN532(uint8_t irq, uint8_t reset, + TwoWire *theWire = &Wire); // Hardware I2C + Adafruit_PN532(uint8_t reset, HardwareSerial *theSer); // Hardware UART + bool begin(void); + + void reset(void); + void wakeup(void); + + // Generic PN532 functions + bool SAMConfig(void); + uint32_t getFirmwareVersion(void); + bool sendCommandCheckAck(uint8_t *cmd, uint8_t cmdlen, + uint16_t timeout = 100); + bool writeGPIO(uint8_t pinstate); + uint8_t readGPIO(void); + bool setPassiveActivationRetries(uint8_t maxRetries); + + // ISO14443A functions + bool readPassiveTargetID( + uint8_t cardbaudrate, uint8_t *uid, uint8_t *uidLength, + uint16_t timeout = + 0); // timeout 0 means no timeout - will block forever. + bool startPassiveTargetIDDetection(uint8_t cardbaudrate); + bool readDetectedPassiveTargetID(uint8_t *uid, uint8_t *uidLength); + bool inDataExchange(uint8_t *send, uint8_t sendLength, uint8_t *response, + uint8_t *responseLength); + bool inListPassiveTarget(); + uint8_t AsTarget(); + uint8_t getDataTarget(uint8_t *cmd, uint8_t *cmdlen); + uint8_t setDataTarget(uint8_t *cmd, uint8_t cmdlen); + + // Mifare Classic functions + bool mifareclassic_IsFirstBlock(uint32_t uiBlock); + bool mifareclassic_IsTrailerBlock(uint32_t uiBlock); + uint8_t mifareclassic_AuthenticateBlock(uint8_t *uid, uint8_t uidLen, + uint32_t blockNumber, + uint8_t keyNumber, + uint8_t *keyData); + uint8_t mifareclassic_ReadDataBlock(uint8_t blockNumber, uint8_t *data); + uint8_t mifareclassic_WriteDataBlock(uint8_t blockNumber, uint8_t *data); + uint8_t mifareclassic_FormatNDEF(void); + uint8_t mifareclassic_WriteNDEFURI(uint8_t sectorNumber, + uint8_t uriIdentifier, const char *url); + + // Mifare Ultralight functions + uint8_t mifareultralight_ReadPage(uint8_t page, uint8_t *buffer); + uint8_t mifareultralight_WritePage(uint8_t page, uint8_t *data); + + // NTAG2xx functions + uint8_t ntag2xx_ReadPage(uint8_t page, uint8_t *buffer); + uint8_t ntag2xx_WritePage(uint8_t page, uint8_t *data); + uint8_t ntag2xx_WriteNDEFURI(uint8_t uriIdentifier, char *url, + uint8_t dataLen); + + // Help functions to display formatted text + static void PrintHex(const byte *data, const uint32_t numBytes); + static void PrintHexChar(const byte *pbtData, const uint32_t numBytes); + + private: + int8_t _irq = -1, _reset = -1, _cs = -1; + int8_t _uid[7]; // ISO14443A uid + int8_t _uidLen; // uid len + int8_t _key[6]; // Mifare Classic key + int8_t _inListedTag; // Tg number of inlisted tag. + + // Low level communication functions that handle both SPI and I2C. + void readdata(uint8_t *buff, uint8_t n); + void writecommand(uint8_t *cmd, uint8_t cmdlen); + bool isready(); + bool waitready(uint16_t timeout); + bool readack(); + + Adafruit_SPIDevice *spi_dev = NULL; + Adafruit_I2CDevice *i2c_dev = NULL; + HardwareSerial *ser_dev = NULL; +}; + +#endif diff --git a/lib/BleMouse/BleConnectionStatus.cpp b/lib/BleMouse/BleConnectionStatus.cpp new file mode 100644 index 0000000..83d3539 --- /dev/null +++ b/lib/BleMouse/BleConnectionStatus.cpp @@ -0,0 +1,17 @@ +#include "BleConnectionStatus.h" + +BleConnectionStatus::BleConnectionStatus(void) {} + +void BleConnectionStatus::onConnect(BLEServer *pServer) { + this->connected = true; + BLE2902 *desc = (BLE2902 *)this->inputMouse->getDescriptorByUUID( + BLEUUID((uint16_t)0x2902)); + desc->setNotifications(true); +} + +void BleConnectionStatus::onDisconnect(BLEServer *pServer) { + this->connected = false; + BLE2902 *desc = (BLE2902 *)this->inputMouse->getDescriptorByUUID( + BLEUUID((uint16_t)0x2902)); + desc->setNotifications(false); +} diff --git a/lib/BleMouse/BleConnectionStatus.h b/lib/BleMouse/BleConnectionStatus.h new file mode 100644 index 0000000..45b7185 --- /dev/null +++ b/lib/BleMouse/BleConnectionStatus.h @@ -0,0 +1,20 @@ +#ifndef ESP32_BLE_CONNECTION_STATUS_H +#define ESP32_BLE_CONNECTION_STATUS_H +#include "sdkconfig.h" +#if defined(CONFIG_BT_ENABLED) + +#include "BLE2902.h" +#include "BLECharacteristic.h" +#include + +class BleConnectionStatus : public BLEServerCallbacks { + public: + BleConnectionStatus(void); + bool connected = false; + void onConnect(BLEServer *pServer); + void onDisconnect(BLEServer *pServer); + BLECharacteristic *inputMouse; +}; + +#endif // CONFIG_BT_ENABLED +#endif // ESP32_BLE_CONNECTION_STATUS_H diff --git a/lib/BleMouse/BleMouse.cpp b/lib/BleMouse/BleMouse.cpp new file mode 100644 index 0000000..8f5c16e --- /dev/null +++ b/lib/BleMouse/BleMouse.cpp @@ -0,0 +1,165 @@ +#include "BLE2902.h" +#include "BLEHIDDevice.h" +#include "HIDKeyboardTypes.h" +#include "HIDTypes.h" +#include "sdkconfig.h" +#include +#include +#include +#include + +#include "BleConnectionStatus.h" +#include "BleMouse.h" + +#if defined(CONFIG_ARDUHAL_ESP_LOG) +#include "esp32-hal-log.h" +#define LOG_TAG "" +#else +#include "esp_log.h" +static const char *LOG_TAG = "BLEDevice"; +#endif + +static const uint8_t _hidReportDescriptor[] = { + USAGE_PAGE(1), 0x01, // USAGE_PAGE (Generic Desktop) + USAGE(1), 0x02, // USAGE (Mouse) + COLLECTION(1), 0x01, // COLLECTION (Application) + USAGE(1), 0x01, // USAGE (Pointer) + COLLECTION(1), 0x00, // COLLECTION (Physical) + // ------------------------------------------------- Buttons (Left, Right, + // Middle, Back, Forward) + USAGE_PAGE(1), 0x09, // USAGE_PAGE (Button) + USAGE_MINIMUM(1), 0x01, // USAGE_MINIMUM (Button 1) + USAGE_MAXIMUM(1), 0x05, // USAGE_MAXIMUM (Button 5) + LOGICAL_MINIMUM(1), 0x00, // LOGICAL_MINIMUM (0) + LOGICAL_MAXIMUM(1), 0x01, // LOGICAL_MAXIMUM (1) + REPORT_SIZE(1), 0x01, // REPORT_SIZE (1) + REPORT_COUNT(1), 0x05, // REPORT_COUNT (5) + HIDINPUT(1), 0x02, // INPUT (Data, Variable, Absolute) ;5 button bits + // ------------------------------------------------- Padding + REPORT_SIZE(1), 0x03, // REPORT_SIZE (3) + REPORT_COUNT(1), 0x01, // REPORT_COUNT (1) + HIDINPUT(1), + 0x03, // INPUT (Constant, Variable, Absolute) ;3 bit padding + // ------------------------------------------------- X/Y position, Wheel + USAGE_PAGE(1), 0x01, // USAGE_PAGE (Generic Desktop) + USAGE(1), 0x30, // USAGE (X) + USAGE(1), 0x31, // USAGE (Y) + USAGE(1), 0x38, // USAGE (Wheel) + LOGICAL_MINIMUM(1), 0x81, // LOGICAL_MINIMUM (-127) + LOGICAL_MAXIMUM(1), 0x7f, // LOGICAL_MAXIMUM (127) + REPORT_SIZE(1), 0x08, // REPORT_SIZE (8) + REPORT_COUNT(1), 0x03, // REPORT_COUNT (3) + HIDINPUT(1), + 0x06, // INPUT (Data, Variable, Relative) ;3 bytes (X,Y,Wheel) + // ------------------------------------------------- Horizontal wheel + USAGE_PAGE(1), 0x0c, // USAGE PAGE (Consumer Devices) + USAGE(2), 0x38, 0x02, // USAGE (AC Pan) + LOGICAL_MINIMUM(1), 0x81, // LOGICAL_MINIMUM (-127) + LOGICAL_MAXIMUM(1), 0x7f, // LOGICAL_MAXIMUM (127) + REPORT_SIZE(1), 0x08, // REPORT_SIZE (8) + REPORT_COUNT(1), 0x01, // REPORT_COUNT (1) + HIDINPUT(1), 0x06, // INPUT (Data, Var, Rel) + END_COLLECTION(0), // END_COLLECTION + END_COLLECTION(0) // END_COLLECTION +}; + +BleMouse::BleMouse(std::string deviceName, std::string deviceManufacturer, + uint8_t batteryLevel) + : _buttons(0), hid(0) { + this->deviceName = deviceName; + this->deviceManufacturer = deviceManufacturer; + this->batteryLevel = batteryLevel; + this->connectionStatus = new BleConnectionStatus(); +} + +void BleMouse::begin(void) { + xTaskCreate(this->taskServer, "server", 20000, (void *)this, 5, NULL); +} + +void BleMouse::end(void) {} + +void BleMouse::click(uint8_t b) { + _buttons = b; + move(0, 0, 0, 0); + _buttons = 0; + move(0, 0, 0, 0); +} + +void BleMouse::move(signed char x, signed char y, signed char wheel, + signed char hWheel) { + if (this->isConnected()) { + uint8_t m[5]; + m[0] = _buttons; + m[1] = x; + m[2] = y; + m[3] = wheel; + m[4] = hWheel; + this->inputMouse->setValue(m, 5); + this->inputMouse->notify(); + } +} + +void BleMouse::buttons(uint8_t b) { + if (b != _buttons) { + _buttons = b; + move(0, 0, 0, 0); + } +} + +void BleMouse::press(uint8_t b) { buttons(_buttons | b); } + +void BleMouse::release(uint8_t b) { buttons(_buttons & ~b); } + +bool BleMouse::isPressed(uint8_t b) { + if ((b & _buttons) > 0) + return true; + return false; +} + +bool BleMouse::isConnected(void) { return this->connectionStatus->connected; } + +void BleMouse::setBatteryLevel(uint8_t level) { + this->batteryLevel = level; + if (hid != 0) + this->hid->setBatteryLevel(this->batteryLevel); +} + +void BleMouse::taskServer(void *pvParameter) { + BleMouse *bleMouseInstance = + (BleMouse *)pvParameter; // static_cast(pvParameter); + BLEDevice::init(std::string(bleMouseInstance->deviceName.c_str())); + BLEServer *pServer = BLEDevice::createServer(); + pServer->setCallbacks(bleMouseInstance->connectionStatus); + + bleMouseInstance->hid = new BLEHIDDevice(pServer); + bleMouseInstance->inputMouse = bleMouseInstance->hid->inputReport( + 0); // <-- input REPORTID from report map + bleMouseInstance->connectionStatus->inputMouse = + bleMouseInstance->inputMouse; + + bleMouseInstance->hid->manufacturer()->setValue( + std::string(bleMouseInstance->deviceManufacturer.c_str())); + + bleMouseInstance->hid->pnp(0x02, 0xe502, 0xa111, 0x0210); + bleMouseInstance->hid->hidInfo(0x00, 0x02); + + BLESecurity *pSecurity = new BLESecurity(); + + pSecurity->setAuthenticationMode(ESP_LE_AUTH_BOND); + + bleMouseInstance->hid->reportMap((uint8_t *)_hidReportDescriptor, + sizeof(_hidReportDescriptor)); + bleMouseInstance->hid->startServices(); + + bleMouseInstance->onStarted(pServer); + + BLEAdvertising *pAdvertising = pServer->getAdvertising(); + pAdvertising->setAppearance(HID_MOUSE); + pAdvertising->addServiceUUID( + bleMouseInstance->hid->hidService()->getUUID()); + pAdvertising->start(); + bleMouseInstance->hid->setBatteryLevel(bleMouseInstance->batteryLevel); + + ESP_LOGD(LOG_TAG, "Advertising started!"); + vTaskDelay(portMAX_DELAY); // delay(portMAX_DELAY); +} diff --git a/lib/BleMouse/BleMouse.h b/lib/BleMouse/BleMouse.h new file mode 100644 index 0000000..4468189 --- /dev/null +++ b/lib/BleMouse/BleMouse.h @@ -0,0 +1,52 @@ +#ifndef ESP32_BLE_MOUSE_H +#define ESP32_BLE_MOUSE_H +#include "sdkconfig.h" +#if defined(CONFIG_BT_ENABLED) + +#include "BLECharacteristic.h" +#include "BLEHIDDevice.h" +#include "BleConnectionStatus.h" + +#define MOUSE_LEFT 1 +#define MOUSE_RIGHT 2 +#define MOUSE_MIDDLE 4 +#define MOUSE_BACK 8 +#define MOUSE_FORWARD 16 +#define MOUSE_ALL \ + (MOUSE_LEFT | MOUSE_RIGHT | \ + MOUSE_MIDDLE) #For compatibility with the Mouse library + +class BleMouse { + private: + uint8_t _buttons; + BleConnectionStatus *connectionStatus; + BLEHIDDevice *hid; + BLECharacteristic *inputMouse; + void buttons(uint8_t b); + void rawAction(uint8_t msg[], char msgSize); + static void taskServer(void *pvParameter); + + public: + BleMouse(std::string deviceName = "ESP32 Bluetooth Mouse", + std::string deviceManufacturer = "Espressif", + uint8_t batteryLevel = 100); + void begin(void); + void end(void); + void click(uint8_t b = MOUSE_LEFT); + void move(signed char x, signed char y, signed char wheel = 0, + signed char hWheel = 0); + void press(uint8_t b = MOUSE_LEFT); // press LEFT by default + void release(uint8_t b = MOUSE_LEFT); // release LEFT by default + bool isPressed(uint8_t b = MOUSE_LEFT); // check LEFT by default + bool isConnected(void); + void setBatteryLevel(uint8_t level); + uint8_t batteryLevel; + std::string deviceManufacturer; + std::string deviceName; + + protected: + virtual void onStarted(BLEServer *pServer) {}; +}; + +#endif // CONFIG_BT_ENABLED +#endif // ESP32_BLE_MOUSE_H diff --git a/lib/ELECHOUSE_CC1101/ELECHOUSE_CC1101_SRC_DRV.cpp b/lib/ELECHOUSE_CC1101/ELECHOUSE_CC1101_SRC_DRV.cpp new file mode 100644 index 0000000..ead012f --- /dev/null +++ b/lib/ELECHOUSE_CC1101/ELECHOUSE_CC1101_SRC_DRV.cpp @@ -0,0 +1,1482 @@ +/* + ELECHOUSE_CC1101.cpp - CC1101 module library + Copyright (c) 2010 Michael. + Author: Michael, + Version: November 12, 2010 + + This library is designed to use CC1101/CC1100 module on Arduino platform. + CC1101/CC1100 module is an useful wireless module.Using the functions of the + library, you can easily send and receive data by the CC1101/CC1100 module. + Just have fun! + For the details, please refer to the datasheet of CC1100/CC1101. +---------------------------------------------------------------------------------------------------------------- +cc1101 Driver for RC Switch. Mod by Little Satan. With permission to modify and +publish Wilson Shen (ELECHOUSE). +---------------------------------------------------------------------------------------------------------------- +*/ +#include "ELECHOUSE_CC1101_SRC_DRV.h" +#include +#include + +/****************************************************************/ +#define WRITE_BURST 0x40 // write burst +#define READ_SINGLE 0x80 // read single +#define READ_BURST 0xC0 // read burst +#define BYTES_IN_RXFIFO 0x7F // byte number in RXfifo +#define max_modul 6 + +SPIClass CCSPI(HSPI); + +byte modulation = 2; +byte frend0; +byte chan = 0; +int pa = 12; +byte last_pa; +byte SCK_PIN; +byte MISO_PIN; +byte MOSI_PIN; +byte SS_PIN; +byte GDO0; +byte GDO2; +byte SCK_PIN_M[max_modul]; +byte MISO_PIN_M[max_modul]; +byte MOSI_PIN_M[max_modul]; +byte SS_PIN_M[max_modul]; +byte GDO0_M[max_modul]; +byte GDO2_M[max_modul]; +byte gdo_set = 0; +bool spi = 0; +bool ccmode = 0; +float MHz = 433.92; +byte m4RxBw = 0; +byte m4DaRa; +byte m2DCOFF; +byte m2MODFM; +byte m2MANCH; +byte m2SYNCM; +byte m1FEC; +byte m1PRE; +byte m1CHSP; +byte pc1PQT; +byte pc1CRC_AF; +byte pc1APP_ST; +byte pc1ADRCHK; +byte pc0WDATA; +byte pc0PktForm; +byte pc0CRC_EN; +byte pc0LenConf; +byte trxstate = 0; +byte clb1[2] = {24, 28}; +byte clb2[2] = {31, 38}; +byte clb3[2] = {65, 76}; +byte clb4[2] = {77, 79}; + +/****************************************************************/ +uint8_t PA_TABLE[8]{0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; +// -30 -20 -15 -10 0 5 7 10 +uint8_t PA_TABLE_315[8]{ + 0x12, 0x0D, 0x1C, 0x34, 0x51, 0x85, 0xCB, 0xC2, +}; // 300 - 348 +uint8_t PA_TABLE_433[8]{ + 0x12, 0x0E, 0x1D, 0x34, 0x60, 0x84, 0xC8, 0xC0, +}; // 387 - 464 +// -30 -20 -15 -10 -6 0 5 7 10 12 +uint8_t PA_TABLE_868[10]{ + 0x03, 0x17, 0x1D, 0x26, 0x37, 0x50, 0x86, 0xCD, 0xC5, 0xC0, +}; // 779 - 899.99 +// -30 -20 -15 -10 -6 0 5 7 10 11 +uint8_t PA_TABLE_915[10]{ + 0x03, 0x0E, 0x1E, 0x27, 0x38, 0x8E, 0x84, 0xCC, 0xC3, 0xC0, +}; // 900 - 928 +/**************************************************************** + *FUNCTION NAME:SpiStart + *FUNCTION :spi communication start + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::SpiStart(void) { + // initialize the SPI pins + pinMode(SCK_PIN, OUTPUT); + pinMode(MOSI_PIN, OUTPUT); + pinMode(MISO_PIN, INPUT); + pinMode(SS_PIN, OUTPUT); + +// enable SPI +#ifdef ESP32 + CCSPI.begin(SCK_PIN, MISO_PIN, MOSI_PIN, SS_PIN); +#else + CCSPI.begin(); +#endif +} +/**************************************************************** + *FUNCTION NAME:SpiEnd + *FUNCTION :spi communication disable + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::SpiEnd(void) { + // disable SPI + CCSPI.endTransaction(); + CCSPI.end(); +} +/**************************************************************** + *FUNCTION NAME: GDO_Set() + *FUNCTION : set GDO0,GDO2 pin for serial pinmode. + *INPUT : none + *OUTPUT : none + ****************************************************************/ +void ELECHOUSE_CC1101::GDO_Set(void) { + pinMode(GDO0, OUTPUT); + pinMode(GDO2, INPUT); +} +/**************************************************************** + *FUNCTION NAME: GDO_Set() + *FUNCTION : set GDO0 for internal transmission mode. + *INPUT : none + *OUTPUT : none + ****************************************************************/ +void ELECHOUSE_CC1101::GDO0_Set(void) { pinMode(GDO0, INPUT); } +/**************************************************************** + *FUNCTION NAME:Reset + *FUNCTION :CC1101 reset //details refer datasheet of CC1101/CC1100// + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::Reset(void) { + digitalWrite(SS_PIN, LOW); + delay(1); + digitalWrite(SS_PIN, HIGH); + delay(1); + digitalWrite(SS_PIN, LOW); + while (digitalRead(MISO_PIN)) + ; + CCSPI.transfer(CC1101_SRES); + while (digitalRead(MISO_PIN)) + ; + digitalWrite(SS_PIN, HIGH); +} +/**************************************************************** + *FUNCTION NAME:Init + *FUNCTION :CC1101 initialization + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::Init(void) { + setSpi(); + SpiStart(); // spi initialization + digitalWrite(SS_PIN, HIGH); + digitalWrite(SCK_PIN, HIGH); + digitalWrite(MOSI_PIN, LOW); + Reset(); // CC1101 reset + RegConfigSettings(); // CC1101 register config + SpiEnd(); +} +/**************************************************************** + *FUNCTION NAME:SpiWriteReg + *FUNCTION :CC1101 write data to register + *INPUT :addr: register address; value: register value + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::SpiWriteReg(byte addr, byte value) { + SpiStart(); + digitalWrite(SS_PIN, LOW); + while (digitalRead(MISO_PIN)) + ; + CCSPI.transfer(addr); + CCSPI.transfer(value); + digitalWrite(SS_PIN, HIGH); + SpiEnd(); +} +/**************************************************************** + *FUNCTION NAME:SpiWriteBurstReg + *FUNCTION :CC1101 write burst data to register + *INPUT :addr: register address; buffer:register value array; num:number + * to write OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::SpiWriteBurstReg(byte addr, byte *buffer, byte num) { + byte i, temp; + SpiStart(); + temp = addr | WRITE_BURST; + digitalWrite(SS_PIN, LOW); + while (digitalRead(MISO_PIN)) + ; + CCSPI.transfer(temp); + for (i = 0; i < num; i++) { + CCSPI.transfer(buffer[i]); + } + digitalWrite(SS_PIN, HIGH); + SpiEnd(); +} +/**************************************************************** + *FUNCTION NAME:SpiStrobe + *FUNCTION :CC1101 Strobe + *INPUT :strobe: command; //refer define in CC1101.h// + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::SpiStrobe(byte strobe) { + SpiStart(); + digitalWrite(SS_PIN, LOW); + while (digitalRead(MISO_PIN)) + ; + CCSPI.transfer(strobe); + digitalWrite(SS_PIN, HIGH); + SpiEnd(); +} +/**************************************************************** + *FUNCTION NAME:SpiReadReg + *FUNCTION :CC1101 read data from register + *INPUT :addr: register address + *OUTPUT :register value + ****************************************************************/ +byte ELECHOUSE_CC1101::SpiReadReg(byte addr) { + byte temp, value; + SpiStart(); + temp = addr | READ_SINGLE; + digitalWrite(SS_PIN, LOW); + while (digitalRead(MISO_PIN)) + ; + CCSPI.transfer(temp); + value = CCSPI.transfer(0); + digitalWrite(SS_PIN, HIGH); + SpiEnd(); + return value; +} + +/**************************************************************** + *FUNCTION NAME:SpiReadBurstReg + *FUNCTION :CC1101 read burst data from register + *INPUT :addr: register address; buffer:array to store register value; + * num: number to read OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::SpiReadBurstReg(byte addr, byte *buffer, byte num) { + byte i, temp; + SpiStart(); + temp = addr | READ_BURST; + digitalWrite(SS_PIN, LOW); + while (digitalRead(MISO_PIN)) + ; + CCSPI.transfer(temp); + for (i = 0; i < num; i++) { + buffer[i] = CCSPI.transfer(0); + } + digitalWrite(SS_PIN, HIGH); + SpiEnd(); +} + +/**************************************************************** + *FUNCTION NAME:SpiReadStatus + *FUNCTION :CC1101 read status register + *INPUT :addr: register address + *OUTPUT :status value + ****************************************************************/ +byte ELECHOUSE_CC1101::SpiReadStatus(byte addr) { + byte value, temp; + SpiStart(); + temp = addr | READ_BURST; + digitalWrite(SS_PIN, LOW); + while (digitalRead(MISO_PIN)) + ; + CCSPI.transfer(temp); + value = CCSPI.transfer(0); + digitalWrite(SS_PIN, HIGH); + SpiEnd(); + return value; +} +/**************************************************************** + *FUNCTION NAME:SPI pin Settings + *FUNCTION :Set Spi pins + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::setSpi(void) { + if (spi == 0) { +#if defined __AVR_ATmega168__ || defined __AVR_ATmega328P__ + SCK_PIN = 13; + MISO_PIN = 12; + MOSI_PIN = 11; + SS_PIN = 10; +#elif defined __AVR_ATmega1280__ || defined __AVR_ATmega2560__ + SCK_PIN = 52; + MISO_PIN = 50; + MOSI_PIN = 51; + SS_PIN = 53; +#elif ESP8266 + SCK_PIN = 14; + MISO_PIN = 12; + MOSI_PIN = 13; + SS_PIN = 15; +#elif ESP32 + SCK_PIN = 18; + MISO_PIN = 19; + MOSI_PIN = 23; + SS_PIN = 5; +#else + SCK_PIN = 13; + MISO_PIN = 12; + MOSI_PIN = 11; + SS_PIN = 10; +#endif + } +} +/**************************************************************** + *FUNCTION NAME:COSTUM SPI + *FUNCTION :set costum spi pins. + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::setSpiPin(byte sck, byte miso, byte mosi, byte ss) { + spi = 1; + SCK_PIN = sck; + MISO_PIN = miso; + MOSI_PIN = mosi; + SS_PIN = ss; +} +/**************************************************************** + *FUNCTION NAME:COSTUM SPI + *FUNCTION :set costum spi pins. + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::addSpiPin(byte sck, byte miso, byte mosi, byte ss, + byte modul) { + spi = 1; + SCK_PIN_M[modul] = sck; + MISO_PIN_M[modul] = miso; + MOSI_PIN_M[modul] = mosi; + SS_PIN_M[modul] = ss; +} +/**************************************************************** + *FUNCTION NAME:GDO Pin settings + *FUNCTION :set GDO Pins + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::setGDO(byte gdo0, byte gdo2) { + GDO0 = gdo0; + GDO2 = gdo2; + GDO_Set(); +} +/**************************************************************** + *FUNCTION NAME:GDO0 Pin setting + *FUNCTION :set GDO0 Pin + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::setGDO0(byte gdo0) { + GDO0 = gdo0; + GDO0_Set(); +} +/**************************************************************** + *FUNCTION NAME:GDO Pin settings + *FUNCTION :add GDO Pins + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::addGDO(byte gdo0, byte gdo2, byte modul) { + GDO0_M[modul] = gdo0; + GDO2_M[modul] = gdo2; + gdo_set = 2; + GDO_Set(); +} +/**************************************************************** + *FUNCTION NAME:add GDO0 Pin + *FUNCTION :add GDO0 Pin + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::addGDO0(byte gdo0, byte modul) { + GDO0_M[modul] = gdo0; + gdo_set = 1; + GDO0_Set(); +} +/**************************************************************** + *FUNCTION NAME:set Modul + *FUNCTION :change modul + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::setModul(byte modul) { + SCK_PIN = SCK_PIN_M[modul]; + MISO_PIN = MISO_PIN_M[modul]; + MOSI_PIN = MOSI_PIN_M[modul]; + SS_PIN = SS_PIN_M[modul]; + if (gdo_set == 1) { + GDO0 = GDO0_M[modul]; + } else if (gdo_set == 2) { + GDO0 = GDO0_M[modul]; + GDO2 = GDO2_M[modul]; + } +} +/**************************************************************** + *FUNCTION NAME:CCMode + *FUNCTION :Format of RX and TX data + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::setCCMode(bool s) { + ccmode = s; + if (ccmode == 1) { + SpiWriteReg(CC1101_IOCFG2, 0x0B); + SpiWriteReg(CC1101_IOCFG0, 0x06); + SpiWriteReg(CC1101_PKTCTRL0, 0x05); + SpiWriteReg(CC1101_MDMCFG3, 0xF8); + SpiWriteReg(CC1101_MDMCFG4, 11 + m4RxBw); + } else { + SpiWriteReg(CC1101_IOCFG2, 0x0D); + SpiWriteReg(CC1101_IOCFG0, 0x0D); + SpiWriteReg(CC1101_PKTCTRL0, 0x32); + SpiWriteReg(CC1101_MDMCFG3, 0x93); + SpiWriteReg(CC1101_MDMCFG4, 7 + m4RxBw); + } + setModulation(modulation); +} +/**************************************************************** + *FUNCTION NAME:Modulation + *FUNCTION :set CC1101 Modulation + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::setModulation(byte m) { + if (m > 4) { + m = 4; + } + modulation = m; + Split_MDMCFG2(); + switch (m) { + case 0: + m2MODFM = 0x00; + frend0 = 0x10; + break; // 2-FSK + case 1: + m2MODFM = 0x10; + frend0 = 0x10; + break; // GFSK + case 2: + m2MODFM = 0x30; + frend0 = 0x11; + break; // ASK + case 3: + m2MODFM = 0x40; + frend0 = 0x10; + break; // 4-FSK + case 4: + m2MODFM = 0x70; + frend0 = 0x10; + break; // MSK + } + SpiWriteReg(CC1101_MDMCFG2, m2DCOFF + m2MODFM + m2MANCH + m2SYNCM); + SpiWriteReg(CC1101_FREND0, frend0); + setPA(pa); +} +/**************************************************************** + *FUNCTION NAME:PA Power + *FUNCTION :set CC1101 PA Power + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::setPA(int p) { + int a; + pa = p; + + if (MHz >= 300 && MHz <= 348) { + if (pa <= -30) { + a = PA_TABLE_315[0]; + } else if (pa > -30 && pa <= -20) { + a = PA_TABLE_315[1]; + } else if (pa > -20 && pa <= -15) { + a = PA_TABLE_315[2]; + } else if (pa > -15 && pa <= -10) { + a = PA_TABLE_315[3]; + } else if (pa > -10 && pa <= 0) { + a = PA_TABLE_315[4]; + } else if (pa > 0 && pa <= 5) { + a = PA_TABLE_315[5]; + } else if (pa > 5 && pa <= 7) { + a = PA_TABLE_315[6]; + } else if (pa > 7) { + a = PA_TABLE_315[7]; + } + last_pa = 1; + } else if (MHz >= 378 && MHz <= 464) { + if (pa <= -30) { + a = PA_TABLE_433[0]; + } else if (pa > -30 && pa <= -20) { + a = PA_TABLE_433[1]; + } else if (pa > -20 && pa <= -15) { + a = PA_TABLE_433[2]; + } else if (pa > -15 && pa <= -10) { + a = PA_TABLE_433[3]; + } else if (pa > -10 && pa <= 0) { + a = PA_TABLE_433[4]; + } else if (pa > 0 && pa <= 5) { + a = PA_TABLE_433[5]; + } else if (pa > 5 && pa <= 7) { + a = PA_TABLE_433[6]; + } else if (pa > 7) { + a = PA_TABLE_433[7]; + } + last_pa = 2; + } else if (MHz >= 779 && MHz <= 899.99) { + if (pa <= -30) { + a = PA_TABLE_868[0]; + } else if (pa > -30 && pa <= -20) { + a = PA_TABLE_868[1]; + } else if (pa > -20 && pa <= -15) { + a = PA_TABLE_868[2]; + } else if (pa > -15 && pa <= -10) { + a = PA_TABLE_868[3]; + } else if (pa > -10 && pa <= -6) { + a = PA_TABLE_868[4]; + } else if (pa > -6 && pa <= 0) { + a = PA_TABLE_868[5]; + } else if (pa > 0 && pa <= 5) { + a = PA_TABLE_868[6]; + } else if (pa > 5 && pa <= 7) { + a = PA_TABLE_868[7]; + } else if (pa > 7 && pa <= 10) { + a = PA_TABLE_868[8]; + } else if (pa > 10) { + a = PA_TABLE_868[9]; + } + last_pa = 3; + } else if (MHz >= 900 && MHz <= 928) { + if (pa <= -30) { + a = PA_TABLE_915[0]; + } else if (pa > -30 && pa <= -20) { + a = PA_TABLE_915[1]; + } else if (pa > -20 && pa <= -15) { + a = PA_TABLE_915[2]; + } else if (pa > -15 && pa <= -10) { + a = PA_TABLE_915[3]; + } else if (pa > -10 && pa <= -6) { + a = PA_TABLE_915[4]; + } else if (pa > -6 && pa <= 0) { + a = PA_TABLE_915[5]; + } else if (pa > 0 && pa <= 5) { + a = PA_TABLE_915[6]; + } else if (pa > 5 && pa <= 7) { + a = PA_TABLE_915[7]; + } else if (pa > 7 && pa <= 10) { + a = PA_TABLE_915[8]; + } else if (pa > 10) { + a = PA_TABLE_915[9]; + } + last_pa = 4; + } + if (modulation == 2) { + PA_TABLE[0] = 0; + PA_TABLE[1] = a; + } else { + PA_TABLE[0] = a; + PA_TABLE[1] = 0; + } + SpiWriteBurstReg(CC1101_PATABLE, PA_TABLE, 8); +} +/**************************************************************** + *FUNCTION NAME:Frequency Calculator + *FUNCTION :Calculate the basic frequency. + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::setMHZ(float mhz) { + byte freq2 = 0; + byte freq1 = 0; + byte freq0 = 0; + + MHz = mhz; + + for (bool i = 0; i == 0;) { + if (mhz >= 26) { + mhz -= 26; + freq2 += 1; + } else if (mhz >= 0.1015625) { + mhz -= 0.1015625; + freq1 += 1; + } else if (mhz >= 0.00039675) { + mhz -= 0.00039675; + freq0 += 1; + } else { + i = 1; + } + } + if (freq0 > 255) { + freq1 += 1; + freq0 -= 256; + } + + SpiWriteReg(CC1101_FREQ2, freq2); + SpiWriteReg(CC1101_FREQ1, freq1); + SpiWriteReg(CC1101_FREQ0, freq0); + + Calibrate(); +} +/**************************************************************** + *FUNCTION NAME:Calibrate + *FUNCTION :Calibrate frequency + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::Calibrate(void) { + + if (MHz >= 300 && MHz <= 348) { + SpiWriteReg(CC1101_FSCTRL0, map(MHz, 300, 348, clb1[0], clb1[1])); + if (MHz < 322.88) { + SpiWriteReg(CC1101_TEST0, 0x0B); + } else { + SpiWriteReg(CC1101_TEST0, 0x09); + int s = ELECHOUSE_cc1101.SpiReadStatus(CC1101_FSCAL2); + if (s < 32) { + SpiWriteReg(CC1101_FSCAL2, s + 32); + } + if (last_pa != 1) { + setPA(pa); + } + } + } else if (MHz >= 378 && MHz <= 464) { + SpiWriteReg(CC1101_FSCTRL0, map(MHz, 378, 464, clb2[0], clb2[1])); + if (MHz < 430.5) { + SpiWriteReg(CC1101_TEST0, 0x0B); + } else { + SpiWriteReg(CC1101_TEST0, 0x09); + int s = ELECHOUSE_cc1101.SpiReadStatus(CC1101_FSCAL2); + if (s < 32) { + SpiWriteReg(CC1101_FSCAL2, s + 32); + } + if (last_pa != 2) { + setPA(pa); + } + } + } else if (MHz >= 779 && MHz <= 899.99) { + SpiWriteReg(CC1101_FSCTRL0, map(MHz, 779, 899, clb3[0], clb3[1])); + if (MHz < 861) { + SpiWriteReg(CC1101_TEST0, 0x0B); + } else { + SpiWriteReg(CC1101_TEST0, 0x09); + int s = ELECHOUSE_cc1101.SpiReadStatus(CC1101_FSCAL2); + if (s < 32) { + SpiWriteReg(CC1101_FSCAL2, s + 32); + } + if (last_pa != 3) { + setPA(pa); + } + } + } else if (MHz >= 900 && MHz <= 928) { + SpiWriteReg(CC1101_FSCTRL0, map(MHz, 900, 928, clb4[0], clb4[1])); + SpiWriteReg(CC1101_TEST0, 0x09); + int s = ELECHOUSE_cc1101.SpiReadStatus(CC1101_FSCAL2); + if (s < 32) { + SpiWriteReg(CC1101_FSCAL2, s + 32); + } + if (last_pa != 4) { + setPA(pa); + } + } +} +/**************************************************************** + *FUNCTION NAME:Calibration offset + *FUNCTION :Set calibration offset + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::setClb(byte b, byte s, byte e) { + if (b == 1) { + clb1[0] = s; + clb1[1] = e; + } else if (b == 2) { + clb2[0] = s; + clb2[1] = e; + } else if (b == 3) { + clb3[0] = s; + clb3[1] = e; + } else if (b == 4) { + clb4[0] = s; + clb4[1] = e; + } +} +/**************************************************************** + *FUNCTION NAME:getCC1101 + *FUNCTION :Test Spi connection and return 1 when true. + *INPUT :none + *OUTPUT :none + ****************************************************************/ +bool ELECHOUSE_CC1101::getCC1101(void) { + setSpi(); + if (SpiReadStatus(0x31) > 0) { + return 1; + } else { + return 0; + } +} +/**************************************************************** + *FUNCTION NAME:getMode + *FUNCTION :Return the Mode. Sidle = 0, TX = 1, Rx = 2. + *INPUT :none + *OUTPUT :none + ****************************************************************/ +byte ELECHOUSE_CC1101::getMode(void) { return trxstate; } +/**************************************************************** + *FUNCTION NAME:Set Sync_Word + *FUNCTION :Sync Word + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::setSyncWord(byte sh, byte sl) { + SpiWriteReg(CC1101_SYNC1, sh); + SpiWriteReg(CC1101_SYNC0, sl); +} +/**************************************************************** + *FUNCTION NAME:Set ADDR + *FUNCTION :Address used for packet filtration. Optional broadcast addresses + * are 0 (0x00) and 255 (0xFF). INPUT :none OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::setAddr(byte v) { SpiWriteReg(CC1101_ADDR, v); } +/**************************************************************** + *FUNCTION NAME:Set PQT + *FUNCTION :Preamble quality estimator threshold + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::setPQT(byte v) { + Split_PKTCTRL1(); + pc1PQT = 0; + if (v > 7) { + v = 7; + } + pc1PQT = v * 32; + SpiWriteReg(CC1101_PKTCTRL1, pc1PQT + pc1CRC_AF + pc1APP_ST + pc1ADRCHK); +} +/**************************************************************** + *FUNCTION NAME:Set CRC_AUTOFLUSH + *FUNCTION :Enable automatic flush of RX FIFO when CRC is not OK + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::setCRC_AF(bool v) { + Split_PKTCTRL1(); + pc1CRC_AF = 0; + if (v == 1) { + pc1CRC_AF = 8; + } + SpiWriteReg(CC1101_PKTCTRL1, pc1PQT + pc1CRC_AF + pc1APP_ST + pc1ADRCHK); +} +/**************************************************************** + *FUNCTION NAME:Set APPEND_STATUS + *FUNCTION :When enabled, two status bytes will be appended to the payload + * of the packet INPUT :none OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::setAppendStatus(bool v) { + Split_PKTCTRL1(); + pc1APP_ST = 0; + if (v == 1) { + pc1APP_ST = 4; + } + SpiWriteReg(CC1101_PKTCTRL1, pc1PQT + pc1CRC_AF + pc1APP_ST + pc1ADRCHK); +} +/**************************************************************** + *FUNCTION NAME:Set ADR_CHK + *FUNCTION :Controls address check configuration of received packages + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::setAdrChk(byte v) { + Split_PKTCTRL1(); + pc1ADRCHK = 0; + if (v > 3) { + v = 3; + } + pc1ADRCHK = v; + SpiWriteReg(CC1101_PKTCTRL1, pc1PQT + pc1CRC_AF + pc1APP_ST + pc1ADRCHK); +} +/**************************************************************** + *FUNCTION NAME:Set WHITE_DATA + *FUNCTION :Turn data whitening on / off. + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::setWhiteData(bool v) { + Split_PKTCTRL0(); + pc0WDATA = 0; + if (v == 1) { + pc0WDATA = 64; + } + SpiWriteReg(CC1101_PKTCTRL0, + pc0WDATA + pc0PktForm + pc0CRC_EN + pc0LenConf); +} +/**************************************************************** + *FUNCTION NAME:Set PKT_FORMAT + *FUNCTION :Format of RX and TX data + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::setPktFormat(byte v) { + Split_PKTCTRL0(); + pc0PktForm = 0; + if (v > 3) { + v = 3; + } + pc0PktForm = v * 16; + SpiWriteReg(CC1101_PKTCTRL0, + pc0WDATA + pc0PktForm + pc0CRC_EN + pc0LenConf); +} +/**************************************************************** + *FUNCTION NAME:Set CRC + *FUNCTION :CRC calculation in TX and CRC check in RX + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::setCrc(bool v) { + Split_PKTCTRL0(); + pc0CRC_EN = 0; + if (v == 1) { + pc0CRC_EN = 4; + } + SpiWriteReg(CC1101_PKTCTRL0, + pc0WDATA + pc0PktForm + pc0CRC_EN + pc0LenConf); +} +/**************************************************************** + *FUNCTION NAME:Set LENGTH_CONFIG + *FUNCTION :Configure the packet length + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::setLengthConfig(byte v) { + Split_PKTCTRL0(); + pc0LenConf = 0; + if (v > 3) { + v = 3; + } + pc0LenConf = v; + SpiWriteReg(CC1101_PKTCTRL0, + pc0WDATA + pc0PktForm + pc0CRC_EN + pc0LenConf); +} +/**************************************************************** + *FUNCTION NAME:Set PACKET_LENGTH + *FUNCTION :Indicates the packet length + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::setPacketLength(byte v) { + SpiWriteReg(CC1101_PKTLEN, v); +} +/**************************************************************** + *FUNCTION NAME:Set DCFILT_OFF + *FUNCTION :Disable digital DC blocking filter before demodulator + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::setDcFilterOff(bool v) { + Split_MDMCFG2(); + m2DCOFF = 0; + if (v == 1) { + m2DCOFF = 128; + } + SpiWriteReg(CC1101_MDMCFG2, m2DCOFF + m2MODFM + m2MANCH + m2SYNCM); +} +/**************************************************************** + *FUNCTION NAME:Set MANCHESTER + *FUNCTION :Enables Manchester encoding/decoding + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::setManchester(bool v) { + Split_MDMCFG2(); + m2MANCH = 0; + if (v == 1) { + m2MANCH = 8; + } + SpiWriteReg(CC1101_MDMCFG2, m2DCOFF + m2MODFM + m2MANCH + m2SYNCM); +} +/**************************************************************** + *FUNCTION NAME:Set SYNC_MODE + *FUNCTION :Combined sync-word qualifier mode + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::setSyncMode(byte v) { + Split_MDMCFG2(); + m2SYNCM = 0; + if (v > 7) { + v = 7; + } + m2SYNCM = v; + SpiWriteReg(CC1101_MDMCFG2, m2DCOFF + m2MODFM + m2MANCH + m2SYNCM); +} +/**************************************************************** + *FUNCTION NAME:Set FEC + *FUNCTION :Enable Forward Error Correction (FEC) + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::setFEC(bool v) { + Split_MDMCFG1(); + m1FEC = 0; + if (v == 1) { + m1FEC = 128; + } + SpiWriteReg(CC1101_MDMCFG1, m1FEC + m1PRE + m1CHSP); +} +/**************************************************************** + *FUNCTION NAME:Set PRE + *FUNCTION :Sets the minimum number of preamble bytes to be transmitted. + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::setPRE(byte v) { + Split_MDMCFG1(); + m1PRE = 0; + if (v > 7) { + v = 7; + } + m1PRE = v * 16; + SpiWriteReg(CC1101_MDMCFG1, m1FEC + m1PRE + m1CHSP); +} +/**************************************************************** + *FUNCTION NAME:Set Channel + *FUNCTION :none + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::setChannel(byte ch) { + chan = ch; + SpiWriteReg(CC1101_CHANNR, chan); +} +/**************************************************************** + *FUNCTION NAME:Set Channel spacing + *FUNCTION :none + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::setChsp(float f) { + Split_MDMCFG1(); + byte MDMCFG0 = 0; + m1CHSP = 0; + if (f > 405.456543) { + f = 405.456543; + } + if (f < 25.390625) { + f = 25.390625; + } + for (int i = 0; i < 5; i++) { + if (f <= 50.682068) { + f -= 25.390625; + f /= 0.0991825; + MDMCFG0 = f; + float s1 = (f - MDMCFG0) * 10; + if (s1 >= 5) { + MDMCFG0++; + } + i = 5; + } else { + m1CHSP++; + f /= 2; + } + } + SpiWriteReg(19, m1CHSP + m1FEC + m1PRE); + SpiWriteReg(20, MDMCFG0); +} +/**************************************************************** + *FUNCTION NAME:Set Receive bandwidth + *FUNCTION :none + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::setRxBW(float f) { + Split_MDMCFG4(); + int s1 = 3; + int s2 = 3; + for (int i = 0; i < 3; i++) { + if (f > 101.5625) { + f /= 2; + s1--; + } else { + i = 3; + } + } + for (int i = 0; i < 3; i++) { + if (f > 58.1) { + f /= 1.25; + s2--; + } else { + i = 3; + } + } + s1 *= 64; + s2 *= 16; + m4RxBw = s1 + s2; + SpiWriteReg(16, m4RxBw + m4DaRa); +} +/**************************************************************** + *FUNCTION NAME:Set Data Rate + *FUNCTION :none + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::setDRate(float d) { + Split_MDMCFG4(); + float c = d; + byte MDMCFG3 = 0; + if (c > 1621.83) { + c = 1621.83; + } + if (c < 0.0247955) { + c = 0.0247955; + } + m4DaRa = 0; + for (int i = 0; i < 20; i++) { + if (c <= 0.0494942) { + c = c - 0.0247955; + c = c / 0.00009685; + MDMCFG3 = c; + float s1 = (c - MDMCFG3) * 10; + if (s1 >= 5) { + MDMCFG3++; + } + i = 20; + } else { + m4DaRa++; + c = c / 2; + } + } + SpiWriteReg(16, m4RxBw + m4DaRa); + SpiWriteReg(17, MDMCFG3); +} +/**************************************************************** + *FUNCTION NAME:Set Devitation + *FUNCTION :none + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::setDeviation(float d) { + float f = 1.586914; + float v = 0.19836425; + int c = 0; + if (d > 380.859375) { + d = 380.859375; + } + if (d < 1.586914) { + d = 1.586914; + } + for (int i = 0; i < 255; i++) { + f += v; + if (c == 7) { + v *= 2; + c = -1; + i += 8; + } + if (f >= d) { + c = i; + i = 255; + } + c++; + } + SpiWriteReg(21, c); +} +/**************************************************************** + *FUNCTION NAME:Split PKTCTRL0 + *FUNCTION :none + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::Split_PKTCTRL1(void) { + int calc = SpiReadStatus(7); + pc1PQT = 0; + pc1CRC_AF = 0; + pc1APP_ST = 0; + pc1ADRCHK = 0; + for (bool i = 0; i == 0;) { + if (calc >= 32) { + calc -= 32; + pc1PQT += 32; + } else if (calc >= 8) { + calc -= 8; + pc1CRC_AF += 8; + } else if (calc >= 4) { + calc -= 4; + pc1APP_ST += 4; + } else { + pc1ADRCHK = calc; + i = 1; + } + } +} +/**************************************************************** + *FUNCTION NAME:Split PKTCTRL0 + *FUNCTION :none + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::Split_PKTCTRL0(void) { + int calc = SpiReadStatus(8); + pc0WDATA = 0; + pc0PktForm = 0; + pc0CRC_EN = 0; + pc0LenConf = 0; + for (bool i = 0; i == 0;) { + if (calc >= 64) { + calc -= 64; + pc0WDATA += 64; + } else if (calc >= 16) { + calc -= 16; + pc0PktForm += 16; + } else if (calc >= 4) { + calc -= 4; + pc0CRC_EN += 4; + } else { + pc0LenConf = calc; + i = 1; + } + } +} +/**************************************************************** + *FUNCTION NAME:Split MDMCFG1 + *FUNCTION :none + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::Split_MDMCFG1(void) { + int calc = SpiReadStatus(19); + m1FEC = 0; + m1PRE = 0; + m1CHSP = 0; + int s2 = 0; + for (bool i = 0; i == 0;) { + if (calc >= 128) { + calc -= 128; + m1FEC += 128; + } else if (calc >= 16) { + calc -= 16; + m1PRE += 16; + } else { + m1CHSP = calc; + i = 1; + } + } +} +/**************************************************************** + *FUNCTION NAME:Split MDMCFG2 + *FUNCTION :none + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::Split_MDMCFG2(void) { + int calc = SpiReadStatus(18); + m2DCOFF = 0; + m2MODFM = 0; + m2MANCH = 0; + m2SYNCM = 0; + for (bool i = 0; i == 0;) { + if (calc >= 128) { + calc -= 128; + m2DCOFF += 128; + } else if (calc >= 16) { + calc -= 16; + m2MODFM += 16; + } else if (calc >= 8) { + calc -= 8; + m2MANCH += 8; + } else { + m2SYNCM = calc; + i = 1; + } + } +} +/**************************************************************** + *FUNCTION NAME:Split MDMCFG4 + *FUNCTION :none + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::Split_MDMCFG4(void) { + int calc = SpiReadStatus(16); + m4RxBw = 0; + m4DaRa = 0; + for (bool i = 0; i == 0;) { + if (calc >= 64) { + calc -= 64; + m4RxBw += 64; + } else if (calc >= 16) { + calc -= 16; + m4RxBw += 16; + } else { + m4DaRa = calc; + i = 1; + } + } +} +/**************************************************************** + *FUNCTION NAME:RegConfigSettings + *FUNCTION :CC1101 register config //details refer datasheet of + * CC1101/CC1100// INPUT :none OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::RegConfigSettings(void) { + SpiWriteReg(CC1101_FSCTRL1, 0x06); + + setCCMode(ccmode); + setMHZ(MHz); + + SpiWriteReg(CC1101_MDMCFG1, 0x02); + SpiWriteReg(CC1101_MDMCFG0, 0xF8); + SpiWriteReg(CC1101_CHANNR, chan); + SpiWriteReg(CC1101_DEVIATN, 0x47); + SpiWriteReg(CC1101_FREND1, 0x56); + SpiWriteReg(CC1101_MCSM0, 0x18); + SpiWriteReg(CC1101_FOCCFG, 0x16); + SpiWriteReg(CC1101_BSCFG, 0x1C); + SpiWriteReg(CC1101_AGCCTRL2, 0xC7); + SpiWriteReg(CC1101_AGCCTRL1, 0x00); + SpiWriteReg(CC1101_AGCCTRL0, 0xB2); + SpiWriteReg(CC1101_FSCAL3, 0xE9); + SpiWriteReg(CC1101_FSCAL2, 0x2A); + SpiWriteReg(CC1101_FSCAL1, 0x00); + SpiWriteReg(CC1101_FSCAL0, 0x1F); + SpiWriteReg(CC1101_FSTEST, 0x59); + SpiWriteReg(CC1101_TEST2, 0x81); + SpiWriteReg(CC1101_TEST1, 0x35); + SpiWriteReg(CC1101_TEST0, 0x09); + SpiWriteReg(CC1101_PKTCTRL1, 0x04); + SpiWriteReg(CC1101_ADDR, 0x00); + SpiWriteReg(CC1101_PKTLEN, 0x00); +} +/**************************************************************** + *FUNCTION NAME:SetTx + *FUNCTION :set CC1101 send data + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::SetTx(void) { + SpiStrobe(CC1101_SIDLE); + SpiStrobe(CC1101_STX); // start send + trxstate = 1; +} +/**************************************************************** + *FUNCTION NAME:SetRx + *FUNCTION :set CC1101 to receive state + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::SetRx(void) { + SpiStrobe(CC1101_SIDLE); + SpiStrobe(CC1101_SRX); // start receive + trxstate = 2; +} +/**************************************************************** + *FUNCTION NAME:SetTx + *FUNCTION :set CC1101 send data and change frequency + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::SetTx(float mhz) { + SpiStrobe(CC1101_SIDLE); + setMHZ(mhz); + SpiStrobe(CC1101_STX); // start send + trxstate = 1; +} +/**************************************************************** + *FUNCTION NAME:SetRx + *FUNCTION :set CC1101 to receive state and change frequency + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::SetRx(float mhz) { + SpiStrobe(CC1101_SIDLE); + setMHZ(mhz); + SpiStrobe(CC1101_SRX); // start receive + trxstate = 2; +} +/**************************************************************** + *FUNCTION NAME:RSSI Level + *FUNCTION :Calculating the RSSI Level + *INPUT :none + *OUTPUT :none + ****************************************************************/ +int ELECHOUSE_CC1101::getRssi(void) { + int rssi; + rssi = SpiReadStatus(CC1101_RSSI); + if (rssi >= 128) { + rssi = (rssi - 256) / 2 - 74; + } else { + rssi = (rssi / 2) - 74; + } + return rssi; +} +/**************************************************************** + *FUNCTION NAME:LQI Level + *FUNCTION :get Lqi state + *INPUT :none + *OUTPUT :none + ****************************************************************/ +byte ELECHOUSE_CC1101::getLqi(void) { + byte lqi; + lqi = SpiReadStatus(CC1101_LQI); + return lqi; +} +/**************************************************************** + *FUNCTION NAME:SetSres + *FUNCTION :Reset CC1101 + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::setSres(void) { + SpiStrobe(CC1101_SRES); + trxstate = 0; +} +/**************************************************************** + *FUNCTION NAME:setSidle + *FUNCTION :set Rx / TX Off + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::setSidle(void) { + SpiStrobe(CC1101_SIDLE); + trxstate = 0; +} +/**************************************************************** + *FUNCTION NAME:goSleep + *FUNCTION :set cc1101 Sleep on + *INPUT :none + *OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::goSleep(void) { + trxstate = 0; + SpiStrobe(0x36); // Exit RX / TX, turn off frequency synthesizer and exit + SpiStrobe(0x39); // Enter power down mode when CSn goes high. +} +/**************************************************************** + *FUNCTION NAME:Char direct SendData + *FUNCTION :use CC1101 send data + *INPUT :txBuffer: data array to send; size: number of data to send, no + * more than 61 OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::SendData(char *txchar) { + int len = strlen(txchar); + byte chartobyte[len]; + for (int i = 0; i < len; i++) { + chartobyte[i] = txchar[i]; + } + SendData(chartobyte, len); +} +/**************************************************************** + *FUNCTION NAME:SendData + *FUNCTION :use CC1101 send data + *INPUT :txBuffer: data array to send; size: number of data to send, no + * more than 61 OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::SendData(byte *txBuffer, byte size) { + SpiWriteReg(CC1101_TXFIFO, size); + SpiWriteBurstReg(CC1101_TXFIFO, txBuffer, size); // write data to send + SpiStrobe(CC1101_SIDLE); + SpiStrobe(CC1101_STX); // start send + while (!digitalRead(GDO0)) + ; // Wait for GDO0 to be set -> sync transmitted + while (digitalRead(GDO0)) + ; // Wait for GDO0 to be cleared -> end of packet + SpiStrobe(CC1101_SFTX); // flush TXfifo + trxstate = 1; +} +/**************************************************************** + *FUNCTION NAME:Char direct SendData + *FUNCTION :use CC1101 send data without GDO + *INPUT :txBuffer: data array to send; size: number of data to send, no + * more than 61 OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::SendData(char *txchar, int t) { + int len = strlen(txchar); + byte chartobyte[len]; + for (int i = 0; i < len; i++) { + chartobyte[i] = txchar[i]; + } + SendData(chartobyte, len, t); +} +/**************************************************************** + *FUNCTION NAME:SendData + *FUNCTION :use CC1101 send data without GDO + *INPUT :txBuffer: data array to send; size: number of data to send, no + * more than 61 OUTPUT :none + ****************************************************************/ +void ELECHOUSE_CC1101::SendData(byte *txBuffer, byte size, int t) { + SpiWriteReg(CC1101_TXFIFO, size); + SpiWriteBurstReg(CC1101_TXFIFO, txBuffer, size); // write data to send + SpiStrobe(CC1101_SIDLE); + SpiStrobe(CC1101_STX); // start send + delay(t); + SpiStrobe(CC1101_SFTX); // flush TXfifo + trxstate = 1; +} +/**************************************************************** + *FUNCTION NAME:Check CRC + *FUNCTION :none + *INPUT :none + *OUTPUT :none + ****************************************************************/ +bool ELECHOUSE_CC1101::CheckCRC(void) { + byte lqi = SpiReadStatus(CC1101_LQI); + bool crc_ok = bitRead(lqi, 7); + if (crc_ok == 1) { + return 1; + } else { + SpiStrobe(CC1101_SFRX); + SpiStrobe(CC1101_SRX); + return 0; + } +} +/**************************************************************** + *FUNCTION NAME:CheckRxFifo + *FUNCTION :check receive data or not + *INPUT :none + *OUTPUT :flag: 0 no data; 1 receive data + ****************************************************************/ +bool ELECHOUSE_CC1101::CheckRxFifo(int t) { + if (trxstate != 2) { + SetRx(); + } + if (SpiReadStatus(CC1101_RXBYTES) & BYTES_IN_RXFIFO) { + delay(t); + return 1; + } else { + return 0; + } +} +/**************************************************************** + *FUNCTION NAME:CheckReceiveFlag + *FUNCTION :check receive data or not + *INPUT :none + *OUTPUT :flag: 0 no data; 1 receive data + ****************************************************************/ +byte ELECHOUSE_CC1101::CheckReceiveFlag(void) { + if (trxstate != 2) { + SetRx(); + } + if (digitalRead(GDO0)) // receive data + { + while (digitalRead(GDO0)) + ; + return 1; + } else // no data + { + return 0; + } +} +/**************************************************************** + *FUNCTION NAME:ReceiveData + *FUNCTION :read data received from RXfifo + *INPUT :rxBuffer: buffer to store data + *OUTPUT :size of data received + ****************************************************************/ +byte ELECHOUSE_CC1101::ReceiveData(byte *rxBuffer) { + byte size; + byte status[2]; + + if (SpiReadStatus(CC1101_RXBYTES) & BYTES_IN_RXFIFO) { + size = SpiReadReg(CC1101_RXFIFO); + SpiReadBurstReg(CC1101_RXFIFO, rxBuffer, size); + SpiReadBurstReg(CC1101_RXFIFO, status, 2); + SpiStrobe(CC1101_SFRX); + SpiStrobe(CC1101_SRX); + return size; + } else { + SpiStrobe(CC1101_SFRX); + SpiStrobe(CC1101_SRX); + return 0; + } +} +ELECHOUSE_CC1101 ELECHOUSE_cc1101; \ No newline at end of file diff --git a/lib/ELECHOUSE_CC1101/ELECHOUSE_CC1101_SRC_DRV.h b/lib/ELECHOUSE_CC1101/ELECHOUSE_CC1101_SRC_DRV.h new file mode 100644 index 0000000..fd6df0a --- /dev/null +++ b/lib/ELECHOUSE_CC1101/ELECHOUSE_CC1101_SRC_DRV.h @@ -0,0 +1,203 @@ +/* + ELECHOUSE_CC1101.cpp - CC1101 module library + Copyright (c) 2010 Michael. + Author: Michael, + Version: November 12, 2010 + + This library is designed to use CC1101/CC1100 module on Arduino platform. + CC1101/CC1100 module is an useful wireless module.Using the functions of the + library, you can easily send and receive data by the CC1101/CC1100 module. + Just have fun! + For the details, please refer to the datasheet of CC1100/CC1101. +---------------------------------------------------------------------------------------------------------------- +cc1101 Driver for RC Switch. Mod by Little Satan. With permission to modify and +publish Wilson Shen (ELECHOUSE). +---------------------------------------------------------------------------------------------------------------- +*/ +#ifndef ELECHOUSE_CC1101_SRC_DRV_h +#define ELECHOUSE_CC1101_SRC_DRV_h + +#include + +//***************************************CC1101 +//define**************************************************// +// CC1101 CONFIG REGSITER +#define CC1101_IOCFG2 0x00 // GDO2 output pin configuration +#define CC1101_IOCFG1 0x01 // GDO1 output pin configuration +#define CC1101_IOCFG0 0x02 // GDO0 output pin configuration +#define CC1101_FIFOTHR 0x03 // RX FIFO and TX FIFO thresholds +#define CC1101_SYNC1 0x04 // Sync word, high INT8U +#define CC1101_SYNC0 0x05 // Sync word, low INT8U +#define CC1101_PKTLEN 0x06 // Packet length +#define CC1101_PKTCTRL1 0x07 // Packet automation control +#define CC1101_PKTCTRL0 0x08 // Packet automation control +#define CC1101_ADDR 0x09 // Device address +#define CC1101_CHANNR 0x0A // Channel number +#define CC1101_FSCTRL1 0x0B // Frequency synthesizer control +#define CC1101_FSCTRL0 0x0C // Frequency synthesizer control +#define CC1101_FREQ2 0x0D // Frequency control word, high INT8U +#define CC1101_FREQ1 0x0E // Frequency control word, middle INT8U +#define CC1101_FREQ0 0x0F // Frequency control word, low INT8U +#define CC1101_MDMCFG4 0x10 // Modem configuration +#define CC1101_MDMCFG3 0x11 // Modem configuration +#define CC1101_MDMCFG2 0x12 // Modem configuration +#define CC1101_MDMCFG1 0x13 // Modem configuration +#define CC1101_MDMCFG0 0x14 // Modem configuration +#define CC1101_DEVIATN 0x15 // Modem deviation setting +#define CC1101_MCSM2 0x16 // Main Radio Control State Machine configuration +#define CC1101_MCSM1 0x17 // Main Radio Control State Machine configuration +#define CC1101_MCSM0 0x18 // Main Radio Control State Machine configuration +#define CC1101_FOCCFG 0x19 // Frequency Offset Compensation configuration +#define CC1101_BSCFG 0x1A // Bit Synchronization configuration +#define CC1101_AGCCTRL2 0x1B // AGC control +#define CC1101_AGCCTRL1 0x1C // AGC control +#define CC1101_AGCCTRL0 0x1D // AGC control +#define CC1101_WOREVT1 0x1E // High INT8U Event 0 timeout +#define CC1101_WOREVT0 0x1F // Low INT8U Event 0 timeout +#define CC1101_WORCTRL 0x20 // Wake On Radio control +#define CC1101_FREND1 0x21 // Front end RX configuration +#define CC1101_FREND0 0x22 // Front end TX configuration +#define CC1101_FSCAL3 0x23 // Frequency synthesizer calibration +#define CC1101_FSCAL2 0x24 // Frequency synthesizer calibration +#define CC1101_FSCAL1 0x25 // Frequency synthesizer calibration +#define CC1101_FSCAL0 0x26 // Frequency synthesizer calibration +#define CC1101_RCCTRL1 0x27 // RC oscillator configuration +#define CC1101_RCCTRL0 0x28 // RC oscillator configuration +#define CC1101_FSTEST 0x29 // Frequency synthesizer calibration control +#define CC1101_PTEST 0x2A // Production test +#define CC1101_AGCTEST 0x2B // AGC test +#define CC1101_TEST2 0x2C // Various test settings +#define CC1101_TEST1 0x2D // Various test settings +#define CC1101_TEST0 0x2E // Various test settings + +// CC1101 Strobe commands +#define CC1101_SRES 0x30 // Reset chip. +#define CC1101_SFSTXON \ + 0x31 // Enable and calibrate frequency synthesizer (if MCSM0.FS_AUTOCAL=1). + // If in RX/TX: Go to a wait state where only the synthesizer is + // running (for quick RX / TX turnaround). +#define CC1101_SXOFF 0x32 // Turn off crystal oscillator. +#define CC1101_SCAL \ + 0x33 // Calibrate frequency synthesizer and turn it off + // (enables quick start). +#define CC1101_SRX \ + 0x34 // Enable RX. Perform calibration first if coming from IDLE and + // MCSM0.FS_AUTOCAL=1. +#define CC1101_STX \ + 0x35 // In IDLE state: Enable TX. Perform calibration first if + // MCSM0.FS_AUTOCAL=1. If in RX state and CCA is enabled: + // Only go to TX if channel is clear. +#define CC1101_SIDLE \ + 0x36 // Exit RX / TX, turn off frequency synthesizer and exit + // Wake-On-Radio mode if applicable. +#define CC1101_SAFC 0x37 // Perform AFC adjustment of the frequency synthesizer +#define CC1101_SWOR 0x38 // Start automatic RX polling sequence (Wake-on-Radio) +#define CC1101_SPWD 0x39 // Enter power down mode when CSn goes high. +#define CC1101_SFRX 0x3A // Flush the RX FIFO buffer. +#define CC1101_SFTX 0x3B // Flush the TX FIFO buffer. +#define CC1101_SWORRST 0x3C // Reset real time clock. +#define CC1101_SNOP \ + 0x3D // No operation. May be used to pad strobe commands to two + // INT8Us for simpler software. +// CC1101 STATUS REGSITER +#define CC1101_PARTNUM 0x30 +#define CC1101_VERSION 0x31 +#define CC1101_FREQEST 0x32 +#define CC1101_LQI 0x33 +#define CC1101_RSSI 0x34 +#define CC1101_MARCSTATE 0x35 +#define CC1101_WORTIME1 0x36 +#define CC1101_WORTIME0 0x37 +#define CC1101_PKTSTATUS 0x38 +#define CC1101_VCO_VC_DAC 0x39 +#define CC1101_TXBYTES 0x3A +#define CC1101_RXBYTES 0x3B + +// CC1101 PATABLE,TXFIFO,RXFIFO +#define CC1101_PATABLE 0x3E +#define CC1101_TXFIFO 0x3F +#define CC1101_RXFIFO 0x3F + +//************************************* class +//**************************************************// +class ELECHOUSE_CC1101 { + private: + void SpiStart(void); + void SpiEnd(void); + void GDO_Set(void); + void GDO0_Set(void); + void Reset(void); + void setSpi(void); + void RegConfigSettings(void); + void Calibrate(void); + void Split_PKTCTRL0(void); + void Split_PKTCTRL1(void); + void Split_MDMCFG1(void); + void Split_MDMCFG2(void); + void Split_MDMCFG4(void); + + public: + void Init(void); + byte SpiReadStatus(byte addr); + void setSpiPin(byte sck, byte miso, byte mosi, byte ss); + void addSpiPin(byte sck, byte miso, byte mosi, byte ss, byte modul); + void setGDO(byte gdo0, byte gdo2); + void setGDO0(byte gdo0); + void addGDO(byte gdo0, byte gdo2, byte modul); + void addGDO0(byte gdo0, byte modul); + void setModul(byte modul); + void setCCMode(bool s); + void setModulation(byte m); + void setPA(int p); + void setMHZ(float mhz); + void setChannel(byte chnl); + void setChsp(float f); + void setRxBW(float f); + void setDRate(float d); + void setDeviation(float d); + void SetTx(void); + void SetRx(void); + void SetTx(float mhz); + void SetRx(float mhz); + int getRssi(void); + byte getLqi(void); + void setSres(void); + void setSidle(void); + void goSleep(void); + void SendData(byte *txBuffer, byte size); + void SendData(char *txchar); + void SendData(byte *txBuffer, byte size, int t); + void SendData(char *txchar, int t); + byte CheckReceiveFlag(void); + byte ReceiveData(byte *rxBuffer); + bool CheckCRC(void); + void SpiStrobe(byte strobe); + void SpiWriteReg(byte addr, byte value); + void SpiWriteBurstReg(byte addr, byte *buffer, byte num); + byte SpiReadReg(byte addr); + void SpiReadBurstReg(byte addr, byte *buffer, byte num); + void setClb(byte b, byte s, byte e); + bool getCC1101(void); + byte getMode(void); + void setSyncWord(byte sh, byte sl); + void setAddr(byte v); + void setWhiteData(bool v); + void setPktFormat(byte v); + void setCrc(bool v); + void setLengthConfig(byte v); + void setPacketLength(byte v); + void setDcFilterOff(bool v); + void setManchester(bool v); + void setSyncMode(byte v); + void setFEC(bool v); + void setPRE(byte v); + void setPQT(byte v); + void setCRC_AF(bool v); + void setAppendStatus(bool v); + void setAdrChk(byte v); + bool CheckRxFifo(int t); +}; + +extern ELECHOUSE_CC1101 ELECHOUSE_cc1101; + +#endif \ No newline at end of file diff --git a/src/bluetooth/ble_mouse.cpp b/src/bluetooth/ble_mouse.cpp index 3499c5f..c627163 100644 --- a/src/bluetooth/ble_mouse.cpp +++ b/src/bluetooth/ble_mouse.cpp @@ -1,5 +1,5 @@ -#include "../config.h" -#include "../hid/badusb.h" +#include "config.h" +#include "hid/badusb.h" #include #include diff --git a/src/libs/Adafruit_PN532.cpp b/src/libs/Adafruit_PN532.cpp deleted file mode 100644 index 0a547b7..0000000 --- a/src/libs/Adafruit_PN532.cpp +++ /dev/null @@ -1,1832 +0,0 @@ -/**************************************************************************/ -/*! - @file Adafruit_PN532.cpp - - @section intro_sec Introduction - - Driver for NXP's PN532 NFC/13.56MHz RFID Transceiver - - This is a library for the Adafruit PN532 NFC/RFID breakout boards - This library works with the Adafruit NFC breakout - ----> https://www.adafruit.com/products/364 - - Check out the links above for our tutorials and wiring diagrams - These chips use SPI or I2C to communicate. - - Adafruit invests time and resources providing this open source code, - please support Adafruit and open-source hardware by purchasing - products from Adafruit! - - @section author Author - - Adafruit Industries - - @section license License - - BSD (see license.txt) - - @section HISTORY - - v2.2 - Added startPassiveTargetIDDetection() to start card detection and - readDetectedPassiveTargetID() to read it, useful when using the - IRQ pin. - - v2.1 - Added NTAG2xx helper functions - - v2.0 - Refactored to add I2C support from Adafruit_NFCShield_I2C library. - - v1.4 - Added setPassiveActivationRetries() - - v1.2 - Added writeGPIO() - - Added readGPIO() - - v1.1 - Changed readPassiveTargetID() to handle multiple UID sizes - - Added the following helper functions for text display - static void PrintHex(const byte * data, const uint32_t numBytes) - static void PrintHexChar(const byte * pbtData, const uint32_t - numBytes) - - Added the following Mifare Classic functions: - bool mifareclassic_IsFirstBlock (uint32_t uiBlock) - bool mifareclassic_IsTrailerBlock (uint32_t uiBlock) - uint8_t mifareclassic_AuthenticateBlock (uint8_t * uid, uint8_t - uidLen, uint32_t blockNumber, uint8_t keyNumber, uint8_t * keyData) uint8_t - mifareclassic_ReadDataBlock (uint8_t blockNumber, uint8_t * data) uint8_t - mifareclassic_WriteDataBlock (uint8_t blockNumber, uint8_t * data) - - Added the following Mifare Ultalight functions: - uint8_t mifareultralight_ReadPage (uint8_t page, uint8_t * buffer) -*/ -/**************************************************************************/ - -#include "Adafruit_PN532.h" - -byte pn532ack[] = {0x00, 0x00, 0xFF, - 0x00, 0xFF, 0x00}; ///< ACK message from PN532 -byte pn532response_firmwarevers[] = { - 0x00, 0x00, 0xFF, - 0x06, 0xFA, 0xD5}; ///< Expected firmware version message from PN532 - -// Uncomment these lines to enable debug output for PN532(SPI) and/or MIFARE -// related code - -// #define PN532DEBUG -// #define MIFAREDEBUG - -// If using Native Port on Arduino Zero or Due define as SerialUSB -#define PN532DEBUGPRINT Serial ///< Fixed name for debug Serial instance -// #define PN532DEBUGPRINT SerialUSB ///< Fixed name for debug Serial instance - -#define PN532_PACKBUFFSIZ 64 ///< Packet buffer size in bytes -byte pn532_packetbuffer[PN532_PACKBUFFSIZ]; ///< Packet buffer used in various - ///< transactions - -/**************************************************************************/ -/*! - @brief Instantiates a new PN532 class using software SPI. - - @param clk SPI clock pin (SCK) - @param miso SPI MISO pin - @param mosi SPI MOSI pin - @param ss SPI chip select pin (CS/SSEL) -*/ -/**************************************************************************/ -Adafruit_PN532::Adafruit_PN532(uint8_t clk, uint8_t miso, uint8_t mosi, - uint8_t ss) { - _cs = ss; - spi_dev = new Adafruit_SPIDevice(ss, clk, miso, mosi, 1000000, - SPI_BITORDER_LSBFIRST, SPI_MODE0); -} - -/**************************************************************************/ -/*! - @brief Instantiates a new PN532 class using I2C. - - @param irq Location of the IRQ pin - @param reset Location of the RSTPD_N pin - @param theWire pointer to I2C bus to use -*/ -/**************************************************************************/ -Adafruit_PN532::Adafruit_PN532(uint8_t irq, uint8_t reset, TwoWire *theWire) - : _irq(irq), _reset(reset) { - pinMode(_irq, INPUT); - pinMode(_reset, OUTPUT); - i2c_dev = new Adafruit_I2CDevice(PN532_I2C_ADDRESS, theWire); -} - -/**************************************************************************/ -/*! - @brief Instantiates a new PN532 class using hardware SPI. - - @param ss SPI chip select pin (CS/SSEL) - @param theSPI pointer to the SPI bus to use -*/ -/**************************************************************************/ -Adafruit_PN532::Adafruit_PN532(uint8_t ss, SPIClass *theSPI) { - _cs = ss; - spi_dev = new Adafruit_SPIDevice(ss, 1000000, SPI_BITORDER_LSBFIRST, - SPI_MODE0, theSPI); -} - -/**************************************************************************/ -/*! - @brief Instantiates a new PN532 class using hardware UART (HSU). - - @param reset Location of the RSTPD_N pin - @param theSer pointer to HardWare Serial bus to use -*/ -/**************************************************************************/ -Adafruit_PN532::Adafruit_PN532(uint8_t reset, HardwareSerial *theSer) - : _reset(reset) { - pinMode(_reset, OUTPUT); - ser_dev = theSer; -} - -/**************************************************************************/ -/*! - @brief Setups the HW - - @returns true if successful, otherwise false -*/ -/**************************************************************************/ -bool Adafruit_PN532::begin() { - if (spi_dev) { - // SPI initialization - if (!spi_dev->begin()) { - return false; - } - } else if (i2c_dev) { - // I2C initialization - // PN532 will fail address check since its asleep, so suppress - if (!i2c_dev->begin(false)) { - return false; - } - } else if (ser_dev) { - ser_dev->begin(115200); - // clear out anything in read buffer - while (ser_dev->available()) - ser_dev->read(); - } else { - // no interface specified - return false; - } - reset(); // HW reset - put in known state - delay(10); - wakeup(); // hey! wakeup! - return true; -} - -/**************************************************************************/ -/*! - @brief Perform a hardware reset. Requires reset pin to have been provided. -*/ -/**************************************************************************/ -void Adafruit_PN532::reset(void) { - // see Datasheet p.209, Fig.48 for timings - if (_reset != -1) { - digitalWrite(_reset, LOW); - delay(1); // min 20ns - digitalWrite(_reset, HIGH); - delay(2); // max 2ms - } -} - -/**************************************************************************/ -/*! - @brief Wakeup from LowVbat mode into Normal Mode. -*/ -/**************************************************************************/ -void Adafruit_PN532::wakeup(void) { - // interface specific wakeups - each one is unique! - if (spi_dev) { - // hold CS low for 2ms - digitalWrite(_cs, LOW); - delay(2); - } else if (ser_dev) { - uint8_t w[3] = {0x55, 0x00, 0x00}; - ser_dev->write(w, 3); - delay(2); - } - - // PN532 will clock stretch I2C during SAMConfig as a "wakeup" - - // need to config SAM to stay in Normal Mode - SAMConfig(); -} - -/**************************************************************************/ -/*! - @brief Prints a hexadecimal value in plain characters - - @param data Pointer to the byte data - @param numBytes Data length in bytes -*/ -/**************************************************************************/ -void Adafruit_PN532::PrintHex(const byte *data, const uint32_t numBytes) { - uint32_t szPos; - for (szPos = 0; szPos < numBytes; szPos++) { - PN532DEBUGPRINT.print(F("0x")); - // Append leading 0 for small values - if (data[szPos] <= 0xF) - PN532DEBUGPRINT.print(F("0")); - PN532DEBUGPRINT.print(data[szPos] & 0xff, HEX); - if ((numBytes > 1) && (szPos != numBytes - 1)) { - PN532DEBUGPRINT.print(F(" ")); - } - } - PN532DEBUGPRINT.println(); -} - -/**************************************************************************/ -/*! - @brief Prints a hexadecimal value in plain characters, along with - the char equivalents in the following format - - 00 00 00 00 00 00 ...... - - @param data Pointer to the byte data - @param numBytes Data length in bytes -*/ -/**************************************************************************/ -void Adafruit_PN532::PrintHexChar(const byte *data, const uint32_t numBytes) { - uint32_t szPos; - for (szPos = 0; szPos < numBytes; szPos++) { - // Append leading 0 for small values - if (data[szPos] <= 0xF) - PN532DEBUGPRINT.print(F("0")); - PN532DEBUGPRINT.print(data[szPos], HEX); - if ((numBytes > 1) && (szPos != numBytes - 1)) { - PN532DEBUGPRINT.print(F(" ")); - } - } - PN532DEBUGPRINT.print(F(" ")); - for (szPos = 0; szPos < numBytes; szPos++) { - if (data[szPos] <= 0x1F) - PN532DEBUGPRINT.print(F(".")); - else - PN532DEBUGPRINT.print((char)data[szPos]); - } - PN532DEBUGPRINT.println(); -} - -/**************************************************************************/ -/*! - @brief Checks the firmware version of the PN5xx chip - - @returns The chip's firmware version and ID -*/ -/**************************************************************************/ -uint32_t Adafruit_PN532::getFirmwareVersion(void) { - uint32_t response; - - pn532_packetbuffer[0] = PN532_COMMAND_GETFIRMWAREVERSION; - - if (!sendCommandCheckAck(pn532_packetbuffer, 1)) { - return 0; - } - - // read data packet - readdata(pn532_packetbuffer, 13); - - // check some basic stuff - if (0 != memcmp((char *)pn532_packetbuffer, - (char *)pn532response_firmwarevers, 6)) { -#ifdef PN532DEBUG - PN532DEBUGPRINT.println(F("Firmware doesn't match!")); -#endif - return 0; - } - - int offset = 7; - response = pn532_packetbuffer[offset++]; - response <<= 8; - response |= pn532_packetbuffer[offset++]; - response <<= 8; - response |= pn532_packetbuffer[offset++]; - response <<= 8; - response |= pn532_packetbuffer[offset++]; - - return response; -} - -/**************************************************************************/ -/*! - @brief Sends a command and waits a specified period for the ACK - - @param cmd Pointer to the command buffer - @param cmdlen The size of the command in bytes - @param timeout timeout before giving up - - @returns 1 if everything is OK, 0 if timeout occured before an - ACK was recieved -*/ -/**************************************************************************/ -// default timeout of one second -bool Adafruit_PN532::sendCommandCheckAck(uint8_t *cmd, uint8_t cmdlen, - uint16_t timeout) { - - // I2C works without using IRQ pin by polling for RDY byte - // seems to work best with some delays between transactions - uint8_t SLOWDOWN = 0; - if (i2c_dev || spi_dev) // SPI and I2C need 1ms slow for page reads - SLOWDOWN = 1; - - // write the command - writecommand(cmd, cmdlen); - - // I2C TUNING - delay(SLOWDOWN); - - // Wait for chip to say its ready! - if (!waitready(timeout)) { - return false; - } - -#ifdef PN532DEBUG - if (spi_dev == NULL) { - PN532DEBUGPRINT.println(F("IRQ received")); - } -#endif - - // read acknowledgement - if (!readack()) { -#ifdef PN532DEBUG - PN532DEBUGPRINT.println(F("No ACK frame received!")); -#endif - return false; - } - - // I2C TUNING - delay(SLOWDOWN); - - // Wait for chip to say its ready! - if (!waitready(timeout)) { - return false; - } - - return true; // ack'd command -} - -/**************************************************************************/ -/*! - @brief Writes an 8-bit value that sets the state of the PN532's GPIO - pins. - @param pinstate P3 pins state. - - @warning This function is provided exclusively for board testing and - is dangerous since it will throw an error if any pin other - than the ones marked "Can be used as GPIO" are modified! All - pins that can not be used as GPIO should ALWAYS be left high - (value = 1) or the system will become unstable and a HW reset - will be required to recover the PN532. - - pinState[0] = P30 Can be used as GPIO - pinState[1] = P31 Can be used as GPIO - pinState[2] = P32 *** RESERVED (Must be 1!) *** - pinState[3] = P33 Can be used as GPIO - pinState[4] = P34 *** RESERVED (Must be 1!) *** - pinState[5] = P35 Can be used as GPIO - - @return 1 if everything executed properly, 0 for an error -*/ -/**************************************************************************/ -bool Adafruit_PN532::writeGPIO(uint8_t pinstate) { - // uint8_t errorbit; - - // Make sure pinstate does not try to toggle P32 or P34 - pinstate |= (1 << PN532_GPIO_P32) | (1 << PN532_GPIO_P34); - - // Fill command buffer - pn532_packetbuffer[0] = PN532_COMMAND_WRITEGPIO; - pn532_packetbuffer[1] = PN532_GPIO_VALIDATIONBIT | pinstate; // P3 Pins - pn532_packetbuffer[2] = 0x00; // P7 GPIO Pins (not used ... taken by SPI) - -#ifdef PN532DEBUG - PN532DEBUGPRINT.print(F("Writing P3 GPIO: ")); - PN532DEBUGPRINT.println(pn532_packetbuffer[1], HEX); -#endif - - // Send the WRITEGPIO command (0x0E) - if (!sendCommandCheckAck(pn532_packetbuffer, 3)) - return 0x0; - - // Read response packet (00 FF PLEN PLENCHECKSUM D5 CMD+1(0x0F) DATACHECKSUM - // 00) - readdata(pn532_packetbuffer, 8); - -#ifdef PN532DEBUG - PN532DEBUGPRINT.print(F("Received: ")); - PrintHex(pn532_packetbuffer, 8); - PN532DEBUGPRINT.println(); -#endif - - int offset = 6; - return (pn532_packetbuffer[offset] == 0x0F); -} - -/**************************************************************************/ -/*! - Reads the state of the PN532's GPIO pins - - @returns An 8-bit value containing the pin state where: - - pinState[0] = P30 - pinState[1] = P31 - pinState[2] = P32 - pinState[3] = P33 - pinState[4] = P34 - pinState[5] = P35 -*/ -/**************************************************************************/ -uint8_t Adafruit_PN532::readGPIO(void) { - pn532_packetbuffer[0] = PN532_COMMAND_READGPIO; - - // Send the READGPIO command (0x0C) - if (!sendCommandCheckAck(pn532_packetbuffer, 1)) - return 0x0; - - // Read response packet (00 FF PLEN PLENCHECKSUM D5 CMD+1(0x0D) P3 P7 IO1 - // DATACHECKSUM 00) - readdata(pn532_packetbuffer, 11); - - /* READGPIO response should be in the following format: - - byte Description - ------------- ------------------------------------------ - b0..5 Frame header and preamble (with I2C there is an extra - 0x00) b6 P3 GPIO Pins b7 P7 GPIO Pins (not used - ... taken by SPI) b8 Interface Mode Pins (not used ... bus - select pins) b9..10 checksum */ - - int p3offset = 7; - -#ifdef PN532DEBUG - PN532DEBUGPRINT.print(F("Received: ")); - PrintHex(pn532_packetbuffer, 11); - PN532DEBUGPRINT.println(); - PN532DEBUGPRINT.print(F("P3 GPIO: 0x")); - PN532DEBUGPRINT.println(pn532_packetbuffer[p3offset], HEX); - PN532DEBUGPRINT.print(F("P7 GPIO: 0x")); - PN532DEBUGPRINT.println(pn532_packetbuffer[p3offset + 1], HEX); - PN532DEBUGPRINT.print(F("IO GPIO: 0x")); - PN532DEBUGPRINT.println(pn532_packetbuffer[p3offset + 2], HEX); - // Note: You can use the IO GPIO value to detect the serial bus being used - switch (pn532_packetbuffer[p3offset + 2]) { - case 0x00: // Using UART - PN532DEBUGPRINT.println(F("Using UART (IO = 0x00)")); - break; - case 0x01: // Using I2C - PN532DEBUGPRINT.println(F("Using I2C (IO = 0x01)")); - break; - case 0x02: // Using SPI - PN532DEBUGPRINT.println(F("Using SPI (IO = 0x02)")); - break; - } -#endif - - return pn532_packetbuffer[p3offset]; -} - -/**************************************************************************/ -/*! - @brief Configures the SAM (Secure Access Module) - @return true on success, false otherwise. -*/ -/**************************************************************************/ -bool Adafruit_PN532::SAMConfig(void) { - pn532_packetbuffer[0] = PN532_COMMAND_SAMCONFIGURATION; - pn532_packetbuffer[1] = 0x01; // normal mode; - pn532_packetbuffer[2] = 0x14; // timeout 50ms * 20 = 1 second - pn532_packetbuffer[3] = 0x01; // use IRQ pin! - - if (!sendCommandCheckAck(pn532_packetbuffer, 4)) - return false; - - // read data packet - readdata(pn532_packetbuffer, 9); - - int offset = 6; - return (pn532_packetbuffer[offset] == 0x15); -} - -/**************************************************************************/ -/*! - Sets the MxRtyPassiveActivation byte of the RFConfiguration register - - @param maxRetries 0xFF to wait forever, 0x00..0xFE to timeout - after mxRetries - - @returns 1 if everything executed properly, 0 for an error -*/ -/**************************************************************************/ -bool Adafruit_PN532::setPassiveActivationRetries(uint8_t maxRetries) { - pn532_packetbuffer[0] = PN532_COMMAND_RFCONFIGURATION; - pn532_packetbuffer[1] = 5; // Config item 5 (MaxRetries) - pn532_packetbuffer[2] = 0xFF; // MxRtyATR (default = 0xFF) - pn532_packetbuffer[3] = 0x01; // MxRtyPSL (default = 0x01) - pn532_packetbuffer[4] = maxRetries; - -#ifdef MIFAREDEBUG - PN532DEBUGPRINT.print(F("Setting MxRtyPassiveActivation to ")); - PN532DEBUGPRINT.print(maxRetries, DEC); - PN532DEBUGPRINT.println(F(" ")); -#endif - - if (!sendCommandCheckAck(pn532_packetbuffer, 5)) - return 0x0; // no ACK - - return 1; -} - -/***** ISO14443A Commands ******/ - -/**************************************************************************/ -/*! - @brief Waits for an ISO14443A target to enter the field and reads - its ID. - - @param cardbaudrate Baud rate of the card - @param uid Pointer to the array that will be populated - with the card's UID (up to 7 bytes) - @param uidLength Pointer to the variable that will hold the - length of the card's UID. - @param timeout Timeout in milliseconds. - - @return 1 if everything executed properly, 0 for an error -*/ -/**************************************************************************/ -bool Adafruit_PN532::readPassiveTargetID(uint8_t cardbaudrate, uint8_t *uid, - uint8_t *uidLength, uint16_t timeout) { - pn532_packetbuffer[0] = PN532_COMMAND_INLISTPASSIVETARGET; - pn532_packetbuffer[1] = - 1; // max 1 cards at once (we can set this to 2 later) - pn532_packetbuffer[2] = cardbaudrate; - - if (!sendCommandCheckAck(pn532_packetbuffer, 3, timeout)) { -#ifdef PN532DEBUG - PN532DEBUGPRINT.println(F("No card(s) read")); -#endif - return 0x0; // no cards read - } - - return readDetectedPassiveTargetID(uid, uidLength); -} - -/**************************************************************************/ -/*! - @brief Put the reader in detection mode, non blocking so interrupts - must be enabled. - @param cardbaudrate Baud rate of the card - @return 1 if everything executed properly, 0 for an error -*/ -/**************************************************************************/ -bool Adafruit_PN532::startPassiveTargetIDDetection(uint8_t cardbaudrate) { - pn532_packetbuffer[0] = PN532_COMMAND_INLISTPASSIVETARGET; - pn532_packetbuffer[1] = - 1; // max 1 cards at once (we can set this to 2 later) - pn532_packetbuffer[2] = cardbaudrate; - - return sendCommandCheckAck(pn532_packetbuffer, 3); -} - -/**************************************************************************/ -/*! - Reads the ID of the passive target the reader has deteceted. - - @param uid Pointer to the array that will be populated - with the card's UID (up to 7 bytes) - @param uidLength Pointer to the variable that will hold the - length of the card's UID. - - @returns 1 if everything executed properly, 0 for an error -*/ -/**************************************************************************/ -bool Adafruit_PN532::readDetectedPassiveTargetID(uint8_t *uid, - uint8_t *uidLength) { - // read data packet - readdata(pn532_packetbuffer, 20); - // check some basic stuff - - /* ISO14443A card response should be in the following format: - - byte Description - ------------- ------------------------------------------ - b0..6 Frame header and preamble - b7 Tags Found - b8 Tag Number (only one used in this example) - b9..10 SENS_RES - b11 SEL_RES - b12 NFCID Length - b13..NFCIDLen NFCID */ - -#ifdef MIFAREDEBUG - PN532DEBUGPRINT.print(F("Found ")); - PN532DEBUGPRINT.print(pn532_packetbuffer[7], DEC); - PN532DEBUGPRINT.println(F(" tags")); -#endif - if (pn532_packetbuffer[7] != 1) - return 0; - - uint16_t sens_res = pn532_packetbuffer[9]; - sens_res <<= 8; - sens_res |= pn532_packetbuffer[10]; -#ifdef MIFAREDEBUG - PN532DEBUGPRINT.print(F("ATQA: 0x")); - PN532DEBUGPRINT.println(sens_res, HEX); - PN532DEBUGPRINT.print(F("SAK: 0x")); - PN532DEBUGPRINT.println(pn532_packetbuffer[11], HEX); -#endif - - /* Card appears to be Mifare Classic */ - *uidLength = pn532_packetbuffer[12]; -#ifdef MIFAREDEBUG - PN532DEBUGPRINT.print(F("UID:")); -#endif - for (uint8_t i = 0; i < pn532_packetbuffer[12]; i++) { - uid[i] = pn532_packetbuffer[13 + i]; -#ifdef MIFAREDEBUG - PN532DEBUGPRINT.print(F(" 0x")); - PN532DEBUGPRINT.print(uid[i], HEX); -#endif - } -#ifdef MIFAREDEBUG - PN532DEBUGPRINT.println(); -#endif - - return 1; -} - -/**************************************************************************/ -/*! - @brief Exchanges an APDU with the currently inlisted peer - - @param send Pointer to data to send - @param sendLength Length of the data to send - @param response Pointer to response data - @param responseLength Pointer to the response data length - @return true on success, false otherwise. -*/ -/**************************************************************************/ -bool Adafruit_PN532::inDataExchange(uint8_t *send, uint8_t sendLength, - uint8_t *response, - uint8_t *responseLength) { - if (sendLength > PN532_PACKBUFFSIZ - 2) { -#ifdef PN532DEBUG - PN532DEBUGPRINT.println(F("APDU length too long for packet buffer")); -#endif - return false; - } - uint8_t i; - - pn532_packetbuffer[0] = 0x40; // PN532_COMMAND_INDATAEXCHANGE; - pn532_packetbuffer[1] = _inListedTag; - for (i = 0; i < sendLength; ++i) { - pn532_packetbuffer[i + 2] = send[i]; - } - - if (!sendCommandCheckAck(pn532_packetbuffer, sendLength + 2, 1000)) { -#ifdef PN532DEBUG - PN532DEBUGPRINT.println(F("Could not send APDU")); -#endif - return false; - } - - if (!waitready(1000)) { -#ifdef PN532DEBUG - PN532DEBUGPRINT.println(F("Response never received for APDU...")); -#endif - return false; - } - - readdata(pn532_packetbuffer, sizeof(pn532_packetbuffer)); - - if (pn532_packetbuffer[0] == 0 && pn532_packetbuffer[1] == 0 && - pn532_packetbuffer[2] == 0xff) { - uint8_t length = pn532_packetbuffer[3]; - if (pn532_packetbuffer[4] != (uint8_t)(~length + 1)) { -#ifdef PN532DEBUG - PN532DEBUGPRINT.println(F("Length check invalid")); - PN532DEBUGPRINT.println(length, HEX); - PN532DEBUGPRINT.println((~length) + 1, HEX); -#endif - return false; - } - if (pn532_packetbuffer[5] == PN532_PN532TOHOST && - pn532_packetbuffer[6] == PN532_RESPONSE_INDATAEXCHANGE) { - if ((pn532_packetbuffer[7] & 0x3f) != 0) { -#ifdef PN532DEBUG - PN532DEBUGPRINT.println(F("Status code indicates an error")); -#endif - return false; - } - - length -= 3; - - if (length > *responseLength) { - length = *responseLength; // silent truncation... - } - - for (i = 0; i < length; ++i) { - response[i] = pn532_packetbuffer[8 + i]; - } - *responseLength = length; - - return true; - } else { - PN532DEBUGPRINT.print(F("Don't know how to handle this command: ")); - PN532DEBUGPRINT.println(pn532_packetbuffer[6], HEX); - return false; - } - } else { - PN532DEBUGPRINT.println(F("Preamble missing")); - return false; - } -} - -/**************************************************************************/ -/*! - @brief 'InLists' a passive target. PN532 acting as reader/initiator, - peer acting as card/responder. - @return true on success, false otherwise. -*/ -/**************************************************************************/ -bool Adafruit_PN532::inListPassiveTarget() { - pn532_packetbuffer[0] = PN532_COMMAND_INLISTPASSIVETARGET; - pn532_packetbuffer[1] = 1; - pn532_packetbuffer[2] = 0; - -#ifdef PN532DEBUG - PN532DEBUGPRINT.print(F("About to inList passive target")); -#endif - - if (!sendCommandCheckAck(pn532_packetbuffer, 3, 1000)) { -#ifdef PN532DEBUG - PN532DEBUGPRINT.println(F("Could not send inlist message")); -#endif - return false; - } - - if (!waitready(30000)) { - return false; - } - - readdata(pn532_packetbuffer, sizeof(pn532_packetbuffer)); - - if (pn532_packetbuffer[0] == 0 && pn532_packetbuffer[1] == 0 && - pn532_packetbuffer[2] == 0xff) { - uint8_t length = pn532_packetbuffer[3]; - if (pn532_packetbuffer[4] != (uint8_t)(~length + 1)) { -#ifdef PN532DEBUG - PN532DEBUGPRINT.println(F("Length check invalid")); - PN532DEBUGPRINT.println(length, HEX); - PN532DEBUGPRINT.println((~length) + 1, HEX); -#endif - return false; - } - if (pn532_packetbuffer[5] == PN532_PN532TOHOST && - pn532_packetbuffer[6] == PN532_RESPONSE_INLISTPASSIVETARGET) { - if (pn532_packetbuffer[7] != 1) { -#ifdef PN532DEBUG - PN532DEBUGPRINT.println( - F("Unhandled number of targets inlisted")); -#endif - PN532DEBUGPRINT.println(F("Number of tags inlisted:")); - PN532DEBUGPRINT.println(pn532_packetbuffer[7]); - return false; - } - - _inListedTag = pn532_packetbuffer[8]; - PN532DEBUGPRINT.print(F("Tag number: ")); - PN532DEBUGPRINT.println(_inListedTag); - - return true; - } else { -#ifdef PN532DEBUG - PN532DEBUGPRINT.print( - F("Unexpected response to inlist passive host")); -#endif - return false; - } - } else { -#ifdef PN532DEBUG - PN532DEBUGPRINT.println(F("Preamble missing")); -#endif - return false; - } - - return true; -} - -/***** Mifare Classic Functions ******/ - -/**************************************************************************/ -/*! - @brief Indicates whether the specified block number is the first block - in the sector (block 0 relative to the current sector) - @param uiBlock Block number to test. - @return true if first block, false otherwise. -*/ -/**************************************************************************/ -bool Adafruit_PN532::mifareclassic_IsFirstBlock(uint32_t uiBlock) { - // Test if we are in the small or big sectors - if (uiBlock < 128) - return ((uiBlock) % 4 == 0); - else - return ((uiBlock) % 16 == 0); -} - -/**************************************************************************/ -/*! - @brief Indicates whether the specified block number is the sector - trailer. - @param uiBlock Block number to test. - @return true if sector trailer, false otherwise. -*/ -/**************************************************************************/ -bool Adafruit_PN532::mifareclassic_IsTrailerBlock(uint32_t uiBlock) { - // Test if we are in the small or big sectors - if (uiBlock < 128) - return ((uiBlock + 1) % 4 == 0); - else - return ((uiBlock + 1) % 16 == 0); -} - -/**************************************************************************/ -/*! - Tries to authenticate a block of memory on a MIFARE card using the - INDATAEXCHANGE command. See section 7.3.8 of the PN532 User Manual - for more information on sending MIFARE and other commands. - - @param uid Pointer to a byte array containing the card UID - @param uidLen The length (in bytes) of the card's UID (Should - be 4 for MIFARE Classic) - @param blockNumber The block number to authenticate. (0..63 for - 1KB cards, and 0..255 for 4KB cards). - @param keyNumber Which key type to use during authentication - (0 = MIFARE_CMD_AUTH_A, 1 = MIFARE_CMD_AUTH_B) - @param keyData Pointer to a byte array containing the 6 byte - key value - - @returns 1 if everything executed properly, 0 for an error -*/ -/**************************************************************************/ -uint8_t Adafruit_PN532::mifareclassic_AuthenticateBlock(uint8_t *uid, - uint8_t uidLen, - uint32_t blockNumber, - uint8_t keyNumber, - uint8_t *keyData) { - // uint8_t len; - uint8_t i; - - // Hang on to the key and uid data - memcpy(_key, keyData, 6); - memcpy(_uid, uid, uidLen); - _uidLen = uidLen; - -#ifdef MIFAREDEBUG - PN532DEBUGPRINT.print(F("Trying to authenticate card ")); - Adafruit_PN532::PrintHex(_uid, _uidLen); - PN532DEBUGPRINT.print(F("Using authentication KEY ")); - PN532DEBUGPRINT.print(keyNumber ? 'B' : 'A'); - PN532DEBUGPRINT.print(F(": ")); - Adafruit_PN532::PrintHex(_key, 6); -#endif - - // Prepare the authentication command // - pn532_packetbuffer[0] = - PN532_COMMAND_INDATAEXCHANGE; /* Data Exchange Header */ - pn532_packetbuffer[1] = 1; /* Max card numbers */ - pn532_packetbuffer[2] = (keyNumber) ? MIFARE_CMD_AUTH_B : MIFARE_CMD_AUTH_A; - pn532_packetbuffer[3] = - blockNumber; /* Block Number (1K = 0..63, 4K = 0..255 */ - memcpy(pn532_packetbuffer + 4, _key, 6); - for (i = 0; i < _uidLen; i++) { - pn532_packetbuffer[10 + i] = _uid[i]; /* 4 byte card ID */ - } - - if (!sendCommandCheckAck(pn532_packetbuffer, 10 + _uidLen)) - return 0; - - // Read the response packet - readdata(pn532_packetbuffer, 12); - - // check if the response is valid and we are authenticated??? - // for an auth success it should be bytes 5-7: 0xD5 0x41 0x00 - // Mifare auth error is technically byte 7: 0x14 but anything other and 0x00 - // is not good - if (pn532_packetbuffer[7] != 0x00) { -#ifdef PN532DEBUG - PN532DEBUGPRINT.print(F("Authentification failed: ")); - Adafruit_PN532::PrintHexChar(pn532_packetbuffer, 12); -#endif - return 0; - } - - return 1; -} - -/**************************************************************************/ -/*! - Tries to read an entire 16-byte data block at the specified block - address. - - @param blockNumber The block number to authenticate. (0..63 for - 1KB cards, and 0..255 for 4KB cards). - @param data Pointer to the byte array that will hold the - retrieved data (if any) - - @returns 1 if everything executed properly, 0 for an error -*/ -/**************************************************************************/ -uint8_t Adafruit_PN532::mifareclassic_ReadDataBlock(uint8_t blockNumber, - uint8_t *data) { -#ifdef MIFAREDEBUG - PN532DEBUGPRINT.print(F("Trying to read 16 bytes from block ")); - PN532DEBUGPRINT.println(blockNumber); -#endif - - /* Prepare the command */ - pn532_packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE; - pn532_packetbuffer[1] = 1; /* Card number */ - pn532_packetbuffer[2] = MIFARE_CMD_READ; /* Mifare Read command = 0x30 */ - pn532_packetbuffer[3] = - blockNumber; /* Block Number (0..63 for 1K, 0..255 for 4K) */ - - /* Send the command */ - if (!sendCommandCheckAck(pn532_packetbuffer, 4)) { -#ifdef MIFAREDEBUG - PN532DEBUGPRINT.println(F("Failed to receive ACK for read command")); -#endif - return 0; - } - - /* Read the response packet */ - readdata(pn532_packetbuffer, 26); - - /* If byte 8 isn't 0x00 we probably have an error */ - if (pn532_packetbuffer[7] != 0x00) { -#ifdef MIFAREDEBUG - PN532DEBUGPRINT.println(F("Unexpected response")); - Adafruit_PN532::PrintHexChar(pn532_packetbuffer, 26); -#endif - return 0; - } - - /* Copy the 16 data bytes to the output buffer */ - /* Block content starts at byte 9 of a valid response */ - memcpy(data, pn532_packetbuffer + 8, 16); - -/* Display data for debug if requested */ -#ifdef MIFAREDEBUG - PN532DEBUGPRINT.print(F("Block ")); - PN532DEBUGPRINT.println(blockNumber); - Adafruit_PN532::PrintHexChar(data, 16); -#endif - - return 1; -} - -/**************************************************************************/ -/*! - Tries to write an entire 16-byte data block at the specified block - address. - - @param blockNumber The block number to authenticate. (0..63 for - 1KB cards, and 0..255 for 4KB cards). - @param data The byte array that contains the data to write. - - @returns 1 if everything executed properly, 0 for an error -*/ -/**************************************************************************/ -uint8_t Adafruit_PN532::mifareclassic_WriteDataBlock(uint8_t blockNumber, - uint8_t *data) { -#ifdef MIFAREDEBUG - PN532DEBUGPRINT.print(F("Trying to write 16 bytes to block ")); - PN532DEBUGPRINT.println(blockNumber); -#endif - - /* Prepare the first command */ - pn532_packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE; - pn532_packetbuffer[1] = 1; /* Card number */ - pn532_packetbuffer[2] = MIFARE_CMD_WRITE; /* Mifare Write command = 0xA0 */ - pn532_packetbuffer[3] = - blockNumber; /* Block Number (0..63 for 1K, 0..255 for 4K) */ - memcpy(pn532_packetbuffer + 4, data, 16); /* Data Payload */ - - /* Send the command */ - if (!sendCommandCheckAck(pn532_packetbuffer, 20)) { -#ifdef MIFAREDEBUG - PN532DEBUGPRINT.println(F("Failed to receive ACK for write command")); -#endif - return 0; - } - delay(10); - - /* Read the response packet */ - readdata(pn532_packetbuffer, 26); - - return 1; -} - -/**************************************************************************/ -/*! - Formats a Mifare Classic card to store NDEF Records - - @returns 1 if everything executed properly, 0 for an error -*/ -/**************************************************************************/ -uint8_t Adafruit_PN532::mifareclassic_FormatNDEF(void) { - uint8_t sectorbuffer1[16] = {0x14, 0x01, 0x03, 0xE1, 0x03, 0xE1, - 0x03, 0xE1, 0x03, 0xE1, 0x03, 0xE1, - 0x03, 0xE1, 0x03, 0xE1}; - uint8_t sectorbuffer2[16] = {0x03, 0xE1, 0x03, 0xE1, 0x03, 0xE1, - 0x03, 0xE1, 0x03, 0xE1, 0x03, 0xE1, - 0x03, 0xE1, 0x03, 0xE1}; - uint8_t sectorbuffer3[16] = {0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, - 0x78, 0x77, 0x88, 0xC1, 0xFF, 0xFF, - 0xFF, 0xFF, 0xFF, 0xFF}; - - // Note 0xA0 0xA1 0xA2 0xA3 0xA4 0xA5 must be used for key A - // for the MAD sector in NDEF records (sector 0) - - // Write block 1 and 2 to the card - if (!(mifareclassic_WriteDataBlock(1, sectorbuffer1))) - return 0; - if (!(mifareclassic_WriteDataBlock(2, sectorbuffer2))) - return 0; - // Write key A and access rights card - if (!(mifareclassic_WriteDataBlock(3, sectorbuffer3))) - return 0; - - // Seems that everything was OK (?!) - return 1; -} - -/**************************************************************************/ -/*! - Writes an NDEF URI Record to the specified sector (1..15) - - Note that this function assumes that the Mifare Classic card is - already formatted to work as an "NFC Forum Tag" and uses a MAD1 - file system. You can use the NXP TagWriter app on Android to - properly format cards for this. - - @param sectorNumber The sector that the URI record should be written - to (can be 1..15 for a 1K card) - @param uriIdentifier The uri identifier code (0 = none, 0x01 = - "http://www.", etc.) - @param url The uri text to write (max 38 characters). - - @returns 1 if everything executed properly, 0 for an error -*/ -/**************************************************************************/ -uint8_t Adafruit_PN532::mifareclassic_WriteNDEFURI(uint8_t sectorNumber, - uint8_t uriIdentifier, - const char *url) { - // Figure out how long the string is - uint8_t len = strlen(url); - - // Make sure we're within a 1K limit for the sector number - if ((sectorNumber < 1) || (sectorNumber > 15)) - return 0; - - // Make sure the URI payload is between 1 and 38 chars - if ((len < 1) || (len > 38)) - return 0; - - // Note 0xD3 0xF7 0xD3 0xF7 0xD3 0xF7 must be used for key A - // in NDEF records - - // Setup the sector buffer (w/pre-formatted TLV wrapper and NDEF message) - uint8_t sectorbuffer1[16] = {0x00, - 0x00, - 0x03, - (uint8_t)(len + 5), - 0xD1, - 0x01, - (uint8_t)(len + 1), - 0x55, - uriIdentifier, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00}; - uint8_t sectorbuffer2[16] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00}; - uint8_t sectorbuffer3[16] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00}; - uint8_t sectorbuffer4[16] = {0xD3, 0xF7, 0xD3, 0xF7, 0xD3, 0xF7, - 0x7F, 0x07, 0x88, 0x40, 0xFF, 0xFF, - 0xFF, 0xFF, 0xFF, 0xFF}; - if (len <= 6) { - // Unlikely we'll get a url this short, but why not ... - memcpy(sectorbuffer1 + 9, url, len); - sectorbuffer1[len + 9] = 0xFE; - } else if (len == 7) { - // 0xFE needs to be wrapped around to next block - memcpy(sectorbuffer1 + 9, url, len); - sectorbuffer2[0] = 0xFE; - } else if ((len > 7) && (len <= 22)) { - // Url fits in two blocks - memcpy(sectorbuffer1 + 9, url, 7); - memcpy(sectorbuffer2, url + 7, len - 7); - sectorbuffer2[len - 7] = 0xFE; - } else if (len == 23) { - // 0xFE needs to be wrapped around to final block - memcpy(sectorbuffer1 + 9, url, 7); - memcpy(sectorbuffer2, url + 7, len - 7); - sectorbuffer3[0] = 0xFE; - } else { - // Url fits in three blocks - memcpy(sectorbuffer1 + 9, url, 7); - memcpy(sectorbuffer2, url + 7, 16); - memcpy(sectorbuffer3, url + 23, len - 24); - sectorbuffer3[len - 22] = 0xFE; - } - - // Now write all three blocks back to the card - if (!(mifareclassic_WriteDataBlock(sectorNumber * 4, sectorbuffer1))) - return 0; - if (!(mifareclassic_WriteDataBlock((sectorNumber * 4) + 1, sectorbuffer2))) - return 0; - if (!(mifareclassic_WriteDataBlock((sectorNumber * 4) + 2, sectorbuffer3))) - return 0; - if (!(mifareclassic_WriteDataBlock((sectorNumber * 4) + 3, sectorbuffer4))) - return 0; - - // Seems that everything was OK (?!) - return 1; -} - -/***** Mifare Ultralight Functions ******/ - -/**************************************************************************/ -/*! - @brief Tries to read an entire 4-byte page at the specified address. - - @param page The page number (0..63 in most cases) - @param buffer Pointer to the byte array that will hold the - retrieved data (if any) - @return 1 on success, 0 on error. -*/ -/**************************************************************************/ -uint8_t Adafruit_PN532::mifareultralight_ReadPage(uint8_t page, - uint8_t *buffer) { - if (page >= 64) { -#ifdef MIFAREDEBUG - PN532DEBUGPRINT.println(F("Page value out of range")); -#endif - return 0; - } - -#ifdef MIFAREDEBUG - PN532DEBUGPRINT.print(F("Reading page ")); - PN532DEBUGPRINT.println(page); -#endif - - /* Prepare the command */ - pn532_packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE; - pn532_packetbuffer[1] = 1; /* Card number */ - pn532_packetbuffer[2] = MIFARE_CMD_READ; /* Mifare Read command = 0x30 */ - pn532_packetbuffer[3] = page; /* Page Number (0..63 in most cases) */ - - /* Send the command */ - if (!sendCommandCheckAck(pn532_packetbuffer, 4)) { -#ifdef MIFAREDEBUG - PN532DEBUGPRINT.println(F("Failed to receive ACK for write command")); -#endif - return 0; - } - - /* Read the response packet */ - readdata(pn532_packetbuffer, 26); -#ifdef MIFAREDEBUG - PN532DEBUGPRINT.println(F("Received: ")); - Adafruit_PN532::PrintHexChar(pn532_packetbuffer, 26); -#endif - - /* If byte 8 isn't 0x00 we probably have an error */ - if (pn532_packetbuffer[7] == 0x00) { - /* Copy the 4 data bytes to the output buffer */ - /* Block content starts at byte 9 of a valid response */ - /* Note that the command actually reads 16 byte or 4 */ - /* pages at a time ... we simply discard the last 12 */ - /* bytes */ - memcpy(buffer, pn532_packetbuffer + 8, 4); - } else { -#ifdef MIFAREDEBUG - PN532DEBUGPRINT.println(F("Unexpected response reading block: ")); - Adafruit_PN532::PrintHexChar(pn532_packetbuffer, 26); -#endif - return 0; - } - -/* Display data for debug if requested */ -#ifdef MIFAREDEBUG - PN532DEBUGPRINT.print(F("Page ")); - PN532DEBUGPRINT.print(page); - PN532DEBUGPRINT.println(F(":")); - Adafruit_PN532::PrintHexChar(buffer, 4); -#endif - - // Return OK signal - return 1; -} - -/**************************************************************************/ -/*! - Tries to write an entire 4-byte page at the specified block - address. - - @param page The page number to write. (0..63 for most cases) - @param data The byte array that contains the data to write. - Should be exactly 4 bytes long. - - @returns 1 if everything executed properly, 0 for an error -*/ -/**************************************************************************/ -uint8_t Adafruit_PN532::mifareultralight_WritePage(uint8_t page, - uint8_t *data) { - - if (page >= 64) { -#ifdef MIFAREDEBUG - PN532DEBUGPRINT.println(F("Page value out of range")); -#endif - // Return Failed Signal - return 0; - } - -#ifdef MIFAREDEBUG - PN532DEBUGPRINT.print(F("Trying to write 4 byte page")); - PN532DEBUGPRINT.println(page); -#endif - - /* Prepare the first command */ - pn532_packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE; - pn532_packetbuffer[1] = 1; /* Card number */ - pn532_packetbuffer[2] = - MIFARE_ULTRALIGHT_CMD_WRITE; /* Mifare Ultralight Write command = 0xA2 - */ - pn532_packetbuffer[3] = page; /* Page Number (0..63 for most cases) */ - memcpy(pn532_packetbuffer + 4, data, 4); /* Data Payload */ - - /* Send the command */ - if (!sendCommandCheckAck(pn532_packetbuffer, 8)) { -#ifdef MIFAREDEBUG - PN532DEBUGPRINT.println(F("Failed to receive ACK for write command")); -#endif - - // Return Failed Signal - return 0; - } - delay(10); - - /* Read the response packet */ - readdata(pn532_packetbuffer, 26); - - // Return OK Signal - return 1; -} - -/***** NTAG2xx Functions ******/ - -/**************************************************************************/ -/*! - @brief Tries to read an entire 4-byte page at the specified address. - - @param page The page number (0..63 in most cases) - @param buffer Pointer to the byte array that will hold the - retrieved data (if any) - @return 1 on success, 0 on error. -*/ -/**************************************************************************/ -uint8_t Adafruit_PN532::ntag2xx_ReadPage(uint8_t page, uint8_t *buffer) { - // TAG Type PAGES USER START USER STOP - // -------- ----- ---------- --------- - // NTAG 203 42 4 39 - // NTAG 213 45 4 39 - // NTAG 215 135 4 129 - // NTAG 216 231 4 225 - - if (page >= 231) { -#ifdef MIFAREDEBUG - PN532DEBUGPRINT.println(F("Page value out of range")); -#endif - return 0; - } - -#ifdef MIFAREDEBUG - PN532DEBUGPRINT.print(F("Reading page ")); - PN532DEBUGPRINT.println(page); -#endif - - /* Prepare the command */ - pn532_packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE; - pn532_packetbuffer[1] = 1; /* Card number */ - pn532_packetbuffer[2] = MIFARE_CMD_READ; /* Mifare Read command = 0x30 */ - pn532_packetbuffer[3] = page; /* Page Number (0..63 in most cases) */ - - /* Send the command */ - if (!sendCommandCheckAck(pn532_packetbuffer, 4)) { -#ifdef MIFAREDEBUG - PN532DEBUGPRINT.println(F("Failed to receive ACK for write command")); -#endif - return 0; - } - - /* Read the response packet */ - readdata(pn532_packetbuffer, 26); -#ifdef MIFAREDEBUG - PN532DEBUGPRINT.println(F("Received: ")); - Adafruit_PN532::PrintHexChar(pn532_packetbuffer, 26); -#endif - - /* If byte 8 isn't 0x00 we probably have an error */ - if (pn532_packetbuffer[7] == 0x00) { - /* Copy the 4 data bytes to the output buffer */ - /* Block content starts at byte 9 of a valid response */ - /* Note that the command actually reads 16 byte or 4 */ - /* pages at a time ... we simply discard the last 12 */ - /* bytes */ - memcpy(buffer, pn532_packetbuffer + 8, 4); - } else { -#ifdef MIFAREDEBUG - PN532DEBUGPRINT.println(F("Unexpected response reading block: ")); - Adafruit_PN532::PrintHexChar(pn532_packetbuffer, 26); -#endif - return 0; - } - -/* Display data for debug if requested */ -#ifdef MIFAREDEBUG - PN532DEBUGPRINT.print(F("Page ")); - PN532DEBUGPRINT.print(page); - PN532DEBUGPRINT.println(F(":")); - Adafruit_PN532::PrintHexChar(buffer, 4); -#endif - - // Return OK signal - return 1; -} - -/**************************************************************************/ -/*! - Tries to write an entire 4-byte page at the specified block - address. - - @param page The page number to write. (0..63 for most cases) - @param data The byte array that contains the data to write. - Should be exactly 4 bytes long. - - @returns 1 if everything executed properly, 0 for an error -*/ -/**************************************************************************/ -uint8_t Adafruit_PN532::ntag2xx_WritePage(uint8_t page, uint8_t *data) { - // TAG Type PAGES USER START USER STOP - // -------- ----- ---------- --------- - // NTAG 203 42 4 39 - // NTAG 213 45 4 39 - // NTAG 215 135 4 129 - // NTAG 216 231 4 225 - - if ((page < 4) || (page > 225)) { -#ifdef MIFAREDEBUG - PN532DEBUGPRINT.println(F("Page value out of range")); -#endif - // Return Failed Signal - return 0; - } - -#ifdef MIFAREDEBUG - PN532DEBUGPRINT.print(F("Trying to write 4 byte page")); - PN532DEBUGPRINT.println(page); -#endif - - /* Prepare the first command */ - pn532_packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE; - pn532_packetbuffer[1] = 1; /* Card number */ - pn532_packetbuffer[2] = - MIFARE_ULTRALIGHT_CMD_WRITE; /* Mifare Ultralight Write command = 0xA2 - */ - pn532_packetbuffer[3] = page; /* Page Number (0..63 for most cases) */ - memcpy(pn532_packetbuffer + 4, data, 4); /* Data Payload */ - - /* Send the command */ - if (!sendCommandCheckAck(pn532_packetbuffer, 8)) { -#ifdef MIFAREDEBUG - PN532DEBUGPRINT.println(F("Failed to receive ACK for write command")); -#endif - - // Return Failed Signal - return 0; - } - delay(10); - - /* Read the response packet */ - readdata(pn532_packetbuffer, 26); - - // Return OK Signal - return 1; -} - -/**************************************************************************/ -/*! - Writes an NDEF URI Record starting at the specified page (4..nn) - - Note that this function assumes that the NTAG2xx card is - already formatted to work as an "NFC Forum Tag". - - @param uriIdentifier The uri identifier code (0 = none, 0x01 = - "http://www.", etc.) - @param url The uri text to write (null-terminated string). - @param dataLen The size of the data area for overflow checks. - - @returns 1 if everything executed properly, 0 for an error -*/ -/**************************************************************************/ -uint8_t Adafruit_PN532::ntag2xx_WriteNDEFURI(uint8_t uriIdentifier, char *url, - uint8_t dataLen) { - uint8_t pageBuffer[4] = {0, 0, 0, 0}; - - // Remove NDEF record overhead from the URI data (pageHeader below) - uint8_t wrapperSize = 12; - - // Figure out how long the string is - uint8_t len = strlen(url); - - // Make sure the URI payload will fit in dataLen (include 0xFE trailer) - if ((len < 1) || (len + 1 > (dataLen - wrapperSize))) - return 0; - - // Setup the record header - // See NFCForum-TS-Type-2-Tag_1.1.pdf for details - uint8_t pageHeader[12] = { - /* NDEF Lock Control TLV (must be first and always present) */ - 0x01, /* Tag Field (0x01 = Lock Control TLV) */ - 0x03, /* Payload Length (always 3) */ - 0xA0, /* The position inside the tag of the lock bytes (upper 4 = page - address, lower 4 = byte offset) */ - 0x10, /* Size in bits of the lock area */ - 0x44, /* Size in bytes of a page and the number of bytes each lock bit - can lock (4 bit + 4 bits) */ - /* NDEF Message TLV - URI Record */ - 0x03, /* Tag Field (0x03 = NDEF Message) */ - (uint8_t)(len + 5), /* Payload Length (not including 0xFE trailer) */ - 0xD1, /* NDEF Record Header (TNF=0x1:Well known record + SR + ME + MB) - */ - 0x01, /* Type Length for the record type indicator */ - (uint8_t)(len + 1), /* Payload len */ - 0x55, /* Record Type Indicator (0x55 or 'U' = URI Record) */ - uriIdentifier /* URI Prefix (ex. 0x01 = "http://www.") */ - }; - - // Write 12 byte header (three pages of data starting at page 4) - memcpy(pageBuffer, pageHeader, 4); - if (!(ntag2xx_WritePage(4, pageBuffer))) - return 0; - memcpy(pageBuffer, pageHeader + 4, 4); - if (!(ntag2xx_WritePage(5, pageBuffer))) - return 0; - memcpy(pageBuffer, pageHeader + 8, 4); - if (!(ntag2xx_WritePage(6, pageBuffer))) - return 0; - - // Write URI (starting at page 7) - uint8_t currentPage = 7; - char *urlcopy = url; - while (len) { - if (len < 4) { - memset(pageBuffer, 0, 4); - memcpy(pageBuffer, urlcopy, len); - pageBuffer[len] = 0xFE; // NDEF record footer - if (!(ntag2xx_WritePage(currentPage, pageBuffer))) - return 0; - // DONE! - return 1; - } else if (len == 4) { - memcpy(pageBuffer, urlcopy, len); - if (!(ntag2xx_WritePage(currentPage, pageBuffer))) - return 0; - memset(pageBuffer, 0, 4); - pageBuffer[0] = 0xFE; // NDEF record footer - currentPage++; - if (!(ntag2xx_WritePage(currentPage, pageBuffer))) - return 0; - // DONE! - return 1; - } else { - // More than one page of data left - memcpy(pageBuffer, urlcopy, 4); - if (!(ntag2xx_WritePage(currentPage, pageBuffer))) - return 0; - currentPage++; - urlcopy += 4; - len -= 4; - } - } - - // Seems that everything was OK (?!) - return 1; -} - -/************** high level communication functions (handles both I2C and SPI) */ - -/**************************************************************************/ -/*! - @brief Tries to read the SPI or I2C ACK signal -*/ -/**************************************************************************/ -bool Adafruit_PN532::readack() { - uint8_t ackbuff[6]; - - if (spi_dev) { - uint8_t cmd = PN532_SPI_DATAREAD; - spi_dev->write_then_read(&cmd, 1, ackbuff, 6); - } else if (i2c_dev || ser_dev) { - readdata(ackbuff, 6); - } - - return (0 == memcmp((char *)ackbuff, (char *)pn532ack, 6)); -} - -/**************************************************************************/ -/*! - @brief Return true if the PN532 is ready with a response. -*/ -/**************************************************************************/ -bool Adafruit_PN532::isready() { - if (spi_dev) { - // SPI ready check via Status Request - uint8_t cmd = PN532_SPI_STATREAD; - uint8_t reply; - spi_dev->write_then_read(&cmd, 1, &reply, 1); - return reply == PN532_SPI_READY; - } else if (i2c_dev) { - // I2C ready check via reading RDY byte - uint8_t rdy[1]; - i2c_dev->read(rdy, 1); - return rdy[0] == PN532_I2C_READY; - } else if (ser_dev) { - // Serial ready check based on non-zero read buffer - return (ser_dev->available() != 0); - } else if (_irq != -1) { - uint8_t x = digitalRead(_irq); - return x == 0; - } - return false; -} - -/**************************************************************************/ -/*! - @brief Waits until the PN532 is ready. - - @param timeout Timeout before giving up -*/ -/**************************************************************************/ -bool Adafruit_PN532::waitready(uint16_t timeout) { - uint16_t timer = 0; - while (!isready()) { - if (timeout != 0) { - timer += 10; - if (timer > timeout) { -#ifdef PN532DEBUG - PN532DEBUGPRINT.println("TIMEOUT!"); -#endif - return false; - } - } - delay(10); - } - return true; -} - -/**************************************************************************/ -/*! - @brief Reads n bytes of data from the PN532 via SPI or I2C. - - @param buff Pointer to the buffer where data will be written - @param n Number of bytes to be read -*/ -/**************************************************************************/ -void Adafruit_PN532::readdata(uint8_t *buff, uint8_t n) { - if (spi_dev) { - // SPI read - uint8_t cmd = PN532_SPI_DATAREAD; - spi_dev->write_then_read(&cmd, 1, buff, n); - } else if (i2c_dev) { - // I2C read - uint8_t rbuff[n + 1]; // +1 for leading RDY byte - i2c_dev->read(rbuff, n + 1); - for (uint8_t i = 0; i < n; i++) { - buff[i] = rbuff[i + 1]; - } - } else if (ser_dev) { - // Serial read - ser_dev->readBytes(buff, n); - } -#ifdef PN532DEBUG - PN532DEBUGPRINT.print(F("Reading: ")); - for (uint8_t i = 0; i < n; i++) { - PN532DEBUGPRINT.print(F(" 0x")); - PN532DEBUGPRINT.print(buff[i], HEX); - } - PN532DEBUGPRINT.println(); -#endif -} - -/**************************************************************************/ -/*! - @brief set the PN532 as iso14443a Target behaving as a SmartCard - @return true on success, false otherwise. - @note Author: Salvador Mendoza (salmg.net) new functions: - -AsTarget - -getDataTarget - -setDataTarget -*/ -/**************************************************************************/ -uint8_t Adafruit_PN532::AsTarget() { - pn532_packetbuffer[0] = 0x8C; - uint8_t target[] = { - 0x8C, // INIT AS TARGET - 0x00, // MODE -> BITFIELD - 0x08, 0x00, // SENS_RES - MIFARE PARAMS - 0xdc, 0x44, 0x20, // NFCID1T - 0x60, // SEL_RES - 0x01, 0xfe, // NFCID2T MUST START WITH 01fe - FELICA PARAMS - POL_RES - 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xc0, - 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, // PAD - 0xff, 0xff, // SYSTEM CODE - 0xaa, 0x99, 0x88, 0x77, 0x66, 0x55, 0x44, - 0x33, 0x22, 0x11, 0x01, 0x00, // NFCID3t MAX 47 BYTES ATR_RES - 0x0d, 0x52, 0x46, 0x49, 0x44, 0x49, 0x4f, - 0x74, 0x20, 0x50, 0x4e, 0x35, 0x33, 0x32 // HISTORICAL BYTES - }; - if (!sendCommandCheckAck(target, sizeof(target))) - return false; - - // read data packet - readdata(pn532_packetbuffer, 8); - - int offset = 6; - return (pn532_packetbuffer[offset] == 0x15); -} -/**************************************************************************/ -/*! - @brief Retrieve response from the emulation mode - - @param cmd = data - @param cmdlen = data length - @return true on success, false otherwise. -*/ -/**************************************************************************/ -uint8_t Adafruit_PN532::getDataTarget(uint8_t *cmd, uint8_t *cmdlen) { - uint8_t length; - pn532_packetbuffer[0] = 0x86; - if (!sendCommandCheckAck(pn532_packetbuffer, 1, 1000)) { - PN532DEBUGPRINT.println(F("Error en ack")); - return false; - } - - // read data packet - readdata(pn532_packetbuffer, 64); - length = pn532_packetbuffer[3] - 3; - - // if (length > *responseLength) {// Bug, should avoid it in the reading - // target data - // length = *responseLength; // silent truncation... - //} - - for (int i = 0; i < length; ++i) { - cmd[i] = pn532_packetbuffer[8 + i]; - } - *cmdlen = length; - return true; -} - -/**************************************************************************/ -/*! - @brief Set data in PN532 in the emulation mode - - @param cmd = data - @param cmdlen = data length - @return true on success, false otherwise. -*/ -/**************************************************************************/ -uint8_t Adafruit_PN532::setDataTarget(uint8_t *cmd, uint8_t cmdlen) { - uint8_t length; - // cmd1[0] = 0x8E; Must! - - if (!sendCommandCheckAck(cmd, cmdlen)) - return false; - - // read data packet - readdata(pn532_packetbuffer, 8); - length = pn532_packetbuffer[3] - 3; - for (int i = 0; i < length; ++i) { - cmd[i] = pn532_packetbuffer[8 + i]; - } - // cmdl = 0 - cmdlen = length; - - int offset = 6; - return (pn532_packetbuffer[offset] == 0x15); -} - -/**************************************************************************/ -/*! - @brief Writes a command to the PN532, automatically inserting the - preamble and required frame details (checksum, len, etc.) - - @param cmd Pointer to the command buffer - @param cmdlen Command length in bytes -*/ -/**************************************************************************/ -void Adafruit_PN532::writecommand(uint8_t *cmd, uint8_t cmdlen) { - if (spi_dev) { - // SPI command write. - uint8_t checksum; - uint8_t packet[9 + cmdlen]; - uint8_t *p = packet; - cmdlen++; - - p[0] = PN532_SPI_DATAWRITE; - p++; - - p[0] = PN532_PREAMBLE; - p++; - p[0] = PN532_STARTCODE1; - p++; - p[0] = PN532_STARTCODE2; - p++; - checksum = PN532_PREAMBLE + PN532_STARTCODE1 + PN532_STARTCODE2; - - p[0] = cmdlen; - p++; - p[0] = ~cmdlen + 1; - p++; - - p[0] = PN532_HOSTTOPN532; - p++; - checksum += PN532_HOSTTOPN532; - - for (uint8_t i = 0; i < cmdlen - 1; i++) { - p[0] = cmd[i]; - p++; - checksum += cmd[i]; - } - - p[0] = ~checksum; - p++; - p[0] = PN532_POSTAMBLE; - p++; - -#ifdef PN532DEBUG - Serial.print("Sending : "); - for (int i = 1; i < 8 + cmdlen; i++) { - Serial.print("0x"); - Serial.print(packet[i], HEX); - Serial.print(", "); - } - Serial.println(); -#endif - - spi_dev->write(packet, 8 + cmdlen); - } else if (i2c_dev || ser_dev) { - // I2C or Serial command write. - uint8_t packet[8 + cmdlen]; - uint8_t LEN = cmdlen + 1; - - packet[0] = PN532_PREAMBLE; - packet[1] = PN532_STARTCODE1; - packet[2] = PN532_STARTCODE2; - packet[3] = LEN; - packet[4] = ~LEN + 1; - packet[5] = PN532_HOSTTOPN532; - uint8_t sum = 0; - for (uint8_t i = 0; i < cmdlen; i++) { - packet[6 + i] = cmd[i]; - sum += cmd[i]; - } - packet[6 + cmdlen] = ~(PN532_HOSTTOPN532 + sum) + 1; - packet[7 + cmdlen] = PN532_POSTAMBLE; - -#ifdef PN532DEBUG - Serial.print("Sending : "); - for (int i = 1; i < 8 + cmdlen; i++) { - Serial.print("0x"); - Serial.print(packet[i], HEX); - Serial.print(", "); - } - Serial.println(); -#endif - - if (i2c_dev) { - i2c_dev->write(packet, 8 + cmdlen); - } else { - ser_dev->write(packet, 8 + cmdlen); - } - } -} diff --git a/src/libs/Adafruit_PN532.h b/src/libs/Adafruit_PN532.h deleted file mode 100644 index c33db5c..0000000 --- a/src/libs/Adafruit_PN532.h +++ /dev/null @@ -1,225 +0,0 @@ -/**************************************************************************/ -/*! - @file Adafruit_PN532.h - - v2.0 - Refactored to add I2C support from Adafruit_NFCShield_I2C library. - - v1.1 - Added full command list - - Added 'verbose' mode flag to constructor to toggle debug output - - Changed readPassiveTargetID() to return variable length values -*/ -/**************************************************************************/ - -#ifndef ADAFRUIT_PN532_H -#define ADAFRUIT_PN532_H - -#include "Arduino.h" - -#include -#include - -#define PN532_PREAMBLE (0x00) ///< Command sequence start, byte 1/3 -#define PN532_STARTCODE1 (0x00) ///< Command sequence start, byte 2/3 -#define PN532_STARTCODE2 (0xFF) ///< Command sequence start, byte 3/3 -#define PN532_POSTAMBLE (0x00) ///< EOD - -#define PN532_HOSTTOPN532 (0xD4) ///< Host-to-PN532 -#define PN532_PN532TOHOST (0xD5) ///< PN532-to-host - -// PN532 Commands -#define PN532_COMMAND_DIAGNOSE (0x00) ///< Diagnose -#define PN532_COMMAND_GETFIRMWAREVERSION (0x02) ///< Get firmware version -#define PN532_COMMAND_GETGENERALSTATUS (0x04) ///< Get general status -#define PN532_COMMAND_READREGISTER (0x06) ///< Read register -#define PN532_COMMAND_WRITEREGISTER (0x08) ///< Write register -#define PN532_COMMAND_READGPIO (0x0C) ///< Read GPIO -#define PN532_COMMAND_WRITEGPIO (0x0E) ///< Write GPIO -#define PN532_COMMAND_SETSERIALBAUDRATE (0x10) ///< Set serial baud rate -#define PN532_COMMAND_SETPARAMETERS (0x12) ///< Set parameters -#define PN532_COMMAND_SAMCONFIGURATION (0x14) ///< SAM configuration -#define PN532_COMMAND_POWERDOWN (0x16) ///< Power down -#define PN532_COMMAND_RFCONFIGURATION (0x32) ///< RF config -#define PN532_COMMAND_RFREGULATIONTEST (0x58) ///< RF regulation test -#define PN532_COMMAND_INJUMPFORDEP (0x56) ///< Jump for DEP -#define PN532_COMMAND_INJUMPFORPSL (0x46) ///< Jump for PSL -#define PN532_COMMAND_INLISTPASSIVETARGET (0x4A) ///< List passive target -#define PN532_COMMAND_INATR (0x50) ///< ATR -#define PN532_COMMAND_INPSL (0x4E) ///< PSL -#define PN532_COMMAND_INDATAEXCHANGE (0x40) ///< Data exchange -#define PN532_COMMAND_INCOMMUNICATETHRU (0x42) ///< Communicate through -#define PN532_COMMAND_INDESELECT (0x44) ///< Deselect -#define PN532_COMMAND_INRELEASE (0x52) ///< Release -#define PN532_COMMAND_INSELECT (0x54) ///< Select -#define PN532_COMMAND_INAUTOPOLL (0x60) ///< Auto poll -#define PN532_COMMAND_TGINITASTARGET (0x8C) ///< Init as target -#define PN532_COMMAND_TGSETGENERALBYTES (0x92) ///< Set general bytes -#define PN532_COMMAND_TGGETDATA (0x86) ///< Get data -#define PN532_COMMAND_TGSETDATA (0x8E) ///< Set data -#define PN532_COMMAND_TGSETMETADATA (0x94) ///< Set metadata -#define PN532_COMMAND_TGGETINITIATORCOMMAND (0x88) ///< Get initiator command -#define PN532_COMMAND_TGRESPONSETOINITIATOR (0x90) ///< Response to initiator -#define PN532_COMMAND_TGGETTARGETSTATUS (0x8A) ///< Get target status - -#define PN532_RESPONSE_INDATAEXCHANGE (0x41) ///< Data exchange -#define PN532_RESPONSE_INLISTPASSIVETARGET (0x4B) ///< List passive target - -#define PN532_WAKEUP (0x55) ///< Wake - -#define PN532_SPI_STATREAD (0x02) ///< Stat read -#define PN532_SPI_DATAWRITE (0x01) ///< Data write -#define PN532_SPI_DATAREAD (0x03) ///< Data read -#define PN532_SPI_READY (0x01) ///< Ready - -// #define PN532_I2C_ADDRESS (0x48 >> 1) ///< Default I2C address -// My fucking clone board for some goddamn reason uses the address 0x28 -#define PN532_I2C_ADDRESS (0x28) -#define PN532_I2C_READBIT (0x01) ///< Read bit -#define PN532_I2C_BUSY (0x00) ///< Busy -#define PN532_I2C_READY (0x01) ///< Ready -#define PN532_I2C_READYTIMEOUT (20) ///< Ready timeout - -#define PN532_MIFARE_ISO14443A (0x00) ///< MiFare - -// Mifare Commands -#define MIFARE_CMD_AUTH_A (0x60) ///< Auth A -#define MIFARE_CMD_AUTH_B (0x61) ///< Auth B -#define MIFARE_CMD_READ (0x30) ///< Read -#define MIFARE_CMD_WRITE (0xA0) ///< Write -#define MIFARE_CMD_TRANSFER (0xB0) ///< Transfer -#define MIFARE_CMD_DECREMENT (0xC0) ///< Decrement -#define MIFARE_CMD_INCREMENT (0xC1) ///< Increment -#define MIFARE_CMD_STORE (0xC2) ///< Store -#define MIFARE_ULTRALIGHT_CMD_WRITE (0xA2) ///< Write (MiFare Ultralight) - -// Prefixes for NDEF Records (to identify record type) -#define NDEF_URIPREFIX_NONE (0x00) ///< No prefix -#define NDEF_URIPREFIX_HTTP_WWWDOT (0x01) ///< HTTP www. prefix -#define NDEF_URIPREFIX_HTTPS_WWWDOT (0x02) ///< HTTPS www. prefix -#define NDEF_URIPREFIX_HTTP (0x03) ///< HTTP prefix -#define NDEF_URIPREFIX_HTTPS (0x04) ///< HTTPS prefix -#define NDEF_URIPREFIX_TEL (0x05) ///< Tel prefix -#define NDEF_URIPREFIX_MAILTO (0x06) ///< Mailto prefix -#define NDEF_URIPREFIX_FTP_ANONAT (0x07) ///< FTP -#define NDEF_URIPREFIX_FTP_FTPDOT (0x08) ///< FTP dot -#define NDEF_URIPREFIX_FTPS (0x09) ///< FTPS -#define NDEF_URIPREFIX_SFTP (0x0A) ///< SFTP -#define NDEF_URIPREFIX_SMB (0x0B) ///< SMB -#define NDEF_URIPREFIX_NFS (0x0C) ///< NFS -#define NDEF_URIPREFIX_FTP (0x0D) ///< FTP -#define NDEF_URIPREFIX_DAV (0x0E) ///< DAV -#define NDEF_URIPREFIX_NEWS (0x0F) ///< NEWS -#define NDEF_URIPREFIX_TELNET (0x10) ///< Telnet prefix -#define NDEF_URIPREFIX_IMAP (0x11) ///< IMAP prefix -#define NDEF_URIPREFIX_RTSP (0x12) ///< RTSP -#define NDEF_URIPREFIX_URN (0x13) ///< URN -#define NDEF_URIPREFIX_POP (0x14) ///< POP -#define NDEF_URIPREFIX_SIP (0x15) ///< SIP -#define NDEF_URIPREFIX_SIPS (0x16) ///< SIPS -#define NDEF_URIPREFIX_TFTP (0x17) ///< TFPT -#define NDEF_URIPREFIX_BTSPP (0x18) ///< BTSPP -#define NDEF_URIPREFIX_BTL2CAP (0x19) ///< BTL2CAP -#define NDEF_URIPREFIX_BTGOEP (0x1A) ///< BTGOEP -#define NDEF_URIPREFIX_TCPOBEX (0x1B) ///< TCPOBEX -#define NDEF_URIPREFIX_IRDAOBEX (0x1C) ///< IRDAOBEX -#define NDEF_URIPREFIX_FILE (0x1D) ///< File -#define NDEF_URIPREFIX_URN_EPC_ID (0x1E) ///< URN EPC ID -#define NDEF_URIPREFIX_URN_EPC_TAG (0x1F) ///< URN EPC tag -#define NDEF_URIPREFIX_URN_EPC_PAT (0x20) ///< URN EPC pat -#define NDEF_URIPREFIX_URN_EPC_RAW (0x21) ///< URN EPC raw -#define NDEF_URIPREFIX_URN_EPC (0x22) ///< URN EPC -#define NDEF_URIPREFIX_URN_NFC (0x23) ///< URN NFC - -#define PN532_GPIO_VALIDATIONBIT (0x80) ///< GPIO validation bit -#define PN532_GPIO_P30 (0) ///< GPIO 30 -#define PN532_GPIO_P31 (1) ///< GPIO 31 -#define PN532_GPIO_P32 (2) ///< GPIO 32 -#define PN532_GPIO_P33 (3) ///< GPIO 33 -#define PN532_GPIO_P34 (4) ///< GPIO 34 -#define PN532_GPIO_P35 (5) ///< GPIO 35 - -/** - * @brief Class for working with Adafruit PN532 NFC/RFID breakout boards. - */ -class Adafruit_PN532 { - public: - Adafruit_PN532(uint8_t clk, uint8_t miso, uint8_t mosi, - uint8_t ss); // Software SPI - Adafruit_PN532(uint8_t ss, SPIClass *theSPI = &SPI); // Hardware SPI - Adafruit_PN532(uint8_t irq, uint8_t reset, - TwoWire *theWire = &Wire); // Hardware I2C - Adafruit_PN532(uint8_t reset, HardwareSerial *theSer); // Hardware UART - bool begin(void); - - void reset(void); - void wakeup(void); - - // Generic PN532 functions - bool SAMConfig(void); - uint32_t getFirmwareVersion(void); - bool sendCommandCheckAck(uint8_t *cmd, uint8_t cmdlen, - uint16_t timeout = 100); - bool writeGPIO(uint8_t pinstate); - uint8_t readGPIO(void); - bool setPassiveActivationRetries(uint8_t maxRetries); - - // ISO14443A functions - bool readPassiveTargetID( - uint8_t cardbaudrate, uint8_t *uid, uint8_t *uidLength, - uint16_t timeout = - 0); // timeout 0 means no timeout - will block forever. - bool startPassiveTargetIDDetection(uint8_t cardbaudrate); - bool readDetectedPassiveTargetID(uint8_t *uid, uint8_t *uidLength); - bool inDataExchange(uint8_t *send, uint8_t sendLength, uint8_t *response, - uint8_t *responseLength); - bool inListPassiveTarget(); - uint8_t AsTarget(); - uint8_t getDataTarget(uint8_t *cmd, uint8_t *cmdlen); - uint8_t setDataTarget(uint8_t *cmd, uint8_t cmdlen); - - // Mifare Classic functions - bool mifareclassic_IsFirstBlock(uint32_t uiBlock); - bool mifareclassic_IsTrailerBlock(uint32_t uiBlock); - uint8_t mifareclassic_AuthenticateBlock(uint8_t *uid, uint8_t uidLen, - uint32_t blockNumber, - uint8_t keyNumber, - uint8_t *keyData); - uint8_t mifareclassic_ReadDataBlock(uint8_t blockNumber, uint8_t *data); - uint8_t mifareclassic_WriteDataBlock(uint8_t blockNumber, uint8_t *data); - uint8_t mifareclassic_FormatNDEF(void); - uint8_t mifareclassic_WriteNDEFURI(uint8_t sectorNumber, - uint8_t uriIdentifier, const char *url); - - // Mifare Ultralight functions - uint8_t mifareultralight_ReadPage(uint8_t page, uint8_t *buffer); - uint8_t mifareultralight_WritePage(uint8_t page, uint8_t *data); - - // NTAG2xx functions - uint8_t ntag2xx_ReadPage(uint8_t page, uint8_t *buffer); - uint8_t ntag2xx_WritePage(uint8_t page, uint8_t *data); - uint8_t ntag2xx_WriteNDEFURI(uint8_t uriIdentifier, char *url, - uint8_t dataLen); - - // Help functions to display formatted text - static void PrintHex(const byte *data, const uint32_t numBytes); - static void PrintHexChar(const byte *pbtData, const uint32_t numBytes); - - private: - int8_t _irq = -1, _reset = -1, _cs = -1; - int8_t _uid[7]; // ISO14443A uid - int8_t _uidLen; // uid len - int8_t _key[6]; // Mifare Classic key - int8_t _inListedTag; // Tg number of inlisted tag. - - // Low level communication functions that handle both SPI and I2C. - void readdata(uint8_t *buff, uint8_t n); - void writecommand(uint8_t *cmd, uint8_t cmdlen); - bool isready(); - bool waitready(uint16_t timeout); - bool readack(); - - Adafruit_SPIDevice *spi_dev = NULL; - Adafruit_I2CDevice *i2c_dev = NULL; - HardwareSerial *ser_dev = NULL; -}; - -#endif diff --git a/src/libs/BleConnectionStatus.cpp b/src/libs/BleConnectionStatus.cpp deleted file mode 100644 index 83d3539..0000000 --- a/src/libs/BleConnectionStatus.cpp +++ /dev/null @@ -1,17 +0,0 @@ -#include "BleConnectionStatus.h" - -BleConnectionStatus::BleConnectionStatus(void) {} - -void BleConnectionStatus::onConnect(BLEServer *pServer) { - this->connected = true; - BLE2902 *desc = (BLE2902 *)this->inputMouse->getDescriptorByUUID( - BLEUUID((uint16_t)0x2902)); - desc->setNotifications(true); -} - -void BleConnectionStatus::onDisconnect(BLEServer *pServer) { - this->connected = false; - BLE2902 *desc = (BLE2902 *)this->inputMouse->getDescriptorByUUID( - BLEUUID((uint16_t)0x2902)); - desc->setNotifications(false); -} diff --git a/src/libs/BleConnectionStatus.h b/src/libs/BleConnectionStatus.h deleted file mode 100644 index 45b7185..0000000 --- a/src/libs/BleConnectionStatus.h +++ /dev/null @@ -1,20 +0,0 @@ -#ifndef ESP32_BLE_CONNECTION_STATUS_H -#define ESP32_BLE_CONNECTION_STATUS_H -#include "sdkconfig.h" -#if defined(CONFIG_BT_ENABLED) - -#include "BLE2902.h" -#include "BLECharacteristic.h" -#include - -class BleConnectionStatus : public BLEServerCallbacks { - public: - BleConnectionStatus(void); - bool connected = false; - void onConnect(BLEServer *pServer); - void onDisconnect(BLEServer *pServer); - BLECharacteristic *inputMouse; -}; - -#endif // CONFIG_BT_ENABLED -#endif // ESP32_BLE_CONNECTION_STATUS_H diff --git a/src/libs/BleMouse.cpp b/src/libs/BleMouse.cpp deleted file mode 100644 index 8f5c16e..0000000 --- a/src/libs/BleMouse.cpp +++ /dev/null @@ -1,165 +0,0 @@ -#include "BLE2902.h" -#include "BLEHIDDevice.h" -#include "HIDKeyboardTypes.h" -#include "HIDTypes.h" -#include "sdkconfig.h" -#include -#include -#include -#include - -#include "BleConnectionStatus.h" -#include "BleMouse.h" - -#if defined(CONFIG_ARDUHAL_ESP_LOG) -#include "esp32-hal-log.h" -#define LOG_TAG "" -#else -#include "esp_log.h" -static const char *LOG_TAG = "BLEDevice"; -#endif - -static const uint8_t _hidReportDescriptor[] = { - USAGE_PAGE(1), 0x01, // USAGE_PAGE (Generic Desktop) - USAGE(1), 0x02, // USAGE (Mouse) - COLLECTION(1), 0x01, // COLLECTION (Application) - USAGE(1), 0x01, // USAGE (Pointer) - COLLECTION(1), 0x00, // COLLECTION (Physical) - // ------------------------------------------------- Buttons (Left, Right, - // Middle, Back, Forward) - USAGE_PAGE(1), 0x09, // USAGE_PAGE (Button) - USAGE_MINIMUM(1), 0x01, // USAGE_MINIMUM (Button 1) - USAGE_MAXIMUM(1), 0x05, // USAGE_MAXIMUM (Button 5) - LOGICAL_MINIMUM(1), 0x00, // LOGICAL_MINIMUM (0) - LOGICAL_MAXIMUM(1), 0x01, // LOGICAL_MAXIMUM (1) - REPORT_SIZE(1), 0x01, // REPORT_SIZE (1) - REPORT_COUNT(1), 0x05, // REPORT_COUNT (5) - HIDINPUT(1), 0x02, // INPUT (Data, Variable, Absolute) ;5 button bits - // ------------------------------------------------- Padding - REPORT_SIZE(1), 0x03, // REPORT_SIZE (3) - REPORT_COUNT(1), 0x01, // REPORT_COUNT (1) - HIDINPUT(1), - 0x03, // INPUT (Constant, Variable, Absolute) ;3 bit padding - // ------------------------------------------------- X/Y position, Wheel - USAGE_PAGE(1), 0x01, // USAGE_PAGE (Generic Desktop) - USAGE(1), 0x30, // USAGE (X) - USAGE(1), 0x31, // USAGE (Y) - USAGE(1), 0x38, // USAGE (Wheel) - LOGICAL_MINIMUM(1), 0x81, // LOGICAL_MINIMUM (-127) - LOGICAL_MAXIMUM(1), 0x7f, // LOGICAL_MAXIMUM (127) - REPORT_SIZE(1), 0x08, // REPORT_SIZE (8) - REPORT_COUNT(1), 0x03, // REPORT_COUNT (3) - HIDINPUT(1), - 0x06, // INPUT (Data, Variable, Relative) ;3 bytes (X,Y,Wheel) - // ------------------------------------------------- Horizontal wheel - USAGE_PAGE(1), 0x0c, // USAGE PAGE (Consumer Devices) - USAGE(2), 0x38, 0x02, // USAGE (AC Pan) - LOGICAL_MINIMUM(1), 0x81, // LOGICAL_MINIMUM (-127) - LOGICAL_MAXIMUM(1), 0x7f, // LOGICAL_MAXIMUM (127) - REPORT_SIZE(1), 0x08, // REPORT_SIZE (8) - REPORT_COUNT(1), 0x01, // REPORT_COUNT (1) - HIDINPUT(1), 0x06, // INPUT (Data, Var, Rel) - END_COLLECTION(0), // END_COLLECTION - END_COLLECTION(0) // END_COLLECTION -}; - -BleMouse::BleMouse(std::string deviceName, std::string deviceManufacturer, - uint8_t batteryLevel) - : _buttons(0), hid(0) { - this->deviceName = deviceName; - this->deviceManufacturer = deviceManufacturer; - this->batteryLevel = batteryLevel; - this->connectionStatus = new BleConnectionStatus(); -} - -void BleMouse::begin(void) { - xTaskCreate(this->taskServer, "server", 20000, (void *)this, 5, NULL); -} - -void BleMouse::end(void) {} - -void BleMouse::click(uint8_t b) { - _buttons = b; - move(0, 0, 0, 0); - _buttons = 0; - move(0, 0, 0, 0); -} - -void BleMouse::move(signed char x, signed char y, signed char wheel, - signed char hWheel) { - if (this->isConnected()) { - uint8_t m[5]; - m[0] = _buttons; - m[1] = x; - m[2] = y; - m[3] = wheel; - m[4] = hWheel; - this->inputMouse->setValue(m, 5); - this->inputMouse->notify(); - } -} - -void BleMouse::buttons(uint8_t b) { - if (b != _buttons) { - _buttons = b; - move(0, 0, 0, 0); - } -} - -void BleMouse::press(uint8_t b) { buttons(_buttons | b); } - -void BleMouse::release(uint8_t b) { buttons(_buttons & ~b); } - -bool BleMouse::isPressed(uint8_t b) { - if ((b & _buttons) > 0) - return true; - return false; -} - -bool BleMouse::isConnected(void) { return this->connectionStatus->connected; } - -void BleMouse::setBatteryLevel(uint8_t level) { - this->batteryLevel = level; - if (hid != 0) - this->hid->setBatteryLevel(this->batteryLevel); -} - -void BleMouse::taskServer(void *pvParameter) { - BleMouse *bleMouseInstance = - (BleMouse *)pvParameter; // static_cast(pvParameter); - BLEDevice::init(std::string(bleMouseInstance->deviceName.c_str())); - BLEServer *pServer = BLEDevice::createServer(); - pServer->setCallbacks(bleMouseInstance->connectionStatus); - - bleMouseInstance->hid = new BLEHIDDevice(pServer); - bleMouseInstance->inputMouse = bleMouseInstance->hid->inputReport( - 0); // <-- input REPORTID from report map - bleMouseInstance->connectionStatus->inputMouse = - bleMouseInstance->inputMouse; - - bleMouseInstance->hid->manufacturer()->setValue( - std::string(bleMouseInstance->deviceManufacturer.c_str())); - - bleMouseInstance->hid->pnp(0x02, 0xe502, 0xa111, 0x0210); - bleMouseInstance->hid->hidInfo(0x00, 0x02); - - BLESecurity *pSecurity = new BLESecurity(); - - pSecurity->setAuthenticationMode(ESP_LE_AUTH_BOND); - - bleMouseInstance->hid->reportMap((uint8_t *)_hidReportDescriptor, - sizeof(_hidReportDescriptor)); - bleMouseInstance->hid->startServices(); - - bleMouseInstance->onStarted(pServer); - - BLEAdvertising *pAdvertising = pServer->getAdvertising(); - pAdvertising->setAppearance(HID_MOUSE); - pAdvertising->addServiceUUID( - bleMouseInstance->hid->hidService()->getUUID()); - pAdvertising->start(); - bleMouseInstance->hid->setBatteryLevel(bleMouseInstance->batteryLevel); - - ESP_LOGD(LOG_TAG, "Advertising started!"); - vTaskDelay(portMAX_DELAY); // delay(portMAX_DELAY); -} diff --git a/src/libs/BleMouse.h b/src/libs/BleMouse.h deleted file mode 100644 index 4468189..0000000 --- a/src/libs/BleMouse.h +++ /dev/null @@ -1,52 +0,0 @@ -#ifndef ESP32_BLE_MOUSE_H -#define ESP32_BLE_MOUSE_H -#include "sdkconfig.h" -#if defined(CONFIG_BT_ENABLED) - -#include "BLECharacteristic.h" -#include "BLEHIDDevice.h" -#include "BleConnectionStatus.h" - -#define MOUSE_LEFT 1 -#define MOUSE_RIGHT 2 -#define MOUSE_MIDDLE 4 -#define MOUSE_BACK 8 -#define MOUSE_FORWARD 16 -#define MOUSE_ALL \ - (MOUSE_LEFT | MOUSE_RIGHT | \ - MOUSE_MIDDLE) #For compatibility with the Mouse library - -class BleMouse { - private: - uint8_t _buttons; - BleConnectionStatus *connectionStatus; - BLEHIDDevice *hid; - BLECharacteristic *inputMouse; - void buttons(uint8_t b); - void rawAction(uint8_t msg[], char msgSize); - static void taskServer(void *pvParameter); - - public: - BleMouse(std::string deviceName = "ESP32 Bluetooth Mouse", - std::string deviceManufacturer = "Espressif", - uint8_t batteryLevel = 100); - void begin(void); - void end(void); - void click(uint8_t b = MOUSE_LEFT); - void move(signed char x, signed char y, signed char wheel = 0, - signed char hWheel = 0); - void press(uint8_t b = MOUSE_LEFT); // press LEFT by default - void release(uint8_t b = MOUSE_LEFT); // release LEFT by default - bool isPressed(uint8_t b = MOUSE_LEFT); // check LEFT by default - bool isConnected(void); - void setBatteryLevel(uint8_t level); - uint8_t batteryLevel; - std::string deviceManufacturer; - std::string deviceName; - - protected: - virtual void onStarted(BLEServer *pServer) {}; -}; - -#endif // CONFIG_BT_ENABLED -#endif // ESP32_BLE_MOUSE_H diff --git a/src/libs/ELECHOUSE_CC1101_SRC_DRV.cpp b/src/libs/ELECHOUSE_CC1101_SRC_DRV.cpp deleted file mode 100644 index ead012f..0000000 --- a/src/libs/ELECHOUSE_CC1101_SRC_DRV.cpp +++ /dev/null @@ -1,1482 +0,0 @@ -/* - ELECHOUSE_CC1101.cpp - CC1101 module library - Copyright (c) 2010 Michael. - Author: Michael, - Version: November 12, 2010 - - This library is designed to use CC1101/CC1100 module on Arduino platform. - CC1101/CC1100 module is an useful wireless module.Using the functions of the - library, you can easily send and receive data by the CC1101/CC1100 module. - Just have fun! - For the details, please refer to the datasheet of CC1100/CC1101. ----------------------------------------------------------------------------------------------------------------- -cc1101 Driver for RC Switch. Mod by Little Satan. With permission to modify and -publish Wilson Shen (ELECHOUSE). ----------------------------------------------------------------------------------------------------------------- -*/ -#include "ELECHOUSE_CC1101_SRC_DRV.h" -#include -#include - -/****************************************************************/ -#define WRITE_BURST 0x40 // write burst -#define READ_SINGLE 0x80 // read single -#define READ_BURST 0xC0 // read burst -#define BYTES_IN_RXFIFO 0x7F // byte number in RXfifo -#define max_modul 6 - -SPIClass CCSPI(HSPI); - -byte modulation = 2; -byte frend0; -byte chan = 0; -int pa = 12; -byte last_pa; -byte SCK_PIN; -byte MISO_PIN; -byte MOSI_PIN; -byte SS_PIN; -byte GDO0; -byte GDO2; -byte SCK_PIN_M[max_modul]; -byte MISO_PIN_M[max_modul]; -byte MOSI_PIN_M[max_modul]; -byte SS_PIN_M[max_modul]; -byte GDO0_M[max_modul]; -byte GDO2_M[max_modul]; -byte gdo_set = 0; -bool spi = 0; -bool ccmode = 0; -float MHz = 433.92; -byte m4RxBw = 0; -byte m4DaRa; -byte m2DCOFF; -byte m2MODFM; -byte m2MANCH; -byte m2SYNCM; -byte m1FEC; -byte m1PRE; -byte m1CHSP; -byte pc1PQT; -byte pc1CRC_AF; -byte pc1APP_ST; -byte pc1ADRCHK; -byte pc0WDATA; -byte pc0PktForm; -byte pc0CRC_EN; -byte pc0LenConf; -byte trxstate = 0; -byte clb1[2] = {24, 28}; -byte clb2[2] = {31, 38}; -byte clb3[2] = {65, 76}; -byte clb4[2] = {77, 79}; - -/****************************************************************/ -uint8_t PA_TABLE[8]{0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; -// -30 -20 -15 -10 0 5 7 10 -uint8_t PA_TABLE_315[8]{ - 0x12, 0x0D, 0x1C, 0x34, 0x51, 0x85, 0xCB, 0xC2, -}; // 300 - 348 -uint8_t PA_TABLE_433[8]{ - 0x12, 0x0E, 0x1D, 0x34, 0x60, 0x84, 0xC8, 0xC0, -}; // 387 - 464 -// -30 -20 -15 -10 -6 0 5 7 10 12 -uint8_t PA_TABLE_868[10]{ - 0x03, 0x17, 0x1D, 0x26, 0x37, 0x50, 0x86, 0xCD, 0xC5, 0xC0, -}; // 779 - 899.99 -// -30 -20 -15 -10 -6 0 5 7 10 11 -uint8_t PA_TABLE_915[10]{ - 0x03, 0x0E, 0x1E, 0x27, 0x38, 0x8E, 0x84, 0xCC, 0xC3, 0xC0, -}; // 900 - 928 -/**************************************************************** - *FUNCTION NAME:SpiStart - *FUNCTION :spi communication start - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::SpiStart(void) { - // initialize the SPI pins - pinMode(SCK_PIN, OUTPUT); - pinMode(MOSI_PIN, OUTPUT); - pinMode(MISO_PIN, INPUT); - pinMode(SS_PIN, OUTPUT); - -// enable SPI -#ifdef ESP32 - CCSPI.begin(SCK_PIN, MISO_PIN, MOSI_PIN, SS_PIN); -#else - CCSPI.begin(); -#endif -} -/**************************************************************** - *FUNCTION NAME:SpiEnd - *FUNCTION :spi communication disable - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::SpiEnd(void) { - // disable SPI - CCSPI.endTransaction(); - CCSPI.end(); -} -/**************************************************************** - *FUNCTION NAME: GDO_Set() - *FUNCTION : set GDO0,GDO2 pin for serial pinmode. - *INPUT : none - *OUTPUT : none - ****************************************************************/ -void ELECHOUSE_CC1101::GDO_Set(void) { - pinMode(GDO0, OUTPUT); - pinMode(GDO2, INPUT); -} -/**************************************************************** - *FUNCTION NAME: GDO_Set() - *FUNCTION : set GDO0 for internal transmission mode. - *INPUT : none - *OUTPUT : none - ****************************************************************/ -void ELECHOUSE_CC1101::GDO0_Set(void) { pinMode(GDO0, INPUT); } -/**************************************************************** - *FUNCTION NAME:Reset - *FUNCTION :CC1101 reset //details refer datasheet of CC1101/CC1100// - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::Reset(void) { - digitalWrite(SS_PIN, LOW); - delay(1); - digitalWrite(SS_PIN, HIGH); - delay(1); - digitalWrite(SS_PIN, LOW); - while (digitalRead(MISO_PIN)) - ; - CCSPI.transfer(CC1101_SRES); - while (digitalRead(MISO_PIN)) - ; - digitalWrite(SS_PIN, HIGH); -} -/**************************************************************** - *FUNCTION NAME:Init - *FUNCTION :CC1101 initialization - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::Init(void) { - setSpi(); - SpiStart(); // spi initialization - digitalWrite(SS_PIN, HIGH); - digitalWrite(SCK_PIN, HIGH); - digitalWrite(MOSI_PIN, LOW); - Reset(); // CC1101 reset - RegConfigSettings(); // CC1101 register config - SpiEnd(); -} -/**************************************************************** - *FUNCTION NAME:SpiWriteReg - *FUNCTION :CC1101 write data to register - *INPUT :addr: register address; value: register value - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::SpiWriteReg(byte addr, byte value) { - SpiStart(); - digitalWrite(SS_PIN, LOW); - while (digitalRead(MISO_PIN)) - ; - CCSPI.transfer(addr); - CCSPI.transfer(value); - digitalWrite(SS_PIN, HIGH); - SpiEnd(); -} -/**************************************************************** - *FUNCTION NAME:SpiWriteBurstReg - *FUNCTION :CC1101 write burst data to register - *INPUT :addr: register address; buffer:register value array; num:number - * to write OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::SpiWriteBurstReg(byte addr, byte *buffer, byte num) { - byte i, temp; - SpiStart(); - temp = addr | WRITE_BURST; - digitalWrite(SS_PIN, LOW); - while (digitalRead(MISO_PIN)) - ; - CCSPI.transfer(temp); - for (i = 0; i < num; i++) { - CCSPI.transfer(buffer[i]); - } - digitalWrite(SS_PIN, HIGH); - SpiEnd(); -} -/**************************************************************** - *FUNCTION NAME:SpiStrobe - *FUNCTION :CC1101 Strobe - *INPUT :strobe: command; //refer define in CC1101.h// - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::SpiStrobe(byte strobe) { - SpiStart(); - digitalWrite(SS_PIN, LOW); - while (digitalRead(MISO_PIN)) - ; - CCSPI.transfer(strobe); - digitalWrite(SS_PIN, HIGH); - SpiEnd(); -} -/**************************************************************** - *FUNCTION NAME:SpiReadReg - *FUNCTION :CC1101 read data from register - *INPUT :addr: register address - *OUTPUT :register value - ****************************************************************/ -byte ELECHOUSE_CC1101::SpiReadReg(byte addr) { - byte temp, value; - SpiStart(); - temp = addr | READ_SINGLE; - digitalWrite(SS_PIN, LOW); - while (digitalRead(MISO_PIN)) - ; - CCSPI.transfer(temp); - value = CCSPI.transfer(0); - digitalWrite(SS_PIN, HIGH); - SpiEnd(); - return value; -} - -/**************************************************************** - *FUNCTION NAME:SpiReadBurstReg - *FUNCTION :CC1101 read burst data from register - *INPUT :addr: register address; buffer:array to store register value; - * num: number to read OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::SpiReadBurstReg(byte addr, byte *buffer, byte num) { - byte i, temp; - SpiStart(); - temp = addr | READ_BURST; - digitalWrite(SS_PIN, LOW); - while (digitalRead(MISO_PIN)) - ; - CCSPI.transfer(temp); - for (i = 0; i < num; i++) { - buffer[i] = CCSPI.transfer(0); - } - digitalWrite(SS_PIN, HIGH); - SpiEnd(); -} - -/**************************************************************** - *FUNCTION NAME:SpiReadStatus - *FUNCTION :CC1101 read status register - *INPUT :addr: register address - *OUTPUT :status value - ****************************************************************/ -byte ELECHOUSE_CC1101::SpiReadStatus(byte addr) { - byte value, temp; - SpiStart(); - temp = addr | READ_BURST; - digitalWrite(SS_PIN, LOW); - while (digitalRead(MISO_PIN)) - ; - CCSPI.transfer(temp); - value = CCSPI.transfer(0); - digitalWrite(SS_PIN, HIGH); - SpiEnd(); - return value; -} -/**************************************************************** - *FUNCTION NAME:SPI pin Settings - *FUNCTION :Set Spi pins - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::setSpi(void) { - if (spi == 0) { -#if defined __AVR_ATmega168__ || defined __AVR_ATmega328P__ - SCK_PIN = 13; - MISO_PIN = 12; - MOSI_PIN = 11; - SS_PIN = 10; -#elif defined __AVR_ATmega1280__ || defined __AVR_ATmega2560__ - SCK_PIN = 52; - MISO_PIN = 50; - MOSI_PIN = 51; - SS_PIN = 53; -#elif ESP8266 - SCK_PIN = 14; - MISO_PIN = 12; - MOSI_PIN = 13; - SS_PIN = 15; -#elif ESP32 - SCK_PIN = 18; - MISO_PIN = 19; - MOSI_PIN = 23; - SS_PIN = 5; -#else - SCK_PIN = 13; - MISO_PIN = 12; - MOSI_PIN = 11; - SS_PIN = 10; -#endif - } -} -/**************************************************************** - *FUNCTION NAME:COSTUM SPI - *FUNCTION :set costum spi pins. - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::setSpiPin(byte sck, byte miso, byte mosi, byte ss) { - spi = 1; - SCK_PIN = sck; - MISO_PIN = miso; - MOSI_PIN = mosi; - SS_PIN = ss; -} -/**************************************************************** - *FUNCTION NAME:COSTUM SPI - *FUNCTION :set costum spi pins. - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::addSpiPin(byte sck, byte miso, byte mosi, byte ss, - byte modul) { - spi = 1; - SCK_PIN_M[modul] = sck; - MISO_PIN_M[modul] = miso; - MOSI_PIN_M[modul] = mosi; - SS_PIN_M[modul] = ss; -} -/**************************************************************** - *FUNCTION NAME:GDO Pin settings - *FUNCTION :set GDO Pins - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::setGDO(byte gdo0, byte gdo2) { - GDO0 = gdo0; - GDO2 = gdo2; - GDO_Set(); -} -/**************************************************************** - *FUNCTION NAME:GDO0 Pin setting - *FUNCTION :set GDO0 Pin - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::setGDO0(byte gdo0) { - GDO0 = gdo0; - GDO0_Set(); -} -/**************************************************************** - *FUNCTION NAME:GDO Pin settings - *FUNCTION :add GDO Pins - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::addGDO(byte gdo0, byte gdo2, byte modul) { - GDO0_M[modul] = gdo0; - GDO2_M[modul] = gdo2; - gdo_set = 2; - GDO_Set(); -} -/**************************************************************** - *FUNCTION NAME:add GDO0 Pin - *FUNCTION :add GDO0 Pin - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::addGDO0(byte gdo0, byte modul) { - GDO0_M[modul] = gdo0; - gdo_set = 1; - GDO0_Set(); -} -/**************************************************************** - *FUNCTION NAME:set Modul - *FUNCTION :change modul - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::setModul(byte modul) { - SCK_PIN = SCK_PIN_M[modul]; - MISO_PIN = MISO_PIN_M[modul]; - MOSI_PIN = MOSI_PIN_M[modul]; - SS_PIN = SS_PIN_M[modul]; - if (gdo_set == 1) { - GDO0 = GDO0_M[modul]; - } else if (gdo_set == 2) { - GDO0 = GDO0_M[modul]; - GDO2 = GDO2_M[modul]; - } -} -/**************************************************************** - *FUNCTION NAME:CCMode - *FUNCTION :Format of RX and TX data - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::setCCMode(bool s) { - ccmode = s; - if (ccmode == 1) { - SpiWriteReg(CC1101_IOCFG2, 0x0B); - SpiWriteReg(CC1101_IOCFG0, 0x06); - SpiWriteReg(CC1101_PKTCTRL0, 0x05); - SpiWriteReg(CC1101_MDMCFG3, 0xF8); - SpiWriteReg(CC1101_MDMCFG4, 11 + m4RxBw); - } else { - SpiWriteReg(CC1101_IOCFG2, 0x0D); - SpiWriteReg(CC1101_IOCFG0, 0x0D); - SpiWriteReg(CC1101_PKTCTRL0, 0x32); - SpiWriteReg(CC1101_MDMCFG3, 0x93); - SpiWriteReg(CC1101_MDMCFG4, 7 + m4RxBw); - } - setModulation(modulation); -} -/**************************************************************** - *FUNCTION NAME:Modulation - *FUNCTION :set CC1101 Modulation - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::setModulation(byte m) { - if (m > 4) { - m = 4; - } - modulation = m; - Split_MDMCFG2(); - switch (m) { - case 0: - m2MODFM = 0x00; - frend0 = 0x10; - break; // 2-FSK - case 1: - m2MODFM = 0x10; - frend0 = 0x10; - break; // GFSK - case 2: - m2MODFM = 0x30; - frend0 = 0x11; - break; // ASK - case 3: - m2MODFM = 0x40; - frend0 = 0x10; - break; // 4-FSK - case 4: - m2MODFM = 0x70; - frend0 = 0x10; - break; // MSK - } - SpiWriteReg(CC1101_MDMCFG2, m2DCOFF + m2MODFM + m2MANCH + m2SYNCM); - SpiWriteReg(CC1101_FREND0, frend0); - setPA(pa); -} -/**************************************************************** - *FUNCTION NAME:PA Power - *FUNCTION :set CC1101 PA Power - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::setPA(int p) { - int a; - pa = p; - - if (MHz >= 300 && MHz <= 348) { - if (pa <= -30) { - a = PA_TABLE_315[0]; - } else if (pa > -30 && pa <= -20) { - a = PA_TABLE_315[1]; - } else if (pa > -20 && pa <= -15) { - a = PA_TABLE_315[2]; - } else if (pa > -15 && pa <= -10) { - a = PA_TABLE_315[3]; - } else if (pa > -10 && pa <= 0) { - a = PA_TABLE_315[4]; - } else if (pa > 0 && pa <= 5) { - a = PA_TABLE_315[5]; - } else if (pa > 5 && pa <= 7) { - a = PA_TABLE_315[6]; - } else if (pa > 7) { - a = PA_TABLE_315[7]; - } - last_pa = 1; - } else if (MHz >= 378 && MHz <= 464) { - if (pa <= -30) { - a = PA_TABLE_433[0]; - } else if (pa > -30 && pa <= -20) { - a = PA_TABLE_433[1]; - } else if (pa > -20 && pa <= -15) { - a = PA_TABLE_433[2]; - } else if (pa > -15 && pa <= -10) { - a = PA_TABLE_433[3]; - } else if (pa > -10 && pa <= 0) { - a = PA_TABLE_433[4]; - } else if (pa > 0 && pa <= 5) { - a = PA_TABLE_433[5]; - } else if (pa > 5 && pa <= 7) { - a = PA_TABLE_433[6]; - } else if (pa > 7) { - a = PA_TABLE_433[7]; - } - last_pa = 2; - } else if (MHz >= 779 && MHz <= 899.99) { - if (pa <= -30) { - a = PA_TABLE_868[0]; - } else if (pa > -30 && pa <= -20) { - a = PA_TABLE_868[1]; - } else if (pa > -20 && pa <= -15) { - a = PA_TABLE_868[2]; - } else if (pa > -15 && pa <= -10) { - a = PA_TABLE_868[3]; - } else if (pa > -10 && pa <= -6) { - a = PA_TABLE_868[4]; - } else if (pa > -6 && pa <= 0) { - a = PA_TABLE_868[5]; - } else if (pa > 0 && pa <= 5) { - a = PA_TABLE_868[6]; - } else if (pa > 5 && pa <= 7) { - a = PA_TABLE_868[7]; - } else if (pa > 7 && pa <= 10) { - a = PA_TABLE_868[8]; - } else if (pa > 10) { - a = PA_TABLE_868[9]; - } - last_pa = 3; - } else if (MHz >= 900 && MHz <= 928) { - if (pa <= -30) { - a = PA_TABLE_915[0]; - } else if (pa > -30 && pa <= -20) { - a = PA_TABLE_915[1]; - } else if (pa > -20 && pa <= -15) { - a = PA_TABLE_915[2]; - } else if (pa > -15 && pa <= -10) { - a = PA_TABLE_915[3]; - } else if (pa > -10 && pa <= -6) { - a = PA_TABLE_915[4]; - } else if (pa > -6 && pa <= 0) { - a = PA_TABLE_915[5]; - } else if (pa > 0 && pa <= 5) { - a = PA_TABLE_915[6]; - } else if (pa > 5 && pa <= 7) { - a = PA_TABLE_915[7]; - } else if (pa > 7 && pa <= 10) { - a = PA_TABLE_915[8]; - } else if (pa > 10) { - a = PA_TABLE_915[9]; - } - last_pa = 4; - } - if (modulation == 2) { - PA_TABLE[0] = 0; - PA_TABLE[1] = a; - } else { - PA_TABLE[0] = a; - PA_TABLE[1] = 0; - } - SpiWriteBurstReg(CC1101_PATABLE, PA_TABLE, 8); -} -/**************************************************************** - *FUNCTION NAME:Frequency Calculator - *FUNCTION :Calculate the basic frequency. - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::setMHZ(float mhz) { - byte freq2 = 0; - byte freq1 = 0; - byte freq0 = 0; - - MHz = mhz; - - for (bool i = 0; i == 0;) { - if (mhz >= 26) { - mhz -= 26; - freq2 += 1; - } else if (mhz >= 0.1015625) { - mhz -= 0.1015625; - freq1 += 1; - } else if (mhz >= 0.00039675) { - mhz -= 0.00039675; - freq0 += 1; - } else { - i = 1; - } - } - if (freq0 > 255) { - freq1 += 1; - freq0 -= 256; - } - - SpiWriteReg(CC1101_FREQ2, freq2); - SpiWriteReg(CC1101_FREQ1, freq1); - SpiWriteReg(CC1101_FREQ0, freq0); - - Calibrate(); -} -/**************************************************************** - *FUNCTION NAME:Calibrate - *FUNCTION :Calibrate frequency - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::Calibrate(void) { - - if (MHz >= 300 && MHz <= 348) { - SpiWriteReg(CC1101_FSCTRL0, map(MHz, 300, 348, clb1[0], clb1[1])); - if (MHz < 322.88) { - SpiWriteReg(CC1101_TEST0, 0x0B); - } else { - SpiWriteReg(CC1101_TEST0, 0x09); - int s = ELECHOUSE_cc1101.SpiReadStatus(CC1101_FSCAL2); - if (s < 32) { - SpiWriteReg(CC1101_FSCAL2, s + 32); - } - if (last_pa != 1) { - setPA(pa); - } - } - } else if (MHz >= 378 && MHz <= 464) { - SpiWriteReg(CC1101_FSCTRL0, map(MHz, 378, 464, clb2[0], clb2[1])); - if (MHz < 430.5) { - SpiWriteReg(CC1101_TEST0, 0x0B); - } else { - SpiWriteReg(CC1101_TEST0, 0x09); - int s = ELECHOUSE_cc1101.SpiReadStatus(CC1101_FSCAL2); - if (s < 32) { - SpiWriteReg(CC1101_FSCAL2, s + 32); - } - if (last_pa != 2) { - setPA(pa); - } - } - } else if (MHz >= 779 && MHz <= 899.99) { - SpiWriteReg(CC1101_FSCTRL0, map(MHz, 779, 899, clb3[0], clb3[1])); - if (MHz < 861) { - SpiWriteReg(CC1101_TEST0, 0x0B); - } else { - SpiWriteReg(CC1101_TEST0, 0x09); - int s = ELECHOUSE_cc1101.SpiReadStatus(CC1101_FSCAL2); - if (s < 32) { - SpiWriteReg(CC1101_FSCAL2, s + 32); - } - if (last_pa != 3) { - setPA(pa); - } - } - } else if (MHz >= 900 && MHz <= 928) { - SpiWriteReg(CC1101_FSCTRL0, map(MHz, 900, 928, clb4[0], clb4[1])); - SpiWriteReg(CC1101_TEST0, 0x09); - int s = ELECHOUSE_cc1101.SpiReadStatus(CC1101_FSCAL2); - if (s < 32) { - SpiWriteReg(CC1101_FSCAL2, s + 32); - } - if (last_pa != 4) { - setPA(pa); - } - } -} -/**************************************************************** - *FUNCTION NAME:Calibration offset - *FUNCTION :Set calibration offset - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::setClb(byte b, byte s, byte e) { - if (b == 1) { - clb1[0] = s; - clb1[1] = e; - } else if (b == 2) { - clb2[0] = s; - clb2[1] = e; - } else if (b == 3) { - clb3[0] = s; - clb3[1] = e; - } else if (b == 4) { - clb4[0] = s; - clb4[1] = e; - } -} -/**************************************************************** - *FUNCTION NAME:getCC1101 - *FUNCTION :Test Spi connection and return 1 when true. - *INPUT :none - *OUTPUT :none - ****************************************************************/ -bool ELECHOUSE_CC1101::getCC1101(void) { - setSpi(); - if (SpiReadStatus(0x31) > 0) { - return 1; - } else { - return 0; - } -} -/**************************************************************** - *FUNCTION NAME:getMode - *FUNCTION :Return the Mode. Sidle = 0, TX = 1, Rx = 2. - *INPUT :none - *OUTPUT :none - ****************************************************************/ -byte ELECHOUSE_CC1101::getMode(void) { return trxstate; } -/**************************************************************** - *FUNCTION NAME:Set Sync_Word - *FUNCTION :Sync Word - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::setSyncWord(byte sh, byte sl) { - SpiWriteReg(CC1101_SYNC1, sh); - SpiWriteReg(CC1101_SYNC0, sl); -} -/**************************************************************** - *FUNCTION NAME:Set ADDR - *FUNCTION :Address used for packet filtration. Optional broadcast addresses - * are 0 (0x00) and 255 (0xFF). INPUT :none OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::setAddr(byte v) { SpiWriteReg(CC1101_ADDR, v); } -/**************************************************************** - *FUNCTION NAME:Set PQT - *FUNCTION :Preamble quality estimator threshold - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::setPQT(byte v) { - Split_PKTCTRL1(); - pc1PQT = 0; - if (v > 7) { - v = 7; - } - pc1PQT = v * 32; - SpiWriteReg(CC1101_PKTCTRL1, pc1PQT + pc1CRC_AF + pc1APP_ST + pc1ADRCHK); -} -/**************************************************************** - *FUNCTION NAME:Set CRC_AUTOFLUSH - *FUNCTION :Enable automatic flush of RX FIFO when CRC is not OK - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::setCRC_AF(bool v) { - Split_PKTCTRL1(); - pc1CRC_AF = 0; - if (v == 1) { - pc1CRC_AF = 8; - } - SpiWriteReg(CC1101_PKTCTRL1, pc1PQT + pc1CRC_AF + pc1APP_ST + pc1ADRCHK); -} -/**************************************************************** - *FUNCTION NAME:Set APPEND_STATUS - *FUNCTION :When enabled, two status bytes will be appended to the payload - * of the packet INPUT :none OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::setAppendStatus(bool v) { - Split_PKTCTRL1(); - pc1APP_ST = 0; - if (v == 1) { - pc1APP_ST = 4; - } - SpiWriteReg(CC1101_PKTCTRL1, pc1PQT + pc1CRC_AF + pc1APP_ST + pc1ADRCHK); -} -/**************************************************************** - *FUNCTION NAME:Set ADR_CHK - *FUNCTION :Controls address check configuration of received packages - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::setAdrChk(byte v) { - Split_PKTCTRL1(); - pc1ADRCHK = 0; - if (v > 3) { - v = 3; - } - pc1ADRCHK = v; - SpiWriteReg(CC1101_PKTCTRL1, pc1PQT + pc1CRC_AF + pc1APP_ST + pc1ADRCHK); -} -/**************************************************************** - *FUNCTION NAME:Set WHITE_DATA - *FUNCTION :Turn data whitening on / off. - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::setWhiteData(bool v) { - Split_PKTCTRL0(); - pc0WDATA = 0; - if (v == 1) { - pc0WDATA = 64; - } - SpiWriteReg(CC1101_PKTCTRL0, - pc0WDATA + pc0PktForm + pc0CRC_EN + pc0LenConf); -} -/**************************************************************** - *FUNCTION NAME:Set PKT_FORMAT - *FUNCTION :Format of RX and TX data - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::setPktFormat(byte v) { - Split_PKTCTRL0(); - pc0PktForm = 0; - if (v > 3) { - v = 3; - } - pc0PktForm = v * 16; - SpiWriteReg(CC1101_PKTCTRL0, - pc0WDATA + pc0PktForm + pc0CRC_EN + pc0LenConf); -} -/**************************************************************** - *FUNCTION NAME:Set CRC - *FUNCTION :CRC calculation in TX and CRC check in RX - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::setCrc(bool v) { - Split_PKTCTRL0(); - pc0CRC_EN = 0; - if (v == 1) { - pc0CRC_EN = 4; - } - SpiWriteReg(CC1101_PKTCTRL0, - pc0WDATA + pc0PktForm + pc0CRC_EN + pc0LenConf); -} -/**************************************************************** - *FUNCTION NAME:Set LENGTH_CONFIG - *FUNCTION :Configure the packet length - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::setLengthConfig(byte v) { - Split_PKTCTRL0(); - pc0LenConf = 0; - if (v > 3) { - v = 3; - } - pc0LenConf = v; - SpiWriteReg(CC1101_PKTCTRL0, - pc0WDATA + pc0PktForm + pc0CRC_EN + pc0LenConf); -} -/**************************************************************** - *FUNCTION NAME:Set PACKET_LENGTH - *FUNCTION :Indicates the packet length - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::setPacketLength(byte v) { - SpiWriteReg(CC1101_PKTLEN, v); -} -/**************************************************************** - *FUNCTION NAME:Set DCFILT_OFF - *FUNCTION :Disable digital DC blocking filter before demodulator - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::setDcFilterOff(bool v) { - Split_MDMCFG2(); - m2DCOFF = 0; - if (v == 1) { - m2DCOFF = 128; - } - SpiWriteReg(CC1101_MDMCFG2, m2DCOFF + m2MODFM + m2MANCH + m2SYNCM); -} -/**************************************************************** - *FUNCTION NAME:Set MANCHESTER - *FUNCTION :Enables Manchester encoding/decoding - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::setManchester(bool v) { - Split_MDMCFG2(); - m2MANCH = 0; - if (v == 1) { - m2MANCH = 8; - } - SpiWriteReg(CC1101_MDMCFG2, m2DCOFF + m2MODFM + m2MANCH + m2SYNCM); -} -/**************************************************************** - *FUNCTION NAME:Set SYNC_MODE - *FUNCTION :Combined sync-word qualifier mode - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::setSyncMode(byte v) { - Split_MDMCFG2(); - m2SYNCM = 0; - if (v > 7) { - v = 7; - } - m2SYNCM = v; - SpiWriteReg(CC1101_MDMCFG2, m2DCOFF + m2MODFM + m2MANCH + m2SYNCM); -} -/**************************************************************** - *FUNCTION NAME:Set FEC - *FUNCTION :Enable Forward Error Correction (FEC) - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::setFEC(bool v) { - Split_MDMCFG1(); - m1FEC = 0; - if (v == 1) { - m1FEC = 128; - } - SpiWriteReg(CC1101_MDMCFG1, m1FEC + m1PRE + m1CHSP); -} -/**************************************************************** - *FUNCTION NAME:Set PRE - *FUNCTION :Sets the minimum number of preamble bytes to be transmitted. - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::setPRE(byte v) { - Split_MDMCFG1(); - m1PRE = 0; - if (v > 7) { - v = 7; - } - m1PRE = v * 16; - SpiWriteReg(CC1101_MDMCFG1, m1FEC + m1PRE + m1CHSP); -} -/**************************************************************** - *FUNCTION NAME:Set Channel - *FUNCTION :none - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::setChannel(byte ch) { - chan = ch; - SpiWriteReg(CC1101_CHANNR, chan); -} -/**************************************************************** - *FUNCTION NAME:Set Channel spacing - *FUNCTION :none - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::setChsp(float f) { - Split_MDMCFG1(); - byte MDMCFG0 = 0; - m1CHSP = 0; - if (f > 405.456543) { - f = 405.456543; - } - if (f < 25.390625) { - f = 25.390625; - } - for (int i = 0; i < 5; i++) { - if (f <= 50.682068) { - f -= 25.390625; - f /= 0.0991825; - MDMCFG0 = f; - float s1 = (f - MDMCFG0) * 10; - if (s1 >= 5) { - MDMCFG0++; - } - i = 5; - } else { - m1CHSP++; - f /= 2; - } - } - SpiWriteReg(19, m1CHSP + m1FEC + m1PRE); - SpiWriteReg(20, MDMCFG0); -} -/**************************************************************** - *FUNCTION NAME:Set Receive bandwidth - *FUNCTION :none - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::setRxBW(float f) { - Split_MDMCFG4(); - int s1 = 3; - int s2 = 3; - for (int i = 0; i < 3; i++) { - if (f > 101.5625) { - f /= 2; - s1--; - } else { - i = 3; - } - } - for (int i = 0; i < 3; i++) { - if (f > 58.1) { - f /= 1.25; - s2--; - } else { - i = 3; - } - } - s1 *= 64; - s2 *= 16; - m4RxBw = s1 + s2; - SpiWriteReg(16, m4RxBw + m4DaRa); -} -/**************************************************************** - *FUNCTION NAME:Set Data Rate - *FUNCTION :none - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::setDRate(float d) { - Split_MDMCFG4(); - float c = d; - byte MDMCFG3 = 0; - if (c > 1621.83) { - c = 1621.83; - } - if (c < 0.0247955) { - c = 0.0247955; - } - m4DaRa = 0; - for (int i = 0; i < 20; i++) { - if (c <= 0.0494942) { - c = c - 0.0247955; - c = c / 0.00009685; - MDMCFG3 = c; - float s1 = (c - MDMCFG3) * 10; - if (s1 >= 5) { - MDMCFG3++; - } - i = 20; - } else { - m4DaRa++; - c = c / 2; - } - } - SpiWriteReg(16, m4RxBw + m4DaRa); - SpiWriteReg(17, MDMCFG3); -} -/**************************************************************** - *FUNCTION NAME:Set Devitation - *FUNCTION :none - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::setDeviation(float d) { - float f = 1.586914; - float v = 0.19836425; - int c = 0; - if (d > 380.859375) { - d = 380.859375; - } - if (d < 1.586914) { - d = 1.586914; - } - for (int i = 0; i < 255; i++) { - f += v; - if (c == 7) { - v *= 2; - c = -1; - i += 8; - } - if (f >= d) { - c = i; - i = 255; - } - c++; - } - SpiWriteReg(21, c); -} -/**************************************************************** - *FUNCTION NAME:Split PKTCTRL0 - *FUNCTION :none - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::Split_PKTCTRL1(void) { - int calc = SpiReadStatus(7); - pc1PQT = 0; - pc1CRC_AF = 0; - pc1APP_ST = 0; - pc1ADRCHK = 0; - for (bool i = 0; i == 0;) { - if (calc >= 32) { - calc -= 32; - pc1PQT += 32; - } else if (calc >= 8) { - calc -= 8; - pc1CRC_AF += 8; - } else if (calc >= 4) { - calc -= 4; - pc1APP_ST += 4; - } else { - pc1ADRCHK = calc; - i = 1; - } - } -} -/**************************************************************** - *FUNCTION NAME:Split PKTCTRL0 - *FUNCTION :none - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::Split_PKTCTRL0(void) { - int calc = SpiReadStatus(8); - pc0WDATA = 0; - pc0PktForm = 0; - pc0CRC_EN = 0; - pc0LenConf = 0; - for (bool i = 0; i == 0;) { - if (calc >= 64) { - calc -= 64; - pc0WDATA += 64; - } else if (calc >= 16) { - calc -= 16; - pc0PktForm += 16; - } else if (calc >= 4) { - calc -= 4; - pc0CRC_EN += 4; - } else { - pc0LenConf = calc; - i = 1; - } - } -} -/**************************************************************** - *FUNCTION NAME:Split MDMCFG1 - *FUNCTION :none - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::Split_MDMCFG1(void) { - int calc = SpiReadStatus(19); - m1FEC = 0; - m1PRE = 0; - m1CHSP = 0; - int s2 = 0; - for (bool i = 0; i == 0;) { - if (calc >= 128) { - calc -= 128; - m1FEC += 128; - } else if (calc >= 16) { - calc -= 16; - m1PRE += 16; - } else { - m1CHSP = calc; - i = 1; - } - } -} -/**************************************************************** - *FUNCTION NAME:Split MDMCFG2 - *FUNCTION :none - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::Split_MDMCFG2(void) { - int calc = SpiReadStatus(18); - m2DCOFF = 0; - m2MODFM = 0; - m2MANCH = 0; - m2SYNCM = 0; - for (bool i = 0; i == 0;) { - if (calc >= 128) { - calc -= 128; - m2DCOFF += 128; - } else if (calc >= 16) { - calc -= 16; - m2MODFM += 16; - } else if (calc >= 8) { - calc -= 8; - m2MANCH += 8; - } else { - m2SYNCM = calc; - i = 1; - } - } -} -/**************************************************************** - *FUNCTION NAME:Split MDMCFG4 - *FUNCTION :none - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::Split_MDMCFG4(void) { - int calc = SpiReadStatus(16); - m4RxBw = 0; - m4DaRa = 0; - for (bool i = 0; i == 0;) { - if (calc >= 64) { - calc -= 64; - m4RxBw += 64; - } else if (calc >= 16) { - calc -= 16; - m4RxBw += 16; - } else { - m4DaRa = calc; - i = 1; - } - } -} -/**************************************************************** - *FUNCTION NAME:RegConfigSettings - *FUNCTION :CC1101 register config //details refer datasheet of - * CC1101/CC1100// INPUT :none OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::RegConfigSettings(void) { - SpiWriteReg(CC1101_FSCTRL1, 0x06); - - setCCMode(ccmode); - setMHZ(MHz); - - SpiWriteReg(CC1101_MDMCFG1, 0x02); - SpiWriteReg(CC1101_MDMCFG0, 0xF8); - SpiWriteReg(CC1101_CHANNR, chan); - SpiWriteReg(CC1101_DEVIATN, 0x47); - SpiWriteReg(CC1101_FREND1, 0x56); - SpiWriteReg(CC1101_MCSM0, 0x18); - SpiWriteReg(CC1101_FOCCFG, 0x16); - SpiWriteReg(CC1101_BSCFG, 0x1C); - SpiWriteReg(CC1101_AGCCTRL2, 0xC7); - SpiWriteReg(CC1101_AGCCTRL1, 0x00); - SpiWriteReg(CC1101_AGCCTRL0, 0xB2); - SpiWriteReg(CC1101_FSCAL3, 0xE9); - SpiWriteReg(CC1101_FSCAL2, 0x2A); - SpiWriteReg(CC1101_FSCAL1, 0x00); - SpiWriteReg(CC1101_FSCAL0, 0x1F); - SpiWriteReg(CC1101_FSTEST, 0x59); - SpiWriteReg(CC1101_TEST2, 0x81); - SpiWriteReg(CC1101_TEST1, 0x35); - SpiWriteReg(CC1101_TEST0, 0x09); - SpiWriteReg(CC1101_PKTCTRL1, 0x04); - SpiWriteReg(CC1101_ADDR, 0x00); - SpiWriteReg(CC1101_PKTLEN, 0x00); -} -/**************************************************************** - *FUNCTION NAME:SetTx - *FUNCTION :set CC1101 send data - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::SetTx(void) { - SpiStrobe(CC1101_SIDLE); - SpiStrobe(CC1101_STX); // start send - trxstate = 1; -} -/**************************************************************** - *FUNCTION NAME:SetRx - *FUNCTION :set CC1101 to receive state - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::SetRx(void) { - SpiStrobe(CC1101_SIDLE); - SpiStrobe(CC1101_SRX); // start receive - trxstate = 2; -} -/**************************************************************** - *FUNCTION NAME:SetTx - *FUNCTION :set CC1101 send data and change frequency - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::SetTx(float mhz) { - SpiStrobe(CC1101_SIDLE); - setMHZ(mhz); - SpiStrobe(CC1101_STX); // start send - trxstate = 1; -} -/**************************************************************** - *FUNCTION NAME:SetRx - *FUNCTION :set CC1101 to receive state and change frequency - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::SetRx(float mhz) { - SpiStrobe(CC1101_SIDLE); - setMHZ(mhz); - SpiStrobe(CC1101_SRX); // start receive - trxstate = 2; -} -/**************************************************************** - *FUNCTION NAME:RSSI Level - *FUNCTION :Calculating the RSSI Level - *INPUT :none - *OUTPUT :none - ****************************************************************/ -int ELECHOUSE_CC1101::getRssi(void) { - int rssi; - rssi = SpiReadStatus(CC1101_RSSI); - if (rssi >= 128) { - rssi = (rssi - 256) / 2 - 74; - } else { - rssi = (rssi / 2) - 74; - } - return rssi; -} -/**************************************************************** - *FUNCTION NAME:LQI Level - *FUNCTION :get Lqi state - *INPUT :none - *OUTPUT :none - ****************************************************************/ -byte ELECHOUSE_CC1101::getLqi(void) { - byte lqi; - lqi = SpiReadStatus(CC1101_LQI); - return lqi; -} -/**************************************************************** - *FUNCTION NAME:SetSres - *FUNCTION :Reset CC1101 - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::setSres(void) { - SpiStrobe(CC1101_SRES); - trxstate = 0; -} -/**************************************************************** - *FUNCTION NAME:setSidle - *FUNCTION :set Rx / TX Off - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::setSidle(void) { - SpiStrobe(CC1101_SIDLE); - trxstate = 0; -} -/**************************************************************** - *FUNCTION NAME:goSleep - *FUNCTION :set cc1101 Sleep on - *INPUT :none - *OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::goSleep(void) { - trxstate = 0; - SpiStrobe(0x36); // Exit RX / TX, turn off frequency synthesizer and exit - SpiStrobe(0x39); // Enter power down mode when CSn goes high. -} -/**************************************************************** - *FUNCTION NAME:Char direct SendData - *FUNCTION :use CC1101 send data - *INPUT :txBuffer: data array to send; size: number of data to send, no - * more than 61 OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::SendData(char *txchar) { - int len = strlen(txchar); - byte chartobyte[len]; - for (int i = 0; i < len; i++) { - chartobyte[i] = txchar[i]; - } - SendData(chartobyte, len); -} -/**************************************************************** - *FUNCTION NAME:SendData - *FUNCTION :use CC1101 send data - *INPUT :txBuffer: data array to send; size: number of data to send, no - * more than 61 OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::SendData(byte *txBuffer, byte size) { - SpiWriteReg(CC1101_TXFIFO, size); - SpiWriteBurstReg(CC1101_TXFIFO, txBuffer, size); // write data to send - SpiStrobe(CC1101_SIDLE); - SpiStrobe(CC1101_STX); // start send - while (!digitalRead(GDO0)) - ; // Wait for GDO0 to be set -> sync transmitted - while (digitalRead(GDO0)) - ; // Wait for GDO0 to be cleared -> end of packet - SpiStrobe(CC1101_SFTX); // flush TXfifo - trxstate = 1; -} -/**************************************************************** - *FUNCTION NAME:Char direct SendData - *FUNCTION :use CC1101 send data without GDO - *INPUT :txBuffer: data array to send; size: number of data to send, no - * more than 61 OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::SendData(char *txchar, int t) { - int len = strlen(txchar); - byte chartobyte[len]; - for (int i = 0; i < len; i++) { - chartobyte[i] = txchar[i]; - } - SendData(chartobyte, len, t); -} -/**************************************************************** - *FUNCTION NAME:SendData - *FUNCTION :use CC1101 send data without GDO - *INPUT :txBuffer: data array to send; size: number of data to send, no - * more than 61 OUTPUT :none - ****************************************************************/ -void ELECHOUSE_CC1101::SendData(byte *txBuffer, byte size, int t) { - SpiWriteReg(CC1101_TXFIFO, size); - SpiWriteBurstReg(CC1101_TXFIFO, txBuffer, size); // write data to send - SpiStrobe(CC1101_SIDLE); - SpiStrobe(CC1101_STX); // start send - delay(t); - SpiStrobe(CC1101_SFTX); // flush TXfifo - trxstate = 1; -} -/**************************************************************** - *FUNCTION NAME:Check CRC - *FUNCTION :none - *INPUT :none - *OUTPUT :none - ****************************************************************/ -bool ELECHOUSE_CC1101::CheckCRC(void) { - byte lqi = SpiReadStatus(CC1101_LQI); - bool crc_ok = bitRead(lqi, 7); - if (crc_ok == 1) { - return 1; - } else { - SpiStrobe(CC1101_SFRX); - SpiStrobe(CC1101_SRX); - return 0; - } -} -/**************************************************************** - *FUNCTION NAME:CheckRxFifo - *FUNCTION :check receive data or not - *INPUT :none - *OUTPUT :flag: 0 no data; 1 receive data - ****************************************************************/ -bool ELECHOUSE_CC1101::CheckRxFifo(int t) { - if (trxstate != 2) { - SetRx(); - } - if (SpiReadStatus(CC1101_RXBYTES) & BYTES_IN_RXFIFO) { - delay(t); - return 1; - } else { - return 0; - } -} -/**************************************************************** - *FUNCTION NAME:CheckReceiveFlag - *FUNCTION :check receive data or not - *INPUT :none - *OUTPUT :flag: 0 no data; 1 receive data - ****************************************************************/ -byte ELECHOUSE_CC1101::CheckReceiveFlag(void) { - if (trxstate != 2) { - SetRx(); - } - if (digitalRead(GDO0)) // receive data - { - while (digitalRead(GDO0)) - ; - return 1; - } else // no data - { - return 0; - } -} -/**************************************************************** - *FUNCTION NAME:ReceiveData - *FUNCTION :read data received from RXfifo - *INPUT :rxBuffer: buffer to store data - *OUTPUT :size of data received - ****************************************************************/ -byte ELECHOUSE_CC1101::ReceiveData(byte *rxBuffer) { - byte size; - byte status[2]; - - if (SpiReadStatus(CC1101_RXBYTES) & BYTES_IN_RXFIFO) { - size = SpiReadReg(CC1101_RXFIFO); - SpiReadBurstReg(CC1101_RXFIFO, rxBuffer, size); - SpiReadBurstReg(CC1101_RXFIFO, status, 2); - SpiStrobe(CC1101_SFRX); - SpiStrobe(CC1101_SRX); - return size; - } else { - SpiStrobe(CC1101_SFRX); - SpiStrobe(CC1101_SRX); - return 0; - } -} -ELECHOUSE_CC1101 ELECHOUSE_cc1101; \ No newline at end of file diff --git a/src/libs/ELECHOUSE_CC1101_SRC_DRV.h b/src/libs/ELECHOUSE_CC1101_SRC_DRV.h deleted file mode 100644 index fd6df0a..0000000 --- a/src/libs/ELECHOUSE_CC1101_SRC_DRV.h +++ /dev/null @@ -1,203 +0,0 @@ -/* - ELECHOUSE_CC1101.cpp - CC1101 module library - Copyright (c) 2010 Michael. - Author: Michael, - Version: November 12, 2010 - - This library is designed to use CC1101/CC1100 module on Arduino platform. - CC1101/CC1100 module is an useful wireless module.Using the functions of the - library, you can easily send and receive data by the CC1101/CC1100 module. - Just have fun! - For the details, please refer to the datasheet of CC1100/CC1101. ----------------------------------------------------------------------------------------------------------------- -cc1101 Driver for RC Switch. Mod by Little Satan. With permission to modify and -publish Wilson Shen (ELECHOUSE). ----------------------------------------------------------------------------------------------------------------- -*/ -#ifndef ELECHOUSE_CC1101_SRC_DRV_h -#define ELECHOUSE_CC1101_SRC_DRV_h - -#include - -//***************************************CC1101 -//define**************************************************// -// CC1101 CONFIG REGSITER -#define CC1101_IOCFG2 0x00 // GDO2 output pin configuration -#define CC1101_IOCFG1 0x01 // GDO1 output pin configuration -#define CC1101_IOCFG0 0x02 // GDO0 output pin configuration -#define CC1101_FIFOTHR 0x03 // RX FIFO and TX FIFO thresholds -#define CC1101_SYNC1 0x04 // Sync word, high INT8U -#define CC1101_SYNC0 0x05 // Sync word, low INT8U -#define CC1101_PKTLEN 0x06 // Packet length -#define CC1101_PKTCTRL1 0x07 // Packet automation control -#define CC1101_PKTCTRL0 0x08 // Packet automation control -#define CC1101_ADDR 0x09 // Device address -#define CC1101_CHANNR 0x0A // Channel number -#define CC1101_FSCTRL1 0x0B // Frequency synthesizer control -#define CC1101_FSCTRL0 0x0C // Frequency synthesizer control -#define CC1101_FREQ2 0x0D // Frequency control word, high INT8U -#define CC1101_FREQ1 0x0E // Frequency control word, middle INT8U -#define CC1101_FREQ0 0x0F // Frequency control word, low INT8U -#define CC1101_MDMCFG4 0x10 // Modem configuration -#define CC1101_MDMCFG3 0x11 // Modem configuration -#define CC1101_MDMCFG2 0x12 // Modem configuration -#define CC1101_MDMCFG1 0x13 // Modem configuration -#define CC1101_MDMCFG0 0x14 // Modem configuration -#define CC1101_DEVIATN 0x15 // Modem deviation setting -#define CC1101_MCSM2 0x16 // Main Radio Control State Machine configuration -#define CC1101_MCSM1 0x17 // Main Radio Control State Machine configuration -#define CC1101_MCSM0 0x18 // Main Radio Control State Machine configuration -#define CC1101_FOCCFG 0x19 // Frequency Offset Compensation configuration -#define CC1101_BSCFG 0x1A // Bit Synchronization configuration -#define CC1101_AGCCTRL2 0x1B // AGC control -#define CC1101_AGCCTRL1 0x1C // AGC control -#define CC1101_AGCCTRL0 0x1D // AGC control -#define CC1101_WOREVT1 0x1E // High INT8U Event 0 timeout -#define CC1101_WOREVT0 0x1F // Low INT8U Event 0 timeout -#define CC1101_WORCTRL 0x20 // Wake On Radio control -#define CC1101_FREND1 0x21 // Front end RX configuration -#define CC1101_FREND0 0x22 // Front end TX configuration -#define CC1101_FSCAL3 0x23 // Frequency synthesizer calibration -#define CC1101_FSCAL2 0x24 // Frequency synthesizer calibration -#define CC1101_FSCAL1 0x25 // Frequency synthesizer calibration -#define CC1101_FSCAL0 0x26 // Frequency synthesizer calibration -#define CC1101_RCCTRL1 0x27 // RC oscillator configuration -#define CC1101_RCCTRL0 0x28 // RC oscillator configuration -#define CC1101_FSTEST 0x29 // Frequency synthesizer calibration control -#define CC1101_PTEST 0x2A // Production test -#define CC1101_AGCTEST 0x2B // AGC test -#define CC1101_TEST2 0x2C // Various test settings -#define CC1101_TEST1 0x2D // Various test settings -#define CC1101_TEST0 0x2E // Various test settings - -// CC1101 Strobe commands -#define CC1101_SRES 0x30 // Reset chip. -#define CC1101_SFSTXON \ - 0x31 // Enable and calibrate frequency synthesizer (if MCSM0.FS_AUTOCAL=1). - // If in RX/TX: Go to a wait state where only the synthesizer is - // running (for quick RX / TX turnaround). -#define CC1101_SXOFF 0x32 // Turn off crystal oscillator. -#define CC1101_SCAL \ - 0x33 // Calibrate frequency synthesizer and turn it off - // (enables quick start). -#define CC1101_SRX \ - 0x34 // Enable RX. Perform calibration first if coming from IDLE and - // MCSM0.FS_AUTOCAL=1. -#define CC1101_STX \ - 0x35 // In IDLE state: Enable TX. Perform calibration first if - // MCSM0.FS_AUTOCAL=1. If in RX state and CCA is enabled: - // Only go to TX if channel is clear. -#define CC1101_SIDLE \ - 0x36 // Exit RX / TX, turn off frequency synthesizer and exit - // Wake-On-Radio mode if applicable. -#define CC1101_SAFC 0x37 // Perform AFC adjustment of the frequency synthesizer -#define CC1101_SWOR 0x38 // Start automatic RX polling sequence (Wake-on-Radio) -#define CC1101_SPWD 0x39 // Enter power down mode when CSn goes high. -#define CC1101_SFRX 0x3A // Flush the RX FIFO buffer. -#define CC1101_SFTX 0x3B // Flush the TX FIFO buffer. -#define CC1101_SWORRST 0x3C // Reset real time clock. -#define CC1101_SNOP \ - 0x3D // No operation. May be used to pad strobe commands to two - // INT8Us for simpler software. -// CC1101 STATUS REGSITER -#define CC1101_PARTNUM 0x30 -#define CC1101_VERSION 0x31 -#define CC1101_FREQEST 0x32 -#define CC1101_LQI 0x33 -#define CC1101_RSSI 0x34 -#define CC1101_MARCSTATE 0x35 -#define CC1101_WORTIME1 0x36 -#define CC1101_WORTIME0 0x37 -#define CC1101_PKTSTATUS 0x38 -#define CC1101_VCO_VC_DAC 0x39 -#define CC1101_TXBYTES 0x3A -#define CC1101_RXBYTES 0x3B - -// CC1101 PATABLE,TXFIFO,RXFIFO -#define CC1101_PATABLE 0x3E -#define CC1101_TXFIFO 0x3F -#define CC1101_RXFIFO 0x3F - -//************************************* class -//**************************************************// -class ELECHOUSE_CC1101 { - private: - void SpiStart(void); - void SpiEnd(void); - void GDO_Set(void); - void GDO0_Set(void); - void Reset(void); - void setSpi(void); - void RegConfigSettings(void); - void Calibrate(void); - void Split_PKTCTRL0(void); - void Split_PKTCTRL1(void); - void Split_MDMCFG1(void); - void Split_MDMCFG2(void); - void Split_MDMCFG4(void); - - public: - void Init(void); - byte SpiReadStatus(byte addr); - void setSpiPin(byte sck, byte miso, byte mosi, byte ss); - void addSpiPin(byte sck, byte miso, byte mosi, byte ss, byte modul); - void setGDO(byte gdo0, byte gdo2); - void setGDO0(byte gdo0); - void addGDO(byte gdo0, byte gdo2, byte modul); - void addGDO0(byte gdo0, byte modul); - void setModul(byte modul); - void setCCMode(bool s); - void setModulation(byte m); - void setPA(int p); - void setMHZ(float mhz); - void setChannel(byte chnl); - void setChsp(float f); - void setRxBW(float f); - void setDRate(float d); - void setDeviation(float d); - void SetTx(void); - void SetRx(void); - void SetTx(float mhz); - void SetRx(float mhz); - int getRssi(void); - byte getLqi(void); - void setSres(void); - void setSidle(void); - void goSleep(void); - void SendData(byte *txBuffer, byte size); - void SendData(char *txchar); - void SendData(byte *txBuffer, byte size, int t); - void SendData(char *txchar, int t); - byte CheckReceiveFlag(void); - byte ReceiveData(byte *rxBuffer); - bool CheckCRC(void); - void SpiStrobe(byte strobe); - void SpiWriteReg(byte addr, byte value); - void SpiWriteBurstReg(byte addr, byte *buffer, byte num); - byte SpiReadReg(byte addr); - void SpiReadBurstReg(byte addr, byte *buffer, byte num); - void setClb(byte b, byte s, byte e); - bool getCC1101(void); - byte getMode(void); - void setSyncWord(byte sh, byte sl); - void setAddr(byte v); - void setWhiteData(bool v); - void setPktFormat(byte v); - void setCrc(bool v); - void setLengthConfig(byte v); - void setPacketLength(byte v); - void setDcFilterOff(bool v); - void setManchester(bool v); - void setSyncMode(byte v); - void setFEC(bool v); - void setPRE(byte v); - void setPQT(byte v); - void setCRC_AF(bool v); - void setAppendStatus(bool v); - void setAdrChk(byte v); - bool CheckRxFifo(int t); -}; - -extern ELECHOUSE_CC1101 ELECHOUSE_cc1101; - -#endif \ No newline at end of file diff --git a/src/main.cpp b/src/main.cpp index fd3d6fe..a82dd59 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -2,14 +2,14 @@ #include #include -#include "libs/BleMouse.h" +#include "BleMouse.h" #include #include #include #include -#include "libs/ELECHOUSE_CC1101_SRC_DRV.h" +#include "ELECHOUSE_CC1101_SRC_DRV.h" #include #include diff --git a/src/rf/cc1101.cpp b/src/rf/cc1101.cpp index 4b165bd..7e11d0b 100644 --- a/src/rf/cc1101.cpp +++ b/src/rf/cc1101.cpp @@ -1,6 +1,6 @@ #include "cc1101.h" #include "config.h" -#include "libs/ELECHOUSE_CC1101_SRC_DRV.h" +#include "ELECHOUSE_CC1101_SRC_DRV.h" #include "ui/display.h" #include "utils/buttons.h" #include "SPI.h" diff --git a/src/utils/device_check.cpp b/src/utils/device_check.cpp index dd3e121..17613b3 100644 --- a/src/utils/device_check.cpp +++ b/src/utils/device_check.cpp @@ -1,4 +1,4 @@ -#include "../libs/ELECHOUSE_CC1101_SRC_DRV.h" +#include "ELECHOUSE_CC1101_SRC_DRV.h" #include #include #include -- cgit v1.2.3