Added much more Debug output

include/main.h

 
 #include "serial.h"
 
+#define DEBUG_UART_MENU
+
 #define debugWrite(x) serialWriteString(0, x);
 #define debugHex(x) serialWriteHex(0, x);
 

makefile

 
 #LINKER = -Wl,--relax
 
-PROGRAMMER = avrisp2
-ISPPORT = usb
+#PROGRAMMER = avrisp2
+#ISPPORT = usb
+PROGRAMMER = arduino
+ISPPORT = /dev/tty.usbserial-A100OZQ1
 ISPBAUD = 57600
 
 TARGET = rx

src/cc2500.c

  * CC2500 helper routines
  */
 
+#ifdef DEBUG
+//#define DEBUG_STATUS
+#endif
+
 #include <util/delay.h>
 
 #include "spi.h"
 #include "cc2500.h"
 #include "main.h"
 
-#ifdef DEBUG
+#ifdef DEBUG_STATUS
 
 static void cc2500PrintStatusByte(uint8_t status) {
     static int16_t lastStatusByte = -1;
 void cc2500ReadRegisterMulti(uint8_t address, uint8_t data[], uint8_t length) {
     CS_off;
 
-#ifdef DEBUG
+#ifdef DEBUG_STATUS
     uint8_t status = spiWrite(address);
 #else
     spiWrite(address);
 
     CS_on;
 
-#ifdef DEBUG
+#ifdef DEBUG_STATUS
     cc2500PrintStatusByte(status);
 #endif
 }
 void cc2500WriteRegisterMulti(uint8_t address, const uint8_t data[], uint8_t length) {
     CS_off;
 
-#ifdef DEBUG
+#ifdef DEBUG_STATUS
     uint8_t status = spiWrite(CC2500_WRITE_BURST | address);
 #else
     spiWrite(CC2500_WRITE_BURST | address);
 
     CS_on;
 
-#ifdef DEBUG
+#ifdef DEBUG_STATUS
     cc2500PrintStatusByte(status);
 #endif
 }
 void cc2500WriteReg(uint8_t address, uint8_t data) {
     CS_off;
 
-#ifdef DEBUG
+#ifdef DEBUG_STATUS
     uint8_t status = spiWrite(address);
 #else
     spiWrite(address);
     spiWrite(data);
     CS_on;
 
-#ifdef DEBUG
+#ifdef DEBUG_STATUS
     cc2500PrintStatusByte(status);
 #endif
 }
         address |= CC2500_READ_SINGLE;
     }
 
-#ifdef DEBUG
+#ifdef DEBUG_STATUS
     uint8_t status = spiWrite(address);
 #else
     spiWrite(address);
     uint8_t result = spiRead();
     CS_on;
 
-#ifdef DEBUG
+#ifdef DEBUG_STATUS
     cc2500PrintStatusByte(status);
 #endif
 
 void cc2500Strobe(uint8_t address) {
     CS_off;
 
-#ifdef DEBUG
+#ifdef DEBUG_STATUS
     uint8_t status = spiWrite(address);
 #else
     spiWrite(address);
 
     CS_on;
 
-#ifdef DEBUG
+#ifdef DEBUG_STATUS
     cc2500PrintStatusByte(status);
 #endif
 }

src/main.c

     wdt_disable();
 }
 
