Further testing

include/main.h

 
 #include "serial.h"
 
-#define DEBUG_UART_MENU
+//#define DEBUG_UART_MENU
 
 #define debugWrite(x) serialWriteString(0, x);
 #define debugHex(x) serialWriteHex(0, x);
 
+#ifdef DEBUG_UART_MENU
 void uartMenu(void);
+#endif
 
 #else // DEBUG
 

src/main.c

  * main() method
  */
 
+#ifndef DEBUG
+// Only use without Arduino Bootloader!
+#define ENABLE_WATCHDOG
+#endif
+
 #include <avr/interrupt.h>
 #include <avr/wdt.h>
 
 #include "rx.h"
 #include "main.h"
 
+#ifdef ENABLE_WATCHDOG
 void watchdogBoot(void) __attribute__((naked)) __attribute__((section(".init3")));
 void watchdogBoot(void) {
     MCUSR = 0;
     wdt_disable();
 }
+#endif
 
 #ifdef DEBUG_UART_MENU
 void uartMenu(void) {
         debugWrite("s\n");
         break;
 
+#ifdef ENABLE_WATCHDOG
     case 'q': case 'Q':
         debugWrite("Resetting...\n\n");
-        wdt_enable(WDTO_15MS);
+        wdt_enable(WDTO_2S);
         for (;;) { }
         break;
+#endif
 
     default:
         debugWrite("Unknown command: '");
         debugWrite("Available commands:\n");
         debugWrite("  h - Help\n");
         debugWrite("  t - Time\n");
+#ifdef ENABLE_WATCHDOG
         debugWrite("  q - Reset\n");
+#endif
         break;
     }
 }
 #endif
 
     sei(); // Enable interrupts (required for timer)
+
+#ifdef ENABLE_WATCHDOG
     //wdt_enable(WDTO_250MS); // Trigger Watchdog after 250ms
     wdt_enable(WDTO_2S); // Trigger Watchdog after 2s
+#endif
 
     //debugWrite("RX reset.\n");
 

src/rx.c

  */
 
 #ifdef DEBUG
+
 //#define DEBUG_TEST_PART_VERSION
 //#define DEBUG_EEPROM_DATA_READ
+//#define DEBUG_EEPROM_DATA_WRITE
 //#define DEBUG_MISSING_PACKETS
 //#define DEBUG_PACKET_DUMP
 //#define DEBUG_PACKET_DUMP_TUNE
 //#define DEBUG_PACKET_DUMP_LIST
 //#define DEBUG_PPM_VALUES
 //#define DEBUG_ERROR_MESSAGES
-#define DEBUG_PACKET_DOT
+//#define DEBUG_MESSAGES
+//#define DEBUG_HOP_DATA
+
+#define DEBUG_SINGLE_CHARACTER_MESSAGES
+
+#define ALWAYS_PERFORM_BINDING
+
 #endif
 
 #include <stdint.h>
 #include "main.h"
 
 #define CHANNELS 8
-#define PPM_MIN 1000
-#define PPM_MAX 2000
 #define HOP_DATA_LENGTH 60
 #define EEPROM_BASE_ADDRESS 100
-#define MISSING_PACKET_DELAY 9
+#define MISSING_PACKET_DELAY 10 // was 9 originally
 #define SEEK_CHANNEL_SKIP   13
 #define MAX_MISSING_PACKET 20
 #define FAILSAFE_MISSING_PACKET 170
 
-//#define FAILSAFE_INVALID_VALUE 850
+#define FAILSAFE_INVALID_VALUE 850
 #define FAILSAFE_INVALID_VALUE_MINIMUM 900
 #define FAILSAFE_INVALID_VALUE_MAXIMUM 2100
 
 #define RSSI_OFFSET 71
 #define RSSI_MIN -103
 #define RSSI_MAX -96
+#define PPM_MIN 1000
+#define PPM_MAX 2000
 
 #define PPM_SCALE 2 / 3
 
 #define FREQ_SCAN_START_1 0x76
 #define FREQ_SCAN_START_0 0x00
 
-uint8_t ccData[27];
+uint8_t ccData[100]; // was 27, led to buffer overruns?!
 uint8_t ccLen;
 uint8_t packet = 0;
 uint8_t channr = 0;
 uint8_t txid[2];
 uint8_t counter = 0;
 uint8_t failed = 0;
-uint8_t frequencyOffsetHack = 0;
+uint16_t frequencyOffsetHack = 0;
 uint16_t c[CHANNELS];
 
 #ifdef FREQUENCY_SCAN
 static void tuning(void);
 static void performBind(void);
 static void nextChannel(uint8_t skip);
