First prototype more or less finished.

include/cppm.h

 extern volatile uint16_t cppmData[8];
 
 void cppmInit(void);
+void cppmCopy(uint16_t *data);
 
 #endif
 

include/rx.h

 #define _RX_H
 
 void rxInit(void);
+void rxReceivePacket(void);
 
 #endif
 

src/cppm.c

     triggerIn(PULSE_LOW);
 }
 
+void cppmCopy(uint16_t *data) {
+    cli();
+    for (int i = 0; i < CHANNELS; i++) {
+        cppmData[i] = data[i];
+    }
+    sei();
+}
+
 static void triggerIn(uint16_t us) {
     TCNT0 = 0; // Reset Timer
     if (us <= (TIME_AFTER_OVERFLOW - 1)) {

src/main.c

     timerInit();
 
     sei(); // Enable interrupts (required for timer)
-    wdt_enable(WDTO_120MS); // Trigger Watchdog after 120ms
+    wdt_enable(WDTO_250MS); // Trigger Watchdog after 250ms
 
     spiInit();
     rxInit();
 
-    for(;;) { }
+    for(;;) {
+        wdt_reset();
+        rxReceivePacket();
+    }
 }
 

src/rx.c

 #include <avr/io.h>
 #include <avr/interrupt.h>
 #include <avr/eeprom.h>
+#include <avr/wdt.h>
 
 #include "cc2500.h"
+#include "cppm.h"
 #include "spi.h"
 #include "timer.h"
-
-// ----------------------------------------------------------------------------
-
-#define TRUE 1
-#define FALSE 0
+#include "rx.h"
 
 #define CHANNELS 8
 #define PPM_MIN 1000
 #define PPM_MAX 2000
-#define RSSI_OVER_PPM 7
 #define HOP_DATA_LENGTH 60
 #define EEPROM_BASE_ADDRESS 100
 #define MISSING_PACKET_DELAY 9
 #define SEEK_CHANNEL_SKIP   13
 #define MAX_MISSING_PACKET 20
 #define FAILSAFE_MISSING_PACKET 170
-
-static uint8_t ccData[27];
-static uint8_t ccLen;
-static uint8_t packet = FALSE;
-static uint8_t channr = 0;
-static uint8_t missingPackets = 0;
+#define RSSI_OVER_PPM 7
+#define RSSI_OFFSET 71
+#define RSSI_MIN -103
+#define RSSI_MAX -96
+#define PPM_SCALE 0.67
+
+uint8_t ccData[27];
+uint8_t ccLen;
+uint8_t packet = 0;
+uint8_t channr = 0;
+uint8_t missingPackets = 0;
 uint8_t hopData[HOP_DATA_LENGTH];
 uint8_t listLength;
 uint8_t txid[2];
-static uint8_t counter = 0;
-volatile uint8_t failed = FALSE;
-int count = 0;
+uint8_t counter = 0;
+uint8_t failed = 0;
+uint8_t frequencyOffsetHack = 0;
 uint16_t c[8];
-
 int rssi;
-const int rssi_offset = 71;
-const int rssi_min = -103;
-const int rssi_max = -96;
-
-void getBind(void);
-void loop(void);
-void tuning(void);
-
-// ----------------------------------------------------------------------------
 
 static uint16_t ppmBuffer[CHANNELS];
 
 static long map(long x, long in_min, long in_max, long out_min, long out_max);
 static long constrain(long x, long min, long max);
+
 static void initialize(uint8_t bind);
 static void binding(void);
-
+static void tuning(void);
+static void performBind(void);
 static void nextChannel(uint8_t skip);
 static void readBindingData(void);
 static void writeBindingData(void);
     cc2500Strobe(CC2500_SRX);
 }
 
