handle errata 1, add timeouts in rx

[fhem-stuff] / culfw / culfw-asksin-fix.diff

Index: clib/rf_asksin.c
===================================================================
--- clib/rf_asksin.c	(revision 373)
+++ clib/rf_asksin.c	(working copy)
@@ -11,13 +11,13 @@
 
 uint8_t asksin_on = 0;
 
-const uint8_t PROGMEM ASKSIN_CFG[50] = {
-     0x00, 0x07,
+const uint8_t PROGMEM ASKSIN_CFG[] = {
+     0x00, 0x01,
      0x02, 0x2e,
      0x03, 0x0d,
      0x04, 0xE9,
      0x05, 0xCA,
-     0x07, 0x0C,
+     0x07, 0x04,
      0x0B, 0x06,
      0x0D, 0x21,
      0x0E, 0x65,
@@ -26,18 +26,22 @@
      0x11, 0x93,
      0x12, 0x03,
      0x15, 0x34,
-     0x17, 0x30, // always go into IDLE
+     0x17, 0x3F, // always go into RX after TX, CCA, ELV uses 0x03
      0x18, 0x18,
      0x19, 0x16,
      0x1B, 0x43,
      0x21, 0x56,
      0x25, 0x00,
      0x26, 0x11,
+     0x29, 0x59,
+     0x2c, 0x81,
      0x2D, 0x35,
-     0x3e, 0xc3,
-     0xff
+     0x3e, 0xc3
 };
 
+static inline uint8_t read_cc1100_rxbytes(void);
+static inline void rf_asksin_reset_rx(void);
+
 void
 rf_asksin_init(void)
 {
@@ -56,20 +60,44 @@
   my_delay_us(100);
 
   // load configuration
-  for (uint8_t i = 0; i<50; i += 2) {
-       
-    if (pgm_read_byte( &ASKSIN_CFG[i] )>0x40)
-      break;
-
+  for (uint8_t i = 0; i < sizeof(ASKSIN_CFG); i += 2) {
     cc1100_writeReg( pgm_read_byte(&ASKSIN_CFG[i]),
                      pgm_read_byte(&ASKSIN_CFG[i+1]) );
   }
   
   ccStrobe( CC1100_SCAL );
 
-  my_delay_ms(1);
+  my_delay_ms(4);
+
+  ccRX();
 }
 
+// Workaround for CC1101 Errata 3
+static inline uint8_t
+read_cc1100_rxbytes(void)
+{
+  uint8_t rxbytes, rxbytes2;
+  
+  rxbytes = cc1100_readReg(CC1100_RXBYTES);
+  while((rxbytes2 = cc1100_readReg(CC1100_RXBYTES)) != rxbytes)
+    rxbytes = rxbytes2;
+
+  return rxbytes;
+}
+
+static inline void
+rf_asksin_reset_rx(void)
+{
+  ccStrobe( CC1100_SFRX  );
+  ccStrobe( CC1100_SIDLE );
+  ccStrobe( CC1100_SNOP  );
+
+  while (read_cc1100_rxbytes() & 0x7f)
+    cc1100_readReg(CC1100_RXFIFO);
+
+  ccStrobe( CC1100_SRX   );
+}
+
 void
 rf_asksin_task(void)
 {
@@ -77,18 +105,41 @@
   uint8_t dec[MAX_ASKSIN_MSG];
   uint8_t rssi;
   uint8_t l;
+  uint8_t rxfifo_cnt;
 
   if(!asksin_on)
     return;
 
-  // see if a CRC OK pkt has been arrived
-  if (bit_is_set( CC1100_IN_PORT, CC1100_IN_PIN )) {
+  // see if there is data to be read
+  while (bit_is_set( CC1100_IN_PORT, CC1100_IN_PIN )) {
+    rxfifo_cnt = read_cc1100_rxbytes();
 
+    if (rxfifo_cnt & 0x80) // Overflow
+      break;
+
+    rxfifo_cnt &= 0x7f;
+
     enc[0] = cc1100_readReg( CC1100_RXFIFO ) & 0x7f; // read len
+    rxfifo_cnt--;
 
-    if (enc[0]>=MAX_ASKSIN_MSG)
-         enc[0] = MAX_ASKSIN_MSG-1;
-    
+    if (enc[0] >= MAX_ASKSIN_MSG) {
+      // Something went horribly wrong, out of sync?
+      rf_asksin_reset_rx();
+      return;
+    }
+
+    l = 50;
+    while (l-- && ((enc[0] + 2) < rxfifo_cnt)) { // Wait for more data
+      my_delay_ms(1);
+      rxfifo_cnt = (read_cc1100_rxbytes() & 0x7f);
+    }
+
+    if (!l) {
+      // Not enough data received, out of sync?
+      rf_asksin_reset_rx();
+      return;
+    }
+
     CC1100_ASSERT;
     cc1100_sendbyte( CC1100_READ_BURST | CC1100_RXFIFO );
     
@@ -97,14 +148,19 @@
     }
     
     rssi = cc1100_sendbyte( 0 );
-    
+
     CC1100_DEASSERT;
 
-    ccStrobe( CC1100_SFRX  );
-    ccStrobe( CC1100_SIDLE );
-    ccStrobe( CC1100_SNOP  );
-    ccStrobe( CC1100_SRX   );
+    // We must not read the last byte from the RX fifo while RX is in progress (Errata 1)
+    while (((read_cc1100_rxbytes() & 0x7f) == 1) && (cc1100_readReg(CC1100_PKTSTATUS) & (1 << 3))) {
+      my_delay_ms(1);
+    }
 
+    l = cc1100_readReg(CC1100_RXFIFO);
+
+    if (!(l & 0x80)) // CRC not ok
+      continue;
+
     dec[0] = enc[0];
     dec[1] = (~enc[1]) ^ 0x89;
     
@@ -113,7 +169,6 @@
     
     dec[l] = enc[l] ^ dec[2];
     
-    
     if (tx_report & REP_BINTIME) {
       
       DC('a');
@@ -131,26 +186,17 @@
       
       DNL();
     }
+  }
 
-    return;
-       
+  switch(cc1100_readReg( CC1100_MARCSTATE )) {
+    case MARCSTATE_RXFIFO_OVERFLOW:
+      ccStrobe( CC1100_SFRX  );
+    case MARCSTATE_IDLE:
+      ccStrobe( CC1100_SIDLE );
+      ccStrobe( CC1100_SNOP  );
+      ccStrobe( CC1100_SRX   );
+      break;
   }
-       
-       
-  switch (cc1100_readReg( CC1100_MARCSTATE )) {
-            
-       // RX_OVERFLOW
-  case 17:
-       // IDLE
-  case 1:
-    ccStrobe( CC1100_SFRX  );
-    ccStrobe( CC1100_SIDLE );
-    ccStrobe( CC1100_SNOP  );
-    ccStrobe( CC1100_SRX   );
-    break;
-       
-  }
-
 }
 
 void
@@ -173,20 +219,7 @@
     my_delay_ms(3);             // 3ms: Found by trial and error
   }
 
-  ccStrobe(CC1100_SIDLE);
-  ccStrobe(CC1100_SFRX );
-  ccStrobe(CC1100_SFTX );
-
-  if (dec[2] & (1 << 4)) { //BURST-bit set?
-    ccStrobe(CC1100_STX  ); //We need to send a burst
-
-    //According to ELV, devices get activated every 300ms, so send burst for 360ms
-    for(l = 0; l < 3; l++)
-      my_delay_ms(120); //arg is uint_8, so loop
-  }
-
   // "crypt"
-
   enc[0] = dec[0];
   enc[1] = (~dec[1]) ^ 0x89;
 
@@ -195,6 +228,15 @@
   
   enc[l] = dec[l] ^ dec[2];
 
+  ccTX();
+  if (dec[2] & (1 << 4)) { // BURST-bit set?
+    // According to ELV, devices get activated every 300ms, so send burst for 360ms
+    for(l = 0; l < 3; l++)
+      my_delay_ms(120); // arg is uint_8, so loop
+  } else {
+  	my_delay_ms(10);
+  }
+
   // send
   CC1100_ASSERT;
   cc1100_sendbyte(CC1100_WRITE_BURST | CC1100_TXFIFO);
@@ -205,12 +247,17 @@
 
   CC1100_DEASSERT;
 
-  ccStrobe( CC1100_SFRX  );
-  ccStrobe( CC1100_STX   );
+  // wait for TX to finish
+  while(cc1100_readReg( CC1100_MARCSTATE ) == MARCSTATE_TX)
+    ;
+
+  if (cc1100_readReg( CC1100_MARCSTATE ) == MARCSTATE_TXFIFO_UNDERFLOW) {
+      ccStrobe( CC1100_SFTX  );
+      ccStrobe( CC1100_SIDLE );
+      ccStrobe( CC1100_SNOP  );
+      ccStrobe( CC1100_SRX   );
+  }
   
-  while( cc1100_readReg( CC1100_MARCSTATE ) != 1 )
-    my_delay_ms(5);
-  
   if(asksin_on) {
     ccRX();
   } else {