-static void readBindingData(void);
 static void writeBindingData(void);
 
+#ifndef ALWAYS_PERFORM_BINDING
+static void readBindingData(void);
+#endif
+
 void rxInit(void) {
     GDO_dir;
 
+#ifdef DEBUG_MESSAGES
     debugWrite("RX: initializing\n");
+#endif
 
     initialize(1); // binding
 
+#ifdef DEBUG_MESSAGES
     debugWrite("RX: binding\n");
+#endif
 
     binding();
 
+#ifdef DEBUG_MESSAGES
     debugWrite("RX: receiving\n");
+#endif
 
     initialize(0); // data
     cc2500WriteReg(CC2500_0A_CHANNR, hopData[channr]);// 0A - hop
     //cc2500WriteReg(CC2500_03_FIFOTHR,  0x0F); // 0x07?
 
     cc2500WriteReg(CC2500_09_ADDR, bind ? 0x03 : txid[0]);
-    //cc2500WriteReg(CC2500_09_ADDR, bind ? 0x00 : txid[0]);
 
+#ifdef DEBUG_MESSAGES
     debugWrite("CC2500: Entering IDLE mode...\n");
+#endif
 
     cc2500Strobe(CC2500_SIDLE); // Go to idle...
 
 }
 
 static void binding(void) {
+#ifndef ALWAYS_PERFORM_BINDING
     readBindingData();
     if ((txid[0] != 0xff) || (txid[1] != 0xff)) {
         // valid binding data found
         debugWrite("RX: found data in EEPROM!\n");
         return;
     }
+#endif
 
+#ifdef DEBUG_MESSAGES
     debugWrite("RX: no stored data, tuning...\n");
+#endif
 
     // No valid txid, forcing bind
     tuning();
     cc2500WriteReg(CC2500_0C_FSCTRL0, frequencyOffsetHack);
     eeprom_write_byte(EEPROM_BASE_ADDRESS + 101, frequencyOffsetHack);
 
+#ifdef DEBUG_EEPROM_DATA_WRITE
+    debugWrite("RX: Write EEPROM Frequency Offset Hack: ");
+    serialWriteUnsigned8(0, frequencyOffsetHack);
+    debugWrite("\n");
+#endif
+
+#ifdef DEBUG_MESSAGES
     debugWrite("RX: tuned, binding...\n");
+#endif
 
     performBind();
 }
     uint16_t frequencyOffsetTimer = 0;
     while (1) {
         frequencyOffsetTimer++;
-        if (frequencyOffsetTimer > 3000) {
-            frequencyOffsetTimer = 0;
-            cc2500WriteReg(CC2500_0C_FSCTRL0, frequencyOffsetHack);
-            if (frequencyOffsetHack <= 250) {
-                frequencyOffsetHack += 5;
-            } else {
-                frequencyOffsetHack = 0;
+        if (frequencyOffsetHack >= 250) {
+            frequencyOffsetHack = 0;
 
 #ifdef FREQUENCY_SCAN
-                if (freq0 < 255) {
-                    freq0++;
+            if (freq0 < 255) {
+                freq0++;
+            } else {
+                freq0 = 0;
+                if (freq1 < 255) {
+                    freq1++;
                 } else {
-                    freq0 = 0;
-                    if (freq1 < 255) {
-                        freq1++;
+                    freq1 = 0;
+                    if (freq2 < 255) {
+                        freq2++;
                     } else {
-                        freq1 = 0;
-                        if (freq2 < 255) {
-                            freq2++;
-                        } else {
-                            freq2 = 0;
-                        }
+                        freq2 = 0;
                     }
                 }
+            }
 
-                debugWrite("0x");
-                debugHex(freq2);
-                debugHex(freq1);
-                debugHex(freq0);
-                debugWrite("\n");
+            debugWrite("0x");
+            debugHex(freq2);
+            debugHex(freq1);
+            debugHex(freq0);
+            debugWrite("\n");
 
-                cc2500WriteReg(CC2500_0D_FREQ2, freq2);
-                cc2500WriteReg(CC2500_0E_FREQ1, freq1);
-                cc2500WriteReg(CC2500_0F_FREQ0, freq0);
+            cc2500WriteReg(CC2500_0D_FREQ2, freq2);
+            cc2500WriteReg(CC2500_0E_FREQ1, freq1);
+            cc2500WriteReg(CC2500_0F_FREQ0, freq0);
 #endif
-            }
+
+        }
+
+        if (frequencyOffsetTimer > 3000) {
+            frequencyOffsetTimer = 0;
+            cc2500WriteReg(CC2500_0C_FSCTRL0, frequencyOffsetHack);
+            frequencyOffsetHack += 10;
             //cc2500Strobe(CC2500_SRX); // enter in rx mode
         }
 
                 debugWrite("):\n");
                 for (uint8_t i = 0; i < ccLen; i++) {
                     debugWrite("0x")
-                    serialWriteHex(0, ccData[i]);
+                    debugHex(ccData[i]);
                     if (i < (ccLen - 1)) {
                         debugWrite(" ");
                     } else {
                 }
 #endif
 
-                if ((ccData[ccLen - 1] & 0x80)
+                if ((ccData[ccLen - 1] & CC2500_LQI_CRC_OK_BM)
                         && (ccData[2] == 0x01)
                         && (ccData[5] == 0x00)) {
+#ifdef DEBUG_MESSAGES
+                    debugWrite("RX: Tune: finished at: ");
+                    serialWriteUnsigned8(0, frequencyOffsetHack);
+                    debugWrite("!\n");
+#endif
+#ifdef DEBUG_SINGLE_CHARACTER_MESSAGES
+                    serialWrite(0, 't');
+#endif
                     break;
+                } else {
+#ifdef DEBUG_ERROR_MESSAGES
+                    if (!(ccData[ccLen - 1] & CC2500_LQI_CRC_OK_BM)) {
+                        debugWrite("RX: Tune: invalid CRC!\n");
+                    }
+                    if (ccData[2] != 0x01) {
+                        debugWrite("RX: Tune: invalid data[2]: ");
+                        serialWriteUnsigned8(0, ccData[2]);
+                        debugWrite(" != ");
+                        serialWriteUnsigned8(0, 0x01);
+                        debugWrite("\n");
+                    }
+                    if (ccData[5] != 0x00) {
+                        debugWrite("RX: Tune: invalid data[5]: ");
+                        serialWriteUnsigned8(0, ccData[5]);
+                        debugWrite(" != ");
+                        serialWriteUnsigned8(0, 0x00);
+                        debugWrite("\n");
+                    }
+#endif
+#ifdef DEBUG_SINGLE_CHARACTER_MESSAGES
+                    serialWrite(0, 'u');
+#endif
                 }
             }
         }
                 debugWrite("):\n");
                 for (uint8_t i = 0; i < ccLen; i++) {
                     debugWrite("0x")
-                    serialWriteHex(0, ccData[i]);
+                    debugHex(ccData[i]);
                     if (i < (ccLen - 1)) {
                         debugWrite(" ");
                     } else {
                 }
 #endif
 
-                if ((ccData[ccLen - 1] & 0x80)
+                if ((ccData[ccLen - 1] & CC2500_LQI_CRC_OK_BM)
                         && (ccData[2] == 0x01)
                         && (ccData[5] == 0x00)) {
                     txid[0] = ccData[3];
                     txid[1] = ccData[4];
+#ifdef DEBUG_MESSAGES
+                    debugWrite("RX: Bind: got txid: 0x");
+                    debugHex(txid[0]);
+                    debugWrite(" 0x");
+                    debugHex(txid[1]);
+                    debugWrite("\n");
+#endif
+#ifdef DEBUG_HOP_DATA
+                    debugWrite("RX: Bind: got hop list:\n");
+#endif
                     for (uint8_t n = 0; n < 5; n++) {
                         hopData[ccData[5] + n] = ccData[6 + n];
+#ifdef DEBUG_HOP_DATA
+                        serialWriteUnsigned8(0, ccData[5] + n);
+                        debugWrite(": ");
+                        serialWriteUnsigned8(0, ccData[6 + n]);
+                        debugWrite("\n");
+#endif
                     }
+#ifdef DEBUG_SINGLE_CHARACTER_MESSAGES
+                    serialWrite(0, 'b');
+#endif
                     break;
+                } else {
+#ifdef DEBUG_ERROR_MESSAGES
+                    if (!(ccData[ccLen - 1] & CC2500_LQI_CRC_OK_BM)) {
+                        debugWrite("RX: Bind: invalid CRC!\n");
+                    }
+                    if (ccData[2] != 0x01) {
+                        debugWrite("RX: Bind: invalid data[2]: ");
+                        serialWriteUnsigned8(0, ccData[2]);
+                        debugWrite(" != ");
+                        serialWriteUnsigned8(0, 0x01);
+                        debugWrite("\n");
+                    }
+                    if (ccData[5] != 0x00) {
+                        debugWrite("RX: Bind: invalid data[5]: ");
+                        serialWriteUnsigned8(0, ccData[5]);
+                        debugWrite(" != ");
+                        serialWriteUnsigned8(0, 0x00);
+                        debugWrite("\n");
+                    }
+#endif
+#ifdef DEBUG_SINGLE_CHARACTER_MESSAGES
+                    serialWrite(0, 'c');
+#endif
                 }
             }
         }
 #endif
     }
 
+#ifdef DEBUG_MESSAGES
     debugWrite("RX: got hop data, reading list...\n");
+#endif
 
     listLength = 0;
     uint8_t eol = 0;
                     debugWrite("):\n");
                     for (uint8_t i = 0; i < ccLen; i++) {
                         debugWrite("0x")
-                        serialWriteHex(0, ccData[i]);
+                        debugHex(ccData[i]);
                         if (i < (ccLen - 1)) {
                             debugWrite(" ");
                         } else {
                     }
 #endif
 
-                    if ((ccData[ccLen - 1] & 0x80)
+                    if ((ccData[ccLen - 1] & CC2500_LQI_CRC_OK_BM)
                             && (ccData[2] == 0x01)
                             && (ccData[3] == txid[0])
                             && (ccData[4] == txid[1])
                             }
                             hopData[ccData[5] + n] = ccData[6 + n];
                         }
+#ifdef DEBUG_SINGLE_CHARACTER_MESSAGES
+                        serialWrite(0, 'l');
+#endif
                         break;
+                    } else {
+#ifdef DEBUG_SINGLE_CHARACTER_MESSAGES
+                        serialWrite(0, 'm');
+#endif
                     }
                 }
             }
         }
     }
 