-#ifdef DEBUG
+#ifdef DEBUG_UART_MENU
 void uartMenu(void) {
     if (!serialHasChar(0))  {
         return;
 #endif
 
 void main(void) {
-    cppmInit();
+    //cppmInit();
     timerInit();
 
 #ifdef DEBUG
     //wdt_enable(WDTO_250MS); // Trigger Watchdog after 250ms
     wdt_enable(WDTO_2S); // Trigger Watchdog after 2s
 
-    debugWrite("RX reset.\n");
+    //debugWrite("RX reset.\n");
 
     spiInit();
     rxInit();
 
-    debugWrite("RX ready!\n");
+    //debugWrite("RX ready!\n");
 
     for(;;) {
         wdt_reset();
         rxReceivePacket();
 
-#ifdef DEBUG
+#ifdef DEBUG_UART_MENU
         uartMenu();
 #endif
     }

src/rx.c

  * FrSky RX 2-way protocol
  */
 
+#ifdef DEBUG
+//#define DEBUG_TEST_PART_VERSION
+//#define DEBUG_EEPROM_DATA_READ
+//#define DEBUG_MISSING_PACKETS
+//#define DEBUG_PACKET_DUMP
+//#define DEBUG_PACKET_DUMP_TUNE
+//#define DEBUG_PACKET_DUMP_BIND
+//#define DEBUG_PACKET_DUMP_LIST
+//#define DEBUG_PPM_VALUES
+//#define DEBUG_ERROR_MESSAGES
+#define DEBUG_PACKET_DOT
+#endif
+
 #include <stdint.h>
 #include <avr/io.h>
 #include <avr/interrupt.h>
 #define SEEK_CHANNEL_SKIP   13
 #define MAX_MISSING_PACKET 20
 #define FAILSAFE_MISSING_PACKET 170
-#define RSSI_OVER_PPM 7
+
+//#define FAILSAFE_INVALID_VALUE 850
+#define FAILSAFE_INVALID_VALUE_MINIMUM 900
+#define FAILSAFE_INVALID_VALUE_MAXIMUM 2100
+
+//#define RSSI_OVER_PPM 7
 #define RSSI_OFFSET 71
 #define RSSI_MIN -103
 #define RSSI_MAX -96
-#define PPM_SCALE 0.67
+
+#define PPM_SCALE 2 / 3
+
+#define FRSKY_PACKET_LENGTH 0x11
+
+#define FREQ_ORIGINAL
+//#define FREQUENCY_SCAN
+
+// Original 0x5C 0x76 0x27
+#define FREQ_SCAN_START_2 0x5C
+#define FREQ_SCAN_START_1 0x76
+#define FREQ_SCAN_START_0 0x00
 
 uint8_t ccData[27];
 uint8_t ccLen;
 uint8_t counter = 0;
 uint8_t failed = 0;
 uint8_t frequencyOffsetHack = 0;
-uint16_t c[8];
-int rssi;
+uint16_t c[CHANNELS];
 
-// original 0x5C 0x76 0x27
-uint8_t freq2 = 0x5C, freq1 = 0x70, freq0 = 0x00;
+#ifdef FREQUENCY_SCAN
+uint8_t freq2 = FREQ_SCAN_START_2;
+uint8_t freq1 = FREQ_SCAN_START_1;
+uint8_t freq0 = FREQ_SCAN_START_0;
+#endif
 
 static uint16_t ppmBuffer[CHANNELS];
 
+#ifdef RSSI_OVER_PPM
+static int rssi;
+
 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);
+#endif
 
 static void initialize(uint8_t bind);
 static void binding(void);
 void rxInit(void) {
     GDO_dir;
 
-    debugWrite("CC2500: initializing\n");
+    debugWrite("RX: initializing\n");
 
     initialize(1); // binding
 
-    debugWrite("CC2500: binding\n");
+    debugWrite("RX: binding\n");
 
     binding();
 
-    debugWrite("CC2500: receiving\n");
+    debugWrite("RX: receiving\n");
 
     initialize(0); // data
     cc2500WriteReg(CC2500_0A_CHANNR, hopData[channr]);// 0A - hop
      * According to the internet, these are the default FrSky
      * FREQ values (0x5C7627) which should equal 2.404GHz.
      * The datasheet mentions Fcarrier = Fxosc * FREQ / 2^16
-     * Therefore, FrSky seems to be using 26MHz too...?
+     * Therefore, FrSky seems to be using 26MHz too.
      */
     cc2500WriteReg(CC2500_0D_FREQ2,    0x5C);
     cc2500WriteReg(CC2500_0E_FREQ1,    0x76);
     cc2500WriteReg(CC2500_0F_FREQ0,    0x27);
 #else
-    cc2500WriteReg(CC2500_0D_FREQ2,    0x5B); // freq2
-    cc2500WriteReg(CC2500_0E_FREQ1,    0x00); // freq1
-    cc2500WriteReg(CC2500_0F_FREQ0,    0x00); // freq0
+    cc2500WriteReg(CC2500_0D_FREQ2,    FREQ_SCAN_START_2);
+    cc2500WriteReg(CC2500_0E_FREQ1,    FREQ_SCAN_START_1);
+    cc2500WriteReg(CC2500_0F_FREQ0,    FREQ_SCAN_START_0);
 #endif
 
     cc2500WriteReg(CC2500_10_MDMCFG4,  0xAA);
 
     cc2500Strobe(CC2500_SIDLE); // Go to idle...
 
-#ifdef DEBUG
+#ifdef DEBUG_TEST_PART_VERSION
     uint8_t part = cc2500ReadReg(CC2500_30_PARTNUM);
     uint8_t version = cc2500ReadReg(CC2500_31_VERSION);
 
             } else {
                 frequencyOffsetHack = 0;
 
+#ifdef FREQUENCY_SCAN
                 if (freq0 < 255) {
                     freq0++;
                 } else {
                 cc2500WriteReg(CC2500_0D_FREQ2, freq2);
                 cc2500WriteReg(CC2500_0E_FREQ1, freq1);
                 cc2500WriteReg(CC2500_0F_FREQ0, freq0);
+#endif
             }
             //cc2500Strobe(CC2500_SRX); // enter in rx mode
         }
 
         if (GDO_1) {
-            debugWrite("Tuning: data flag has been set!\n");
-
-            //ccLen = cc2500ReadReg(CC2500_3B_RXBYTES | CC2500_READ_BURST) & 0x7F;
             ccLen = cc2500ReadReg(CC2500_3B_RXBYTES) & 0x7F;
             if (ccLen) {
-                debugWrite("Tuning: got data!\n");
                 cc2500ReadFifo(ccData, ccLen);
+
+#ifdef DEBUG_PACKET_DUMP_TUNE
+                debugWrite("RX: Tune Packet Dump (");
+                serialWriteUnsigned8(0, ccLen);
+                debugWrite("):\n");
+                for (uint8_t i = 0; i < ccLen; i++) {
+                    debugWrite("0x")
+                    serialWriteHex(0, ccData[i]);
+                    if (i < (ccLen - 1)) {
+                        debugWrite(" ");
+                    } else {
+                        debugWrite("\n");
+                    }
+                }
+#endif
+
                 if ((ccData[ccLen - 1] & 0x80)
                         && (ccData[2] == 0x01)
                         && (ccData[5] == 0x00)) {
                     break;
                 }
-            } else {
-                debugWrite("Tuning: no data?!\n");
             }
         }
 
         wdt_reset();
 
-#ifdef DEBUG
+#ifdef DEBUG_UART_MENU
         uartMenu();
 #endif
     }
 
     while (1) {
         if (GDO_1) {
-            //ccLen = cc2500ReadReg(CC2500_3B_RXBYTES | CC2500_READ_BURST) & 0x7F;
             ccLen = cc2500ReadReg(CC2500_3B_RXBYTES) & 0x7F;
             if (ccLen) {
                 cc2500ReadFifo(ccData, ccLen);
+
+#ifdef DEBUG_PACKET_DUMP_BIND
+                debugWrite("RX: Bind Packet Dump (");
+                serialWriteUnsigned8(0, ccLen);
+                debugWrite("):\n");
+                for (uint8_t i = 0; i < ccLen; i++) {
+                    debugWrite("0x")
+                    serialWriteHex(0, ccData[i]);
+                    if (i < (ccLen - 1)) {
+                        debugWrite(" ");
+                    } else {
+                        debugWrite("\n");
+                    }
+                }
+#endif
+
                 if ((ccData[ccLen - 1] & 0x80)
                         && (ccData[2] == 0x01)
                         && (ccData[5] == 0x00)) {
 
         wdt_reset();
 
-#ifdef DEBUG
+#ifdef DEBUG_UART_MENU
         uartMenu();
 #endif
     }
     for (uint8_t bindIdx = 0x05; bindIdx <= 120; bindIdx += 5) {
         while (1) {
             if (GDO_1) {
-                //ccLen = cc2500ReadReg(CC2500_3B_RXBYTES | CC2500_READ_BURST) & 0x7F;
                 ccLen = cc2500ReadReg(CC2500_3B_RXBYTES) & 0x7F;
                 if (ccLen) {
                     cc2500ReadFifo(ccData, ccLen);
+
+#ifdef DEBUG_PACKET_DUMP_LIST
+                    debugWrite("RX: List Packet Dump (");
+                    serialWriteUnsigned8(0, ccLen);
+                    debugWrite("):\n");
+                    for (uint8_t i = 0; i < ccLen; i++) {
+                        debugWrite("0x")
+                        serialWriteHex(0, ccData[i]);
+                        if (i < (ccLen - 1)) {
+                            debugWrite(" ");
+                        } else {
+                            debugWrite("\n");
+                        }
+                    }
+#endif
+
                     if ((ccData[ccLen - 1] & 0x80)
                             && (ccData[2] == 0x01)
                             && (ccData[3] == txid[0])
 
             wdt_reset();
 
-#ifdef DEBUG
+#ifdef DEBUG_UART_MENU
             uartMenu();
 #endif
         }
 }
 
 static void readBindingData() {
+#ifdef DEBUG_EEPROM_DATA_READ
+    debugWrite("RX: EEPROM TXID: ");
+#endif
     for (uint8_t i = 0; i < 2; i++) {
         txid[i] = eeprom_read_byte(EEPROM_BASE_ADDRESS + i);
+#ifdef DEBUG_EEPROM_DATA_READ
+        debugWrite("0x")
+        serialWriteHex(0, txid[i]);
+        debugWrite(" ");
+#endif
     }
+#ifdef DEBUG_EEPROM_DATA_READ
+    debugWrite("\n");
+#endif
 
+#ifdef DEBUG_EEPROM_DATA_READ
+    debugWrite("RX: EEPROM Hop Data (");
+    serialWriteUnsigned8(0, HOP_DATA_LENGTH);
+    debugWrite(")\n");
+#endif
     for (uint8_t i = 0; i < HOP_DATA_LENGTH; i++) {
         hopData[i] = eeprom_read_byte(EEPROM_BASE_ADDRESS + 10 + i);
+#ifdef DEBUG_EEPROM_DATA_READ
+        debugWrite("0x")
+        serialWriteHex(0, hopData[i]);
+        debugWrite(" ");
+#endif
     }
+#ifdef DEBUG_EEPROM_DATA_READ
+    debugWrite("\n");
+#endif
 
     listLength = eeprom_read_byte(EEPROM_BASE_ADDRESS + 100);
     frequencyOffsetHack = eeprom_read_byte(EEPROM_BASE_ADDRESS + 101);
+
+#ifdef DEBUG_EEPROM_DATA_READ
+    debugWrite("RX: EEPROM List Length: ");
+    serialWriteUnsigned8(0, listLength);
+    debugWrite("\nRX: EEPROM Frequency Offset Hack: ");
+    serialWriteUnsigned8(0, frequencyOffsetHack);
+    debugWrite("\n");
+#endif
 }
 
 static void writeBindingData() {
 void rxReceivePacket() {
     time_t time = timerGet();
 
+#ifdef DEBUG_MISSING_PACKETS
+    static uint8_t packetMissingNotification = 0;
+#endif
+
     if (missingPackets > FAILSAFE_MISSING_PACKET) {
         failed = 1;
         missingPackets = 0;
                 counter++;
 
                 if (counter > (MAX_MISSING_PACKET << 1)) {
-                    debugWrite("RX: missing packet notification!\n");
+#ifdef DEBUG_MISSING_PACKETS
+                    if (packetMissingNotification < 1) {
+                        debugWrite("RX: missing packet notification!\n");
+                        packetMissingNotification = 1;
+                    }
+#endif
                 }
 
-                if (counter == (MAX_MISSING_PACKET << 2)) counter = 0;
-                break;
-            } else
+                if (counter == (MAX_MISSING_PACKET << 2)) {
+#ifdef DEBUG_MISSING_PACKETS
+                    if (packetMissingNotification < 2) {
+                        debugWrite("RX: missing packet notification 2!\n");
+                        packetMissingNotification = 2;
+                    }
+#endif
+                    counter = 0;
+                }
+            } else {
                 nextChannel(1);
+            }
             break;
         }
 
         if (GDO_1) {
-            //ccLen = cc2500ReadReg(CC2500_3B_RXBYTES | CC2500_READ_BURST) & 0x7F;
             ccLen = cc2500ReadReg(CC2500_3B_RXBYTES) & 0x7F;
             if (ccLen > 20) {
+#ifdef DEBUG_ERROR_MESSAGES
+                debugWrite("RX: packet too long: ");
+                serialWriteUnsigned8(0, ccLen);
+                debugWrite("\n");
+#endif
                 ccLen = 20;
             }
             if (ccLen) {
                 cc2500ReadFifo((uint8_t *)ccData, ccLen);
-                if (ccData[ccLen - 1] & 0x80) { // Only if correct CRC
+                if (ccData[ccLen - 1] & CC2500_LQI_CRC_OK_BM) { // Only if correct CRC
+
+#ifdef DEBUG_PACKET_DUMP
+                    debugWrite("RX: Packet Dump (");
+                    serialWriteUnsigned8(0, ccLen);
+                    debugWrite("):\n");
+                    for (uint8_t i = 0; i < ccLen; i++) {
+                        debugWrite("0x")
+                        serialWriteHex(0, ccData[i]);
+                        if (i < (ccLen - 1)) {
+                            debugWrite(" ");
+                        } else {
+                            debugWrite("\n");
+                        }
+                    }
+#endif
+
                     missingPackets = 0;
-                    if ((ccData[0] == 0x11) // Correct length
+                    if ((ccData[0] == FRSKY_PACKET_LENGTH) // Correct length
                             && (ccData[1] == txid[0]) // Correct txid
                             && (ccData[2] == txid[1])) {
+#ifdef DEBUG_MISSING_PACKETS
+                        packetMissingNotification = 0;
+#endif
+
                         packet = 1;
 
 #ifdef RSSI_OVER_PPM
-                        //int rssi_dec = cc2500ReadReg(CC2500_34_RSSI | CC2500_READ_BURST);
                         int rssi_dec = cc2500ReadReg(CC2500_34_RSSI);
                         if (rssi_dec < 128) {
                             rssi = ((rssi_dec / 2) - RSSI_OFFSET) & 0x7f;
                         nextChannel(1);
                         failed = 0;
                         break;
+                    } else {
+#ifdef DEBUG_ERROR_MESSAGES
+                        if (ccData[0] != FRSKY_PACKET_LENGTH) {
+                            debugWrite("RX: invalid packet length: ");
+                            serialWriteUnsigned8(0, ccData[0]);
+                            debugWrite(" != ");
+                            serialWriteUnsigned8(0, FRSKY_PACKET_LENGTH);
+                            debugWrite("\n");
+                        }
+                        if (ccData[1] != txid[0]) {
+                            debugWrite("RX: invalid txid[0]: ");
+                            serialWriteUnsigned8(0, ccData[1]);
+                            debugWrite(" != ");
+                            serialWriteUnsigned8(0, txid[0]);
+                            debugWrite("\n");
+                        }
+                        if (ccData[2] == txid[1]) {
+                            debugWrite("RX: invalid txid[1]: ");
+                            serialWriteUnsigned8(0, ccData[2]);
+                            debugWrite(" != ");
+                            serialWriteUnsigned8(0, txid[1]);
+                            debugWrite("\n");
+                        }
+#endif
                     }
+                } else {
+#ifdef DEBUG_ERROR_MESSAGES
+                    debugWrite("RX: invalid CRC!\n");
+#endif
                 }
             }
         }
 
         wdt_reset();
 
-#ifdef DEBUG
+#ifdef DEBUG_UART_MENU
         uartMenu();
 #endif
     }
         c[7] = (uint16_t)(ccData[17] & 0xF0) << 4 | ccData[15];
 
         for (int i = 0; i < CHANNELS; i++) {
-            ppmBuffer[i] = PPM_SCALE * c[i];
-            if ((ppmBuffer[i] < 900) || (ppmBuffer[i] > 2100)) {
-                ppmBuffer[i] = 850;
+            ppmBuffer[i] = (uint16_t)((uint32_t)(c[i]) * PPM_SCALE);
+            if (ppmBuffer[i] < FAILSAFE_INVALID_VALUE_MINIMUM) {
+#ifdef FAILSAFE_INVALID_VALUE
+                ppmBuffer[i] = FAILSAFE_INVALID_VALUE;
+#else
+                ppmBuffer[i] = FAILSAFE_INVALID_VALUE_MINIMUM;
+#endif
+            }
+
+            if (ppmBuffer[i] > FAILSAFE_INVALID_VALUE_MAXIMUM) {
+#ifdef FAILSAFE_INVALID_VALUE
+                ppmBuffer[i] = FAILSAFE_INVALID_VALUE;
+#else
+                ppmBuffer[i] = FAILSAFE_INVALID_VALUE_MAXIMUM;
+#endif
             }
         }
 
         ppmBuffer[RSSI_OVER_PPM] = map(rssi, RSSI_MIN, RSSI_MAX, PPM_MIN, PPM_MAX);
 #endif
 
-        debugWrite("RX: packet received, sending CPPM!\n");
+#ifdef DEBUG_PPM_VALUES
+        debugWrite("RX: got packet @ ");
+        serialWriteUnsigned64(0, timerGet() / 1000);
+        debugWrite("s:\n");
+        for (uint8_t i = 0; i < CHANNELS; i++) {
+            serialWriteUnsigned8(0, i);
+            debugWrite(": ");
+            serialWriteUnsigned16(0, ppmBuffer[i]);
+            debugWrite(" - ");
+            serialWriteUnsigned16(0, c[i]);
+            debugWrite("\n");
+        }
+#endif
+
+#ifdef DEBUG_PACKET_DOT
+        serialWrite(0, '.');
+#endif
+
         cppmCopy(ppmBuffer);
     }
 
     cc2500Strobe(CC2500_SRX);
 }
 
+#ifdef RSSI_OVER_PPM
 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;
 }
     }
     return x;
 }
+#endif