-static long map(long x, long in_min, long in_max, long out_min, long out_max) {
-    return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
-}
-
-static long constrain(long x, long min, long max) {
-    if (x < min) {
-        x = min;
-    }
-    if (x > max) {
-        x = max;
-    }
-    return x;
-}
-
 static void initialize(uint8_t bind) {
     cc2500ResetChip();
     cc2500WriteReg(CC2500_02_IOCFG0,   0x01); // RX complete interrupt(GDO0)
     cc2500WriteReg(CC2500_07_PKTCTRL1, 0x0D);
 
     //cc2500WriteReg(CC2500_0C_FSCTRL0, 0); // Frequency offset
-    cc2500WriteReg(CC2500_0C_FSCTRL0, bind ? 0x00 : count); // Frequency offset hack
+    cc2500WriteReg(CC2500_0C_FSCTRL0, bind ? 0x00 : frequencyOffsetHack);
 
     cc2500WriteReg(CC2500_0A_CHANNR, 0x00);
 }
 
 static void binding(void) {
-    uint8_t jumper2 = 0; //bind_jumper();
-
-    while (1) {
-        if (jumper2 == 0) {
-            // bind complete or no bind
-            readBindingData();
-            if ((txid[0] == 0xff) && (txid[1] == 0xff)) {
-                // No valid txid, forcing bind
-                jumper2 = 1;
-                continue;
-            }
-            break;
-        } else {
-            tuning();
-            //count=0xC8;//for test
-            cc2500WriteReg(CC2500_0C_FSCTRL0, count);
-            eeprom_write_byte(EEPROM_BASE_ADDRESS + 101, count);
-            getBind();
-            // TODO reset?!
-            while (1) { }
-        }
+    readBindingData();
+    if ((txid[0] != 0xff) || (txid[1] != 0xff)) {
+        // valid binding data found
+        return;
     }
-}
 
-static void nextChannel(uint8_t skip) {
-    channr += skip;
-    if (channr >= listLength) {
-        channr -= listLength;
-    }
+    // No valid txid, forcing bind
+    tuning();
 
-    cc2500WriteReg(CC2500_0A_CHANNR, hopData[channr]);
-    cc2500WriteReg(CC2500_23_FSCAL3, 0x89);
-}
+    //frequencyOffsetHack = 0xC8; // for test
+    cc2500WriteReg(CC2500_0C_FSCTRL0, frequencyOffsetHack);
+    eeprom_write_byte(EEPROM_BASE_ADDRESS + 101, frequencyOffsetHack);
 
-static void readBindingData() {
-    for (uint8_t i = 0; i < 2; i++) {
-        txid[i] = eeprom_read_byte(EEPROM_BASE_ADDRESS + i);
-    }
-    for (uint8_t i = 0; i < HOP_DATA_LENGTH; i++) {
-        hopData[i] = eeprom_read_byte(EEPROM_BASE_ADDRESS + 10 + i);
-    }
-    listLength = eeprom_read_byte(EEPROM_BASE_ADDRESS + 100);
-    count = eeprom_read_byte(EEPROM_BASE_ADDRESS + 101);
+    performBind();
 }
 
-static void writeBindingData() {
-    for (uint8_t i = 0; i < 2; i++) {
-        eeprom_write_byte(EEPROM_BASE_ADDRESS + i, txid[i]);
-    }
-    for (uint8_t i = 0; i < HOP_DATA_LENGTH; i++) {
-        eeprom_write_byte(EEPROM_BASE_ADDRESS + 10 + i, hopData[i]);
+static void tuning() {
+    cc2500Strobe(CC2500_SRX); // enter in rx mode
+
+    int frequencyOffsetTimer = 0;
+    while (1) {
+        frequencyOffsetTimer++;
+        if (frequencyOffsetTimer > 3000) {
+            frequencyOffsetTimer = 0;
+            cc2500WriteReg(CC2500_0C_FSCTRL0, frequencyOffsetHack);
+            frequencyOffsetHack += 10;
+            if (frequencyOffsetHack > 250) {
+                frequencyOffsetHack = 0;
+            }
+            //cc2500Strobe(CC2500_SRX); // enter in rx mode
+        }
+
+        if (GDO_1) {
+            ccLen = cc2500ReadReg(CC2500_3B_RXBYTES | CC2500_READ_BURST) & 0x7F;
+            if (ccLen) {
+                cc2500ReadFifo(ccData, ccLen);
+                if ((ccData[ccLen - 1] & 0x80)
+                        && (ccData[2] == 0x01)
+                        && (ccData[5] == 0x00)) {
+                    break;
+                }
+            }
+        }
+
+        wdt_reset();
     }
-    eeprom_write_byte(EEPROM_BASE_ADDRESS + 100, listLength);
 }
 
-// ----------------------------------------------------------------------------
-
-// Receives complete bind setup
-void getBind(void) {
+static void performBind(void) {
     cc2500Strobe(CC2500_SRX); // enter in rx mode
 
     while (1) {
         if (GDO_1) {
             ccLen = cc2500ReadReg(CC2500_3B_RXBYTES | CC2500_READ_BURST) & 0x7F;
             if (ccLen) {
-                cc2500ReadFifo((uint8_t *)ccData, ccLen);
+                cc2500ReadFifo(ccData, ccLen);
                 if ((ccData[ccLen - 1] & 0x80)
                         && (ccData[2] == 0x01)
                         && (ccData[5] == 0x00)) {
                 }
             }
         }
+
+        wdt_reset();
     }
 
     listLength = 0;
-    uint8_t eol = FALSE;
+    uint8_t eol = 0;
     for (uint8_t bindIdx = 0x05; bindIdx <= 120; bindIdx += 5) {
         while (1) {
             if (GDO_1) {
                 ccLen = cc2500ReadReg(CC2500_3B_RXBYTES | CC2500_READ_BURST) & 0x7F;
                 if (ccLen) {
-                    cc2500ReadFifo((uint8_t *)ccData, ccLen);
+                    cc2500ReadFifo(ccData, ccLen);
                     if ((ccData[ccLen - 1] & 0x80)
                             && (ccData[2] == 0x01)
                             && (ccData[3] == txid[0])
                         for (uint8_t n = 0; n < 5; n++) {
                             //if (ccData[6 + n] == ccData[ccLen - 3]) {
                               if (ccData[6 + n] <= 3) {
-                                eol = TRUE;
+                                eol = 1;
                                 listLength = ccData[5] + n;
                                 break;
                             }
                     }
                 }
             }
+
+            wdt_reset();
         }
 
         if (eol) {
     cc2500Strobe(CC2500_SIDLE); // Back to idle
 }
 
-void loop() {
+static void nextChannel(uint8_t skip) {
+    channr += skip;
+    if (channr >= listLength) {
+        channr -= listLength;
+    }
+
+    cc2500WriteReg(CC2500_0A_CHANNR, hopData[channr]);
+    cc2500WriteReg(CC2500_23_FSCAL3, 0x89);
+}
+
+static void readBindingData() {
+    for (uint8_t i = 0; i < 2; i++) {
+        txid[i] = eeprom_read_byte(EEPROM_BASE_ADDRESS + i);
+    }
+
+    for (uint8_t i = 0; i < HOP_DATA_LENGTH; i++) {
+        hopData[i] = eeprom_read_byte(EEPROM_BASE_ADDRESS + 10 + i);
+    }
+
+    listLength = eeprom_read_byte(EEPROM_BASE_ADDRESS + 100);
+    frequencyOffsetHack = eeprom_read_byte(EEPROM_BASE_ADDRESS + 101);
+}
+
+static void writeBindingData() {
+    for (uint8_t i = 0; i < 2; i++) {
+        eeprom_write_byte(EEPROM_BASE_ADDRESS + i, txid[i]);
+    }
+
+    for (uint8_t i = 0; i < HOP_DATA_LENGTH; i++) {
+        eeprom_write_byte(EEPROM_BASE_ADDRESS + 10 + i, hopData[i]);
+    }
+
+    eeprom_write_byte(EEPROM_BASE_ADDRESS + 100, listLength);
+}
+
+void rxReceivePacket() {
     time_t time = timerGet();
 
     if (missingPackets > FAILSAFE_MISSING_PACKET) {
-        failed = TRUE;
+        failed = 1;
         missingPackets = 0;
     }
 
                 nextChannel(1);
             break;
         }
+
         if (GDO_1) {
             ccLen = cc2500ReadReg(CC2500_3B_RXBYTES | CC2500_READ_BURST) & 0x7F;
-            if (ccLen > 20)
+            if (ccLen > 20) {
                 ccLen = 20;
+            }
             if (ccLen) {
                 cc2500ReadFifo((uint8_t *)ccData, ccLen);
                 if (ccData[ccLen - 1] & 0x80) { // Only if correct CRC
                     missingPackets = 0;
-                    if (ccData[0] == 0x11) { // Correct length
-                        if ((ccData[1] == txid[0]) && (ccData[2] == txid[1])) { // Only if correct txid
-                            packet = TRUE;
-                            //sei();
+                    if ((ccData[0] == 0x11) // Correct length
+                            && (ccData[1] == txid[0]) // Correct txid
+                            && (ccData[2] == txid[1])) {
+                        packet = 1;
 
 #ifdef RSSI_OVER_PPM
-                            int rssi_dec = cc2500ReadReg(CC2500_34_RSSI | CC2500_READ_BURST);
-                            if (rssi_dec < 128) {
-                                rssi = ((rssi_dec / 2) - rssi_offset) & 0x7f;
-                            } else {
-                                rssi = (((rssi_dec - 256) / 2)) - rssi_offset;
-                            }
-                            rssi = constrain(rssi, rssi_min, rssi_max);
+                        int rssi_dec = cc2500ReadReg(CC2500_34_RSSI | CC2500_READ_BURST);
+                        if (rssi_dec < 128) {
+                            rssi = ((rssi_dec / 2) - RSSI_OFFSET) & 0x7f;
+                        } else {
+                            rssi = (((rssi_dec - 256) / 2)) - RSSI_OFFSET;
+                        }
+                        rssi = constrain(rssi, RSSI_MIN, RSSI_MAX);
 #endif
 
-                            cc2500Strobe(CC2500_SIDLE);
-                            nextChannel(1);
-                            failed = FALSE;
-                            break;
-                        }
+                        cc2500Strobe(CC2500_SIDLE);
+                        nextChannel(1);
+                        failed = 0;
+                        break;
                     }
                 }
             }
         }
+
+        wdt_reset();
     }
 
-    if (packet == TRUE) {
-        packet = FALSE;
-        //cli();
+    if (packet != 0) {
+        packet = 0;
         c[0] = (uint16_t)(ccData[10] & 0x0F) << 8 | ccData[6];
         c[1] = (uint16_t)(ccData[10] & 0xF0) << 4 | ccData[7];
         c[2] = (uint16_t)(ccData[11] & 0x0F) << 8 | ccData[8];
         c[5] = (uint16_t)(ccData[16] & 0xF0) << 4 | ccData[13];
         c[6] = (uint16_t)(ccData[17] & 0x0F) << 8 | ccData[14];
         c[7] = (uint16_t)(ccData[17] & 0xF0) << 4 | ccData[15];
-        //sei();
 
         for (int i = 0; i < CHANNELS; i++) {
-            ppmBuffer[i] = 0.67 * c[i];
-            /*
-            if (ppmBuffer[i] < 900) {
-                ppmBuffer[i] = 1500;
-                //ppmBuffer[2] = 1000;
+            ppmBuffer[i] = PPM_SCALE * c[i];
+            if ((ppmBuffer[i] < 900) || (ppmBuffer[i] > 2100)) {
+                ppmBuffer[i] = 850;
             }
-            */
         }
 
 #ifdef RSSI_OVER_PPM
-        ppmBuffer[RSSI_OVER_PPM] = map(rssi, rssi_min, rssi_max, PPM_MIN, PPM_MAX);
+        ppmBuffer[RSSI_OVER_PPM] = map(rssi, RSSI_MIN, RSSI_MAX, PPM_MIN, PPM_MAX);
 #endif
+
+        cppmCopy(ppmBuffer);
     }
 
     cc2500Strobe(CC2500_SRX);
 }
 
-void tuning() {
-    cc2500Strobe(CC2500_SRX); // enter in rx mode
-    int count1 = 0;
-    while (1) {
-        count1++;
-        if (count >= 250) {
-            count = 0;
-        }
-        if (count1 > 3000) {
-            count1 = 0;
-            cc2500WriteReg(CC2500_0C_FSCTRL0, count);  // Frequency offset hack
-            count = count + 10;
-            //cc2500Strobe(CC2500_SRX);// enter in rx mode
-        }
-        if (GDO_1) {
-            ccLen = cc2500ReadReg(CC2500_3B_RXBYTES | CC2500_READ_BURST) & 0x7F;
-            if (ccLen) {
-                cc2500ReadFifo((uint8_t *)ccData, ccLen);
-                if (ccData[ccLen - 1] & 0x80) {
-                    if (ccData[2] == 0x01) {
-                        if (ccData[5] == 0x00) {
-                            break;
-                        }
-                    }
-                }
-            }
-        }
+static long map(long x, long in_min, long in_max, long out_min, long out_max) {
+    return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
+}
+
+static long constrain(long x, long min, long max) {
+    if (x < min) {
+        x = min;
     }
+    if (x > max) {
+        x = max;
+    }
+    return x;
 }