rfidrig/ChameleonMini
0
0
Fork 0
mirror of https://github.com/RfidResearchGroup/ChameleonMini.git synced 2026-05-12 11:20:37 -07:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #182 from bosb/ISO15693_base

Browse Source 
Iso15693 base
This commit is contained in:
Georg Land
2019-03-21 16:04:22 +01:00
committed by GitHub
parent 4cd514238b fc24f84a63
commit 8a2755eaa0
25 changed files with 2659 additions and 15 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Dumps/EM4233_example.dmp
BIN
View File
Binary file not shown.
Firmware/Chameleon-Mini/Application/Application.h
+6 -2
View File
@@ -16,7 +16,11 @@
#include "MifareUltralight.h"
#include "MifareClassic.h"
#include "Reader14443A.h"
#include "Vicinity.h"
#include "Sl2s2002.h"
#include "TITagitstandard.h"
#include "Sniff14443A.h"
#include "EM4233.h"
/* Function wrappers */
INLINE void ApplicationInit(void) {
@@ -24,11 +28,11 @@ INLINE void ApplicationInit(void) {
}
INLINE void ApplicationTask(void) {
ActiveConfiguration.ApplicationTaskFunc();
ActiveConfiguration.ApplicationTaskFunc();
}
INLINE void ApplicationTick(void) {
ActiveConfiguration.ApplicationTickFunc();
ActiveConfiguration.ApplicationTickFunc();
}
INLINE uint16_t ApplicationProcess(uint8_t* ByteBuffer, uint16_t ByteCount) {
Firmware/Chameleon-Mini/Application/EM4233.c
+696
View File
File diff suppressed because it is too large Load Diff
Firmware/Chameleon-Mini/Application/EM4233.h
+79
View File
@@ -0,0 +1,79 @@
/*
* EM4233.h
*
* Created on: 04.12.2018
* Author: ceres-c & MrMoDDoM
*/
#ifndef EM4233_H_
#define EM4233_H_
#include "Application.h"
#define EM4233_STD_UID_SIZE ISO15693_GENERIC_UID_SIZE
#define EM4233_STD_MEM_SIZE 0xD0 // Bytes
#define EM4233_BYTES_PER_BLCK 0x04
#define EM4233_BLCKS_PER_PAGE 0x04
#define EM4233_NUMBER_OF_BLCKS ( EM4233_STD_MEM_SIZE / EM4233_BYTES_PER_BLCK )
#define EM4233_NUMBER_OF_PAGES ( EM4233_STD_MEM_SIZE / (EM4233_BYTES_PER_BLCK * EM4233_BLCKS_PER_PAGE) )
#define EM4233_IC_REFERENCE 0x02 // From EM4233SLIC datasheet and checked against real tags
#define EM4233_MEM_UID_ADDRESS 0xD0 // From 0x0100 to 0x0107 - UID
#define EM4233_MEM_AFI_ADDRESS 0xD8 // AFI byte address
#define EM4233_MEM_DSFID_ADDRESS 0xD9 // DSFID byte adress
#define EM4233_MEM_INF_ADDRESS 0xDC // Some status bits
#define EM4233_MEM_LSM_ADDRESS 0xE0 // From 0xE0 to 0x0113 - Lock status masks
#define EM4233_MEM_PSW_ADDRESS 0x0114 // From 0x0114 to 0x0117 - 32 bit Password
#define EM4233_MEM_KEY_ADDRESS 0x0118 // From 0x0118 to 0x0123 - 96 bit Encryption Key
#define EM4233_SYSINFO_BYTE 0x0F // == DSFID - AFI - VICC mem size - IC ref are present
/* Bit masks */
#define EM4233_MASK_READ_PROT ( 1 << 2 ) // For lock status byte
#define EM4233_MASK_WRITE_PROT ( 1 << 3 )
#define EM4233_MASK_AFI_STATUS ( 1 << 0 )
#define EM4233_MASK_DSFID_STATUS ( 1 << 1 )
/* Custom command code */
#define EM4233_CMD_SET_EAS 0xA2
#define EM4233_CMD_RST_EAS 0xA3
#define EM4233_CMD_LCK_EAS 0xA4
#define EM4233_CMD_ACT_EAS 0xA5
#define EM4233_CMD_PRT_EAS 0xA6
#define EM4233_CMD_WRT_EAS_ID 0xA7
#define EM4233_CMD_WRT_EAS_CFG 0xA8
#define EM4233_CMD_WRT_PSW 0xB4
#define EM4233_CMD_WRT_MEM_PAG 0xB6
#define EM4233_CMD_GET_BLKS_PRT_STS 0xB8
#define EM4233_CMD_DESTROY 0xB9
#define EM4233_CMD_ENABLE_PRCY 0xBA
#define EM4233_CMD_DISBLE_PRCY 0xBB
#define EM4233_CMD_FST_READ_BLKS 0xC3
/* Proprietary command code */
#define EM4233_CMD_AUTH1 0xE0
#define EM4233_CMD_AUTH2 0xE1
#define EM4233_CMD_GEN_READ 0xE2 // Implies some sort of singed CRC. Unknown at the moment
#define EM4233_CMD_GEN_WRITE 0xE3 // Same
#define EM4233_CMD_LOGIN 0xE4
/* Compile time switch */
/* EM4233_LOGIN_YES_CARD has to be uncommented if you want your emulated card
* to accept any given password from the reader when a Login request (E4) is issued.
* It is expecially useful when analyzing an unknown system and you want to fool a reader
* into thiking you are using the original tag without actually knowing the password.
*/
#define EM4233_LOGIN_YES_CARD
void EM4233AppInit(void);
void EM4233AppReset(void);
void EM4233AppTask(void);
void EM4233AppTick(void);
uint16_t EM4233AppProcess(uint8_t* FrameBuf, uint16_t FrameBytes);
void EM4233GetUid(ConfigurationUidType Uid);
void EM4233SetUid(ConfigurationUidType Uid);
void EM4233FlipUid(ConfigurationUidType Uid);
#endif /* EM4233_H_ */
Firmware/Chameleon-Mini/Application/ISO15693-A.c
+160
View File
@@ -0,0 +1,160 @@
#include "ISO15693-A.h"
#include "../Common.h"
#include <util/crc16.h>
//Refer to ISO/IEC 15693-3:2001 page 41
uint16_t calculateCRC(void* FrameBuf, uint16_t FrameBufSize)
{
uint16_t reg = ISO15693_CRC16_PRESET;
uint8_t i, j;
uint8_t *DataPtr = (uint8_t *)FrameBuf;
for(i = 0; i < FrameBufSize; i++) {
reg = reg ^ *DataPtr++;
for (j = 0; j < 8; j++) {
if (reg & 0x0001) {
reg = (reg >> 1) ^ ISO15693_CRC16_POLYNORMAL;
} else {
reg = (reg >> 1);
}
}
}
return ~reg;
}
void ISO15693AppendCRC(uint8_t* FrameBuf, uint16_t FrameBufSize)
{
uint16_t crc;
crc = calculateCRC(FrameBuf, FrameBufSize);
uint8_t crcLb = crc & 0xFF;
uint8_t crcHb = crc >> 8;
FrameBuf[FrameBufSize] = crcLb;
FrameBuf[FrameBufSize + 1] = crcHb;
}
bool ISO15693CheckCRC(void* FrameBuf, uint16_t FrameBufSize)
{
uint16_t crc;
uint8_t *DataPtr = (uint8_t *)FrameBuf;
crc = calculateCRC(DataPtr, FrameBufSize);
uint8_t crcLb = crc & 0xFF;
uint8_t crcHb = crc >> 8;
return (DataPtr[FrameBufSize] == crcLb && DataPtr[FrameBufSize + 1] == crcHb);
}
/*
* ISO15693PrepareFrame
*
* This function sets pointers in 'frame' struct to relevant byte(s) of 'FrameBuf'.
* Also sets frame.Addressed as true if the command is addressed, same goes for frame.Selected
*
* Returns:
* - true: Frame is valid and a response is needed
* - false: Request is not addressed to us
* Frame is not valid because it's too short or CRC is wrong
*
* Authors: ceres-c & MrMoDDoM
*/
bool ISO15693PrepareFrame(uint8_t* FrameBuf, uint16_t FrameBytes, CurrentFrame* FrameStruct, uint8_t IsSelected, uint8_t* MyUid, uint8_t MyAFI)
{
/* following declarations are not dependent on addressed/unaddressed state */
FrameStruct -> Flags = &FrameBuf[ISO15693_ADDR_FLAGS];
FrameStruct -> Command = &FrameBuf[ISO15693_REQ_ADDR_CMD];
if(!(FrameBuf[ISO15693_ADDR_FLAGS] & ISO15693_REQ_FLAG_INVENTORY)) { /* if inventory flag is not set */
FrameStruct -> Addressed = (FrameBuf[ISO15693_ADDR_FLAGS] & ISO15693_REQ_FLAG_ADDRESS); /* check for addressed flag */
FrameStruct -> Selected = (FrameBuf[ISO15693_ADDR_FLAGS] & ISO15693_REQ_FLAG_SELECT); /* check for selected flag */
} else { /* otherwise always false */
FrameStruct -> Addressed = false;
FrameStruct -> Selected = false;
}
if (FrameStruct -> Addressed)
/* UID sits between CMD and PARAM */
FrameStruct -> Parameters = &FrameBuf[ISO15693_REQ_ADDR_PARAM + ISO15693_GENERIC_UID_SIZE];
else
FrameStruct -> Parameters = &FrameBuf[ISO15693_REQ_ADDR_PARAM];
if ( (*FrameStruct -> Command) >= 0xA0) { /* if command is Custom or Proprietary */
/* then between CMD and UID is placed another byte which is IC Mfg Code, but we don't need it */
if (FrameBuf[ISO15693_REQ_ADDR_PARAM] != MyUid[1])
/* if IC Mfg Code is different from our Mfg code (2nd byte of UID), then don't respond */
return false;
FrameStruct -> Parameters += 0x01;
}
else if ( ((*FrameStruct -> Command) == ISO15693_CMD_INVENTORY) && (FrameBuf[ISO15693_ADDR_FLAGS] & ISO15693_REQ_FLAG_AFI)) { /* or if it is Inventory with AFI flag set */
/* then between CMD and UID is placed another byte which is requested AFI, but we don't need it */
if (FrameBuf[ISO15693_REQ_ADDR_PARAM] != MyAFI)
/* if requested AFI is different from our current one, then don't respond */
return false;
FrameStruct -> Parameters += 0x01;
}
FrameStruct -> ParamLen = FrameBuf + (FrameBytes - ISO15693_CRC16_SIZE) - (FrameStruct -> Parameters);
/* The UID, if present, always sits right befoore the parameters */
if (FrameStruct -> Addressed && !ISO15693CompareUid(FrameStruct -> Parameters - ISO15693_GENERIC_UID_SIZE, MyUid)) {
/* addressed request but we're not the addressee */
return false;
} else if (FrameStruct -> Selected && !IsSelected) {
/* selected request but we're not in selected state */
return false;
} else {
return true;
}
}
/*
* ISO15693AntiColl
*
* This function performs ISO15693 Anticollision
*
* Returns:
* - true: Inventory is addressed to us and a response is needed
* - false: Request is not addressed to us (different bitmask)
* and no response should be issued.
*
* Authors: ceres-c
*
* TODO:
* - Implement 16 slots mode (still, it seems to work as it is, even for 16 slots mode ._.)
*/
bool ISO15693AntiColl(uint8_t* FrameBuf, uint16_t FrameBytes, CurrentFrame* FrameStruct, uint8_t* MyUid) {
uint8_t CurrentUID[ ISO15693_GENERIC_UID_SIZE ]; /* Holds the UID flipped */
ISO15693CopyUid(CurrentUID, MyUid);
uint8_t MaskLenght = *FrameStruct -> Parameters; /* First byte of parameters is mask lenght... */
uint8_t* MaskValue = FrameStruct -> Parameters + 1; /* ... then the mask itself begins */
uint8_t BytesNum = MaskLenght / 8; /* Gets the number of full bytes in mask */
uint8_t BitsNum = MaskLenght % 8; /* Gets the number of spare bits */
uint8_t B; /* B stands for Bytes and will be our reference point (I know, terrible name, I'm sorry) */
/* Compare the full bytes in mask with UID */
for (B = 0; B < BytesNum; B++ ) {
if (CurrentUID[B] != MaskValue[B])
return false; /* UID different */
}
/* Once we got here, B points for sure to the last byte of the mask, the one composed of spare bits */
/* Compare spare bits in mask with bits of UID */
uint8_t BitsMask = ((1 << BitsNum) - 1); /* (1 << Bits) = 00010000 -> (1 << Bits) - 1 = 00001111 */
if ((MaskValue[B] & BitsMask) != (CurrentUID[B] & BitsMask)) {
/* |-----------------------| Here we extract bits from the mask we received from the reader
* |------------------------| Here we extract bits from the UID
* The two extracted bit vectors are compared, if different then we're not the addressee.
* Only the latest byte of MaskValue and UID is considered.
*/
return false;
}
return true;
}
Firmware/Chameleon-Mini/Application/ISO15693-A.h
+147
View File
@@ -0,0 +1,147 @@
/*
* ISO15693-3.h
*
* Created on: 24.08.2013
* Author: skuser
*/
#ifndef ISO15693_3_H_
#define ISO15693_3_H_
#include "../Common.h"
/* request and response fields addresses */
#define ISO15693_ADDR_FLAGS 0x00
#define ISO15693_REQ_ADDR_CMD 0x01
#define ISO15693_REQ_ADDR_PARAM 0x02
#define ISO15693_RES_ADDR_PARAM 0x01
/* command codes */
#define ISO15693_CMD_INVENTORY 0x01
#define ISO15693_CMD_STAY_QUIET 0x02
#define ISO15693_CMD_READ_SINGLE 0x20
#define ISO15693_CMD_WRITE_SINGLE 0x21
#define ISO15693_CMD_LOCK_BLOCK 0x22
#define ISO15693_CMD_READ_MULTIPLE 0x23
#define ISO15693_CMD_WRITE_MULTIPLE 0x24
#define ISO15693_CMD_SELECT 0x25
#define ISO15693_CMD_RESET_TO_READY 0x26
#define ISO15693_CMD_WRITE_AFI 0x27
#define ISO15693_CMD_LOCK_AFI 0x28
#define ISO15693_CMD_WRITE_DSFID 0x29
#define ISO15693_CMD_LOCK_DSFID 0x2A
#define ISO15693_CMD_GET_SYS_INFO 0x2B
#define ISO15693_CMD_GET_BLOCK_SEC 0x2C
#define ISO15693_REQ_FLAG_SUBCARRIER 0x01
#define ISO15693_REQ_FLAG_DATARATE 0x02
#define ISO15693_REQ_FLAG_INVENTORY 0x04
#define ISO15693_REQ_FLAG_PROT_EXT 0x08
#define ISO15693_REQ_FLAG_OPTION 0x40
#define ISO15693_REQ_FLAG_RFU 0x80
/* When INVENTORY flag is not set: */
#define ISO15693_REQ_FLAG_SELECT 0x10
#define ISO15693_REQ_FLAG_ADDRESS 0x20
/* When INVENTORY flag is set: */
#define ISO15693_REQ_FLAG_AFI 0x10
#define ISO15693_REQ_FLAG_NB_SLOTS 0x20
#define ISO15693_RES_FLAG_NO_ERROR 0x00
#define ISO15693_RES_FLAG_ERROR 0x01
#define ISO15693_RES_FLAG_PROT_EXT 0x08
#define ISO15693_RES_ERR_NOT_SUPP 0x01
#define ISO15693_RES_ERR_NOT_REC 0x02
#define ISO15693_RES_ERR_OPT_NOT_SUPP 0x03
#define ISO15693_RES_ERR_GENERIC 0x0F
#define ISO15693_RES_ERR_BLK_NOT_AVL 0x10
#define ISO15693_RES_ERR_BLK_ALRD_LKD 0x11
#define ISO15693_RES_ERR_BLK_CHG_LKD 0x12
#define ISO15693_RES_ERR_BLK_NOT_PRGR 0x13
#define ISO15693_RES_ERR_BLK_NOT_LKD 0x14
#define ISO15693_RES_INVENTORY_DSFID 0x00
#define ISO15693_MIN_FRAME_SIZE 0x04
#define ISO15693_GENERIC_UID_SIZE 0x08
#define ISO15693_GENERIC_MEM_SIZE 8192
#define ISO15693_CRC16_SIZE 0x2 /* Bytes */
#define ISO15693_CRC16_POLYNORMAL 0x8408
#define ISO15693_CRC16_PRESET 0xFFFF
/* The lock status byte has bits assigned as follow */
#define ISO15693_MASK_UNLOCKED ( 0 << 0 )
#define ISO15693_MASK_USER_LOCK ( 1 << 0 )
#define ISO15693_MASK_FACTORY_LOCK ( 1 << 1 )
typedef struct {
uint8_t* Flags;
uint8_t* Command;
uint8_t* Parameters;
uint8_t ParamLen;
bool Addressed;
bool Selected;
} CurrentFrame;
void ISO15693AppendCRC(uint8_t* FrameBuf, uint16_t FrameBufSize);
bool ISO15693CheckCRC(void* FrameBuf, uint16_t FrameBufSize);
bool ISO15693PrepareFrame(uint8_t* FrameBuf, uint16_t FrameBytes, CurrentFrame* FrameStruct, uint8_t IsSelected, uint8_t* MyUid, uint8_t MyAFI);
bool ISO15693AntiColl(uint8_t* FrameBuf, uint16_t FrameBytes, CurrentFrame* FrameStruct, uint8_t* MyUid);
INLINE
bool ISO15693CompareUid(uint8_t* Uid1, uint8_t* Uid2)
{
if ( (Uid1[0] == Uid2[7])
&& (Uid1[1] == Uid2[6])
&& (Uid1[2] == Uid2[5])
&& (Uid1[3] == Uid2[4])
&& (Uid1[4] == Uid2[3])
&& (Uid1[5] == Uid2[2])
&& (Uid1[6] == Uid2[1])
&& (Uid1[7] == Uid2[0]) ) {
return true;
} else {
return false;
}
}
INLINE
void ISO15693CopyUid(uint8_t* DstUid, uint8_t* SrcUid)
{
DstUid[0] = SrcUid[7];
DstUid[1] = SrcUid[6];
DstUid[2] = SrcUid[5];
DstUid[3] = SrcUid[4];
DstUid[4] = SrcUid[3];
DstUid[5] = SrcUid[2];
DstUid[6] = SrcUid[1];
DstUid[7] = SrcUid[0];
}
INLINE
bool ISO15693Addressed(uint8_t* Buffer) {
return (Buffer[ISO15693_ADDR_FLAGS] & ISO15693_REQ_FLAG_ADDRESS); /* if the flag is set, the command is addressed */
}
INLINE
bool ISO15693AddressedLegacy(uint8_t* Buffer, uint8_t* MyUid) {
if (Buffer[0] & ISO15693_REQ_FLAG_ADDRESS) {
/* Addressed mode */
if ( ISO15693CompareUid(&Buffer[2], MyUid) ) {
/* Our UID addressed */
return true;
} else {
/* Our UID not addressed */
return false;
}
} else {
/* Non-Addressed mode */
return true;
}
}
#endif /* ISO15693_3_H_ */
Firmware/Chameleon-Mini/Application/Sl2s2002.c
+180
View File
@@ -0,0 +1,180 @@
/*
* ISO15693.c
*
* Created on: 01-03-2017
* Author: Phillip Nash
*
* TODO:
* - ISO15693AddressedLegacy should be replaced with ISO15693Addressed and appropriate check
* should be performed (see TITagitstandard.c) - ceres-c
*/
#include "Sl2s2002.h"
#include "../Codec/ISO15693.h"
#include "../Memory.h"
#include "Crypto1.h"
#include "../Random.h"
#include "ISO15693-A.h"
#define BYTES_PER_PAGE 4
#define MEM_UID_ADDRESS 0x00
static enum {
STATE_READY,
STATE_SELECTED,
STATE_QUIET
} State;
void Sl2s2002AppInit(void)
{
State = STATE_READY;
}
void Sl2s2002AppReset(void)
{
State = STATE_READY;
}
void Sl2s2002AppTask(void)
{
}
void Sl2s2002AppTick(void)
{
}
uint16_t Sl2s2002AppProcess(uint8_t* FrameBuf, uint16_t FrameBytes)
{
if (FrameBytes >= ISO15693_MIN_FRAME_SIZE) {
if(ISO15693CheckCRC(FrameBuf, FrameBytes - ISO15693_CRC16_SIZE)) {
// At this point, we have a valid ISO15693 frame
uint8_t Command = FrameBuf[1];
uint16_t ResponseByteCount = ISO15693_APP_NO_RESPONSE;
uint8_t Uid[8];
MemoryReadBlock(Uid, MEM_UID_ADDRESS, ActiveConfiguration.UidSize);
switch(State) {
case STATE_READY:
if (Command == ISO15693_CMD_INVENTORY) {
FrameBuf[0] = 0x00; /* Flags */
FrameBuf[1] = 0x00; /* DSFID */
ISO15693CopyUid(&FrameBuf[2], Uid);
ResponseByteCount = 10;
} else if (Command == ISO15693_CMD_STAY_QUIET) {
if (ISO15693AddressedLegacy(FrameBuf, Uid)) {
State = STATE_QUIET;
}
} else if (Command == ISO15693_CMD_GET_SYS_INFO) {
if (ISO15693AddressedLegacy(FrameBuf, Uid)) {
FrameBuf[0] = 0; /* Flags */
FrameBuf[1] = 0x0F; /* InfoFlags */
ISO15693CopyUid(&FrameBuf[2], Uid);
FrameBuf[10] = 0x00;
FrameBuf[11] = 0xC2;
FrameBuf[12] = 0x03;
FrameBuf[13] = 0x03;
FrameBuf[14] = 0x01;
ResponseByteCount = 15;
}
} else if (Command == ISO15693_CMD_READ_SINGLE) {
if (ISO15693AddressedLegacy(FrameBuf, Uid)) {
uint8_t PageAddress = FrameBuf[10];
if (FrameBuf[0] & ISO15693_REQ_FLAG_OPTION)
{
FrameBuf[0] = 0x00; /* Flags */
FrameBuf[1] = 0x00; /* security dummy to 0 */
MemoryReadBlock(FrameBuf + 2, PageAddress * BYTES_PER_PAGE, BYTES_PER_PAGE);
ResponseByteCount = 6;
} else {
FrameBuf[0] = 0x00; /* Flags */
MemoryReadBlock(FrameBuf + 1, PageAddress * BYTES_PER_PAGE, BYTES_PER_PAGE);
ResponseByteCount = 5;
}
}
} else if (Command == ISO15693_CMD_READ_MULTIPLE) {
if (ISO15693AddressedLegacy(FrameBuf, Uid)) {
uint16_t PageAddress = FrameBuf[10];
uint16_t PageAddressCount = FrameBuf[11] + 1;
uint8_t * FrameBufPtr = FrameBuf + 1;
if (FrameBuf[0] & ISO15693_REQ_FLAG_OPTION)
{
uint8_t count;
for (count = 0; count < PageAddressCount; count++)
{
*FrameBufPtr++ = 0; // block security status = unlocked
MemoryReadBlock(FrameBufPtr, PageAddress * BYTES_PER_PAGE, BYTES_PER_PAGE);
FrameBufPtr += BYTES_PER_PAGE;
PageAddress += 1;
}
ResponseByteCount = 1 + (BYTES_PER_PAGE + 1) * PageAddressCount;
} else {
MemoryReadBlock(FrameBufPtr, PageAddress * BYTES_PER_PAGE, BYTES_PER_PAGE * PageAddressCount);
ResponseByteCount = 1 + BYTES_PER_PAGE * PageAddressCount;
}
FrameBuf[0] = 0; /* Flags */
}
} else if (Command == ISO15693_CMD_GET_BLOCK_SEC) {
if (ISO15693AddressedLegacy(FrameBuf, Uid)) {
uint8_t PageAddressStart = FrameBuf[10];
uint8_t PageAddressCount = FrameBuf[11] + 1;
FrameBuf[0] = 0; /* Flags */
for (uint8_t i = 0; i < PageAddressCount; i++) {
FrameBuf[i] = 0x00;
}
ResponseByteCount = 1 + PageAddressCount;
}
}
break;
case STATE_SELECTED:
break;
case STATE_QUIET:
if (Command == ISO15693_CMD_RESET_TO_READY) {
if (ISO15693AddressedLegacy(FrameBuf, Uid)) {
FrameBuf[0] = 0;
ResponseByteCount = 1;
State = STATE_READY;
}
}
break;
default:
break;
}
if (ResponseByteCount > 0) {
/* There is data to be sent. Append CRC */
ISO15693AppendCRC(FrameBuf, ResponseByteCount);
ResponseByteCount += ISO15693_CRC16_SIZE;
}
return ResponseByteCount;
} else { // Invalid CRC
return ISO15693_APP_NO_RESPONSE;
}
} else { // Min frame size not met
return ISO15693_APP_NO_RESPONSE;
}
}
void Sl2s2002GetUid(ConfigurationUidType Uid)
{
MemoryReadBlock(&Uid[0], MEM_UID_ADDRESS, ActiveConfiguration.UidSize);
}
void Sl2s2002SetUid(ConfigurationUidType Uid)
{
MemoryWriteBlock(Uid, MEM_UID_ADDRESS, ActiveConfiguration.UidSize);
}
Firmware/Chameleon-Mini/Application/Sl2s2002.h
+24
View File
@@ -0,0 +1,24 @@
/*
* MifareClassic.h
*
* Created on: 01.03.2017
* Author: skuser
*/
#ifndef SL2S2002_H_
#define SL2S2002_H_
#include "Application.h"
#include "ISO15693-A.h"
void Sl2s2002AppInit(void);
void Sl2s2002AppReset(void);
void Sl2s2002AppTask(void);
void Sl2s2002AppTick(void);
uint16_t Sl2s2002AppProcess(uint8_t* FrameBuf, uint16_t FrameBytes);
void Sl2s2002GetUid(ConfigurationUidType Uid);
void Sl2s2002SetUid(ConfigurationUidType Uid);
#endif /* VICINITY_H_ */
Firmware/Chameleon-Mini/Application/TITagitstandard.c
+240
View File
@@ -0,0 +1,240 @@
/*
* TITagitstandard.c
*
* Created on: 01-03-2017
* Author: Phillip Nash
* Modified by rickventura for texas 15693 tag-it STANDARD
* Modified by ceres-c & MrMoDDoM to finish things up
*/
#include "ISO15693-A.h"
#include "TITagitstandard.h"
static enum {
STATE_READY,
STATE_SELECTED,
STATE_QUIET
} State;
uint8_t MyAFI; /* Holds current tag's AFI (is used in inventory) */
uint16_t UserLockBits_Mask = 0; /* Holds lock state of blocks */
uint16_t FactoryLockBits_Mask = 0; /* Holds lock state of blocks */
CurrentFrame FrameInfo;
void TITagitstandardAppInit(void)
{
State = STATE_READY;
FactoryLockBits_Mask |= (1 << 8); /* Locks block 8... */
FactoryLockBits_Mask |= (1 << 9); /* ...and 9, which contains the UID */
FrameInfo.Flags = NULL;
FrameInfo.Command = NULL;
FrameInfo.Parameters = NULL;
FrameInfo.ParamLen = 0;
FrameInfo.Addressed = false;
FrameInfo.Selected = false;
MemoryReadBlock(&MyAFI, TITAGIT_MEM_AFI_ADDRESS, 1);
}
void TITagitstandardAppReset(void)
{
State = STATE_READY;
FrameInfo.Flags = NULL;
FrameInfo.Command = NULL;
FrameInfo.Parameters = NULL;
FrameInfo.ParamLen = 0;
FrameInfo.Addressed = false;
FrameInfo.Selected = false;
}
void TITagitstandardAppTask(void)
{
}
void TITagitstandardAppTick(void)
{
}
uint16_t TITagitstandardAppProcess(uint8_t* FrameBuf, uint16_t FrameBytes)
{
uint16_t ResponseByteCount = ISO15693_APP_NO_RESPONSE;
uint8_t Uid[ActiveConfiguration.UidSize];
TITagitstandardGetUid(Uid);
if ((FrameBytes < ISO15693_MIN_FRAME_SIZE) || !ISO15693CheckCRC(FrameBuf, FrameBytes - ISO15693_CRC16_SIZE))
/* malformed frame */
return ResponseByteCount;
if (!ISO15693PrepareFrame(FrameBuf, FrameBytes, &FrameInfo, State == STATE_SELECTED, Uid, MyAFI))
return ISO15693_APP_NO_RESPONSE;
switch(State) {
case STATE_READY:
if (*FrameInfo.Command == ISO15693_CMD_INVENTORY) {
FrameBuf[ISO15693_ADDR_FLAGS] = ISO15693_RES_FLAG_NO_ERROR;
FrameBuf[ISO15693_RES_ADDR_PARAM] = ISO15693_RES_INVENTORY_DSFID;
ISO15693CopyUid(&FrameBuf[ISO15693_RES_ADDR_PARAM + 0x01], Uid);
ResponseByteCount = 10;
} else if (*FrameInfo.Command == ISO15693_CMD_STAY_QUIET && FrameInfo.Addressed) {
State = STATE_QUIET;
} else if (*FrameInfo.Command == ISO15693_CMD_READ_SINGLE) {
uint8_t *FramePtr; /* holds the address where block's data will be put */
uint8_t PageAddress = *FrameInfo.Parameters;
if (FrameInfo.ParamLen != 1)
break; /* malformed: not enough or too much data */
if (PageAddress >= TITAGIT_NUMBER_OF_SECTORS) { /* the reader is requesting a sector out of bound */
FrameBuf[ISO15693_ADDR_FLAGS] = ISO15693_RES_FLAG_ERROR;
FrameBuf[ISO15693_RES_ADDR_PARAM] = ISO15693_RES_ERR_BLK_NOT_AVL; /* real TiTag standard reply with this error */
ResponseByteCount = 2;
break;
}
if (FrameBuf[ISO15693_ADDR_FLAGS] & ISO15693_REQ_FLAG_OPTION) { /* request with option flag set */
if (FactoryLockBits_Mask & (1 << PageAddress)) { /* tests if the n-th bit of the factory bitmask if set to 1 */
FrameBuf[1] = 0x02; /* return bit 1 set as 1 (factory locked) */
} else if (UserLockBits_Mask & (1 << PageAddress)) { /* tests if the n-th bit of the user bitmask if set to 1 */
FrameBuf[1] = 0x01; /* return bit 0 set as 1 (user locked) */
} else
FrameBuf[1] = 0x00; /* return lock status 00 (unlocked) */
FramePtr = FrameBuf + 2; /* block's data from byte 2 */
ResponseByteCount = 6;
} else { /* request with option flag not set */
FramePtr = FrameBuf + 1; /* block's data from byte 1 */
ResponseByteCount = 5;
}
FrameBuf[ISO15693_ADDR_FLAGS] = ISO15693_RES_FLAG_NO_ERROR; /* flags */
MemoryReadBlock(FramePtr, PageAddress * TITAGIT_BYTES_PER_PAGE, TITAGIT_BYTES_PER_PAGE);
} else if (*FrameInfo.Command == ISO15693_CMD_WRITE_SINGLE) {
uint8_t* Dataptr;
uint8_t PageAddress = *FrameInfo.Parameters;
if (FrameInfo.ParamLen != 5)
break; /* malformed: not enough or too much data */
if (PageAddress > TITAGIT_NUMBER_OF_SECTORS) {
FrameBuf[ISO15693_ADDR_FLAGS] = ISO15693_RES_FLAG_ERROR;
FrameBuf[ISO15693_RES_ADDR_PARAM] = ISO15693_RES_ERR_OPT_NOT_SUPP;
ResponseByteCount = 2;
break; /* malformed: trying to write in a non-existing block */
}
Dataptr = PageAddress + 0x01;
if (FactoryLockBits_Mask & (1 << PageAddress)) {
FrameBuf[ISO15693_ADDR_FLAGS] = ISO15693_RES_FLAG_ERROR;
FrameBuf[ISO15693_RES_ADDR_PARAM] = ISO15693_RES_ERR_OPT_NOT_SUPP;
ResponseByteCount = 2;
} else if (UserLockBits_Mask & (1 << PageAddress)) {
FrameBuf[ISO15693_ADDR_FLAGS] = ISO15693_RES_FLAG_ERROR;
FrameBuf[ISO15693_RES_ADDR_PARAM] = ISO15693_RES_ERR_BLK_CHG_LKD;
ResponseByteCount = 2;
} else {
MemoryWriteBlock(Dataptr, PageAddress * TITAGIT_BYTES_PER_PAGE, TITAGIT_BYTES_PER_PAGE);
FrameBuf[ISO15693_ADDR_FLAGS] = ISO15693_RES_FLAG_NO_ERROR;
ResponseByteCount = 1;
}
} else if (*FrameInfo.Command == ISO15693_CMD_LOCK_BLOCK) {
uint8_t PageAddress = *FrameInfo.Parameters;
if (FrameInfo.ParamLen != 1)
break; /* malformed: not enough or too much data */
if (PageAddress > TITAGIT_NUMBER_OF_SECTORS) {
FrameBuf[ISO15693_ADDR_FLAGS] = ISO15693_RES_FLAG_ERROR;
FrameBuf[ISO15693_RES_ADDR_PARAM] = ISO15693_RES_ERR_OPT_NOT_SUPP;
ResponseByteCount = 2;
break; /* malformed: trying to lock a non-existing block */
}
if ((FactoryLockBits_Mask & (1 << PageAddress)) || (UserLockBits_Mask & (1 << PageAddress))) {
FrameBuf[ISO15693_ADDR_FLAGS] = ISO15693_RES_FLAG_ERROR;
FrameBuf[ISO15693_RES_ADDR_PARAM] = ISO15693_RES_ERR_BLK_ALRD_LKD;
ResponseByteCount = 2;
} else {
UserLockBits_Mask |= (1 << PageAddress); /* */
FrameBuf[ISO15693_ADDR_FLAGS] = ISO15693_RES_FLAG_NO_ERROR;
ResponseByteCount = 1;
}
} else {
FrameBuf[ISO15693_ADDR_FLAGS] = ISO15693_RES_FLAG_ERROR;
FrameBuf[ISO15693_RES_ADDR_PARAM] = ISO15693_RES_ERR_NOT_SUPP;
ResponseByteCount = 2;
}
break;
case STATE_SELECTED:
/* Selected state is not supported by Ti TagIt Standard */
break;
case STATE_QUIET:
/* Ti TagIt Standard does not support reset to ready command */
/* following code is lef for future reference for other tags */
/*
if (Command == ISO15693_CMD_RESET_TO_READY) {
FrameBuf[ISO15693_ADDR_FLAGS] = ISO15693_RES_FLAG_NO_ERROR;
ResponseByteCount = 1;
State = STATE_READY;
FrameInfo.Flags = NULL;
FrameInfo.Command = NULL;
FrameInfo.Parameters = NULL;
FrameInfo.ParamLen = 0;
FrameInfo.Addressed = false;
}
*/
ResponseByteCount = 0; /* better safe than sorry */
break;
default:
break;
}
if (ResponseByteCount > 0) {
/* There is data to be sent. Append CRC */
ISO15693AppendCRC(FrameBuf, ResponseByteCount);
ResponseByteCount += ISO15693_CRC16_SIZE;
}
return ResponseByteCount;
}
void TITagitstandardGetUid(ConfigurationUidType Uid)
{
MemoryReadBlock(&Uid[0], TITAGIT_MEM_UID_ADDRESS, ActiveConfiguration.UidSize);
// Reverse UID after reading it
TITagitstandardFlipUid(Uid);
}
void TITagitstandardSetUid(ConfigurationUidType Uid)
{
// Reverse UID before writing it
TITagitstandardFlipUid(Uid);
MemoryWriteBlock(Uid, TITAGIT_MEM_UID_ADDRESS, ActiveConfiguration.UidSize);
}
void TITagitstandardFlipUid(ConfigurationUidType Uid)
{
uint8_t tmp, *tail;
tail = Uid + ActiveConfiguration.UidSize - 1;
while ( Uid < tail ) {
tmp = *Uid;
*Uid++ = *tail;
*tail-- = tmp;
}
}
Firmware/Chameleon-Mini/Application/TITagitstandard.h
+30
View File
@@ -0,0 +1,30 @@
/*
* MifareClassic.h
*
* Created on: 01.03.2017
* Author: skuser
* modified by rickventura
*/
#ifndef TITAGITSTANDARD_H_
#define TITAGITSTANDARD_H_
#include "Application.h"
#define TITAGIT_STD_UID_SIZE ISO15693_GENERIC_UID_SIZE //ISO15693_UID_SIZE
#define TITAGIT_STD_MEM_SIZE 44 //TAG-IT STANDARD MAX MEM SIZE
#define TITAGIT_BYTES_PER_PAGE 4
#define TITAGIT_NUMBER_OF_SECTORS ( TITAGIT_STD_MEM_SIZE / TITAGIT_BYTES_PER_PAGE )
#define TITAGIT_MEM_UID_ADDRESS 0x20
#define TITAGIT_MEM_AFI_ADDRESS 0x28 // AFI byte address
void TITagitstandardAppInit(void);
void TITagitstandardAppReset(void);
void TITagitstandardAppTask(void);
void TITagitstandardAppTick(void);
uint16_t TITagitstandardAppProcess(uint8_t* FrameBuf, uint16_t FrameBytes);
void TITagitstandardGetUid(ConfigurationUidType Uid);
void TITagitstandardSetUid(ConfigurationUidType Uid);
void TITagitstandardFlipUid(ConfigurationUidType Uid);
#endif /* TITAGITSTANDARD_H_ */
Firmware/Chameleon-Mini/Application/Vicinity.c
+128
View File
@@ -0,0 +1,128 @@
/*
* ISO15693.c
*
* Created on: 01-03-2017
* Author: Phillip Nash
*
* TODO:
* - ISO15693AddressedLegacy should be replaced with ISO15693Addressed and appropriate check
* should be performed (see TITagitstandard.c) - ceres-c
*/
#include "Vicinity.h"
#include "../Codec/ISO15693.h"
#include "../Memory.h"
#include "Crypto1.h"
#include "../Random.h"
#include "ISO15693-A.h"
#define MEM_UID_ADDRESS 0x00
static enum {
STATE_READY,
STATE_SELECTED,
STATE_QUIET
} State;
void VicinityAppInit(void)
{
State = STATE_READY;
}
void VicinityAppReset(void)
{
State = STATE_READY;
}
void VicinityAppTask(void)
{
}
void VicinityAppTick(void)
{
}
uint16_t VicinityAppProcess(uint8_t* FrameBuf, uint16_t FrameBytes)
{
if (FrameBytes >= ISO15693_MIN_FRAME_SIZE) {
if(ISO15693CheckCRC(FrameBuf, FrameBytes - ISO15693_CRC16_SIZE)) {
// At this point, we have a valid ISO15693 frame
uint8_t Command = FrameBuf[1];
uint16_t ResponseByteCount = ISO15693_APP_NO_RESPONSE;
uint8_t Uid[8];
MemoryReadBlock(Uid, MEM_UID_ADDRESS, ActiveConfiguration.UidSize);
switch(State) {
case STATE_READY:
if (Command == ISO15693_CMD_INVENTORY) {
FrameBuf[0] = 0x00; /* Flags */
FrameBuf[1] = 0x00; /* DSFID */
ISO15693CopyUid(&FrameBuf[2], Uid);
ResponseByteCount = 10;
} else if (Command == ISO15693_CMD_STAY_QUIET) {
if (ISO15693AddressedLegacy(FrameBuf, Uid)) {
State = STATE_QUIET;
}
} else if (Command == ISO15693_CMD_GET_SYS_INFO) {
if (ISO15693AddressedLegacy(FrameBuf, Uid)) {
FrameBuf[0] = 0; /* Flags */
FrameBuf[1] = 0; /* InfoFlags */
ISO15693CopyUid(&FrameBuf[2], Uid);
ResponseByteCount = 10;
}
}
break;
case STATE_SELECTED:
break;
case STATE_QUIET:
if (Command == ISO15693_CMD_RESET_TO_READY) {
MemoryReadBlock(Uid, MEM_UID_ADDRESS, ActiveConfiguration.UidSize);
if (ISO15693AddressedLegacy(FrameBuf, Uid)) {
FrameBuf[0] = 0;
ResponseByteCount = 1;
State = STATE_READY;
}
}
break;
default:
break;
}
if (ResponseByteCount > 0) {
/* There is data to be sent. Append CRC */
ISO15693AppendCRC(FrameBuf, ResponseByteCount);
ResponseByteCount += ISO15693_CRC16_SIZE;
}
return ResponseByteCount;
} else { // Invalid CRC
return ISO15693_APP_NO_RESPONSE;
}
} else { // Min frame size not met
return ISO15693_APP_NO_RESPONSE;
}
}
void VicinityGetUid(ConfigurationUidType Uid)
{
MemoryReadBlock(&Uid[0], MEM_UID_ADDRESS, ActiveConfiguration.UidSize);
}
void VicinitySetUid(ConfigurationUidType Uid)
{
MemoryWriteBlock(Uid, MEM_UID_ADDRESS, ActiveConfiguration.UidSize);
}
Firmware/Chameleon-Mini/Application/Vicinity.h
+24
View File
@@ -0,0 +1,24 @@
/*
* MifareClassic.h
*
* Created on: 01.03.2017
* Author: skuser
*/
#ifndef VICINITY_H_
#define VICINITY_H_
#include "Application.h"
#include "ISO15693-A.h"
void VicinityAppInit(void);
void VicinityAppReset(void);
void VicinityAppTask(void);
void VicinityAppTick(void);
uint16_t VicinityAppProcess(uint8_t* FrameBuf, uint16_t FrameBytes);
void VicinityGetUid(ConfigurationUidType Uid);
void VicinitySetUid(ConfigurationUidType Uid);
#endif /* VICINITY_H_ */
Firmware/Chameleon-Mini/Button.c
+5
View File
@@ -4,6 +4,7 @@
#include "Settings.h"
#include "Memory.h"
#include "Map.h"
#include "Configuration.h"
#include "Terminal/CommandLine.h"
#include "Application/Application.h"
@@ -42,6 +43,10 @@ static void ExecuteButtonAction(ButtonActionEnum ButtonAction)
for (uint8_t i=0; i<ActiveConfiguration.UidSize; i++) {
UidBuffer[i] = RandomGetByte();
}
/* If we are using an ISO15 tag, the first byte needs to be E0 by standard */
if (ActiveConfiguration.TagFamily == TAG_FAMILY_ISO15693) {
UidBuffer[0] = 0xE0;
}
ApplicationSetUid(UidBuffer);
break;
Firmware/Chameleon-Mini/Codec/Codec.h
+17 -1
View File
@@ -18,6 +18,7 @@
#include "ISO14443-2A.h"
#include "Reader14443-2A.h"
#include "SniffISO14443-2A.h"
#include "ISO15693.h"
/* Timing definitions for ISO14443A */
#define ISO14443A_SUBCARRIER_DIVIDER 16
@@ -38,7 +39,7 @@
#define CODEC_DEMOD_IN_PINCTRL1 PIN2CTRL
#define CODEC_DEMOD_IN_EVMUX0 EVSYS_CHMUX_PORTB_PIN1_gc
#define CODEC_DEMOD_IN_EVMUX1 EVSYS_CHMUX_PORTB_PIN2_gc
#define CODEC_DEMOD_IN_INT0_VECT PORTB_INT0_vect
#define CODEC_DEMOD_IN_INT0_VECT PORTB_INT0_vect
#define CODEC_DEMOD_IN_INT1_VECT PORTB_INT1_vect
#define CODEC_LOADMOD_PORT PORTC
#define CODEC_LOADMOD_MASK PIN6_bm
@@ -114,6 +115,16 @@ typedef enum {
extern uint8_t CodecBuffer[CODEC_BUFFER_SIZE];
extern uint8_t CodecBuffer2[CODEC_BUFFER_SIZE];
volatile void (*isr_func_TCD0_CCC_vect)(void);
void isr_Reader14443_2A_TCD0_CCC_vect(void);
void isr_ISO15693_CODEC_TIMER_SAMPLING_CCC_VECT(void);
volatile void (*isr_func_CODEC_DEMOD_IN_INT0_VECT)(void);
void isr_ISO14443_2A_TCD0_CCC_vect(void);
void isr_ISO15693_CODEC_DEMOD_IN_INT0_VECT(void);
volatile void (*isr_func_CODEC_TIMER_LOADMOD_CCB_VECT)(void);
void isr_ISO15693_CODEC_TIMER_LOADMOD_CCB_VECT(void);
void isr_SniffISO14443_2A_CODEC_TIMER_LOADMOD_CCB_VECT(void);
INLINE void CodecInit(void) {
ActiveConfiguration.CodecInitFunc();
}
@@ -214,6 +225,11 @@ INLINE void CodecSetSubcarrier(SubcarrierModType ModType, uint16_t Divider)
}
}
INLINE void CodecChangeDivider(uint16_t Divider)
{
CODEC_SUBCARRIER_TIMER.PER = Divider - 1;
}
INLINE void CodecStartSubcarrier(void)
{
CODEC_SUBCARRIER_TIMER.CTRLA = CODEC_TIMER_CARRIER_CLKSEL;
Firmware/Chameleon-Mini/Codec/ISO14443-2A.c
+10 -1
View File
@@ -79,8 +79,15 @@ static void StartDemod(void) {
CODEC_DEMOD_IN_PORT.INT0MASK = CODEC_DEMOD_IN_MASK0;
}
ISR (CODEC_DEMOD_IN_INT0_VECT)
{
isr_func_CODEC_DEMOD_IN_INT0_VECT();
}
// ISR(CODEC_DEMOD_IN_INT0_VECT)
// Find first pause and start sampling
ISR(CODEC_DEMOD_IN_INT0_VECT) {
void isr_ISO14443_2A_TCD0_CCC_vect(void)
{
/* This is the first edge of the first modulation-pause after StartDemod.
* Now we have time to start
* demodulating beginning from one bit-width after this edge. */
@@ -384,6 +391,8 @@ void ISO14443ACodecInit(void) {
Flags.DemodFinished = 0;
Flags.LoadmodFinished = 0;
isr_func_TCD0_CCC_vect = &isr_Reader14443_2A_TCD0_CCC_vect;
isr_func_CODEC_DEMOD_IN_INT0_VECT = &isr_ISO14443_2A_TCD0_CCC_vect;
CodecInitCommon();
StartDemod();
}
Firmware/Chameleon-Mini/Codec/ISO15693.c
+659
View File
File diff suppressed because it is too large Load Diff
Firmware/Chameleon-Mini/Codec/ISO15693.h
+42
View File
@@ -0,0 +1,42 @@
/*
* ISO15693.h
*
* Created on: 25.01.2017
* Author: Phillip Nash
*/
#ifndef ISO15693_H_
#define ISO15693_H_
#include "Terminal/CommandLine.h"
#define ISO15693_APP_NO_RESPONSE 0x0000
#define SUBCARRIER_1 32
#define SUBCARRIER_2 28
#define SUBCARRIER_OFF 0
#define SOF_PATTERN 0x1D
#define EOF_PATTERN 0xB8
#define T1_NOMINAL_CYCLES 4352 - 14//4352 - 25 /* ISR prologue compensation */
#define WRITE_GRID_CYCLES 4096
//Used when checking the request sent from the reader
#define ISO15693_REQ_SUBCARRIER_SINGLE 0x00
#define ISO15693_REQ_SUBCARRIER_DUAL 0x01
#define ISO15693_REQ_DATARATE_LOW 0x00
#define ISO15693_REQ_DATARATE_HIGH 0x02
/* Codec Interface */
void ISO15693CodecInit(void);
void ISO15693CodecDeInit(void);
void ISO15693CodecTask(void);
/* Application Interface */
void ISO15693CodecStart(void);
void ISO15693CodecReset(void);
#endif /* ISO15693_H_ */
Firmware/Chameleon-Mini/Codec/Reader14443-2A.c
+7
View File
@@ -48,6 +48,7 @@ void Reader14443ACodecInit(void) {
/* Initialize common peripherals and start listening
* for incoming data. */
CodecInitCommon();
isr_func_TCD0_CCC_vect = &isr_Reader14443_2A_TCD0_CCC_vect;
CodecSetDemodPower(true);
CODEC_TIMER_SAMPLING.PER = SAMPLE_RATE_SYSTEM_CYCLES - 1;
@@ -180,6 +181,12 @@ INLINE void BufferToSequence(void)
}
// Frame Delay Time PCD to PICC ends
ISR (CODEC_TIMER_SAMPLING_CCC_VECT)
{
isr_func_TCD0_CCC_vect();
}
// ISR (TCD0_CCC_vect)
void isr_Reader14443_2A_TCD0_CCC_vect(void)
{
CODEC_TIMER_SAMPLING.INTFLAGS = TC0_CCCIF_bm;
CODEC_TIMER_SAMPLING.INTCTRLB = TC_CCCINTLVL_OFF_gc;
Firmware/Chameleon-Mini/Codec/SniffISO14443-2A.c
+9 -1
View File
@@ -363,11 +363,18 @@ ISR(ACA_AC0_vect) // this interrupt either finds the SOC or gets triggered befor
CODEC_TIMER_LOADMOD.CTRLA = TC_CLKSEL_DIV1_gc;
StateRegister = PICC_FRAME;
}
ISR(CODEC_TIMER_LOADMOD_CCB_VECT) // pause found
{
isr_func_CODEC_TIMER_LOADMOD_CCB_VECT();
}
// Decode the Card -> Reader signal
// according to the pause and modulated period
// if the half bit duration is modulated, then add 1 to buffer
// if the half bit duration is not modulated, then add 0 to buffer
ISR(CODEC_TIMER_LOADMOD_CCB_VECT) // pause found
//ISR(CODEC_TIMER_LOADMOD_CCB_VECT) // pause found
void isr_SniffISO14443_2A_CODEC_TIMER_LOADMOD_CCB_VECT(void)
{
uint8_t tmp = CODEC_TIMER_TIMESTAMPS.CNTL;
CODEC_TIMER_TIMESTAMPS.CNT = 0;
@@ -487,6 +494,7 @@ void Sniff14443ACodecInit(void)
PORTE.DIRSET= PIN3_bm | PIN2_bm;
// Common Codec Register settings
CodecInitCommon();
isr_func_CODEC_TIMER_LOADMOD_CCB_VECT = &isr_SniffISO14443_2A_CODEC_TIMER_LOADMOD_CCB_VECT;
// Enable demodulator power
CodecSetDemodPower(true);
Firmware/Chameleon-Mini/Configuration.c
+125 -10
View File
@@ -37,6 +37,21 @@ static const MapEntryType PROGMEM ConfigurationMap[] = {
#ifdef CONFIG_ISO14443A_READER_SUPPORT
{ .Id = CONFIG_ISO14443A_READER, .Text = "ISO14443A_READER" },
#endif
#ifdef CONFIG_VICINITY_SUPPORT
{ .Id = CONFIG_VICINITY, .Text = "VICINITY" },
#endif
#ifdef CONFIG_ISO15693_SNIFF_SUPPORT
{ .Id = CONFIG_ISO15693_SNIFF, .Text = "ISO15693_SNIFF" },
#endif
#ifdef CONFIG_SL2S2002_SUPPORT
{ .Id = CONFIG_SL2S2002, .Text = "SL2S2002" },
#endif
#ifdef CONFIG_TITAGITSTANDARD_SUPPORT
{ .Id = CONFIG_TITAGITSTANDARD, .Text = "TITAGITSTANDARD" },
#endif
#ifdef CONFIG_EM4233_SUPPORT
{ .Id = CONFIG_EM4233, .Text = "EM4233" },
#endif
};
/* Include all Codecs and Applications */
@@ -69,7 +84,8 @@ static const PROGMEM ConfigurationType ConfigurationTable[] = {
.ApplicationSetUidFunc = ApplicationSetUidDummy,
.UidSize = 0,
.MemorySize = 0,
.ReadOnly = true
.ReadOnly = true,
.TagFamily = TAG_FAMILY_NONE
},
#ifdef CONFIG_MF_ULTRALIGHT_SUPPORT
[CONFIG_MF_ULTRALIGHT] = {
@@ -85,7 +101,8 @@ static const PROGMEM ConfigurationType ConfigurationTable[] = {
.ApplicationSetUidFunc = MifareUltralightSetUid,
.UidSize = MIFARE_ULTRALIGHT_UID_SIZE,
.MemorySize = MIFARE_ULTRALIGHT_MEM_SIZE,
.ReadOnly = false
.ReadOnly = false,
.TagFamily = TAG_FAMILY_ISO14443A
},
[CONFIG_MF_ULTRALIGHT_EV1_80B] = {
.CodecInitFunc = ISO14443ACodecInit,
@@ -100,7 +117,8 @@ static const PROGMEM ConfigurationType ConfigurationTable[] = {
.ApplicationSetUidFunc = MifareUltralightSetUid,
.UidSize = MIFARE_ULTRALIGHT_UID_SIZE,
.MemorySize = MIFARE_ULTRALIGHT_EV11_MEM_SIZE,
.ReadOnly = false
.ReadOnly = false,
.TagFamily = TAG_FAMILY_ISO14443A
},
[CONFIG_MF_ULTRALIGHT_EV1_164B] = {
.CodecInitFunc = ISO14443ACodecInit,
@@ -115,7 +133,8 @@ static const PROGMEM ConfigurationType ConfigurationTable[] = {
.ApplicationSetUidFunc = MifareUltralightSetUid,
.UidSize = MIFARE_ULTRALIGHT_UID_SIZE,
.MemorySize = MIFARE_ULTRALIGHT_EV12_MEM_SIZE,
.ReadOnly = false
.ReadOnly = false,
.TagFamily = TAG_FAMILY_ISO14443A
},
#endif
#ifdef CONFIG_MF_CLASSIC_1K_SUPPORT
@@ -132,7 +151,8 @@ static const PROGMEM ConfigurationType ConfigurationTable[] = {
.ApplicationSetUidFunc = MifareClassicSetUid,
.UidSize = MIFARE_CLASSIC_UID_SIZE,
.MemorySize = MIFARE_CLASSIC_1K_MEM_SIZE,
.ReadOnly = false
.ReadOnly = false,
.TagFamily = TAG_FAMILY_ISO14443A
},
#endif
#ifdef CONFIG_MF_CLASSIC_1K_7B_SUPPORT
@@ -149,7 +169,8 @@ static const PROGMEM ConfigurationType ConfigurationTable[] = {
.ApplicationSetUidFunc = MifareClassicSetUid,
.UidSize = ISO14443A_UID_SIZE_DOUBLE,
.MemorySize = MIFARE_CLASSIC_1K_MEM_SIZE,
.ReadOnly = false
.ReadOnly = false,
.TagFamily = TAG_FAMILY_ISO14443A
},
#endif
#ifdef CONFIG_MF_CLASSIC_4K_SUPPORT
@@ -166,7 +187,8 @@ static const PROGMEM ConfigurationType ConfigurationTable[] = {
.ApplicationSetUidFunc = MifareClassicSetUid,
.UidSize = MIFARE_CLASSIC_UID_SIZE,
.MemorySize = MIFARE_CLASSIC_4K_MEM_SIZE,
.ReadOnly = false
.ReadOnly = false,
.TagFamily = TAG_FAMILY_ISO14443A
},
#endif
#ifdef CONFIG_MF_CLASSIC_4K_7B_SUPPORT
@@ -183,7 +205,8 @@ static const PROGMEM ConfigurationType ConfigurationTable[] = {
.ApplicationSetUidFunc = MifareClassicSetUid,
.UidSize = ISO14443A_UID_SIZE_DOUBLE,
.MemorySize = MIFARE_CLASSIC_4K_MEM_SIZE,
.ReadOnly = false
.ReadOnly = false,
.TagFamily = TAG_FAMILY_ISO14443A
},
#endif
#ifdef CONFIG_ISO14443A_SNIFF_SUPPORT
@@ -200,7 +223,8 @@ static const PROGMEM ConfigurationType ConfigurationTable[] = {
.ApplicationSetUidFunc = ApplicationSetUidDummy,
.UidSize = 0,
.MemorySize = 0,
.ReadOnly = true
.ReadOnly = true,
.TagFamily = TAG_FAMILY_NONE
},
#endif
#ifdef CONFIG_ISO14443A_READER_SUPPORT
@@ -217,7 +241,98 @@ static const PROGMEM ConfigurationType ConfigurationTable[] = {
.ApplicationSetUidFunc = ApplicationSetUidDummy,
.UidSize = 0,
.MemorySize = 0,
.ReadOnly = false
.ReadOnly = false,
.TagFamily = TAG_FAMILY_NONE
},
#endif
#ifdef CONFIG_VICINITY_SUPPORT
[CONFIG_VICINITY] = {
.CodecInitFunc = ISO15693CodecInit,
.CodecDeInitFunc = ISO15693CodecDeInit,
.CodecTaskFunc = ISO15693CodecTask,
.ApplicationInitFunc = VicinityAppInit,
.ApplicationResetFunc = VicinityAppReset,
.ApplicationTaskFunc = VicinityAppTask,
.ApplicationTickFunc = VicinityAppTick,
.ApplicationProcessFunc = VicinityAppProcess,
.ApplicationGetUidFunc = VicinityGetUid,
.ApplicationSetUidFunc = VicinitySetUid,
.UidSize = ISO15693_GENERIC_UID_SIZE,
.MemorySize = ISO15693_GENERIC_MEM_SIZE,
.ReadOnly = false,
.TagFamily = TAG_FAMILY_ISO15693
},
#endif
#ifdef CONFIG_ISO15693_SNIFF_SUPPORT
[CONFIG_ISO15693_SNIFF] = {
.CodecInitFunc = ISO15693CodecInit,
.CodecDeInitFunc = ISO15693CodecDeInit,
.CodecTaskFunc = ISO15693CodecTask,
.ApplicationInitFunc = ApplicationInitDummy,
.ApplicationResetFunc = ApplicationResetDummy,
.ApplicationTaskFunc = ApplicationTaskDummy,
.ApplicationTickFunc = ApplicationTickDummy,
.ApplicationProcessFunc = ApplicationProcessDummy,
.ApplicationGetUidFunc = ApplicationGetUidDummy,
.ApplicationSetUidFunc = ApplicationSetUidDummy,
.UidSize = 0,
.MemorySize = 0,
.ReadOnly = true,
.TagFamily = TAG_FAMILY_NONE
},
#endif
#ifdef CONFIG_SL2S2002_SUPPORT
[CONFIG_SL2S2002] = {
.CodecInitFunc = ISO15693CodecInit,
.CodecDeInitFunc = ISO15693CodecDeInit,
.CodecTaskFunc = ISO15693CodecTask,
.ApplicationInitFunc = Sl2s2002AppInit,
.ApplicationResetFunc = Sl2s2002AppReset,
.ApplicationTaskFunc = Sl2s2002AppTask,
.ApplicationTickFunc = Sl2s2002AppTick,
.ApplicationProcessFunc = Sl2s2002AppProcess,
.ApplicationGetUidFunc = Sl2s2002GetUid,
.ApplicationSetUidFunc = Sl2s2002SetUid,
.UidSize = ISO15693_GENERIC_UID_SIZE,
.MemorySize = ISO15693_GENERIC_MEM_SIZE,
.ReadOnly = false,
.TagFamily = TAG_FAMILY_ISO15693
},
#endif
#ifdef CONFIG_TITAGITSTANDARD_SUPPORT
[CONFIG_TITAGITSTANDARD] = {
.CodecInitFunc = ISO15693CodecInit,
.CodecDeInitFunc = ISO15693CodecDeInit,
.CodecTaskFunc = ISO15693CodecTask,
.ApplicationInitFunc = TITagitstandardAppInit,
.ApplicationResetFunc = TITagitstandardAppReset,
.ApplicationTaskFunc = TITagitstandardAppTask,
.ApplicationTickFunc = TITagitstandardAppTick,
.ApplicationProcessFunc = TITagitstandardAppProcess,
.ApplicationGetUidFunc = TITagitstandardGetUid,
.ApplicationSetUidFunc = TITagitstandardSetUid,
.UidSize = TITAGIT_STD_UID_SIZE,
.MemorySize = TITAGIT_STD_MEM_SIZE,
.ReadOnly = false,
.TagFamily = TAG_FAMILY_ISO15693
},
#endif
#ifdef CONFIG_EM4233_SUPPORT
[CONFIG_EM4233] = {
.CodecInitFunc = ISO15693CodecInit,
.CodecDeInitFunc = ISO15693CodecDeInit,
.CodecTaskFunc = ISO15693CodecTask,
.ApplicationInitFunc = EM4233AppInit,
.ApplicationResetFunc = EM4233AppReset,
.ApplicationTaskFunc = EM4233AppTask,
.ApplicationTickFunc = EM4233AppTick,
.ApplicationProcessFunc = EM4233AppProcess,
.ApplicationGetUidFunc = EM4233GetUid,
.ApplicationSetUidFunc = EM4233SetUid,
.UidSize = EM4233_STD_UID_SIZE,
.MemorySize = EM4233_STD_MEM_SIZE,
.ReadOnly = false,
.TagFamily = TAG_FAMILY_ISO15693
},
#endif
};

Some files were not shown because too many files have changed in this diff Show More