+#ifdef DEBUG_MESSAGES
     debugWrite("RX: binding finished!\n");
+#endif
 
     writeBindingData();
     cc2500Strobe(CC2500_SIDLE); // Back to idle
     cc2500WriteReg(CC2500_23_FSCAL3, 0x89);
 }
 
+#ifndef ALWAYS_PERFORM_BINDING
 static void readBindingData() {
 #ifdef DEBUG_EEPROM_DATA_READ
-    debugWrite("RX: EEPROM TXID: ");
+    debugWrite("RX: Read 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]);
+        debugHex(txid[i]);
         debugWrite(" ");
 #endif
     }
 #endif
 
 #ifdef DEBUG_EEPROM_DATA_READ
-    debugWrite("RX: EEPROM Hop Data (");
+    debugWrite("RX: Read EEPROM Hop Data (");
     serialWriteUnsigned8(0, HOP_DATA_LENGTH);
     debugWrite(")\n");
 #endif
         hopData[i] = eeprom_read_byte(EEPROM_BASE_ADDRESS + 10 + i);
 #ifdef DEBUG_EEPROM_DATA_READ
         debugWrite("0x")
-        serialWriteHex(0, hopData[i]);
+        debugHex(hopData[i]);
         debugWrite(" ");
 #endif
     }
     frequencyOffsetHack = eeprom_read_byte(EEPROM_BASE_ADDRESS + 101);
 
 #ifdef DEBUG_EEPROM_DATA_READ
