-
Notifications
You must be signed in to change notification settings - Fork 1
/
mfrc522.py
307 lines (245 loc) · 8.49 KB
/
mfrc522.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
from machine import Pin, SPI
from os import uname
emptyRecv = b""
class MFRC522:
GAIN_REG = 0x26
MAX_GAIN = 0x07
OK = 0
NOTAGERR = 1
ERR = 2
REQIDL = 0x26
REQALL = 0x52
AUTHENT1A = 0x60
AUTHENT1B = 0x61
def __init__(self, spi=None, gpioRst=None, gpioCs=None):
if gpioRst is not None:
self.rst = Pin(gpioRst, Pin.OUT)
else:
self.rst = None
assert(gpioCs is not None, "Needs gpioCs") # TODO fails without cableSelect
if gpioCs is not None:
self.cs = Pin(gpioCs, Pin.OUT)
else:
self.cs = None
# TODO CH rationalise which of these are referenced, which can be identical
self.regBuf = bytearray(4)
self.blockWriteBuf = bytearray(18)
self.authBuf = bytearray(12)
self.wregBuf = bytearray(2)
self.rregBuf = bytearray(1)
self.recvBuf = bytearray(16)
self.recvMv = memoryview(self.recvBuf)
if self.rst is not None:
self.rst.value(0)
if self.cs is not None:
self.cs.value(1)
if spi is not None:
self.spi = spi
else:
sck = Pin(14, Pin.OUT)
mosi = Pin(13, Pin.OUT)
miso = Pin(12, Pin.IN)
if uname()[0] == 'WiPy':
self.spi = SPI(0)
self.spi.init(SPI.MASTER, baudrate=1000000, pins=(sck, mosi, miso))
elif uname()[0] == 'esp8266': # TODO update to match https://github.com/cefn/avatap/blob/master/python/host/cockle.py #prepareHost()
self.spi = SPI(baudrate=100000, polarity=0, phase=0, sck=sck, mosi=mosi, miso=miso)
self.spi.init()
else:
raise RuntimeError("Unsupported platform")
if self.rst is not None:
self.rst.value(1)
self.init()
def _wreg(self, reg, val):
if self.cs is not None:
self.cs.value(0)
buf = self.wregBuf
buf[0]=0xff & ((reg << 1) & 0x7e)
buf[1]=0xff & val
self.spi.write(buf)
if self.cs is not None:
self.cs.value(1)
def _rreg(self, reg):
if self.cs is not None:
self.cs.value(0)
buf = self.rregBuf
buf[0]=0xff & (((reg << 1) & 0x7e) | 0x80)
self.spi.write(buf)
val = self.spi.read(1)
if self.cs is not None:
self.cs.value(1)
return val[0]
def _sflags(self, reg, mask):
self._wreg(reg, self._rreg(reg) | mask)
def _cflags(self, reg, mask):
self._wreg(reg, self._rreg(reg) & (~mask))
def _tocard(self, cmd, send, into=None):
recv = emptyRecv
bits = irq_en = wait_irq = n = 0
stat = self.ERR
if cmd == 0x0E:
irq_en = 0x12
wait_irq = 0x10
elif cmd == 0x0C:
irq_en = 0x77
wait_irq = 0x30
self._wreg(0x02, irq_en | 0x80)
self._cflags(0x04, 0x80)
self._sflags(0x0A, 0x80)
self._wreg(0x01, 0x00)
for c in send:
self._wreg(0x09, c)
self._wreg(0x01, cmd)
if cmd == 0x0C:
self._sflags(0x0D, 0x80)
i = 2000
while True:
n = self._rreg(0x04)
i -= 1
if ~((i != 0) and ~(n & 0x01) and ~(n & wait_irq)):
break
self._cflags(0x0D, 0x80)
if i:
if (self._rreg(0x06) & 0x1B) == 0x00:
stat = self.OK
if n & irq_en & 0x01:
stat = self.NOTAGERR
elif cmd == 0x0C:
n = self._rreg(0x0A)
lbits = self._rreg(0x0C) & 0x07
if lbits != 0:
bits = (n - 1) * 8 + lbits
else:
bits = n * 8
if n == 0:
n = 1
elif n > 16:
n = 16
if into is None:
recv = self.recvBuf
else:
recv = into
pos = 0
while pos < n:
recv[pos] = self._rreg(0x09)
pos += 1
if into is None:
recv = self.recvMv[:n]
else:
recv = into
else:
stat = self.ERR
return stat, recv, bits
def _assign_crc(self, data, count):
self._cflags(0x05, 0x04)
self._sflags(0x0A, 0x80)
dataPos = 0
while dataPos < count:
self._wreg(0x09, data[dataPos])
dataPos += 1
self._wreg(0x01, 0x03)
i = 0xFF
while True:
n = self._rreg(0x05)
i -= 1
if not ((i != 0) and not (n & 0x04)):
break
data[count] = self._rreg(0x22)
data[count + 1] = self._rreg(0x21)
def init(self):
self.reset()
self._wreg(0x2A, 0x8D)
self._wreg(0x2B, 0x3E)
self._wreg(0x2D, 30)
self._wreg(0x2C, 0)
self._wreg(0x15, 0x40)
self._wreg(0x11, 0x3D)
self.set_gain(self.MAX_GAIN)
self.antenna_on()
def reset(self):
self._wreg(0x01, 0x0F)
def antenna_on(self, on=True):
if on and ~(self._rreg(0x14) & 0x03):
self._sflags(0x14, 0x03)
else:
self._cflags(0x14, 0x03)
def request(self, mode):
self._wreg(0x0D, 0x07)
(stat, recv, bits) = self._tocard(0x0C, [mode])
if (stat != self.OK) | (bits != 0x10):
stat = self.ERR
return stat, bits
def anticoll(self):
ser_chk = 0
ser = [0x93, 0x20]
self._wreg(0x0D, 0x00)
(stat, recv, bits) = self._tocard(0x0C, ser)
if stat == self.OK:
if len(recv) == 5:
for i in range(4):
ser_chk = ser_chk ^ recv[i]
if ser_chk != recv[4]:
stat = self.ERR
else:
stat = self.ERR
# CH Note bytearray allocation here
return stat, bytearray(recv)
def select_tag(self, ser):
# TODO CH normalise all list manipulation to bytearray, avoid below allocation
buf = bytearray(9)
buf[0] = 0x93
buf[1] = 0x70
buf[2:7] = ser
self._assign_crc(buf, 7)
(stat, recv, bits) = self._tocard(0x0C, buf)
return self.OK if (stat == self.OK) and (bits == 0x18) else self.ERR
def auth(self, mode, addr, sect, ser):
# TODO CH void ser[:4] implicit list allocation
buf = self.authBuf
buf[0]=mode # A or B
buf[1]=addr # block
buf[2:8]=sect # key bytes
buf[8:12]=ser[:4] # 4 bytes of id
return self._tocard(0x0E, buf)[0]
# TODO this may well need to be implemented for vault to properly back out from a card session
# TODO how, why, when is 'HaltA' needed? see https://github.com/cefn/micropython-mfrc522/issues/1
def halt_a(self):
pass
def stop_crypto1(self):
self._cflags(0x08, 0x08)
def set_gain(self, gain):
assert gain <= self.MAX_GAIN
# clear bits
self._cflags(self.GAIN_REG, 0x07<< 4)
# set bits according to gain
self._sflags(self.GAIN_REG, gain << 4)
def read(self, addr, into = None):
buf = self.regBuf
buf[0]=0x30
buf[1]=addr
self._assign_crc(buf, 2)
(stat, recv, _) = self._tocard(0x0C, buf, into=into)
# TODO this logic probably wrong (should be 'into is None'?)
if into is None: # superstitiously avoid returning read buffer memoryview
# CH Note bytearray allocation here
recv = bytearray(recv)
return recv if stat == self.OK else None
def write(self, addr, data):
buf = self.regBuf
buf[0] = 0xA0
buf[1] = addr
self._assign_crc(buf, 2)
(stat, recv, bits) = self._tocard(0x0C, buf)
if not (stat == self.OK) or not (bits == 4) or not ((recv[0] & 0x0F) == 0x0A):
stat = self.ERR
else:
buf = self.blockWriteBuf
i = 0
while i < 16:
buf[i] = data[i] # TODO CH eliminate this, accelerate it?
i += 1
self._assign_crc(buf, 16)
(stat, recv, bits) = self._tocard(0x0C, buf)
if not (stat == self.OK) or not (bits == 4) or not ((recv[0] & 0x0F) == 0x0A):
stat = self.ERR
return stat