Ran AStyle to make a bit more readable.

cc2500_BB_SPI.ino

@@ -0,0 +1,122 @@
+//-------------------------------
+//-------------------------------
+//CC2500 SPI routines
+//-------------------------------
+//-------------------------------
+#include <util/delay.h>
+
+void cc2500_readFifo(uint8_t *dpbuffer, int len)
+{
+    ReadRegisterMulti(CC2500_3F_RXFIFO | CC2500_READ_BURST, dpbuffer, len);
+}
+
+//----------------------
+static void ReadRegisterMulti(uint8_t address, uint8_t data[], uint8_t length)
+{
+    unsigned char i;
+
+    CS_off;
+    _spi_write(address);
+    for (i = 0; i < length; i++) {
+        data[i] = _spi_read();
+    }
+    CS_on;
+}
+
+//*********************************************
+
+void CC2500_WriteRegisterMulti(uint8_t address, const uint8_t data[], uint8_t length)
+{
+    CS_off;
+    _spi_write(CC2500_WRITE_BURST | address);
+    for (int i = 0; i < length; i++) {
+        _spi_write(data[i]);
+    }
+    CS_on;
+}
+
+void cc2500_writeFifo(uint8_t *dpbuffer, uint8_t len)
+{
+    cc2500_strobe(CC2500_SFTX);//0x3B
+    CC2500_WriteRegisterMulti(CC2500_3F_TXFIFO, dpbuffer, len);
+    cc2500_strobe(CC2500_STX);//0x35
+}
+
+//--------------------------------------
+void _spi_write(uint8_t command)
+{
+    uint8_t n = 8;
+    SCK_off;//SCK start low
+    MO_off;
+    while (n--) {
+        if (command & 0x80)
+            MO_on;
+        else
+            MO_off;
+        SCK_on;
+        NOP();
+        SCK_off;
+        command = command << 1;
+    }
+    MO_on;
+}
+
+//----------------------------
+void cc2500_writeReg(uint8_t address, uint8_t data)  //same as 7105
+{
+    CS_off;
+    _spi_write(address);
+    NOP();
+    _spi_write(data);
+    CS_on;
+}
+
+uint8_t _spi_read(void)
+{
+    uint8_t result;
+    uint8_t i;
+    result = 0;
+    for (i = 0; i < 8; i++) {
+        if (MI_1) ///
+            result = (result << 1) | 0x01;
+        else
+            result = result << 1;
+        SCK_on;
+        NOP();
+        SCK_off;
+        NOP();
+    }
+    return result;
+}
+
+//--------------------------------------------
+unsigned char cc2500_readReg(unsigned char address)
+{
+    uint8_t result;
+    CS_off;
+    address |= 0x80; //bit 7 =1 for reading
+    _spi_write(address);
+    result = _spi_read();
+    CS_on;
+    return (result);
+}
+//------------------------
+void cc2500_strobe(uint8_t address)
+{
+    CS_off;
+    _spi_write(address);
+    CS_on;
+}
+//------------------------
+void cc2500_resetChip(void)
+{
+    // Toggle chip select signal
+    CS_on;
+    _delay_us(30);
+    CS_off;
+    _delay_us(30);
+    CS_on;
+    _delay_us(45);
+    cc2500_strobe(CC2500_SRES);
+    _delay_ms(100);
+}

frsky_arduino_rx_complete.ino