-    debugWrite("RX: EEPROM List Length: ");
+    debugWrite("RX: Read EEPROM List Length: ");
     serialWriteUnsigned8(0, listLength);
-    debugWrite("\nRX: EEPROM Frequency Offset Hack: ");
+    debugWrite("\nRX: Read EEPROM Frequency Offset Hack: ");
     serialWriteUnsigned8(0, frequencyOffsetHack);
     debugWrite("\n");
 #endif
 }
+#endif
 
 static void writeBindingData() {
+#ifdef DEBUG_EEPROM_DATA_WRITE
+    debugWrite("RX: Write EEPROM TXID: ");
+#endif
     for (uint8_t i = 0; i < 2; i++) {
         eeprom_write_byte(EEPROM_BASE_ADDRESS + i, txid[i]);
+#ifdef DEBUG_EEPROM_DATA_WRITE
+        debugWrite("0x")
+        debugHex(txid[i]);
+        debugWrite(" ");
+#endif
     }
+#ifdef DEBUG_EEPROM_DATA_WRITE
+    debugWrite("\n");
+#endif
 
+#ifdef DEBUG_EEPROM_DATA_WRITE
+    debugWrite("RX: Write EEPROM Hop Data (");
+    serialWriteUnsigned8(0, HOP_DATA_LENGTH);
+    debugWrite(")\n");
+#endif
     for (uint8_t i = 0; i < HOP_DATA_LENGTH; i++) {
         eeprom_write_byte(EEPROM_BASE_ADDRESS + 10 + i, hopData[i]);
+#ifdef DEBUG_EEPROM_DATA_WRITE
+        debugWrite("0x")
+        debugHex(hopData[i]);
+        debugWrite(" ");
+#endif
     }
+#ifdef DEBUG_EEPROM_DATA_WRITE
+    debugWrite("\n");
+#endif
 
     eeprom_write_byte(EEPROM_BASE_ADDRESS + 100, listLength);
+#ifdef DEBUG_EEPROM_DATA_WRITE
+    debugWrite("RX: Write EEPROM List Length: ");
+    serialWriteUnsigned8(0, listLength);
+    debugWrite("\n");
+#endif
 }
 
 void rxReceivePacket() {
     time_t time = timerGet();
 
-#ifdef DEBUG_MISSING_PACKETS
+#if defined(DEBUG_MISSING_PACKETS) || defined(DEBUG_SINGLE_CHARACTER_MESSAGES)
     static uint8_t packetMissingNotification = 0;
 #endif
 
     }
 
     while (1) {
-        if ((timerGet() - time) > MISSING_PACKET_DELAY) {
+        if ((timerGet() - time) >= MISSING_PACKET_DELAY) {
             missingPackets++;
             cc2500Strobe(CC2500_SIDLE);
             if (missingPackets > MAX_MISSING_PACKET) {
                         packetMissingNotification = 1;
                     }
 #endif
+#ifdef DEBUG_SINGLE_CHARACTER_MESSAGES
+                    if (packetMissingNotification < 1) {
+                        serialWrite(0, '1');
+                        packetMissingNotification = 1;
+                    }
+#endif
                 }
 
                 if (counter == (MAX_MISSING_PACKET << 2)) {
                         packetMissingNotification = 2;
                     }
 #endif
+#ifdef DEBUG_SINGLE_CHARACTER_MESSAGES
+                    if (packetMissingNotification < 2) {
+                        serialWrite(0, '2');
+                        packetMissingNotification = 2;
+                    }
+#endif
                     counter = 0;
                 }
             } else {
                     debugWrite("):\n");
                     for (uint8_t i = 0; i < ccLen; i++) {
                         debugWrite("0x")
-                        serialWriteHex(0, ccData[i]);
+                        debugHex(ccData[i]);
                         if (i < (ccLen - 1)) {
                             debugWrite(" ");
                         } else {
                     if ((ccData[0] == FRSKY_PACKET_LENGTH) // Correct length
                             && (ccData[1] == txid[0]) // Correct txid
                             && (ccData[2] == txid[1])) {
-#ifdef DEBUG_MISSING_PACKETS
+#if defined(DEBUG_MISSING_PACKETS) || defined(DEBUG_SINGLE_CHARACTER_MESSAGES)
                         packetMissingNotification = 0;
 #endif
 
                             debugWrite("\n");
                         }
 #endif
+#ifdef DEBUG_SINGLE_CHARACTER_MESSAGES
+                        serialWrite(0, 'r');
+#endif
                     }
                 } else {
 #ifdef DEBUG_ERROR_MESSAGES
                     debugWrite("RX: invalid CRC!\n");
 #endif
+#ifdef DEBUG_SINGLE_CHARACTER_MESSAGES
+                    serialWrite(0, 'q');
+#endif
                 }
             }
         }
         }
 #endif
 
-#ifdef DEBUG_PACKET_DOT
-        serialWrite(0, '.');
+#ifdef DEBUG_SINGLE_CHARACTER_MESSAGES
+        serialWrite(0, 'p');
 #endif
 
         cppmCopy(ppmBuffer);

src/spi.c

  * Bit-Banged SPI routines
  */
 
+//#define DEBUG_SLOW_SPI_TRAFFIC
+
 #include "spi.h"
 
 void spiInit(void) {
         SCK_on;
         NOP();
 
-#ifdef DEBUG
+#ifdef DEBUG_SLOW_SPI_TRAFFIC
         NOP();
         NOP();
         NOP();
         SCK_off;
         NOP();
 
-#ifdef DEBUG
+#ifdef DEBUG_SLOW_SPI_TRAFFIC
         NOP();
         NOP();
         NOP();