git.rot13.org Git - goodfet/blob - client/goodfet.nrf

   1 #!/usr/bin/env python
   2
   3 #GoodFET SPI Flash Client
   4 #by Travis Goodspeed
   5
   6 import sys;
   7 import binascii;
   8 import array;
   9 import time;
  10
  11 from GoodFETNRF import GoodFETNRF;
  12 from intelhex import IntelHex;
  13
  14
  15 regnames=["CONFIG","EN_AA","EN_RXADDR","SETUP_AW","SETUP_RET",
  16           "RF_CH","RF_SETUP","STATUS","OBSERVE_TX","RPD",
  17           "RX_ADDR_P0","RX_ADDR_P1","RX_ADDR_P2","RX_ADDR_P3","RX_ADDR_P4","RX_ADDR_P5",
  18           "TX_ADDR",
  19           "RX_PW_P0","RX_PW_P1","RX_PW_P2","RX_PW_P3","RX_PW_P4","RX_PW_P5",
  20           "FIFO_STATUS","?",
  21           "?","?","?","DYNPD","FEATURE","AGC_CONFIG","?","?",
  22           "?","?","?","?","?","?","?","?"];
  23
  24 def printpacket(packet):
  25     s="";
  26     i=0;
  27     for foo in packet:
  28         i=i+1;
  29         if i>client.packetlen: break;
  30         s="%s %02x" % (s,ord(foo));
  31     print "%s" % s;
  32
  33
  34 def printmspacket(packet,offset=1):
  35     keyword=client.RF_getsmac();
  36     #print "keyword=%010x" % key;
  37     key=[];
  38     ct=[];
  39     for foo in range(0,5):
  40         key.append(keyword&0xFF);
  41         keyword=(keyword>>8);
  42         #print "Keybyte %02x" % key[foo];
  43     i=0;
  44     s="";
  45
  46     for foo in packet:
  47         if i>=4:
  48             ct.append(ord(foo)^key[(i+offset)%5]);
  49             s="%s %02x" % (s,ord(foo)^key[(i+offset)%5]);
  50         else:
  51             ct.append(ord(foo));
  52             s="%s %02x" % (s,ord(foo));
  53         i=i+1;
  54     #print "%s" % (s);
  55
  56     if ct[0]==0x0a and ct[1]==0x78 and ct[9]!=0:
  57         letter=ct[9]+ord('A')-4;
  58         print "%c" % letter;
  59 def printconfig():
  60     print "Encoding %s" % client.RF_getenc();
  61     print "Freq    %10i MHz" % (client.RF_getfreq()/10**6);
  62     print "Rate    %10i kbps" % (client.RF_getrate()/1000);
  63     print "PacketLen %02i bytes" % client.RF_getpacketlen();
  64     #print "MacLen    %2i bytes" % client.RF_getmaclen();
  65     print "SMAC  0x%010x" % client.RF_getsmac();
  66     print "TMAC  0x%010x" % client.RF_gettmac();
  67
  68
  69 if(len(sys.argv)==1):
  70     print "Usage: %s verb [objects]\n" % sys.argv[0];
  71     print "%s info" % sys.argv[0];
  72     print "%s test" % sys.argv[0];
  73     print "%s regs" % sys.argv[0];
  74     print "%s regbits" % sys.argv[0];
  75     print "%s pyregs" % sys.argv[0];
  76     print "";
  77     print "%s tune aa|55,mac,r5,r6\n\tTunes to a configuration." % sys.argv[0];
  78     print "%s sniff\n\tSniffs packets by current config." % sys.argv[0];
  79     print "%s sniffob\n\tSniffs OpenBeacon traffic." % sys.argv[0];
  80     print "%s snifftp\n\tSniffs Turning Point Clicker traffic." % sys.argv[0];
  81     print "%s sniffsf\n\tSniffs SparkFun Dongle traffic." % sys.argv[0];
  82     print "";
  83     print "%s sniffmacs \n\tSniffs for MAC addresses on the present channel." % sys.argv[0];
  84     print "%s sniffprom [0xaa|0x55]\n\tSniffs promiscuously for a preamble of 0xAA or 0x55" % sys.argv[0];
  85     print "%s autotune\n\tSearches for a valid destination address." % sys.argv[0];
  86     print "";
  87     print "%s sniffskybrake\n\tSniffs skybrake. [broken?]" % sys.argv[0];
  88     print "%s sniffmskb\n\tSniffs MS KB. [broken?]" % sys.argv[0];
  89
  90     print "%s hosttp\n\tHosts Turning Point Clicker traffic." % sys.argv[0];
  91
  92     print "%s carrier [freq]\n\tHolds a carrier on [freq] Hz." % sys.argv[0];
  93     sys.exit();
  94
  95 #Initialize FET and set baud rate
  96 client=GoodFETNRF();
  97 client.serInit()
  98
  99 client.NRFsetup();
 100
 101 if(sys.argv[1]=="info"):
 102     printconfig();
 103
 104 if(sys.argv[1]=="test"):
 105     print "Old registers:"
 106     printconfig();
 107
 108     # Set PWR_UP=1 and PRIM_RX=0 in CONFIG.
 109     client.poke(0x00,2);
 110     #Delay of 1.5ms by round-trip.
 111
 112     print "\n\n";
 113
 114     #Try all data rates
 115     for foo in [250*10**3,
 116                 1*10**6,
 117                 2*10**6]:
 118         client.RF_setrate(foo);
 119         if(client.RF_getrate()!=foo):
 120             print "ERROR Rate %i not supported.  Got %i instead." % (foo,
 121                                                                      client.RF_getrate());
 122
 123     print "\n\n";
 124     client.poke(0x0A,0xDEADBEEF,5);
 125     #print "SMAC set to %010x" % client.RF_getsmac();
 126     if client.RF_getsmac()!=0xdeadbeef:
 127         print "ERROR: Failed to set MAC address.";
 128     print "Final registers:"
 129     printconfig();
 130
 131 if(sys.argv[1]=="carrier"):
 132     if len(sys.argv)>2:
 133         client.RF_setfreq(eval(sys.argv[2]));
 134     client.RF_carrier();
 135     printconfig();
 136     print "\nHolding a carrier wave.";
 137     while(1):
 138         time.sleep(1);
 139
 140 if(sys.argv[1]=="tune"):
 141     if len(sys.argv)>2:
 142         client.tune(sys.argv[2]);
 143     else:
 144         print "Specify a tuning, such as 'aa,c78c65805e,14,09'";
 145 if(sys.argv[1]=="regs"):
 146     for r in range(0,0x20):
 147         print "r[0x%02x]=0x%010x //%16s " % (r,client.peek(r),regnames[r]);
 148 if(sys.argv[1]=="pyregs"):
 149     for r in range(0,0x20):
 150         print "client.set(0x%02x,0x%010x); #%16s " % (r,client.peek(r),regnames[r]);
 151
 152 if(sys.argv[1]=="peek"):
 153     start=0x0000;
 154     if(len(sys.argv)>2):
 155         start=int(sys.argv[2],16);
 156     stop=start;
 157     if(len(sys.argv)>3):
 158         stop=int(sys.argv[3],16);
 159     print "Peeking from %02x to %02x." % (start,stop);
 160     while start<=stop:
 161         print "%02x: %010x" % (start,client.peek(start));
 162         start=start+1;
 163 if(sys.argv[1]=="poke"):
 164     start=0x0000;
 165     val=0x00;
 166     if(len(sys.argv)>2):
 167         start=int(sys.argv[2],16);
 168     if(len(sys.argv)>3):
 169         val=int(sys.argv[3],16);
 170     print "Poking %02x to become %010x." % (start,val);
 171
 172     client.poke(start,val);
 173     print "Poked to %04x" % client.peek(start);
 174
 175 if(sys.argv[1]=="sniffob"):
 176     #Reversal of transmitter code from nRF_CMD.c of OpenBeacon
 177     #TODO remove all poke() calls.
 178
 179     client.poke(0x00,0x00); #Stop nRF
 180     client.poke(0x01,0x00); #Disable Shockburst
 181     client.poke(0x02,0x01); #Set RX Pipe 0
 182
 183     client.RF_setfreq(2481 * 10**6);
 184     client.poke(0x06,0x09); #2MBps, -18dBm in RF_SETUP
 185     client.poke(0x07,0x78); #Reset status register
 186
 187     #OpenBeacon defines these in little endian as follows.
 188     client.RF_setmaclen(5); # SETUP_AW for 5-byte addresses.
 189     #0x01, 0x02, 0x03, 0x02, 0x01
 190     client.RF_setsmac(0x0102030201);
 191     #'O', 'C', 'A', 'E', 'B'
 192     client.RF_settmac(0x424541434F);
 193
 194     #Set packet length of 16.
 195     client.RF_setpacketlen(16);
 196
 197     #Power radio, prime for RX, one-byte checksum.
 198     client.poke(0x00,0x70|0x03|0x08); #0x08 for one byte, 0x04 for two.
 199
 200     print "Listening as %010x on %i MHz" % (client.RF_getsmac(),
 201                                            client.RF_getfreq()/10**6);
 202     #Now we're ready to get packets.
 203     while 1:
 204         packet=None;
 205         while packet==None:
 206             #time.sleep(0.1);
 207             packet=client.RF_rxpacket();
 208         printpacket(packet);
 209         sys.stdout.flush();
 210
 211 if(sys.argv[1]=="regbits"):
 212     print "Scanning registers to determine which bits are valid."
 213     regbits=range(0,0x30);
 214     for r in range(0,0x30):
 215         old=client.peek(r);
 216         #Which bits can be set?
 217         client.poke(r,0xFF);
 218         ones=client.peek(r);
 219         #Which bits can be clear?
 220         client.poke(r,0x00);
 221         zeroes=client.peek(r);
 222         regbits[r]=(ones & (~zeroes));
 223     for r in range(0,0x30):
 224         if regbits[r]!=0:
 225             print "r[0x%02x] masked %02x // %s" % (r,regbits[r], regnames[r]);
 226 if(sys.argv[1]=="sniffprom"):
 227     #Reversal of transmitter code from nRF_CMD.c of OpenBeacon
 228     #TODO remove all poke() calls.
 229
 230     client.poke(0x00,0x00); #Stop nRF
 231     client.poke(0x01,0x00); #Disable Shockburst
 232     client.poke(0x02,0x01); #Set RX Pipe 0
 233
 234     #client.RF_setfreq(2481 * 10**6);
 235     #client.poke(0x06,0x09); #2MBps, -18dBm in RF_SETUP
 236     client.poke(0x07,0x78); #Reset status register
 237
 238     #OpenBeacon defines these in little endian as follows.
 239     client.RF_setmaclen(2); # SETUP_AW for shortest
 240
 241     #It's better to have a known fragment, when one is available.
 242     #client.RF_setsmac(0x00AA);
 243     #client.RF_setsmac(0x0055);
 244
 245     #Should end in 55 or AA depending upon the packet.
 246     tail=0x55
 247     if(len(sys.argv)>2):
 248         tail=int(sys.argv[2],16);
 249     else:
 250         print "Please specify a tail of 0xAA or 0x55.";
 251         sys.exit(1);
 252     client.RF_setsmac(tail);
 253
 254     #Longest length.
 255     client.RF_setpacketlen(32);
 256
 257     #Power radio, prime for RX, no checksum
 258     client.poke(0x00,0x70|0x03); #0x08 for checksum, 0x04 for two.
 259
 260     print "Listening as %010x on %i MHz" % (client.RF_getsmac(),
 261                                            client.RF_getfreq()/10**6);
 262     #Now we're ready to get packets.
 263     while 1:
 264         packet=None;
 265         while packet==None:
 266             #time.sleep(0.1);
 267             packet=client.RF_rxpacket();
 268         printpacket(packet);
 269         sys.stdout.flush();
 270
 271 class AutoTuner():
 272     """This guesses addresses by searching through packets."""
 273     addresses={};
 274     client=None;
 275
 276     #Limits on search space, because you usually know what you're looking for.
 277     rate=False;
 278     chan=False;
 279     sync=False;
 280     startch=0; #Useful for forcing an early match.
 281     def init(self,goodfet,
 282              rate=True,chan=True,sync=True):
 283         """Initializes a link to the GoodFET for autotuning."""
 284         self.client=goodfet;
 285         self.rate=rate;
 286         self.chan=chan;
 287         self.sync=sync;
 288
 289         client.poke(0x00,0x00); #Stop nRF
 290         client.poke(0x01,0x00); #Disable Shockburst
 291         client.poke(0x02,0x01); #Set RX Pipe 0
 292
 293         #Disable shockburst.
 294         client.poke(0x1C,0x00);
 295         client.poke(0x1D,0x00);
 296
 297         client.RF_setmaclen(2); # SETUP_AW for shortest
 298
 299         #historic
 300         #client.RF_setsmac(0x00AA);
 301         #client.RF_setsmac(0x0055);
 302
 303         client.poke(0x00,0x70|0x03); #prime radio.
 304
 305         return;
 306     def packetaddr(self,packet,justmac=False):
 307         """Returns a loaded packet address, including channel and rate."""
 308
 309         sync=self.client.RF_getsmac()&0xFF;
 310
 311         mac="";
 312         #MAC,RF_CH,RATE
 313         for i in range(0,5):
 314             mac="%s%02x" % (mac,ord(packet[i]));
 315         if justmac:
 316             return mac;
 317         ch=self.client.peek(0x05);
 318         rate=self.client.peek(0x06);
 319         return "%02x,%s,%02x,%02x" % (
 320             sync,mac,ch,rate);
 321     def validmac(self,packet):
 322         sync=self.client.RF_getsmac()&0xFF;
 323         mac=self.packetaddr(packet,justmac=True);
 324         if (ord(packet[0])&0x80)^(sync&0x80):
 325             #print "%02x%02x invalid entry." % (sync,ord(packet[0]));
 326             #This is a special kind of failure.  Freq is probably right, but MAC is wrong.
 327             return False;
 328         if mac=='5555555555' or mac=='aaaaaaaaaa' or mac=='0000000000':
 329             return False;
 330         return True;
 331
 332     def handle(self,packet):
 333         """Handles a packet."""
 334         #printpacket(packet);
 335
 336         if not self.validmac(packet):
 337             #print "Dropped packet from %s" % self.packetaddr(packet,justmac=True);
 338             #printpacket(packet);
 339             return;
 340
 341         addr=self.packetaddr(packet);
 342
 343         #Increment the address count.
 344         count=0;
 345         try:
 346             count=self.addresses[addr];
 347         except:
 348             pass;
 349         self.addresses[addr]=count+1;
 350         rate=count*1.0/len(self.addresses);
 351         if self.addresses[addr]>1 or rate>0.01:
 352             print "'%s' looks valid\t%i\t%0.5f" % (
 353                 addr,count,rate);
 354         return addr;
 355     tunecount=0;
 356     def selftune(self,threshold=2,forever=False,
 357                  delay=5.0):
 358         """Tunes to the first strong signal.
 359         It's important that this not get triggered by false positives."""
 360
 361         while 1:
 362             self.retune();
 363             start=time.mktime(time.localtime());
 364             sys.stdout.flush();
 365             while (time.mktime(time.localtime())-start) < delay:
 366                 packet=None;
 367                 while packet==None:
 368                     packet=client.RF_rxpacket();
 369                 addr=guesser.handle(packet);
 370                 try:
 371                     count=self.addresses[addr];
 372                 except:
 373                     count=0;
 374                 if count>threshold and forever==False:
 375                     #Tune it in here?
 376                     client.tune(addr);
 377                     return addr;
 378
 379
 380     def retune(self):
 381         """Tunes to another channel or preamble looking for the next packet."""
 382         count=self.tunecount;
 383         self.tunecount=count+1;
 384
 385         #Swap the SYNC value most often.
 386         if self.sync:
 387             sync=0x00AA;
 388             if count&1:
 389                 sync=0x0055;
 390             self.client.RF_setsmac(sync);
 391             count=(count>>1);
 392
 393         if self.rate:
 394             #Then the data rate.
 395             rate=0;
 396
 397             #This swaps between 1Mbps and 2Mbps.
 398             #TODO add support for 256kbps, if anyone uses it.
 399             if count&1:
 400                 rate=rate|0x08;
 401             #print "Setting rate to 0x%02x" % rate;
 402             if(rate==0x20):
 403                 rate=0x08;
 404             self.client.poke(0x06,rate);
 405             count=(count>>1);
 406
 407         if self.chan:
 408             self.client.poke(0x05,
 409                              (count+self.startch)&0x7f);
 410             print "Tuned to %i MHz" % (
 411                 self.client.RF_getfreq()
 412                 /(10**6));
 413         #Grab two packets to clear buffers.
 414         #Should retune only after a few packets to reduce this delay.
 415         packet=client.RF_rxpacket();
 416         packet=client.RF_rxpacket();
 417         return;
 418
 419
 420 if(sys.argv[1]=="autotune"):
 421     #Reversal of transmitter code from nRF_CMD.c of OpenBeacon
 422     #TODO remove all poke() calls.
 423     guesser=AutoTuner();
 424     guesser.init(client,rate=True,sync=True,chan=True);
 425
 426
 427     #client.RF_setfreq(2481 * 10**6);
 428     client.poke(0x06,0x09); #2MBps, -18dBm in RF_SETUP
 429     client.poke(0x07,0x78); #Reset status register
 430
 431     #This is determined by the MAC, which we don't yet know.
 432
 433     #Longest length.
 434     client.RF_setpacketlen(32);
 435
 436     #Power radio, prime for RX, no checksum
 437     client.poke(0x00,0x70|0x03); #0x08 for checksum, 0x04 for two.
 438
 439     print "Autotuning on %i MHz" % (
 440         client.RF_getfreq()/10**6);
 441     print "sync,mac,r5,r6";
 442     #Now we're ready to get packets.
 443     guesser.selftune(threshold=2,
 444                      forever=True);
 445
 446 if(sys.argv[1]=="sniffmacs"):
 447     #Reversal of transmitter code from nRF_CMD.c of OpenBeacon
 448     #TODO remove all poke() calls.
 449     guesser=AutoTuner();
 450     guesser.init(client,rate=False,sync=True,chan=False);
 451
 452     #Longest length.
 453     client.RF_setpacketlen(32);
 454
 455     #Power radio, prime for RX, no checksum
 456     client.poke(0x00,0x70|0x03); #0x08 for checksum, 0x04 for two.
 457
 458     print "Holding autotune on %i MHz" % (
 459         client.RF_getfreq()/10**6);
 460     print "sync,mac,r5,r6";
 461     #Now we're ready to get packets.
 462     guesser.selftune(threshold=2,
 463                      forever=True);
 464
 465 if(sys.argv[1]=="sniffmskb"):
 466     #MSWK 3000 v2.0
 467     #TODO remove all poke() calls.
 468
 469     client.poke(0x00,0x00); #Stop nRF
 470     client.poke(0x01,0x00); #Disable Shockburst
 471     client.poke(0x02,0x01); #Set RX Pipe 0
 472
 473     client.poke(0x06,0x09); #2MBps, -18dBm in RF_SETUP
 474     client.poke(0x07,0x78); #Reset status register
 475
 476     #This is the address of a specific keyboard.
 477     #Other keyboards will be different.
 478
 479     client.RF_setmaclen(5);
 480
 481     #Known pairs.  The channel and the low address bytes must match.
 482     #client.RF_setfreq((2400+0x13) * 10**6);
 483     #client.RF_setsmac(0xc00a3598cd);
 484
 485     #client.RF_setfreq((2400+0x15) * 10**6);
 486     #client.RF_setsmac(0xc10446facd);
 487
 488     #Mac packet length, illegally 0-length address field.
 489     client.RF_setpacketlen(16);
 490
 491     #aa,c00a3598cd,13,09
 492     if len(sys.argv)>2:
 493         client.tune(sys.argv[2]);
 494     else:
 495
 496         print "Searching for a keyboard.";
 497
 498         guesser=AutoTuner();
 499         guesser.init(client, rate=False, sync=True, chan=True);
 500         guesser.selftune(threshold=4,forever=False,
 501                          delay=10.0);
 502
 503     client.poke(0x00,0x00); #Stop nRF
 504     client.poke(0x01,0x00); #Disable Shockburst
 505     client.poke(0x02,0x01); #Set RX Pipe 0
 506     client.RF_setmaclen(5);
 507
 508     #Finally, dynamic payload lengths need to be enabled.
 509     #client.poke(0x01,0x01);
 510     client.poke(0x1C,0x01);
 511     client.poke(0x1D,0x06);
 512
 513     client.poke(0x00,0x70|0x03); #prime radio.
 514     print "Listening as %010x on %i MHz" % (client.RF_getsmac(),
 515                                            client.RF_getfreq()/10**6);
 516     #Now we're ready to get packets.
 517     while 1:
 518         packet=None;
 519         while packet==None:
 520             #time.sleep(1);
 521             packet=client.RF_rxpacket();
 522             #print ".";
 523         printmspacket(packet);
 524         sys.stdout.flush();
 525
 526 if(sys.argv[1]=="sniffant"):
 527     #Prototyped on Garmin device.
 528     #Channel hopping is pretty damned fast, hard to follow.
 529     #This doesn't really work yet, still experimenting.
 530
 531     #Might be more effective to sniff knowing the MFG ID and Dev. ID,
 532     #as these predict a lot of the MAC address.
 533
 534     client.poke(0x00,0x00); #Stop nRF
 535     client.poke(0x01,0x00); #Disable Shockburst
 536     client.poke(0x02,0x01); #Set RX Pipe 0
 537
 538     client.poke(0x05,57); #broadcast-only channel
 539     client.poke(0x06,0x00); #1MBps
 540     client.poke(0x07,0x78); #Reset status register
 541
 542     #Is this appropriate?  Might be 3.
 543     client.RF_setmaclen(5);
 544
 545
 546     #Mac packet length, illegally 0-length address field.
 547     client.RF_setpacketlen(16);
 548
 549     if len(sys.argv)>2:
 550         client.tune(sys.argv[2]);
 551     else:
 552
 553         print "Searching for ANT+.";
 554
 555         guesser=AutoTuner();
 556         guesser.init(client, rate=False, sync=True, chan=True);
 557         guesser.selftune(threshold=2,forever=False,
 558                          delay=9.0);
 559
 560     client.poke(0x00,0x00); #Stop nRF
 561     client.poke(0x01,0x00); #Disable Shockburst
 562     client.poke(0x02,0x01); #Set RX Pipe 0
 563     client.RF_setmaclen(5);
 564
 565
 566     client.poke(0x00,0x70|0x03); #prime radio.
 567     print "Dumping ANT as %010x on %i MHz" % (client.RF_getsmac(),
 568                                               client.RF_getfreq()/10**6);
 569     #Now we're ready to get packets.
 570     while 1:
 571         packet=None;
 572         while packet==None:
 573             #time.sleep(1);
 574             packet=client.RF_rxpacket();
 575             #print ".";
 576         printpacket(packet);
 577         sys.stdout.flush();
 578
 579
 580
 581 if(sys.argv[1]=="sniffskybrake"):
 582     #Reversal of transmitter code from nRF_CMD.c of OpenBeacon
 583     #TODO remove all poke() calls.
 584
 585     client.poke(0x00,0x00); #Stop nRF
 586     client.poke(0x01,0x00); #Disable Shockburst
 587     client.poke(0x02,0x01); #Set RX Pipe 0
 588
 589     client.RF_setfreq(2439 * 10**6);
 590     client.poke(0x06,0x00); #1MBps
 591     client.poke(0x07,0x78); #Reset status register
 592
 593     #OpenBeacon defines these in little endian as follows.
 594     client.RF_setmaclen(2); # SETUP_AW for 3-byte addresses.
 595     #0x01, 0x02, 0x03, 0x02, 0x01
 596
 597     client.RF_setsmac(0x070700d2c4); #reversed
 598
 599     #client.RF_setsmac(0xd2c4);
 600     #client.RF_setsmac(0);
 601
 602     #Mac packet length, illegally 0-length address field.
 603     client.RF_setpacketlen(32);
 604
 605     #Power radio, prime for RX, one-byte checksum.
 606     client.poke(0x00,0x70|0x03); #0x08 for one byte, 0x04 for two.
 607
 608     print "Listening as %010x on %i MHz" % (client.RF_getsmac(),
 609                                            client.RF_getfreq()/10**6);
 610     print "%i byte mac match." % client.RF_getmaclen();
 611     #Now we're ready to get packets.
 612     while 1:
 613         packet=None;
 614         while packet==None:
 615             #time.sleep(0.1);
 616             packet=client.RF_rxpacket();
 617         printpacket(packet);
 618         sys.stdout.flush();
 619
 620 if(sys.argv[1]=="sniffsf"):
 621     #Reversal of transmitter code from nRF_CMD.c of OpenBeacon
 622     #TODO remove all poke() calls.
 623
 624     client.poke(0x00,0x00); #Stop nRF
 625     client.poke(0x01,0x00); #Disable Shockburst
 626     client.poke(0x02,0x01); #Set RX Pipe 0
 627
 628     client.RF_setfreq(2402 * 10**6);
 629     client.poke(0x06,0x07); #1Mbps
 630     client.poke(0x07,0x78); #Reset status register
 631
 632     #OpenBeacon defines these in little endian as follows.
 633     client.RF_setmaclen(5); # SETUP_AW for 5-byte addresses.
 634     client.RF_setsmac(0xe7e7e7e7e7);
 635     client.RF_settmac(0xe7e7e7e7e7);
 636
 637     #Set packet length of 16.
 638     client.RF_setpacketlen(4);
 639
 640     #Power radio, prime for RX, one-byte checksum.
 641     client.poke(0x00,0x70|0x03|0x08); #0x08 for one byte, 0x04 for two.
 642
 643     print "Listening as %010x on %i MHz" % (client.RF_getsmac(),
 644                                            client.RF_getfreq()/10**6);
 645     #Now we're ready to get packets.
 646     while 1:
 647         packet=None;
 648         while packet==None:
 649             #time.sleep(0.1);
 650             packet=client.RF_rxpacket();
 651         printpacket(packet);
 652         sys.stdout.flush();
 653
 654 if(sys.argv[1]=="snifftp"):
 655     client.poke(0x00,0x00); #Stop nRF
 656     client.poke(0x01,0x00); #Disable Shockburst
 657     client.poke(0x02,0x01); #Set RX Pipe 0
 658
 659     #Disable shockburst.
 660     client.poke(0x1C,0x00);
 661     client.poke(0x1D,0x00);
 662
 663     client.RF_setfreq((2400+0x29) * 10**6);
 664     client.poke(0x06,0x00); #1Mbps
 665     client.poke(0x07,0x78); #Reset status register
 666
 667     client.RF_setmaclen(3); # SETUP_AW for 3-byte addresses.
 668     client.RF_setsmac(0x123456);
 669     client.RF_setpacketlen(4);
 670
 671     #Power radio, prime for RX, two-byte checksum.
 672     client.poke(0x00,0x70|0x03|0x04|0x08);
 673
 674     print "Listening as %010x on %i MHz" % (client.RF_getsmac(),
 675                                            client.RF_getfreq()/10**6);
 676     #Now we're ready to get packets.
 677     while 1:
 678         packet=None;
 679         while packet==None:
 680             #time.sleep(0.1);
 681             packet=client.RF_rxpacket();
 682         printpacket(packet);
 683         sys.stdout.flush();
 684
 685 if(sys.argv[1]=="hosttp"):
 686     client.poke(0x00,0x00); #Stop nRF
 687     client.poke(0x01,0x00); #Disable Shockburst
 688     client.poke(0x02,0x01); #Set RX Pipe 0
 689
 690     chan=0x29;
 691
 692     client.RF_setfreq((2400+chan) * 10**6);
 693     client.poke(0x06,0x00); #1Mbps
 694     client.poke(0x07,0x78); #Reset status register
 695
 696     client.RF_setmaclen(3); # SETUP_AW for 3-byte addresses.
 697     client.RF_setsmac(0x123456);
 698     client.RF_setpacketlen(4);
 699
 700     #Power radio, prime for RX, two-byte checksum.
 701     client.poke(0x00,0x70|0x03|0x04|0x08);
 702
 703     print "Listening as %010x on %i MHz" % (client.RF_getsmac(),
 704                                            client.RF_getfreq()/10**6);
 705     #Now we're ready to get packets.
 706     while 1:
 707         packet=None;
 708         while packet==None:
 709             packet=client.RF_rxpacket();
 710         mac=((ord(packet[0])<<16)+
 711              (ord(packet[1])<<8)+
 712              ord(packet[2]));
 713         key=packet[3];
 714         print "%c from %06x" % (key,mac);
 715         sys.stdout.flush();
 716
 717 if(sys.argv[1]=="sniff"):
 718     if len(sys.argv)>2:
 719         print "Set MAC to %s" % sys.argv[2];
 720         client.tune(sys.argv[2]);
 721         client.RF_setmaclen(5);
 722
 723     #client.poke(0x00,0x00); #Stop nRF
 724     client.poke(0x07,0x78); #Reset status register
 725
 726     #Power radio, prime for RX, no checksum.
 727     client.poke(0x00,0x70|0x03);
 728     #Mac packet length.
 729     client.RF_setpacketlen(32);
 730     #Mac length, reduced
 731     #client.RF_setmaclen(3); # SETUP_AW for shortest
 732
 733     print "Listening as %010x on %i MHz" % (client.RF_getsmac(),
 734                                            client.RF_getfreq()/10**6);
 735     #Now we're ready to get packets.
 736
 737     while 1:
 738         packet=None;
 739         while packet==None:
 740             #time.sleep(0.1);
 741             packet=client.RF_rxpacket();
 742         printpacket(packet);
 743         sys.stdout.flush();
 744 if(sys.argv[1]=="explore"):
 745     #client.poke(0x00,0x00); #Stop nRF
 746     client.poke(0x07,0x78); #Reset status register
 747
 748     #Power radio, prime for RX, no checksum.
 749     client.poke(0x00,0x70|0x03);
 750
 751     #Set packet length of 32.
 752     #Without checksums, extra data will mix in.
 753     client.RF_setpacketlen(32);
 754     client.RF_setmaclen(3); # shortest address length
 755
 756     #Now we're ready to get packets.
 757     for smac in [0x0102030201, 0]:
 758         client.RF_setsmac(smac);
 759         for chan in range(0,0x80):
 760             client.RF_setfreq((2400+chan) * 10**6);
 761             time.sleep(1);
 762             packet=client.RF_rxpacket();
 763             if packet!=None:
 764                 print "Listening as %010x on %i MHz" % (client.RF_getsmac(),
 765                                                         client.RF_getfreq()/10**6);
 766                 printpacket(packet);
 767                 sys.stdout.flush();