@@ -0,0 +1,632 @@
+/*
+ * Frsky RX 2-way
+ *  By  Midelic
+ *  on RCGroups
+ * an adaptation from Kyrre Aalerud(Kreature)
+ * 2012 Frsky rx demo code
+ * http://www.rcgroups.com/forums/showthread.php?t=1667453
+ * Thanks also to Phracturedblue and his deviation firmware
+ **********************************
+ */
+
+#include <avr/interrupt.h>
+#include <EEPROM.h>
+#include "iface_cc2500.h"
+//#define DEBUG
+//#define DEBUG0
+//#define DEBUG1
+//#define DEBUG2
+//#define DEBUG3
+//#define DEBUG4
+//#define DEBUG5
+#define FAILSAFE
+#define SPIBB
+//#define SPIHW
+#if defined SPIHW
+#include <SPI.h>
+#endif
+
+#define chanel_number 8  //set the number of chanels
+#define SEEK_CHANSKIP   13
+#define MAX_MISSING_PKT 20
+//*****************************************
+#define PPM_FrLen 22500
+#define PPM_PulseLen 300
+#define default_servo_value 1500
+#define onState 1  //set polarity of the pulses: 1 is positive, 0 is negative
+#define sigPin 10
+
+#if defined(SPIBB)
+#define MO_pin 5 //D5
+#define MI_pin 6//D6
+#define SCLK_pin 4 //D4
+#define CS 2 //D2
+#define GDO_pin 3//D3  GDO0 pin
+//
+#define  SCK_on PORTD |= 0x10//D4
+#define  SCK_off PORTD &= 0xEF//D4
+
+#define  MO_on PORTD |= 0x20  //D5 
+#define  MO_off PORTD &= 0xDF //D5
+//
+#define  MI_1 (PIND & 0x40) == 0x40 //D6 input
+#define  MI_0 (PIND & 0x40) == 0x00 //D6
+//
+#define  CS_on PORTD |= 0x04 //D2
+#define  CS_off PORTD &= 0xFB //D2 
+//
+#define GDO_1 (PIND & 0x08) == 0x08 //D3 input
+#define GDO_0 (PIND & 0x08) == 0x00 //D3  
+//
+#endif
+
+#define bind_pin A0//C0 bind plug also servo8
+//
+#define Servo1_OUT 7 //Servo1(D7)
+#define Servo2_OUT 8 //Servo2(B0)
+#define Servo3_OUT 9 //Servo3(B1)
+#define Servo4_OUT 10 //Servo4(B2)//PPM pin
+#define Servo5_OUT 11 //Servo5(B3)
+#define Servo6_OUT 12 //Servo6(B4)
+#define Servo7_OUT 13 //Servo7(B5)
+#define Servo8_OUT A0 //Servo8(C0)
+//
+
+#define Servo1_OUT_HIGH PORTD |= _BV(7) //Servo1(D7)
+#define Servo2_OUT_HIGH PORTB |= _BV(0) //Servo2(B0)
+#define Servo3_OUT_HIGH PORTB |= _BV(1) //Servo3(B1)
+#define Servo4_OUT_HIGH PORTB |= _BV(2) //Servo4(B2)
+#define Servo5_OUT_HIGH PORTB |= _BV(3) //Servo5(B3)
+#define Servo6_OUT_HIGH PORTB |= _BV(4) //Servo6(B4)
+#define Servo7_OUT_HIGH PORTB |= _BV(5)//Servo7(B5) 
+#define Servo8_OUT_HIGH PORTC |= _BV(0) //Servo8(C0)
+//
+#define Servo_Ports_LOW PORTD &= 0x7F ; PORTB &= 0xc0; PORTC &=0xFE //all servos low
+//
+#define LED_pin A3
+#define LED_ON  PORTC |= _BV(3)
+#define LED_OFF  PORTC &= ~_BV(3)
+#define NOP() __asm__ __volatile__("nop")
+//*******************************************
+
+// Globals:
+static uint8_t ccData[27];
+static uint8_t ccLen;
+static boolean packet = false;
+//static uint16_t time;
+static uint8_t channr;
+static uint8_t missingPackets = 0;
+uint8_t calData[60];
+uint8_t hopData[60];
+uint8_t listLength;
+uint8_t txid[2];
+static uint8_t counter = 0;
+volatile uint16_t Servo_data[10] = {1500, 1500, 1500, 1500, 1500, 1500, 1500, 1500};
+volatile byte scale;
+static byte jumper1 = 0;
+static byte jumper2 = 0;
+volatile int ppm[chanel_number];
+static uint16_t total_servo_time = 0;
+static byte cur_chan_numb = 0;
+boolean debug = false;
+int count = 0;
+uint16_t c[8];
+
+//
+void setup()
+{
+
+#if defined(SPIBB)
+    pinMode(MO_pin, OUTPUT);//SI
+    pinMode(MI_pin, INPUT);//SO
+    pinMode(SCLK_pin, OUTPUT);//SCLK
+    pinMode(CS, OUTPUT);//CS output
+    pinMode(GDO_pin, INPUT); //GDO0 pin
+    SCK_off;//start sck low
+    MO_off;//low
+#endif
+    //
+    pinMode(LED_pin, OUTPUT);
+    CS_on;
+    //
+#if defined(SPIHW)
+    pinMode(CS, OUTPUT);
+    pinMode(GDO_pin, INPUT);
+    //
+    SPI.setClockDivider(SPI_CLOCK_DIV2);
+    SPI.setBitOrder( MSBFIRST);
+    SPI.begin();
+#endif
+    //
+    pinMode(Servo1_OUT, OUTPUT); //Servo1
+    pinMode(Servo2_OUT, OUTPUT); //Servo2
+    pinMode(Servo3_OUT, OUTPUT); //Servo3
+    pinMode(Servo4_OUT, OUTPUT); //Servo4
+    //
+    pinMode(Servo6_OUT, OUTPUT); //Servo6
+    pinMode(Servo7_OUT, OUTPUT); //Servo7
+    pinMode(Servo8_OUT, OUTPUT); //Servo8
+    //Servo8_OUT_HIGH;//bindpin pullup
+    //
+#if defined DEBUG
+    Serial.begin(115200);
+    int8_t i;
+    Serial.print("PartNum ");
+    i = cc2500_readReg(CC2500_30_PARTNUM + CC2500_READ_BURST);
+    Serial.println(i);
+    delay(10);
+    Serial.print("Version ");
+    i = cc2500_readReg(CC2500_31_VERSION + CC2500_READ_BURST);
+    Serial.println(i);
+#endif
+    //
+#if F_CPU == 16000000
+    scale = 2;
+#elif F_CPU == 8000000
+    scale = 1;
+#else
+#error // 8 or 16MHz only !
+#endif
+    //
+    initialize(1);//binding
+    binding();
+    pinMode(Servo8_OUT, OUTPUT); //Servo8.bind pin is set to output again.
+    initialize(0);//data
+    //
+    jumper1 = PPM_jumper(); // Check the possible jumper positions for changing the receiver mode.
+    //
+    if (jumper1 == 1) {
+        //initiallize default ppm values
+        for (int i = 0; i < chanel_number; i++) {
+            ppm[i] = default_servo_value;
+        }
+        pinMode(sigPin, OUTPUT);
+        digitalWrite(sigPin, !onState);  //set the PPM signal pin to the default state (off)
+    }
+    config_timer();
+    //
+    channr = 0;
+    cc2500_writeReg(CC2500_0A_CHANNR, hopData[channr]);//0A-hop
+    cc2500_writeReg(CC2500_23_FSCAL3, 0x89); //23-89
+    cc2500_strobe(CC2500_SRX);
+}
+
+
+
+void loop()
+{
+    unsigned long time = micros();
+#if defined(FAILSAFE)
+    if (missingPackets > 170) {
+        //**************************************
+        //noInterrupts();//
+        //digitalWrite(sigPin, LOW);
+        //Servo_Ports_LOW;
+        //**********************************************
+        missingPackets = 0;
+        int i;
+        for (i = 0; i < 8; i++) {
+            Servo_data[i] = 1500;
+            ppm[i] = 1500;
+            if (i == 2) {
+                Servo_data[2] = 1000; //THROTLE ON CHN3 here it can be changed Throttle on other channel
+                ppm[2] = 1000;
+            }
+        }
+    }
+#endif
+    while (1) {
+        if ((micros() - time) > 9000) {
+            missingPackets++;
+            cc2500_strobe(CC2500_SIDLE);
+            if (missingPackets > MAX_MISSING_PKT) {
+                nextChannel(SEEK_CHANSKIP);
+                LED_OFF;
+                counter++;
+                if (counter > (MAX_MISSING_PKT << 1))
+                    LED_ON;
+                if (counter == (MAX_MISSING_PKT << 2)) counter = 0;
+                break;
+            } else
+                nextChannel(1);
+            break;
+        }
+        if (GDO_1) {
+            ccLen = cc2500_readReg(CC2500_3B_RXBYTES | CC2500_READ_BURST) & 0x7F;
+            if (ccLen > 20)
+                ccLen = 20;//
+            if (ccLen) {
+                cc2500_readFifo((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();    ///////////////////////////////////////////////////////////////////////////////////////
+                            //int rssi = cc2500_readReg(CC2500_34_RSSI | CC2500_READ_BURST);//check RSSI
+                            cc2500_strobe(CC2500_SIDLE);
+                            nextChannel(1);
+                            LED_ON;
+                            break;
+                        }
+                    }
+                }
+
+            }
+
+        }
+    }
+
+    if (packet == true) {
+        packet = false;
+        debug = true;
+        //cli();
+        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[3] = (uint16_t)(ccData[11] & 0xF0) << 4 | ccData[9];
+        c[4] = (uint16_t)(ccData[16] & 0x0F) << 8 | ccData[12];
+        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 < 8; i++) {
+            Servo_data[i] = 0.67 * c[i];
+            if (Servo_data[i] < 900) { //added new
+                Servo_data[i] = 1500; //added new
+                Servo_data[2] = 1000;
+            }
+            ppm[i] = Servo_data[i];
+        }
+#if defined(DEBUG5)
+        //Serial.println(rssi);
+#endif
+#if defined(DEBUG0)
+        for (int i = 0; i < 8; i++) {
+            Serial.print(" ");
+            Serial.print(Servo_data[i]);
+            Serial.print(" ");
+        }
+        Serial.println(" ");
+#endif
+    }
+    //
+    cc2500_strobe(CC2500_SRX);
+    if (debug == true) {
+        debug = false;
+#if defined(DEBUG2)
+        Serial.println(ccData[3], HEX);
+#endif
+    }
+}
+
+void initialize(int bind)
+{
+    cc2500_resetChip();
+    cc2500_writeReg(CC2500_02_IOCFG0,   0x01);  // reg 0x02: RX complete interrupt(GDO0)
+    cc2500_writeReg(CC2500_17_MCSM1,    0x0C);  // reg 0x17:
+    cc2500_writeReg(CC2500_18_MCSM0,    0x18);  // reg 0x18:
+    cc2500_writeReg(CC2500_06_PKTLEN,   0x19);  // Leave room for appended status bytes
+    cc2500_writeReg(CC2500_08_PKTCTRL0, 0x05);  // reg 0x08:
+    cc2500_writeReg(CC2500_3E_PATABLE,  0xFF);  //
+    cc2500_writeReg(CC2500_0B_FSCTRL1,  0x08);  // reg 0x0B:
+    cc2500_writeReg(CC2500_0C_FSCTRL0,  0x00);  // reg 0x0C
+    cc2500_writeReg(CC2500_0D_FREQ2,    0x5C);  // reg 0x0D
+    cc2500_writeReg(CC2500_0E_FREQ1,    0x76);  // reg 0x0E
+    cc2500_writeReg(CC2500_0F_FREQ0,    0x27);  // reg 0x0F
+    cc2500_writeReg(CC2500_10_MDMCFG4,  0xAA);  // reg 0x10
+    cc2500_writeReg(CC2500_11_MDMCFG3,  0x39);  // reg 0x11
+    cc2500_writeReg(CC2500_12_MDMCFG2,  0x11);  // reg 0x12
+    cc2500_writeReg(CC2500_13_MDMCFG1,  0x23);  // reg 0x13
+    cc2500_writeReg(CC2500_14_MDMCFG0,  0x7A);  // reg 0x14
+    cc2500_writeReg(CC2500_15_DEVIATN,  0x42);  // reg 0x15
+    cc2500_writeReg(CC2500_19_FOCCFG,   0x16);  // reg 0x16
+    cc2500_writeReg(CC2500_1A_BSCFG,    0x6C);  // reg 0x1A
+    cc2500_writeReg(CC2500_1B_AGCCTRL2, 0x03);  // reg 0x1B
+    cc2500_writeReg(CC2500_1C_AGCCTRL1, 0x40);  // reg 0x1C
+    cc2500_writeReg(CC2500_1D_AGCCTRL0, 0x91);  // reg 0x1D
+    cc2500_writeReg(CC2500_21_FREND1,   0x56);  // reg 0x21:
+    cc2500_writeReg(CC2500_22_FREND0,   0x10);  // reg 0x22:
+    cc2500_writeReg(CC2500_23_FSCAL3,   0xA9);  // reg 0x23:
+    cc2500_writeReg(CC2500_24_FSCAL2,   0x05);  // reg 0x24:
+    cc2500_writeReg(CC2500_25_FSCAL1,   0x00);  // reg 0x25
+    cc2500_writeReg(CC2500_26_FSCAL0,   0x11);  // reg 0x26
+    cc2500_writeReg(CC2500_29_FSTEST,   0x59);  // reg 0x29
+    cc2500_writeReg(CC2500_2C_TEST2,    0x88);  // reg 0x2C
+    cc2500_writeReg(CC2500_2D_TEST1,    0x31);  // reg 0x2D
+    cc2500_writeReg(CC2500_2E_TEST0,    0x0B);  // reg 0x2E
+    cc2500_writeReg(CC2500_03_FIFOTHR,  0x0F);  // reg 0x03:
+    cc2500_writeReg(CC2500_09_ADDR, bind ? 0x03 : txid[0]);
+    cc2500_strobe(CC2500_SIDLE);    // Go to idle...
+
+    cc2500_writeReg(CC2500_07_PKTCTRL1, 0x0D);  // reg 0x07 hack: Append status, filter by address, auto-flush on bad crc, PQT=0
+    //cc2500_writeReg(CC2500_0C_FSCTRL0, 0);    // Frequency offset...
+    cc2500_writeReg(CC2500_0C_FSCTRL0, bind ? 0x00 : count); // Frequency offset hack
+    cc2500_writeReg(CC2500_0A_CHANNR, 0x00);
+}
+// Receives complete bind setup
+void getBind(void)
+{
+    cc2500_strobe(CC2500_SRX);//enter in rx mode
+    listLength = 0;
+    boolean eol = false;
+    //           len|bind |tx id|idx|h0|h1|h2|h3|h4|00|00|00|00|00|00|01
+    // Start by getting bind packet 0 and the txid
+    //        0  1   2  txid0(3) txid1()4    5  6  7   8  9 10 11 12 13 14 15 16 17
+    //ccdata    //11 03 01  d7       2d          00 00 1e 3c 5b 78 00 00 00 00 00 00 01
+    //11 03 01  19       3e          00 02 8e 2f bb 5c 00 00 00 00 00 00 01
+    while (1) {
+        if (GDO_1) {
+            ccLen = cc2500_readReg(CC2500_3B_RXBYTES | CC2500_READ_BURST) & 0x7F;
+            if (ccLen) {
+                cc2500_readFifo((uint8_t *)ccData, ccLen);
+                if (ccData[ccLen - 1] & 0x80) {
+                    if (ccData[2] == 0x01) {
+                        if (ccData[5] == 0x00) {
+                            txid[0] = ccData[3];
+                            txid[1] = ccData[4];
+                            for (uint8_t n = 0; n < 5; n++) {
+                                hopData[ccData[5] + n] = ccData[6 + n];
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+#if defined(DEBUG)
+    Serial.print(txid[0], HEX);
+    Serial.println(txid[1], HEX);
+#endif
+    for (uint8_t bindIdx = 0x05; bindIdx <= 120; bindIdx += 5) {
+        while (1) {
+            if (GDO_1) {
+                ccLen = cc2500_readReg(CC2500_3B_RXBYTES | CC2500_READ_BURST) & 0x7F;
+                if (ccLen) {
+                    cc2500_readFifo((uint8_t *)ccData, ccLen);
+                    if (ccData[ccLen - 1] & 0x80) {
+                        if (ccData[2] == 0x01) {
+                            if ((ccData[3] == txid[0]) && (ccData[4] == txid[1])) {
+                                if (ccData[5] == bindIdx) {
+                                    for (uint8_t n = 0; n < 5; n++) {
+                                        if (ccData[6 + n] == ccData[ccLen - 3]) {
+                                            eol = true;
+                                            listLength = ccData[5] + n;
+                                            break;
+                                        }
+                                        hopData[ccData[5] + n] = ccData[6 + n];
+                                    }
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#if defined(DEBUG)
+        Serial.println(bindIdx / 5);
+#endif
+        if (eol) break; // End of list found, stop!
+    }
+#if defined(DEBUG)
+    for (uint8_t jumpIdx = 0; jumpIdx < (listLength); jumpIdx++) {
+        Serial.print(" ");
+        Serial.print(hopData[jumpIdx], HEX);
+        Serial.print(" ");
+    }
+    Serial.println(" ");
+#endif
+    Store_bind();
+    cc2500_strobe(CC2500_SIDLE);    // Back to idle
+}
+
+ISR(TIMER1_COMPA_vect)
+{
+    TCNT1 = 0;
+    if (jumper1 == 0) {
+        pinMode(Servo5_OUT, OUTPUT);
+        Servo_Ports_LOW;
+        //code for servo.
+        cur_chan_numb++;//next servo
+        if (cur_chan_numb < chanel_number) {
+            total_servo_time += Servo_data[cur_chan_numb] * scale;
+            OCR1A = Servo_data[cur_chan_numb] * scale;
+        } else {
+            OCR1A = PPM_FrLen * scale - total_servo_time;
+            cur_chan_numb = 0xff;
+            total_servo_time = 0;
+        }
+
+        switch (cur_chan_numb) {
+        case 0:
+            Servo1_OUT_HIGH;
+            break;
+        case 1:
+            Servo2_OUT_HIGH;
+            break;
+        case 2:
+            Servo3_OUT_HIGH;
+            break;
+        case 3:
+            Servo4_OUT_HIGH;
+            break;
+        case 4:
+            Servo5_OUT_HIGH;
+            break;
+        case 5:
+            Servo6_OUT_HIGH;
+            break;
+        case 6:
+            Servo7_OUT_HIGH;
+            break;
+        case 7:
+            Servo8_OUT_HIGH;
+            break;
+        }
+    } else {
+        static boolean state = true;
+        pinMode(sigPin, OUTPUT);
+        digitalWrite(sigPin, !onState);
+
+        if (state) {
+            digitalWrite(sigPin, onState);
+            OCR1A = PPM_PulseLen * scale;
+            state = false;
+        } else {
+            static byte cur_chan_numb;
+            static unsigned int calc_rest;
+            // digitalWrite(sigPin, !onState);//PPM on servo4 pin10
+            state = true;
+
+            if (cur_chan_numb >= chanel_number) {
+                cur_chan_numb = 0;
+                calc_rest = calc_rest + PPM_PulseLen;//
+                OCR1A = (PPM_FrLen - calc_rest) * scale;
+                calc_rest = 0;
+            } else {
+                OCR1A = (ppm[cur_chan_numb] - PPM_PulseLen) * scale;
+                calc_rest = calc_rest + ppm[cur_chan_numb];
+                cur_chan_numb++;
+            }
+        }
+    }
+}
+
+void config_timer()
+{
+    OCR1A = 50 * scale;
+    cli();
+    TCCR1A = 0; //
+    TCCR1B = 0;
+    TCCR1B |= (1 << WGM12);
+    TCCR1B |= (1 << CS11);
+    TIMSK1 |= (1 << OCIE1A);
+    sei();
+}
+
+void nextChannel(uint8_t skip)
+{
+    channr += skip;//
+    if (channr >= listLength) channr -= listLength;
+    cc2500_writeReg(CC2500_0A_CHANNR, hopData[channr]);
+    cc2500_writeReg(CC2500_23_FSCAL3, 0x89);
+
+}
+
+void binding()
+{
+    jumper2 = bind_jumper();
+    while (1) {
+        if (jumper2 == 0) { //bind complete or no bind
+            uint8_t i;
+            uint8_t adr = 100;
+            for (i = 0; i < 2; i++) {
+                txid[i] = EEPROM.read(adr + i);
+            }
+            for (i = 0; i < sizeof(hopData); i++) {
+                hopData[i] = EEPROM.read(adr + 10 + i);
+            }
+            listLength = EEPROM.read(adr + 100);
+            count = EEPROM.read(adr + 101);
+            break;
+        } else {
+            LED_ON;
+            tunning();
+            //count=0xC8;//for test
+            cc2500_writeReg(CC2500_0C_FSCTRL0, count);
+            int adr = 100;
+            EEPROM.write(adr + 101, count);
+            getBind();
+            while (1) {
+                LED_ON;
+                delay(500);
+                LED_OFF;
+                delay(500);
+            }
+        }
+    }
+}
+
+
+void tunning()
+{
+    cc2500_strobe(CC2500_SRX);//enter in rx mode
+    int count1 = 0;
+    while (1) {
+        count1++;
+        if (count >= 250) {
+            count = 0;
+        }
+        if (count1 > 3000) {
+            count1 = 0;
+            cc2500_writeReg(CC2500_0C_FSCTRL0, count);  // Frequency offset hack
+            count = count + 10;
+            //cc2500_strobe(CC2500_SRX);//enter in rx mode
+        }
+        if (GDO_1) {
+            ccLen = cc2500_readReg(CC2500_3B_RXBYTES | CC2500_READ_BURST) & 0x7F;
+            if (ccLen) {
+                cc2500_readFifo((uint8_t *)ccData, ccLen);
+                if (ccData[ccLen - 1] & 0x80) {
+                    if (ccData[2] == 0x01) {
+                        if (ccData[5] == 0x00) {
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+#if defined(DEBUG1)
+    Serial.println(count, HEX);
+#endif
+}
+
+
+
+void Store_bind()
+{
+    uint8_t i;
+    int adr = 100;
+    for (i = 0; i < 2; i++) {
+        EEPROM.write(adr + i, txid[i]);
+    }
+    for (i = 0; i < sizeof(hopData); i++) {
+        EEPROM.write(adr + 10 + i, hopData[i]);
+    }
+    EEPROM.write(adr + 100, listLength);
+}
+
+unsigned char PPM_jumper(void)
+{
+    // PPM Selection (jumper between Ch1 and ch3)
+    pinMode(Servo3_OUT, INPUT); //CH3 input
+    digitalWrite(Servo3_OUT, HIGH); // pull up
+    digitalWrite(Servo1_OUT, HIGH); // CH1 is HIGH
+    delayMicroseconds(1);
+    if ( digitalRead(Servo3_OUT) == HIGH) {
+        digitalWrite(Servo1_OUT, LOW); // CH1 is LOW
+        delayMicroseconds(1);
+        if (digitalRead(Servo3_OUT) == LOW) { // OK jumper plugged
+            pinMode(Servo3_OUT, OUTPUT);
+            return  1;
+        }
+    }
+    pinMode(Servo3_OUT, OUTPUT);
+
+    return  0; // servo PWM by default
+}
+
+//bind jumper
+unsigned char bind_jumper(void)
+{
+    pinMode(bind_pin, INPUT_PULLUP);//pull up
+    if ( digitalRead(bind_pin) == LOW) {
+        delayMicroseconds(1);
+        return 1;
+    }
+    return  0;
+}

iface_cc2500.h

@@ -0,0 +1,133 @@
+#ifndef _IFACE_CC2500_H_
+#define _IFACE_CC2500_H_
+
+enum {
+    CC2500_00_IOCFG2           = 0x00,        // GDO2 output pin configuration
+    CC2500_01_IOCFG1           = 0x01,        // GDO1 output pin configuration
+    CC2500_02_IOCFG0           = 0x02,        // GDO0 output pin configuration
+    CC2500_03_FIFOTHR          = 0x03,        // RX FIFO and TX FIFO thresholds
+    CC2500_04_SYNC1            = 0x04,        // Sync word, high byte
+    CC2500_05_SYNC0            = 0x05,        // Sync word, low byte
+    CC2500_06_PKTLEN           = 0x06,        // Packet length
+    CC2500_07_PKTCTRL1         = 0x07,        // Packet automation control
+    CC2500_08_PKTCTRL0         = 0x08,        // Packet automation control
+    CC2500_09_ADDR             = 0x09,        // Device address
+    CC2500_0A_CHANNR           = 0x0A,        // Channel number
+    CC2500_0B_FSCTRL1          = 0x0B,        // Frequency synthesizer control
+    CC2500_0C_FSCTRL0          = 0x0C,        // Frequency synthesizer control
+    CC2500_0D_FREQ2            = 0x0D,        // Frequency control word, high byte
+    CC2500_0E_FREQ1            = 0x0E,        // Frequency control word, middle byte
+    CC2500_0F_FREQ0            = 0x0F,        // Frequency control word, low byte
+    CC2500_10_MDMCFG4          = 0x10,        // Modem configuration
+    CC2500_11_MDMCFG3          = 0x11,        // Modem configuration
+    CC2500_12_MDMCFG2          = 0x12,        // Modem configuration
+    CC2500_13_MDMCFG1          = 0x13,        // Modem configuration
+    CC2500_14_MDMCFG0          = 0x14,        // Modem configuration
+    CC2500_15_DEVIATN          = 0x15,        // Modem deviation setting
+    CC2500_16_MCSM2            = 0x16,        // Main Radio Cntrl State Machine config
+    CC2500_17_MCSM1            = 0x17,        // Main Radio Cntrl State Machine config
+    CC2500_18_MCSM0            = 0x18,        // Main Radio Cntrl State Machine config
+    CC2500_19_FOCCFG           = 0x19,        // Frequency Offset Compensation config
+    CC2500_1A_BSCFG            = 0x1A,        // Bit Synchronization configuration
+    CC2500_1B_AGCCTRL2         = 0x1B,        // AGC control
+    CC2500_1C_AGCCTRL1         = 0x1C,        // AGC control
+    CC2500_1D_AGCCTRL0         = 0x1D,        // AGC control
+    CC2500_1E_WOREVT1          = 0x1E,        // High byte Event 0 timeout
+    CC2500_1F_WOREVT0          = 0x1F,        // Low byte Event 0 timeout
+    CC2500_20_WORCTRL          = 0x20,        // Wake On Radio control
+    CC2500_21_FREND1           = 0x21,        // Front end RX configuration
+    CC2500_22_FREND0           = 0x22,        // Front end TX configuration
+    CC2500_23_FSCAL3           = 0x23,        // Frequency synthesizer calibration
+    CC2500_24_FSCAL2           = 0x24,        // Frequency synthesizer calibration
+    CC2500_25_FSCAL1           = 0x25,        // Frequency synthesizer calibration
+    CC2500_26_FSCAL0           = 0x26,        // Frequency synthesizer calibration
+    CC2500_27_RCCTRL1          = 0x27,        // RC oscillator configuration
+    CC2500_28_RCCTRL0          = 0x28,        // RC oscillator configuration
+    CC2500_29_FSTEST           = 0x29,        // Frequency synthesizer cal control
+    CC2500_2A_PTEST            = 0x2A,        // Production test
+    CC2500_2B_AGCTEST          = 0x2B,        // AGC test
+    CC2500_2C_TEST2            = 0x2C,        // Various test settings
+    CC2500_2D_TEST1            = 0x2D,        // Various test settings
+    CC2500_2E_TEST0            = 0x2E,        // Various test settings
+
+// Status registers
+    CC2500_30_PARTNUM          = 0x30,        // Part number
+    CC2500_31_VERSION          = 0x31,        // Current version number
+    CC2500_32_FREQEST          = 0x32,        // Frequency offset estimate
+    CC2500_33_LQI              = 0x33,        // Demodulator estimate for link quality
+    CC2500_34_RSSI             = 0x34,        // Received signal strength indication
+    CC2500_35_MARCSTATE        = 0x35,        // Control state machine state
+    CC2500_36_WORTIME1         = 0x36,        // High byte of WOR timer
+    CC2500_37_WORTIME0         = 0x37,        // Low byte of WOR timer
+    CC2500_38_PKTSTATUS        = 0x38,        // Current GDOx status and packet status
+    CC2500_39_VCO_VC_DAC       = 0x39,        // Current setting from PLL cal module
+    CC2500_3A_TXBYTES          = 0x3A,        // Underflow and # of bytes in TXFIFO
+    CC2500_3B_RXBYTES          = 0x3B,        // Overflow and # of bytes in RXFIFO
+
+// Multi byte memory locations
+    CC2500_3E_PATABLE          = 0x3E,
+    CC2500_3F_TXFIFO           = 0x3F,
+    CC2500_3F_RXFIFO           = 0x3F,
+};
+
+// Definitions for burst/single access to registers
+#define CC2500_WRITE_SINGLE     0x00
+#define CC2500_WRITE_BURST      0x40
+#define CC2500_READ_SINGLE      0x80
+#define CC2500_READ_BURST       0xC0
+
+// Strobe commands
+#define CC2500_SRES             0x30        // Reset chip.
+#define CC2500_SFSTXON          0x31        // Enable and calibrate frequency synthesizer (if MCSM0.FS_AUTOCAL=1).
+                                            // If in RX/TX: Go to a wait state where only the synthesizer is
+                                            // running (for quick RX / TX turnaround).
+#define CC2500_SXOFF            0x32        // Turn off crystal oscillator.
+#define CC2500_SCAL             0x33        // Calibrate frequency synthesizer and turn it off
+                                            // (enables quick start).
+#define CC2500_SRX              0x34        // Enable RX. Perform calibration first if coming from IDLE and
+                                            // MCSM0.FS_AUTOCAL=1.
+#define CC2500_STX              0x35        // In IDLE state: Enable TX. Perform calibration first if
+                                            // MCSM0.FS_AUTOCAL=1. If in RX state and CCA is enabled:
+                                            // Only go to TX if channel is clear.
+#define CC2500_SIDLE            0x36        // Exit RX / TX, turn off frequency synthesizer and exit
+                                            // Wake-On-Radio mode if applicable.
+#define CC2500_SAFC             0x37        // Perform AFC adjustment of the frequency synthesizer
+#define CC2500_SWOR             0x38        // Start automatic RX polling sequence (Wake-on-Radio)
+#define CC2500_SPWD             0x39        // Enter power down mode when CSn goes high.
+#define CC2500_SFRX             0x3A        // Flush the RX FIFO buffer.
+#define CC2500_SFTX             0x3B        // Flush the TX FIFO buffer.
+#define CC2500_SWORRST          0x3C        // Reset real time clock.
+#define CC2500_SNOP             0x3D        // No operation. May be used to pad strobe commands to two
+                                            // bytes for simpler software.
+//----------------------------------------------------------------------------------
+// Chip Status Byte
+//----------------------------------------------------------------------------------
+
+// Bit fields in the chip status byte
+#define CC2500_STATUS_CHIP_RDYn_BM             0x80
+#define CC2500_STATUS_STATE_BM                 0x70
+#define CC2500_STATUS_FIFO_BYTES_AVAILABLE_BM  0x0F
+
+// Chip states
+#define CC2500_STATE_IDLE                      0x00
+#define CC2500_STATE_RX                        0x10
+#define CC2500_STATE_TX                        0x20
+#define CC2500_STATE_FSTXON                    0x30
+#define CC2500_STATE_CALIBRATE                 0x40
+#define CC2500_STATE_SETTLING                  0x50
+#define CC2500_STATE_RX_OVERFLOW               0x60
+#define CC2500_STATE_TX_UNDERFLOW              0x70
+
+//----------------------------------------------------------------------------------
+// Other register bit fields
+//----------------------------------------------------------------------------------
+#define CC2500_LQI_CRC_OK_BM                   0x80
+#define CC2500_LQI_EST_BM                      0x7F
+
+//void CC2500_WriteReg(u8 addr, u8 data);
+//u8 CC2500_ReadReg(u8 addr);
+//void CC2500_Reset();
+//void CC2500_Strobe(u8 cmd);
+//void CC2500_WriteData(u8 *packet, u8 length);
+//void CC2500_ReadData(u8 *dpbuffer, int len);
+#endif

readme.txt

@@ -0,0 +1 @@
+ with autotuning complete with 8 channels servo and PPM out