2 # GoodFET Chipcon RF Radio Client for CC2500
4 # (C) 2013 Jean-Michel Picod <jean-michel.picod at cassidian.com>
10 from GoodFET import GoodFET
12 class GoodFETCC2500(GoodFET):
29 "IOCFG2", "IOCFG1", "IOCFG0", "FIFOTHR", "SYNC1", "SYNC0",
30 "PKTLEN", "PKTCTRL1", "PKTCTRL0", "ADDR", "CHANNR",
31 "FSCTRL1", "FSCTRL0", "FREQ2", "FREQ1", "FREQ0",
32 "MDMCFG4", "MDMCFG3", "MDMCFG2", "MDMCFG1", "MDMCFG0", "DEVIATN",
33 "MCSM2", "MCSM1", "MCSM0", "FOCCFG", "BSCFG", "AGCCTRL2",
34 "AGCCTRL1", "AGCCTRL0", "WOREVT1", "WOREVT0", "WORCTRL",
35 "FREND1", "FREND0", "FSCAL3", "FSCAL2", "FSCAL1", "FSCAL0",
36 "RCCTRL1", "RCCTRL0", "FSTEST", "PTEST", "AGCTEST", "TEST2",
37 "TEST1", "TEST0", "?",
39 "SRES", "SFSTXON", "SXOFF", "SCAL", "SRX", "STX", "SIDLE",
40 "?", "SWOR", "SPWD", "SFRX", "SFTX", "SWORRST", "SNOP",
42 "IOCFG2", "IOCFG1", "IOCFG0", "FIFOTHR", "SYNC1", "SYNC0",
43 "PKTLEN", "PKTCTRL1", "PKTCTRL0", "ADDR", "CHANNR",
44 "FSCTRL1", "FSCTRL0", "FREQ2", "FREQ1", "FREQ0",
45 "MDMCFG4", "MDMCFG3", "MDMCFG2", "MDMCFG1", "MDMCFG0", "DEVIATN",
46 "MCSM2", "MCSM1", "MCSM0", "FOCCFG", "BSCFG", "AGCCTRL2",
47 "AGCCTRL1", "AGCCTRL0", "WOREVT1", "WOREVT0", "WORCTRL",
48 "FREND1", "FREND0", "FSCAL3", "FSCAL2", "FSCAL1", "FSCAL0",
49 "RCCTRL1", "RCCTRL0", "FSTEST", "PTEST", "AGCTEST", "TEST2",
50 "TEST1", "TEST0", "?",
51 "?", "?", "?", "?", "?", "?", "?",
52 "?", "?", "?", "?", "?", "?", "?",
54 "IOCFG2", "IOCFG1", "IOCFG0", "FIFOTHR", "SYNC1", "SYNC0",
55 "PKTLEN", "PKTCTRL1", "PKTCTRL0", "ADDR", "CHANNR",
56 "FSCTRL1", "FSCTRL0", "FREQ2", "FREQ1", "FREQ0",
57 "MDMCFG4", "MDMCFG3", "MDMCFG2", "MDMCFG1", "MDMCFG0", "DEVIATN",
58 "MCSM2", "MCSM1", "MCSM0", "FOCCFG", "BSCFG", "AGCCTRL2",
59 "AGCCTRL1", "AGCCTRL0", "WOREVT1", "WOREVT0", "WORCTRL",
60 "FREND1", "FREND0", "FSCAL3", "FSCAL2", "FSCAL1", "FSCAL0",
61 "RCCTRL1", "RCCTRL0", "FSTEST", "PTEST", "AGCTEST", "TEST2",
62 "TEST1", "TEST0", "?",
64 "SRES", "SFSTXON", "SXOFF", "SCAL", "SRX", "STX", "SIDLE",
65 "?", "SWOR", "SPWD", "SFRX", "SFTX", "SWORRST", "SNOP",
67 "IOCFG2", "IOCFG1", "IOCFG0", "FIFOTHR", "SYNC1", "SYNC0",
68 "PKTLEN", "PKTCTRL1", "PKTCTRL0", "ADDR", "CHANNR",
69 "FSCTRL1", "FSCTRL0", "FREQ2", "FREQ1", "FREQ0",
70 "MDMCFG4", "MDMCFG3", "MDMCFG2", "MDMCFG1", "MDMCFG0", "DEVIATN",
71 "MCSM2", "MCSM1", "MCSM0", "FOCCFG", "BSCFG", "AGCCTRL2",
72 "AGCCTRL1", "AGCCTRL0", "WOREVT1", "WOREVT0", "WORCTRL",
73 "FREND1", "FREND0", "FSCAL3", "FSCAL2", "FSCAL1", "FSCAL0",
74 "RCCTRL1", "RCCTRL0", "FSTEST", "PTEST", "AGCTEST", "TEST2",
75 "TEST1", "TEST0", "?",
76 "PARTNUM", "VERSION", "FREQEST", "LQI", "RSSI", "MARCSTATE",
77 "WORTIME1", "WORTIME0", "PKTSTATUS", "VCO_VC_DAC", "TXBYTES",
78 "RXBYTES", "RCCTRL1_STATUS", "RCCTRL0_STATUS",
82 """Move the FET into the CCSPI application."""
83 self.writecmd(self.APP, self.SETUP, 0, self.data) #CCSPI/SETUP
85 def CC_trans8(self, byte):
86 """Read and write 8 bits by CCSPI."""
87 data = self.CC_trans([byte])
90 def CC_trans(self, data):
91 """Exchange data by CCSPI."""
93 self.writecmd(self.APP, self.READ, len(data), data)
95 def strobe(self, reg=0x00):
96 """Strobes a strobe register, returning the status."""
99 return ord(self.data[0])
100 def CC_strobe_RES(self):
102 self.int_state = self.strobe(0x30)
103 def CC_strobe_FSTXON(self):
104 """Enable and calibrate the frequency synthesizer"""
105 self.int_state = self.strobe(0x31)
106 def CC_strobe_XOFF(self):
107 """Turn off crystal oscillator"""
108 self.int_state = self.strobe(0x32)
109 def CC_strobe_CAL(self):
110 """Calibrate frequency synthesizer and turn it off"""
111 self.int_state = self.strobe(0x33)
112 def CC_strobe_RX(self):
114 self.int_state = self.strobe(0x34)
115 def CC_strobe_TX(self):
117 self.int_state = self.strobe(0x35)
118 def CC_strobe_IDLE(self):
120 self.int_state = self.strobe(0x36)
121 def CC_strobe_WOR(self):
123 self.int_state = self.strobe(0x38)
124 def CC_strobe_PWD(self):
125 """Power Down mode"""
126 self.int_state = self.strobe(0x39)
127 def CC_strobe_FRX(self):
128 """Flush RX FIFO buffer. Only issue in IDLE or RXFIFO_OVERFLOW state"""
129 self.int_state = self.strobe(0x3A)
130 def CC_strobe_FTX(self):
131 """Flush TX FIFO buffer. Only issue in IDLE or TXFIFO_UNDERFLOW state"""
132 self.int_state = self.strobe(0x3B)
133 def CC_strobe_WORRST(self):
134 """Reset realtime clock"""
135 self.int_state = self.strobe(0x3C)
136 def CC_strobe_NOP_READ(self):
137 """No operation. May be used to get access to the chip status byte"""
138 self.int_state = self.writecmd(self.APP, self.READ, 1, [0x3D])
139 def CC_strobe_NOP_WRITE(self):
140 """No operation. May be used to get access to the chip status byte"""
141 self.int_state = self.strobe(0x3D)
143 def peek_by_name(self, regname):
144 return self.peek(self._regnames.index(regname), 1)[0]
145 def poke_by_name(self, regname, val):
146 return self.poke(self._regnames.index(regname), [val])
147 def peek(self, reg, bytes=1):
148 """Read one or more CCSPI Register."""
149 #Reg is ORed with 0x80 by the GoodFET.
152 data = [0 for i in xrange(bytes+1)]
154 self.writecmd(self.APP, self.PEEK, len(data), data)
155 self.int_state = ord(self.data[0])
156 return [ ord(i) for i in self.data[1:] ]
158 def poke(self, reg, val):
159 """Write one or more CCSPI Register."""
160 if isinstance(val, int):
162 if not isinstance(val, list):
163 raise TypeError("val must be a list of int or an int")
166 data.append(v & 0x0ff)
167 self.writecmd(self.APP, self.POKE, len(data), data)
168 res = self.peek(reg, len(val))
169 for i in xrange(len(val)):
171 print "Warning, failed to set %s(%02x)=0x%02x, got 0x%02x." % (
172 self._regnames[reg + i], reg + i,
179 (part, ver) = self.peek(0x30, bytes=2)
180 return self._chips.get((part << 8) + ver, "Unsupported chip (0x%02x%02x)" % (part, ver))
182 _state = [ "RX_FIFO_LOW", "RX_FIFO_HIGH", "TX_FIFO_LOW", "TX_FIFO_HIGH", "RX_FIFO_OVERFLOW", "TX_FIFO_UNDERFLOW", "SYNC_WORD_SEEN",
183 "PACKET_CRC_OK", "PREAMBLE_QUALITY_REACHED", "CLEAR_CHANNEL_ASSESSMENT", "PLL_LOCK", "SERIAL_CLOCK", "SERIAL_SYNCHRONOUS_DATA",
184 "SERIAL_DATA_OUTPUT", "CARRIER_SENSE", "CRC_OK", "RESERVED (0x10)", "RESERVED (0x11)", "RESERVED (0x12)", "RESERVED (0x13)",
185 "RESERVED (0x14)", "RESERVED (0x15)", "RX_HARD_DATA[1]", "RX_HARD_DATA[0]", "TEST (0x18)", "TEST (0x19)", "TEST (0x1A)", "PA_PD",
186 "LNA_PD", "RX_SYMBOL_TICK", "RESERVED (0x1E)", "RESERVED (0x1F)", "RESERVED (0x20)", "RESERVED (0x21)", "RESERVED (0x22)",
187 "RESERVED (0x23)", "WOR_EVNT0", "WOR_EVNT1", "TEST (0x26)", "CLK_32K", "TEST (0x28)", "CHIP_READY", "TEST (0x2A)", "XOSC_STABLE",
188 "TEST (0x2C)", "GDO0_Z_EN_N", "HIGH_IMPEDANCE", "HW_0", "CLK_XOSC/1", "CLK_XOSC/1.5", "CLK_XOSC/2", "CLK_XOSC/3", "CLK_XOSC/4",
189 "CLK_XOSC/6", "CLK_XOSC/8", "CLK_XOSC/12", "CLK_XOSC/16", "CLK_XOSC/24", "CLK_XOSC/32", "CLK_XOSC/48", "CLK_XOSC/64",
190 "CLK_XOSC/96", "CLK_XOSC/128", "CLK_XOSC/192"
192 # Read IOCFG2 register
193 self.writecmd(self.APP, self.PEEK, 2, [ 0x00, 0x00 ])
194 self.int_state = ord(self.data[0])
195 return _state[ord(self.data[1]) & 0x3F]
197 def internal_status(self):
198 """Read the status byte."""
199 _statestr = [ "IDLE", "RX", "TX", "FSTXON", "CALIBRATE", "SETTLING", "RXFIFO_OVERFLOW", "TXFIFO_UNDERFLOW" ]
200 status = self.int_state
202 state = (status >> 3) & 7
204 return "State: %s - Ready: %s - FIFO available bytes: %d" % (_statestr[state], bool(ready == 0), fifo)
208 vals = self.peek(0xC0, bytes=0x2F)
209 for i in xrange(0x2f):
210 rv.append((self._regnames[0xC0 + i], vals[i]))
213 #Radio stuff begins here.
214 _bandwith = [ 812, 650, 541, 464, 406, 325, 270, 232, 203, 162, 135, 116, 102, 81, 68, 58 ]
215 def RF_setbandwith(self, bw):
216 """Sets the bandwith"""
218 conf = self._bandwith.index(bw)
220 conf |= self.peek_by_name("MDMCFG4") & 0x0f
221 self.poke_by_name("MDMCFG4", conf)
223 print "ERROR: unsupported bandwith (%d KHz). Should be %s" % (bw, ", ".join(self._bandwith))
224 def RF_getbandwith(self):
225 reg = self.peek_by_name("MDMCFG4")
226 bw_e = (reg >> 6) & 0x3
227 bw_m = (reg >> 4) & 0x3
228 conf = (bw_e << 2) + bw_m
229 return self._bandwith[conf]
231 def RF_get_frequency(self):
232 vals = self.peek(0x0D, 3)
233 freq = (vals[0] << 16) + (vals[1] << 8) + vals[2]
234 return freq * 26000000.0 / 2**16
236 def RF_set_frequency(self, freq):
238 freq = int(round(freq*2**16/26000000))
239 self.peek_by_name("FREQ2", freq >> 16)
240 self.peek_by_name("FREQ1", (freq >> 8) & 0x0ff)
241 self.peek_by_name("FREQ0", freq & 0x0ff)
243 def RF_get_IF_freq(self):
244 return (self.peek_by_name("FSCTRL1") & 15) * 26000000.0 / 2**10
246 def RF_set_channel(self, n):
247 self.poke_by_name("CHANNR", n % 256)
248 def RF_get_channel(self):
249 return self.peek_by_name("CHANNR")
251 def RF_get_chan_spacing(self):
252 space = (256 + self.peek_by_name("MDMCFG0")) * 2**((self.peek_by_name("MDMCFG1") & 3) - 2)
253 return space * 26000000.0 / 2**16
255 def RF_get_addr(self):
256 return self.peek_by_name("ADDR")
257 def RF_set_addr(self, addr):
258 return self.poke_by_name("ADDR", addr % 256)
259 def RF_enable_whitening(self):
260 self.poke_by_name("PKTCTRL0", self.peek_by_name("PKTCTRL0") | 0x40)
261 self.RF_disable_CC2400()
262 def RF_disable_whitening(self):
263 self.poke_by_name("PKTCTRL0", (self.peek_by_name("PKTCTRL0") & ~0x40) % 256)
264 def RF_enable_CC2400(self):
265 self.poke_by_name("PKTCTRL0", self.peek_by_name("PKTCTRL0") | 0x8)
266 self.RF_disable_whitening()
267 self.RF_disable_CRC_autoflush()
268 def RF_disable_CC2400(self):
269 self.poke_by_name("PKTCTRL0", (self.peek_by_name("PKTCTRL0") & ~0x8) % 256)
270 def RF_enable_CRC(self):
271 self.poke_by_name("PKTCTRL0", self.peek_by_name("PKTCTRL0") | 0x4)
272 def RF_disable_CRC(self):
273 self.poke_by_name("PKTCTRL0", (self.peek_by_name("PKTCTRL0") & ~0x4) % 256)
274 def RF_get_pkt_len(self):
275 """Returns packet length.
276 Positive integer means fixed.
277 Negative integer means a variable packet with at most N bytes.
278 None means Infinite length."""
279 conf = self.peek_by_name("PKTCTRL0") & 0x3
282 return self.peek_by_name("PKTLEN")
285 return -self.peek_by_name("PKTLEN")
291 print "ERROR: Reserved packet length"
292 def RF_set_pkt_len(self, size):
293 """Sets packet length.
294 Positive integer means fixed.
295 Negative integer means a variable packet with at most N bytes.
296 None means Infinite length."""
298 self.poke_by_name((self.peek_by_name("PKTCTRL0") & 0x0fc) | 0x2)
300 self.poke_by_name((self.peek_by_name("PKTCTRL0") & 0x0fc) | 0x0)
301 self.poke_by_name("PKTLEN", abs(size))
303 self.poke_by_name((self.peek_by_name("PKTCTRL0") & 0x0fc) | 0x1)
304 self.poke_by_name("PKTLEN", abs(size))
306 def RF_get_syncword(self):
307 return (self.peek_by_name("SYNC1") << 8) + self.peek_by_name("SYNC0")
308 def RF_set_syncword(self, sync):
309 self.poke_by_name("SYNC1", (sync >> 8) & 0x0ff)
310 self.poke_by_name("SYNC0", sync & 0x0ff)
312 def RF_get_datarate(self):
313 """return the configured value in bauds"""
314 drate_m = self.peek_by_name("MDMCFG3")
315 drate_e = self.peek_by_name("MDMCFG4") & 0x0f
316 return 26000000 * ((256 + drate_m) * 2**drate_e)/2**28
317 def RF_set_datarate(self, rate):
318 """rate is expressed as a float in bauds"""
319 drate_e = int(math.floor(math.log(rate * 2**20 / 26000000.0, 2)))
320 drate_m = int(round(((rate * 2**28) / (26000000.0 * 2**drate_e)) - 256))
324 if drate_e < 0 or drate_e > 15:
325 print "ERROR: can't set datarate (too high or too low)"
327 self.poke_by_name("MDMCFG3", drate_m % 256)
328 self.poke_by_name("MDMCFG4", (self.peek_by_name("MDMCFG4") & 0xf0) | drate_e)
330 def RF_set_modulation(self, mod):
331 """modulation can be 2-FSK, GFSK, OOK or MSK"""
332 _vals = { "2-FSK": 0, "GFSK": 1, "OOK": 3, "MSK": 7}
334 print "ERROR: invalid modulation. Must be: %s" % ", ".join(_vals.keys())
336 self.poke_by_name("MDMCFG2", (self.peek_by_name("MDMCFG2") & 0x8f) | _vals[mod])
337 def RF_get_modulation(self):
338 _vals = [ "2-FSK", "GFSK", "? (2)", "OOK", "? (4)", "? (5)", "? (6)", "MSK" ]
339 return _vals[(self.peek_by_name("MDMCFG2") & 0x70) >> 4]
341 def RF_enable_manchester(self):
342 self.poke_by_name("MDMCFG2", self.peek_by_name("MDMCFG2") | 0x8)
343 def RF_disable_manchester(self):
344 self.poke_by_name("MDMCFG2", (self.peek_by_name("MDMCFG2") & ~0x8) % 256)
346 def RF_set_preamble_len(self, length):
347 _valid = [2, 3, 4, 6, 8, 12, 16, 24]
348 if length not in _valid:
349 print "ERROR: preamble len should be %s" % ", ".join(_valid)
351 self.poke_by_name("MDMCFG1", (self.peek_by_name("MDMCFG1") & 0x8f) + (length<<4))
352 def RF_get_preamble_len(self):
353 _vals = [2, 3, 4, 6, 8, 12, 16, 24]
354 return _vals[(self.peek_by_name("MDMCFG1") >> 4) & 0x7]
356 def RF_set_rxoff_mode(self, mode):
357 _valid = { "IDLE": 0, "FSTXON": 1, "TX": 2, "RX": 3}
358 if mode not in _valid:
359 print "ERROR: mode should be " % ", ".join(_valid)
361 self.poke_by_name("MCSM1", (self.peek_by_name("MCSM1") & 0xf3) + (_valid[mode] << 2))
362 def RF_get_rxoff_mode(self):
363 _vals = ["IDLE", "FSTXON", "TX", "RX"]
364 return _vals[(self.peek_by_name("MCSM1") & 0x0c) >> 2]
366 def RF_set_txoff_mode(self, mode):
367 _valid = { "IDLE": 0, "FSTXON": 1, "TX": 2, "RX": 3}
368 if mode not in _valid:
369 print "ERROR: mode should be " % ", ".join(_valid)
371 self.poke_by_name("MCSM1", (self.peek_by_name("MCSM1") & 0xfc) + _valid[mode])
372 def RF_get_txoff_mode(self):
373 _vals = ["IDLE", "FSTXON", "TX", "RX"]
374 return _vals[self.peek_by_name("MCSM1") & 0x03]
376 def RF_get_RSSI(self):
377 rssi = self.peek_by_name("RSSI")
379 rssi = (rssi - 256) / 2.0
382 rssi -= 71.0 ## mean rssi offset. Not accurate
384 def RF_carrier(self):
385 print "ERROR: RF Carrier is not implemented"
387 def RF_rxpacket(self, bytes=None):
388 """Get a packet from the radio. Returns None if none is
392 self.writecmd(self.APP, self.RX, len(data), data)
393 if len(self.data) == 0:
397 def RF_txpacket(self,packet):
398 """Send a packet through the radio."""
399 if isinstance(packet, str):
400 packet = [ ord(x) for x in packet ]
401 self.writecmd(self.APP, self.TX, len(packet), packet)
404 def RF_rxpacketrepeat(self):
405 self.writecmd(self.APP, self.REPEAT_RX, 0, None)