stackMasterSlaveSync.c

Go to the documentation of this file.

// don't change the order of the includes!
#include <chipcon/reg1010.h>

// include one of the two follwoing. cc1010eb.h for the evaluation board, and partCboard for the 
// teco partC board.
//#include <chipcon/cc1010eb.h>
#include <chipcon/partCboard.h>

#include <chipcon/hal.h>
#include <chipcon/sdccutils.h>
#include "../acltypes.h"
#include <chipcon/partCStack.h>

data byte i;


    //#define DEBUG_USE_UART
    
    #define DEBUG_USE_UART1_FOR_DUMPING
    
    //#define DEBUG_DUMP_RSSI_SAMPLES
    
    #define DEBUG_DUMP_RF_STATE

    //#define DEBUG_DUMP_SYNC_VALUES

    //#define DEBUG_DUMP_RF_STATISTICS

    //#define DEBUG_VERIFY_SCRAMBLING

    //#define DEBUG_ARBITRATION_TEST_0
    //#define DEBUG_ARBITRATION_TEST_PATTERN
    //#define DEBUG_ARBITRATION_TEST_COUNT
    
    #ifdef DEBUG_ARBITRATION_TEST_PATTERN
        #define DEBUG_ARBITRATION_TEST_ACTIVE
    #endif
    #ifdef DEBUG_ARBITRATION_TEST_COUNT
        #define DEBUG_ARBITRATION_TEST_ACTIVE
    #endif
    #ifdef DEBUG_ARBITRATION_TEST_0
        #define DEBUG_ARBITRATION_TEST_ACTIVE
    #endif


    // the possible states of the rf layer
    #define RF_STATE_MASTER BIN(00000001)

    #define RF_STATE_ALONE BIN(00000010)
    
    #define RF_STATE_IN_SYNC BIN(00000100)
    
    #define RF_STATE_TRAFFIC_GROUP BIN(00001000)
    
    #define RF_STATE_LONG_SEARCH_FOR_MASTER BIN(00010000)

    #define RF_STATE_MASTER_RIVAL_TEST BIN(00100000)
    
    #define RF_STATE_RUNNING BIN(10000000)
    
    data volatile byte rfState= 0;
    
    #ifdef DEBUG_USE_UART
    #ifdef DEBUG_DUMP_RF_STATE
        data volatile byte rfStateOld= 0xFF;
    #endif
    #endif
    
    #define RF_SYNC_MAX_SLOT_COUNT 10
    
    //#define RF_USE_ALONE_DETECTION
    
    #define RF_ALONE_TEST_FAILED_THRESHOLD 167
    
    #define RF_ALONE_DEEP_SLEEP

    #define RF_PREAMBLE_LENGTH_TX 20
    
    #define RF_PREAMBLE_LENGTH_RX 20
    
    #define RF_MAX_SYNC_JITTER 5769ul
    
    #define RF_SLOT_LENGTH_IN_US 36865ul
    
    #define RF_MASTER_SEARCH_SLOTS_STARTUP 50
    
    #define RF_MASTER_SEARCH_SLOTS_AFTER_ALONE 167
    
    #define RF_MAX_FAILED_SYNC_COUNT 6
    
    #define RF_MASTER_RIVAL_TEST_SYNC_COUNT 30
    
    #define RF_SYNC_ADDITIONAL_OFFSET 0x89B3

    #define RF_ARBITRATION_RSSI_THRESHOLD 0x64

    #define RF_ALONE_TEST_RSSI_THRESHOLD 0xC0
    
    #define RF_RENDEZVOUS_SYNC_START_HI 0x7C
    #define RF_RENDEZVOUS_SYNC_START_LO 0xC8
    
    #define RF_RENDEZVOUS_DATA_PACKET_START_HI 0x93
    #define RF_RENDEZVOUS_DATA_PACKET_START_LO 0x12
    
    #define RF_RENDEZVOUS_ARBITRATION_START_HI 0x71
    #define RF_RENDEZVOUS_ARBITRATION_START_LO 0x88
    
    #define RF_ARBITRATION_TIMER_TICS_OTHER_PERIODS 0x390
    

    
    #define RF_BUFFER_SIZE 64
    
    //#define RF_USE_TRAFFIC_INDICATION
    
    #define RF_RENDEZVOUS_TRAFFIC_INDICATION_HI 0x92
    #define RF_RENDEZVOUS_TRAFFIC_INDICATION_LO 0x60

    #define RF_RENDEZVOUS_ALONE_TEST_HI 0x8C
    #define RF_RENDEZVOUS_ALONE_TEST_LO 0xBA
    
    static byte rfSlotCount= 0;
    
    static byte rfSyncCount= 0;
    
    static byte rfFailedSyncCount= 0;
    
    data byte rfScramblerReg= BIN(01101100);
    
    data unsigned long randomNumberReg;
    
    unsigned short rfSlotsWithoutSignalReceived= 0;
    
    data unsigned short tEndAvg= 0;
    //data unsigned long rfAverageTEndBuffer;
    
    xdata TIMER_DATA periodDataSlot;
    xdata TIMER_DATA periodDataSyncByteReceiveTimeout;
    
    xdata signed short moduloTimer0;
    
    #ifdef DEBUG_USE_UART
    #ifdef DEBUG_DUMP_RSSI_SAMPLES

        xdata byte rssiSamples[16];
        unsigned short arbitrationGood= 0;
        unsigned short arbitrationBad= 0;
    #endif
    #endif
    
    RF_RXTXPAIR_SETTINGS code RF_SETTINGS = {
        0xA0, 0x2F, 0x52,    // Modem 0, 1 and 2
        0x76, 0x00, 0x00,    // Freq A
        0x58, 0x7A, 0x8D,    // Freq B
        0x01, 0xAB,          // FSEP 1 and 0
        0x40,                // PLL_RX
        0x30,                // PLL_TX
        0x6C,                // CURRENT_RX
        0xF3,                // CURRENT_TX
        0x32,                // FREND
        0x0F,                // PA_POW
        0x00,                // MATCH
        0x00,                // PRESCALER
    };
    xdata RF_RXTXPAIR_CALDATA RF_CALDATA;

    xdata byte rfFieldStrength;

    #ifdef RF_USE_ALONE_DETECTION
    #ifndef RF_ALONE_DEEP_SLEEP

        xdata unsigned short rfSlotsInAloneModeLeft;
    #endif
    #endif


 

    #define LL_PROTOCOL_VERSION     4
    #define LL_HEADER_SIZE          12
    #define LL_PAYLOAD_SIZE         64
    #define LL_TAIL_SIZE            2
    #define LL_FRAME_MAX_SIZE       (LL_HEADER_SIZE+LL_PAYLOAD_SIZE+LL_TAIL_SIZE) 

    #define LL_CRC16_POLY 0x1021
    
    #define LL_CRC16_INIT 0xFFFF
    
    #define LL_CRC_OK     0
    
    xdata byte LL_sequence_no;
    
    byte LL_slots_left;

    #define LL_STATE_SEND_SUCCESS           BIN(00000001)

    #define LL_STATE_CTRL_MESSAGE_INSERTED  BIN(00000010)

    #define LL_STATE_NEED_TO_SEND           BIN(00000100)

    #define LL_STATE_RECEIVE_BUFFER_LOCKED  BIN(00001000)

    #define LL_STATE_NEW_DATA               BIN(00010000)

    #define LL_STATE_PACKET_JUST_SENT       BIN(00100000)

    #define LL_STATE_PACKET_JUST_RECEIVED   BIN(01000000)

    #define LL_STATE_RUNNING                BIN(10000000)

    data volatile byte llState= 0;
    data static byte llStateOld= 0xFF;
    
    code nodeAddrType llEpromAddress= {10, 1, 0, 1, 10, 1, 2, 0};

    
    #define ACL_SUBSCRIPTIONLIST_LENGTH 8

    #define ACL_CONTROL_MESSAGES_TIMEOUT    30
    
    #define ACL_TYPE_ACM_H      ACL_TYPE_ACM_HI

    #define ACL_TYPE_ACM_L      ACL_TYPE_ACM_LO

    
    xdata byte ACL_subscriptions[ACL_SUBSCRIPTIONLIST_LENGTH][2];
    xdata boolean ACL_send_buffer_locked;
    xdata boolean ACL_subscribe_all;
    xdata boolean ACL_ACM_answers;      // answer on ACM messages like helo and so on
    xdata byte ACL_write_position;
    
    xdata boolean ACL_ignore_control_messages;
    xdata boolean ACL_pass_control_messages;



    xdata byte LL_header_received[LL_HEADER_SIZE];
    xdata byte LL_payload_received[LL_PAYLOAD_SIZE];
    xdata byte LL_payload_received_length;
    xdata byte LL_tail_received[LL_TAIL_SIZE];



    volatile xdata byte LL_header_receivebuffer[LL_HEADER_SIZE];
    volatile xdata byte LL_payload_receivebuffer[LL_PAYLOAD_SIZE];
    volatile xdata byte LL_payload_receivebuffer_length; 
    volatile xdata byte LL_tail_receivebuffer[LL_TAIL_SIZE];



    xdata byte LL_payload_send[LL_PAYLOAD_SIZE];
    xdata byte LL_payload_send_length; 



    xdata byte LL_header_sendbuffer[LL_HEADER_SIZE];
    xdata byte LL_payload_sendbuffer[LL_PAYLOAD_SIZE];
    xdata byte LL_payload_sendbuffer_length; 
    xdata byte LL_tail_sendbuffer[LL_TAIL_SIZE];


    xdata unsigned long statsRfSlotsInSync;

    xdata unsigned long statsRfSlotsNeedToSend;
    xdata unsigned long statsRfArbitrationWon;
    
    /* /// those of the statsRfSlotsNeedToSend where arbitration was lost
    xdata unsigned long statsRfArbitrationLost;
    xdata unsigned long statsRfDataPacketsReceivedNeedingToSend;

    xdata unsigned long statsRfArbitrationSingalDetected;
    xdata unsigned long statsRfArbitrationNoSingalDetected; */ 
    
    xdata unsigned long statsRfDataPacketsReceivedNotNeedingToSend; 

    #ifdef DEBUG_USE_UART
    #ifdef DEBUG_DUMP_RF_STATE

    void DebugDumpRfState() {
        if (rfState != rfStateOld || llState != llStateOld) {
            putchar((rfState & RF_STATE_RUNNING) ? 'R' : 'S');
            putchar('-');
            putchar((rfState & RF_STATE_MASTER_RIVAL_TEST) ? 'R' : '-');
            putchar((rfState & RF_STATE_LONG_SEARCH_FOR_MASTER) ? 'L' : '-');
            putchar((rfState & RF_STATE_TRAFFIC_GROUP) ? 'T' : '-');
            putchar((rfState & RF_STATE_IN_SYNC) ? 'Y' : '-');
            putchar((rfState & RF_STATE_ALONE) ? 'A' : '-');
            putchar((rfState & RF_STATE_MASTER) ? 'M' : 'S');
            DEBUG_SPACE;
            rfStateOld= rfState;
            putchar((llState & LL_STATE_RUNNING) ? 'R' : '-');
            putchar((llState & LL_STATE_PACKET_JUST_RECEIVED) ? 'J' : '-');
            putchar((llState & LL_STATE_PACKET_JUST_SENT) ? 'J' : '-');
            putchar((llState & LL_STATE_NEW_DATA) ? 'N' : '-');
            putchar((llState & LL_STATE_RECEIVE_BUFFER_LOCKED) ? 'L' : '-');
            putchar((llState & LL_STATE_NEED_TO_SEND) ? 'S' : '-');
            putchar((llState & LL_STATE_CTRL_MESSAGE_INSERTED) ? 'C' : '-');
            putchar((llState & LL_STATE_SEND_SUCCESS) ? 'S' : '-');
            DEBUG_NEWLINE;
            llStateOld= llState;
        }
    }
    #endif
    #endif
    
    #ifdef DEBUG_USE_UART
        void DebugDumpReceivedAclPacket() {
            int i, dataEnd;
            
            ACLLockReceiveBuffer();
    
            // dump last byte of sender address
            putchar('A');
            putchar(':');
            sendByteToUart(LL_header_received[3+7]);
            DEBUG_SPACE;
            // dump packet content
            for (i=0; i < LL_payload_received_length;) {
                sendByteToUart(LL_payload_received[i++]);
                sendByteToUart(LL_payload_received[i++]);
                dataEnd= i + LL_payload_received[i++];
                putchar(':');
                while (i < dataEnd && i < LL_payload_received_length)
                    sendByteToUart(LL_payload_received[i++]);
                DEBUG_SPACE;
            }
            DEBUG_NEWLINE;
        }
        
    #endif
    
    void putchar(char c) {
        #ifdef DEBUG_USE_UART
            #ifdef DEBUG_USE_UART1_FOR_DUMPING
                UART1_WAIT_AND_SEND(c);
            #else
                UART0_WAIT_AND_SEND(c);
            #endif
        #endif
    }

    void DebugBuildTestPacketACL() {
/*  
        byte i;
        // this is only testcode
    
        ACLAddNewType(ACL_TYPE_ACM_H,ACL_TYPE_ACM_L);
        ACLAddNewType(115,216); //helo
    
        ACLAddData(255);
        ACLAddData(255);
        ACLAddData(255);
        ACLAddData(255);
    
        ACLAddData(255);
        ACLAddData(255);
        ACLAddData(255);
        ACLAddData(255);
    
    
        //ACLAddNewType(100,100);
        //for (i=0;i<32;i++)
        // ACLAddData(i);
     */
    }


    #ifdef DEBUG_VERIFY_SCRAMBLING
    bool DebugScrambleAndDescrambleTest() {
        byte b, j;
        byte scrReg;
        
        // test scrambling and descrambling for some numbers
        j=0;
        //YLED= LED_ON;
        do {
            b= j;
            //YLED= ~YLED;
            
            // scramble b
            scrReg= rfScramblerReg;
            b= RFScramble(j);
            
            // descramble b
            rfScramblerReg= scrReg;
            b= RFDescramble(b);
    
            if (b != j) {
                //YLED= LED_OFF;
                return FALSE;
            }
    
            rfScramblerReg= scrReg;
        } while (++j);
        //YLED= LED_OFF;
        return TRUE;
    } 
    #endif
    
    /* 
    void waitUsingTimer2(TIMER_DATA *timeOutPeriodData) {
        TIMER2_RUN(FALSE);
        INT_SETFLAG(INUM_TIMER2, INT_CLR);
        halConfigTimerFast23(TIMER2|TIMER23_NO_INT_TIMER, timeOutPeriodData);
        TIMER2_RUN(TRUE);
    
        while (1) {
            if (INT_GETFLAG(INUM_TIMER2)) {
                INT_SETFLAG(INUM_TIMER2, INT_CLR);
                break;
            }
        }
    }
    */
    
    #ifdef DEBUG_USE_UART
    #ifdef DEBUG_DUMP_RF_STATISTICS

    void DebugResetStats() {
        statsRfSlotsInSync= 0;

        statsRfSlotsNeedToSend= 0;
        statsRfArbitrationWon= 0;

        statsRfDataPacketsReceivedNotNeedingToSend= 0; 
    }
    
    void DebugDumpStats() {
        //sendUlongToUart(statsRfSlotsInSync);
        //putchar(':');
        sendUlongToUart(statsRfSlotsNeedToSend);
        putchar(':');
        sendUlongToUart(statsRfArbitrationWon);
        putchar(':');
        sendUlongToUart(statsRfDataPacketsReceivedNotNeedingToSend);
        DEBUG_NEWLINE;
    }
    #endif
    #endif




    void ParticleInit() {
        #ifdef DEBUG_USE_UART
            byte i;
        #endif
        
        // Initialize peripherals
        //WDT_ENABLE(FALSE);
        // for BIZARRE reasons, the watchdog timer is only disabled when the
        // WDT register is set directly and TWICE (???). found this out by trial and error.
        WDT= 0x13;  
        WDT= 0x13;
        
        // Set optimum settings for speed and low power consumption
        MEM_NO_WAIT_STATES();
        FLASH_SET_POWER_MODE(FLASH_STANDBY_BETWEEN_READS);
    
        // setup leds
        RLED_OE(TRUE);
        YLED_OE(TRUE);
        GLED_OE(TRUE);
        BLED_OE(TRUE);
        RLED= YLED= GLED= BLED= LED_OFF;
        
        TIMER0_RUN(FALSE);
        
        // generate a truly random seed for the random number generator
        // rf must not be used when this happens
        RFInitRandom();
    
        #ifdef DEBUG_VERIFY_SCRAMBLING
            // make sure scrambling and descrambling macros work correctly
            if (!DebugScrambleAndDescrambleTest()) {
                RLED= LED_ON;
                while (1);
            } 
        #endif
        
        #ifdef DEBUG_USE_UART
        #ifdef DEBUG_DUMP_RSSI_SAMPLES
            for (i=0; i<3*8; i++) {
                rssiSamples[i]= 0;
            }
        #endif
        #endif
    
        #ifdef DEBUG_USE_UART
            // setup UART for serial debug messages
            #ifdef DEBUG_USE_UART1_FOR_DUMPING
                UART1_SETUP(57600, CC1010EB_CLKFREQ, UART_NO_PARITY | UART_TX_ONLY | UART_POLLED);
            #else
                UART0_SETUP(57600, CC1010EB_CLKFREQ, UART_NO_PARITY | UART_TX_ONLY | UART_POLLED);
            #endif  
            
            DEBUG_CLEAR_SCREEN;
            sendStringToUart("Welcome to the CC1010 Particle Sensor Node!\r\nOn this console you will see debug information. Have Fun!\r\n\r\nSync method: master slave\r\n\r\nRandom numbers:\r\n");
            
            for (i=0; i<10; i++) {
                sendByteToUart(RF_NEW_RANDOM_BYTE());
                DEBUG_SPACE;
            }
            DEBUG_NEWLINE;
        #endif
        
        // let the 32 kHz clock run continously
        X32_INPUT_SOURCE(X32_USING_CRYSTAL);
        X32_ENABLE(TRUE);
    }
    
    byte AppSelfTest(char* result) {
        int i;
        
        for (i=0; i<10; i++) {
            result[i]= RF_NEW_RANDOM_BYTE();
        }
        
        return TRUE;
    }


    void RFInit() {
        ulong tmp;
        
        // Calibration (now done in rfStart)
        // halRFCalib(&RF_SETTINGS, &RF_CALDATA);  
    
        // calculate timer periods for timer 2 (timeouts)
        halCalcTimerPeriod(RF_SLOT_LENGTH_IN_US, CC1010EB_CLKFREQ, &periodDataSlot);
        halCalcTimerPeriod(RF_MAX_SYNC_JITTER, CC1010EB_CLKFREQ, &periodDataSyncByteReceiveTimeout);
        
        // Set up timer 0 as the slot timer
        TIMER0_RUN(FALSE);
        tmp= halConfigTimer01(TIMER0|TIMER01_INT_TIMER, RF_SLOT_LENGTH_IN_US, CC1010EB_CLKFREQ, &moduloTimer0);
        #ifdef DEBUG_USE_UART
            sendStringToUart("\r\nTimer start val:\r\n");
            sendUshortToUart(moduloTimer0);
            DEBUG_NEWLINE;
        #endif

        // Turn on interrupts for timer0, turn off for timer 2
        INT_GLOBAL_ENABLE(INT_ON);
        INT_ENABLE(INUM_TIMER0, INT_ON);
        INT_ENABLE(INUM_TIMER2, INT_OFF);
        PA_POW= 0;
        
        // set current field strength from data structure
        rfFieldStrength= RF_SETTINGS.pa_pow;

        // Calibration
        halWait(200, CC1010EB_CLKFREQ);
        halRFCalib(&RF_SETTINGS, &RF_CALDATA);

        // the function halRFSetRxTxOff() has to be called at least once, because later, we use
        // the simpler functions RFstartRx and RFstartTx instead, that don't set the values needed.
        halRFSetRxTxOff(RF_RX, &RF_SETTINGS, &RF_CALDATA);
        halWait(200, CC1010EB_CLKFREQ);
        halRFSetRxTxOff(RF_TX, &RF_SETTINGS, &RF_CALDATA);
        halWait(200, CC1010EB_CLKFREQ);
        halRFSetRxTxOff(RF_OFF, &RF_SETTINGS, &RF_CALDATA);
        halWait(200, CC1010EB_CLKFREQ);

        // turn on ADC for RSSI reading (needs 200ms, because it waits until ADC has stabilized)
        halRFReadRSSIlevel(RSSI_MODE_INIT);
        ADC_POWER(FALSE);
        
    }
    
    void RFStart() {
        PA_POW= 0;
        
        // set initial rf state
        rfState= RF_STATE_RUNNING | RF_STATE_LONG_SEARCH_FOR_MASTER;  // RF_STATE_MASTER | RF_STATE_ALONE; //
        #ifndef RF_USE_TRAFFIC_INDICATION
            // if traffic indication is not used, the flag has to be set permanently, so that
            // all packets are sent and received immediately
            rfState|= RF_STATE_TRAFFIC_GROUP;
        #endif
        
        #ifdef RF_USE_ALONE_DETECTION
            rfSlotsWithoutSignalReceived= 0;
        #endif
        
        
        #ifdef DEBUG_USE_UART
        #ifdef DEBUG_DUMP_RF_STATE
            DebugDumpRfState();
        #endif
        #endif

        // start timer0
        INT_SETFLAG(INUM_TIMER0, INT_CLR);
        TIMER0_RUN(TRUE);
    }
    
    void RFStop() {
        // clear flag RF_STATE_RUNNING and all other flags
        rfState= 0; 
        // stop timer0
        TIMER0_RUN(FALSE);
        // stop sending
        RF_SET_MODE_SLEEP;
        // turn off rf power
        //PA_POW= 0;
    }
    
    void RFSetModeTransmit() {
        code byte *rfSettingsPtr= (code byte *)&RF_SETTINGS;
        unsigned short i;
    
        PA_POW= 0;
        
        // turn on transceiver for tx-ing
        PLL=rfSettingsPtr[12];             // pll_tx
        RFMAIN=0xF0;
        TEST5=0x10 | RF_CALDATA.vco_ao_tx;
        TEST6=0x3B;
        CURRENT=rfSettingsPtr[14];
    
        // Wait 200 usec before monitoring LOCK, slowly raise rf power to reduce spurious emission.
        // the data sheet says 200 usec for each step is optimal, but this is too long for our application
        // we use 50 us for each step. this should mitigate spurious emission.
        for(i=LOCK_MONITOR_DELAY; i>0; i--);

        /* for(i=LOCK_MONITOR_DELAY / 4; i>0; i--);
        if (rfFieldStrength >= 0x01)
            PA_POW= 0x01;
        for(i=LOCK_MONITOR_DELAY / 4; i>0; i--);
        if (rfFieldStrength >= 0x1E)
            PA_POW= 0x1E;
        for(i=LOCK_MONITOR_DELAY / 4; i>0; i--);
        if (rfFieldStrength >= 0x8F)
            PA_POW= 0x8F;
        for(i=LOCK_MONITOR_DELAY / 4; i>0; i--);
            PA_POW= rfFieldStrength; */

        // Wait for lock (much less than normal version!)
        for(i=LOCK_TIMEOUT; !(LOCK&0x01) && (i>0); i--);
        PA_POW= rfFieldStrength;
    }
    
    void RFSetModeReceive() {
        code byte *rfSettingsPtr= (code byte *)&RF_SETTINGS;
        unsigned short i;
        
        // turn on transceiver for rx-ing
        PLL=rfSettingsPtr[11];             // pll_rx
        RFMAIN=0x30;
        TEST5=0x10 | RF_CALDATA.vco_ao_rx;
        TEST6=0x20 | RF_CALDATA.chp_co_rx;
        CURRENT=rfSettingsPtr[13];
    
        // Wait 200 usec before monitoring LOCK
        // notice: had to change the value of constant LOCK_MONITOR_DELAY, because
        //   it produced a wait time of 418 us -> sdcc seems to have less efficient
        //   integer algorithms. perhaps keil sees that LOCK_MONITOR_DELAY is < 256
        //   and temporary uses i as a byte variable (?), which is much faster
        for(i=LOCK_MONITOR_DELAY; i>0; i--);
    
        // Wait for lock (much less than normal version!)
        for(i=LOCK_TIMEOUT; !(LOCK&0x01) && (i>0); i--);
    }
    
    void RFInitRandom() {
        byte a;
        
        randomNumberReg= 0;
        do {
            halRandomNumberGen(&a, 1);
        } while (bit_ones(a) < 2 || bit_ones(a) > 6);
        randomNumberReg=  (ulong)a << 24;
        do {
            halRandomNumberGen(&a, 1);
        } while (bit_ones(a) < 2 || bit_ones(a) > 6);
        randomNumberReg|= (ulong)a << 16;
        do {
            halRandomNumberGen(&a, 1);
        } while (bit_ones(a) < 2 || bit_ones(a) > 6);
        randomNumberReg|= (ulong)a << 8;
        do {
            halRandomNumberGen(&a, 1);
        } while (bit_ones(a) < 2 || bit_ones(a) > 6);
        randomNumberReg|= (ulong)a;
        
        for (a=0; a<128; a++)
            RF_NEW_RANDOM_BYTE();
    }
    
    byte RFDescramble(byte b) {
        byte i, scrReg;
        
        scrReg= rfScramblerReg;
        RF_DESCRAMBLE(b, scrReg, i);
        rfScramblerReg= scrReg;
        return b;
    }
    
    unsigned short RFReceivePacket(xdata TIMER_DATA *timeOutPeriodData, bool onlyDataPackets) {
        bool syncByteReceived, aclMatch;
        byte j, tHi, tLo, a, b, length, sync;
        unsigned short crc;
    
        // Turn on RF for RX, do this early, because it needs 200us to power up
        RFSetModeReceive();
        //halRFSetRxTxOff(RF_RX, &RF_SETTINGS, &RF_CALDATA);
        //BLED= ~BLED;
        RFCON|=0x01;  // Ensure that bytemode is selected
        RF_SET_PREAMBLE_COUNT(RF_PREAMBLE_LENGTH_RX);
        RF_SET_SYNC_BYTE(RF_SUITABLE_SYNC_BYTE);
        MODEM1=(MODEM1&0x03)|0x24;  // Make sure avg filter is free-running + 22 baud settling time
        INT_ENABLE(INUM_RF, INT_OFF);
        INT_SETFLAG(INUM_RF, INT_CLR);
        
        if (onlyDataPackets) {
            WAIT_FOR_TIMER0_EXACT(RF_RENDEZVOUS_DATA_PACKET_START_HI, RF_RENDEZVOUS_DATA_PACKET_START_LO);
        }
        BLED= LED_ON;  // start receiving
        RF_START_RX();

        // setup timer 2 as a no-interrupt timer for timeout of the master search process
        halConfigTimerFast23(TIMER2|TIMER23_NO_INT_TIMER, timeOutPeriodData);
        //halConfigTimer23(TIMER2|TIMER23_NO_INT_TIMER, 5000, CC1010EB_CLKFREQ);
        INT_SETFLAG(INUM_TIMER2, INT_CLR);
        TIMER2_RUN(TRUE);
        //BLED= ~BLED;
    
        // receive sync byte
        syncByteReceived= FALSE;
        while (1) {
            // Check if timer2 is finished so that we time out
            // alternatively, if interrupt for timer0 is enabled, also check if enough time is left 
            // before the next slot
            if (INT_GETFLAG(INUM_TIMER2) || (ET0 == INT_ON && !RF_SLOT_500_US_LEFT)) {
                // Clear interrupt and timeout
                INT_SETFLAG(INUM_TIMER2, INT_CLR);
                //RLED= ~RLED;
                break;
            }
            // Check if sync byte received
            if (INT_GETFLAG(INUM_RF)) {
                INT_SETFLAG(INUM_RF, INT_CLR); // Clear the flag
                syncByteReceived= TRUE;
                break;
            }
        }
        //BLED= ~BLED;
        //BLED= ~BLED;
        
        length= 0;
        if (syncByteReceived) {
            // turn on blue led when sync byte is received
            //BLED= ~BLED;
            //YLED= ~YLED;
    
            // Lock average filter
            RF_LOCK_AVERAGE_FILTER(TRUE);
    
            // get scrambler init
            //RF_SPI_RECEIVE_BYTE(rfScramblerReg);
            
            // receveive scrambled FF to train local descrambling register
            RF_SPI_RECEIVE_BYTE(a);
            a= RFDescramble(a);

            // get rf options byte
            RF_SPI_RECEIVE_BYTE(a);
            a= RFDescramble(a);
            
            // it's a sync packet if the lsb of the rf options byte is 1
            sync= a & 1;
            
            if (sync) { 
                // receive timestamp
                RF_SPI_RECEIVE_BYTE(tHi);
                tHi= RFDescramble(tHi);
                RF_SPI_RECEIVE_BYTE(tLo);
                tLo= RFDescramble(tLo);
                // receive the xor protection byte
                RF_SPI_RECEIVE_BYTE(j);
                j= RFDescramble(j);

                // if xor bit is correct
                if (j == tHi ^ tLo) {
                    TIMER0_RUN(FALSE);
                    a= TH0;
                    b= TL0;
                    TH0= tHi;
                    TL0= tLo;
                    TIMER0_RUN(TRUE);
                    
                    //GLED= ~GLED;
                    // turn rf off
                    RF_SET_MODE_SLEEP;   // shorter for halRFSetRxTxOff(RF_OFF, &RF_SETTINGS, &RF_CALDATA);
                    length= 1;

                    #ifdef DEBUG_DUMP_SYNC_VALUES
                    #ifdef DEBUG_USE_UART
                        // dump received tHi and tLo
                        sendByteToUart(tHi);
                        sendByteToUart(tLo);
                        DEBUG_SPACE;
        
                        // dump local tHi and tLo before setting
                        sendByteToUart(a);
                        sendByteToUart(b);
                        DEBUG_SPACE;
    
                        // dump difference between reported and set timer values
                        sendSignedByteToUart((int)tHi-(int)a,3);
                        sendSignedByteToUart((int)tLo-(int)b,3);
                        DEBUG_NEWLINE;
                    #endif
                    #endif
                }
            } else {
                // get physical payload length
                RF_SPI_RECEIVE_BYTE(length);
                length= RFDescramble(length);
                
                // read acl filter types
                RF_SPI_RECEIVE_BYTE(a);
                a= RFDescramble(a);

                RF_SPI_RECEIVE_BYTE(b);
                b= RFDescramble(b);
    
                // now we expect 4 "don't-care bytes" in order to have enough time to check local subscriptions 
                if (ACL_subscribe_all) {
                    // don't test anything
                    RF_SPI_RECEIVE_BYTE(a);
                    //BLED= ~BLED;
                    //BLED= ~BLED;
                    RF_SPI_RECEIVE_BYTE(a);
                    //BLED= ~BLED;
                    //BLED= ~BLED;
                    RF_SPI_RECEIVE_BYTE(a);
                    //BLED= ~BLED;
                    //BLED= ~BLED;
                    RF_SPI_RECEIVE_BYTE(a);
                    //BLED= ~BLED;
                    //BLED= ~BLED;
                } else {
                    aclMatch= FALSE;
                    // check subscriptions 0-3
                    for (i=0; i < ACL_SUBSCRIPTIONLIST_LENGTH; i+= ACL_SUBSCRIPTIONLIST_LENGTH / 4) {
                        // receive next 0
                        while(!(EXIF & 0x10)); EXIF&=~0x10;
                        for (j=i;j < i + ACL_SUBSCRIPTIONLIST_LENGTH / 4;j++) {
                            if ((ACL_subscriptions[j][0] == a) && (ACL_subscriptions[j][1] == b))
                                aclMatch= TRUE;
                            //BLED= ~BLED;
                            //BLED= ~BLED;
                        }
                    }
                    if (!aclMatch) {
                        RF_SET_MODE_SLEEP;
                        return 0;
                    }
                }
                
                // receive the incoming packet into the receivebuffer
                                
                // receive ll header
                for (j=0; j<12; j++) {
                    RF_SPI_RECEIVE_BYTE(b);
                    LL_header_receivebuffer[j]= RFDescramble(b);
                }

                // receive ll packet payload
                length= length-LL_HEADER_SIZE-LL_TAIL_SIZE;
                if (length > 64) {
                    // length is not in allowed range
                    RF_SET_MODE_SLEEP;
                    return 0;
                }
                for (j=0; j<length; j++) {
                    RF_SPI_RECEIVE_BYTE(b);
                    LL_payload_receivebuffer[j]= RFDescramble(b);
                }
                
                // receive ll tail
                for (j=0; j<LL_TAIL_SIZE; j++) {
                    RF_SPI_RECEIVE_BYTE(b);
                    LL_tail_receivebuffer[j]= RFDescramble(b);
                }
                // turn rf off
                RF_SET_MODE_SLEEP;   // shorter for halRFSetRxTxOff(RF_OFF, &RF_SETTINGS, &RF_CALDATA);
                
                // check the crc of the packet
                crc= LLCalcCRC16(LL_header_receivebuffer, LL_payload_receivebuffer, length);
                if ((crc >> 8) == LL_tail_receivebuffer[0] && (crc & 0xFF) == LL_tail_receivebuffer[1]) {
                    // crc was correct, so copy received packet to the "received" buffer
                    for (i=0; i<LL_HEADER_SIZE; i++) {
                        LL_header_received[i]= LL_header_receivebuffer[i];
                    }
                    for (i=0; i<length; i++) {
                        LL_payload_received[i]= LL_payload_receivebuffer[i];
                    }
                    for (i=0; i<LL_TAIL_SIZE; i++) {
                        LL_tail_received[i]= LL_tail_receivebuffer[i];
                    }
                } else {
                    // crc check failed
                    /* if (onlyDataPackets) {
                        putchar('c');
                    } */
                    RF_SET_MODE_SLEEP;
                    return 0;
                }               
            }
        } /* else {
            if (onlyDataPackets) {
                putchar('_');
            }
        } */
    
        // turn transceiver off
        RFCON&=~0x01;  // Ensure that bitmode is selected
        
        // don't write back the local scrambler register to the global variable:
        // each node should have it's own scrReg sequence
        // rfScramblerReg= scrReg;
    
        // stop timer 2 and start timer 3 if not already done
        INT_SETFLAG(INUM_TIMER2, INT_CLR);
        TIMER2_RUN(FALSE);
    
        BLED= LED_OFF; // end RFReceivePacket
        /* if (onlyDataPackets) {
            putchar('L');
            sendByteToUart(length);
            DEBUG_SPACE;
        } */
        if (sync && length == 1) {
            return 2;
        } else if (!sync && length > 0) { 
            return 1 + 256 * length;
        } else {
            return 0;
        }
    }
    
    
    byte RFArbitrationBit(bool sendOrListen, byte t0hi, byte t0lo) {
        byte i, sample1, paPow;

        if (sendOrListen) {
            // bit is 1, so send a short signal (2 bit)
            // turn on transceiver for tx-ing
            BLED= ~BLED;  // mark powering up the transceiver with an extra peak
            BLED= ~BLED;
            // increase transmission power for the small burst
            paPow= PA_POW;
            PA_POW= 0xF0;
            RFSetModeTransmit();
            RFBUF= 0xFF;
            BLED= ~BLED;  // mark finish of transceiver power-up and waiting for rendezvous point 
            BLED= ~BLED;
            // write rf buffer
            RFBUF= sample1= BIN(10101010); 
            
            // wait for next rendezvous point
            WAIT_FOR_TIMER0_EXACT(t0hi, t0lo);
            BLED= ~BLED;
            RF_START_TX();
            for (i=0; i<30; i++) { 
                sample1= ((sample1 << 1) | (sample1 >> 7));  // rotate left (not through carry, because it's faster!)
                while(!RF_READY_TO_SEND());
                RFBUF= sample1;
            }
            while(!RF_READY_TO_SEND());
            BLED= ~BLED;
            BLED= ~BLED;  // mark the 1 with an extra peak
            BLED= ~BLED;
            PA_POW= paPow;
            
            // we sent a 1, so we must send the highest number possible, because a low number could 
            // indicate that we lost the arbitration.
            return 255;
        } else {
            // bit is 0, so listen to the channel
            // turn on transceiver for rx-ing
            BLED= ~BLED;  // mark powering up the transceiver with an extra peak
            BLED= ~BLED;
            // turn on continuous sampling
            RFSetModeReceive(); // param true means fast
            RF_SET_PREAMBLE_COUNT(RF_PREDET_OFF);
            RF_START_RX();
            BLED= ~BLED;  // mark finish of transceiver power-up and waiting for rendezvous point 
            BLED= ~BLED;
            
            // wait for next rendezvous point
            WAIT_FOR_TIMER0_EXACT(t0hi, t0lo-5);
            // the next two lines must (for strange) reasons be there
            // because otherwise you would get the result of the last 
            // sample instead of the current result
            BLED= ~BLED;
            ADC_SAMPLE_SINGLE();
            ADC_GET_SAMPLE_8BIT();
            ADC_SAMPLE_SINGLE();
            sample1= ADC_GET_SAMPLE_8BIT();

            BLED= ~BLED;        // mark finish of sync slice
            // if the medium is not clear
            return sample1;
        }
    }

    byte RFArbitrationBitDebug(bool sendOrListen, byte t0hi, byte t0lo) {
        byte sample1;

        if (sendOrListen) {
            // bit is 1, so send a short signal (2 bit)
            // turn on transceiver for tx-ing
            BLED= ~BLED;  // mark powering up the transceiver with an extra peak
            BLED= ~BLED;
            RFSetModeTransmit();
            RFBUF= 0xFF;
            BLED= ~BLED;  // mark finish of transceiver power-up and waiting for rendezvous point 
            BLED= ~BLED;
            // write rf buffer
            RFBUF= sample1= BIN(10101010); 
            
            t0hi= TH0;
            t0lo= TL0; 
        } else {
            // bit is 0, so listen to the channel
            // turn on transceiver for rx-ing
            BLED= ~BLED;  // mark powering up the transceiver with an extra peak
            BLED= ~BLED;
            // turn on continuous sampling
            RFSetModeReceive(); // param true means fast
            RF_SET_PREAMBLE_COUNT(RF_PREDET_OFF);
            RF_START_RX();
            BLED= ~BLED;  // mark finish of transceiver power-up and waiting for rendezvous point 
            BLED= ~BLED;
            
            t0hi= TH0;
            t0lo= TL0; 
        }
        sendByteToUart(t0hi);
        putchar(':');
        sendByteToUart(t0lo);
        DEBUG_NEWLINE;
        return 0;  // return 0, the strongest signal possible
    }

    #ifdef DEBUG_ARBITRATION_TEST_COUNT
        byte arbitrationByteGlob= 0;
    #endif

    bool RFArbitration(bool tryToObtainMediaAccess) {
        bool success= TRUE;
        byte arbitrationByte, j, sample1, syncTimeH, syncTimeL;
        
        // get timer0 time when entering the function, should be the same on both nodes 
        //syncTimeH= TH0;
        //syncTimeL= TL0;
        BLED= LED_ON;  // start RFArbitration
        
        halConfigADC(ADC_MODE_SINGLE | ADC_REFERENCE_INTERNAL_1_25, CC1010EB_CLKFREQ, 0);
        ADC_SELECT_INPUT(ADC_INPUT_AD2);  // select RSSI input pin
        ADC_POWER(TRUE); // turn on adc
    
        // do CAN-like arbitration for media access
        // see param documentation for explanation
        #ifndef DEBUG_ARBITRATION_TEST_ACTIVE
            if (tryToObtainMediaAccess) {
                arbitrationByte= RF_NEW_RANDOM_BYTE();
                // if the node competes for the medium, he must send at least one 1, 
                // so 0 as arbitration byte is not allowed
                if (!arbitrationByte)
                    arbitrationByte= 1;
            } else {
                arbitrationByte= 0; 
            }
        #endif
        
        // for debugging, one of the following three assignments can be chosen for arbitrationByte
        #ifdef DEBUG_ARBITRATION_TEST_PATTERN
            arbitrationByte= BIN(10101010); // for debugging
        #endif
        #ifdef DEBUG_ARBITRATION_TEST_COUNT
            arbitrationByte= arbitrationByteGlob++; // for debugging
        #endif
        #ifdef DEBUG_ARBITRATION_TEST_0
            arbitrationByte= 0; // for debugging
        #endif
        
        /* syncTimeH= TH0;
        syncTimeL= TL0; 
        sendByteToUart(syncTimeH);
        putchar(':');
        sendByteToUart(syncTimeL);
        DEBUG_NEWLINE;
        RF_SET_MODE_SLEEP;
        return 0; */
        
        // synchronize. hint: the value of this sync time has been measured with the 
        // commented out block above
        syncTimeH= RF_RENDEZVOUS_ARBITRATION_START_HI;  // first period should be shorter
        syncTimeL= RF_RENDEZVOUS_ARBITRATION_START_LO;

        RFCON&=~0x01;  // Ensure that bitmode is selected
        for (j=0; j<8; j++) {

            sample1= RFArbitrationBit(bit_test(arbitrationByte, j), syncTimeH, syncTimeL);
            #ifdef DEBUG_USE_UART
            #ifdef DEBUG_DUMP_RSSI_SAMPLES
                rssiSamples[j]=   sample1;
                //rssiSamples[8+j]= sample2;
                //rssiSamples[3*j+2]= sample3;
            #endif
            #endif
            // if the medium is not clear
            if (sample1 < RF_ARBITRATION_RSSI_THRESHOLD) {
                success= FALSE;
                // we're out, so break
                #ifndef DEBUG_ARBITRATION_TEST_ACTIVE
                    break;  // for testing and calibration of the arbitration threshold, this line has to be commented out
                #endif
            }
            
            // this adds an equivalent of approx. 2.5 * 206 us to the variables for the next rendezvous point 
            syncTimeH= ((syncTimeH << 8 | syncTimeL) + RF_ARBITRATION_TIMER_TICS_OTHER_PERIODS) >> 8;
            syncTimeL+= RF_ARBITRATION_TIMER_TICS_OTHER_PERIODS;
        } 
        RF_SET_MODE_SLEEP;   // shorter for halRFSetRxTxOff(RF_OFF, &RF_SETTINGS, &RF_CALDATA);
        ADC_POWER(FALSE);
        return sample1;
        //BLED= LED_OFF;
        if (success)
            GLED= ~GLED;
        else
            RLED= ~RLED;
        #ifdef DEBUG_USE_UART
        #ifdef DEBUG_DUMP_RSSI_SAMPLES
            if (success) {
                arbitrationGood++;
            } else {
                arbitrationBad++;
            }
            sample1= 0;
            for (j=0; j<8; j++) {
                // if (rssiSamples[j] > 0xAF) {
                    // continue;
                // }
                sendByteToUart(j);
                DEBUG_SPACE;
                //putchar((bit_test(arbitrationByte, j) ? '1' : '0'));
                //DEBUG_SPACE;
                sendByteToUart(rssiSamples[j]);
                //sendByteToUart(rssiSamples[8+j]);
                //DEBUG_SPACE;
                /* if ((rssiSamples[j] < RF_ARBITRATION_RSSI_THRESHOLD)) {
                    putchar('1');
                    //sample1|= 1<<j;
                } else {
                    putchar('0');
                } */
                //putchar((bit_test(arbitrationByte,j)) ? '1' : '0');
                DEBUG_NEWLINE;
            } 
            //sendByteToUart(sample1);
            //DEBUG_SPACE;

            // this dumps the value of successful and not successful arbitration
            //sendUlongToUart(arbitrationGood);
            //DEBUG_SPACE;
            //sendUlongToUart(arbitrationBad);
            DEBUG_NEWLINE;
        #endif
        #endif
        BLED= LED_OFF;  // end RFArbitration
        return success;
    }
    
    
    #ifdef RF_USE_TRAFFIC_INDICATION
        void RFTrafficIndication() {
            bool result,tmp;
            
            BLED= LED_ON;  // start 
            halConfigADC(ADC_MODE_SINGLE | ADC_REFERENCE_INTERNAL_1_25, CC1010EB_CLKFREQ, 0);
            ADC_SELECT_INPUT(ADC_INPUT_AD2);  // select RSSI input pin
            ADC_POWER(TRUE); // turn on adc

            if (llState & LL_STATE_NEED_TO_SEND) {
                RFArbitrationBit(TRUE, RF_RENDEZVOUS_TRAFFIC_INDICATION_HI, RF_RENDEZVOUS_TRAFFIC_INDICATION_LO);
                result= TRUE;
            } else {
                // let's be pessimistic and compare the rssi value to the more conservative
                // alone test value. there is a trade off between unnecessary traffic groups
                // and lost packets. we choose reliable reception at the cost of some 
                // unnecessary traffic groups.
                tmp= RFArbitrationBit(FALSE, RF_RENDEZVOUS_TRAFFIC_INDICATION_HI, RF_RENDEZVOUS_TRAFFIC_INDICATION_LO);
                result= tmp < RF_ALONE_TEST_RSSI_THRESHOLD;
            }
            
            RF_SET_MODE_SLEEP;   // shorter for halRFSetRxTxOff(RF_OFF, &RF_SETTINGS, &RF_CALDATA);
            ADC_POWER(FALSE);
            BLED= LED_OFF;

            //putchar((result) ? 'T' : 't');
            //sendByteToUart(tmp);
            if (result)
                rfState|=  RF_STATE_TRAFFIC_GROUP;
            else
                rfState&= ~RF_STATE_TRAFFIC_GROUP;
        }
    #endif  
    
    #ifdef RF_USE_ALONE_DETECTION
        bool RFAloneTest() {
            bool result;
            byte tmp;
            
            BLED= LED_ON;  // start 
            halConfigADC(ADC_MODE_SINGLE | ADC_REFERENCE_INTERNAL_1_25, CC1010EB_CLKFREQ, 0);
            ADC_SELECT_INPUT(ADC_INPUT_AD2);  // select RSSI input pin
            ADC_POWER(TRUE); // turn on adc
            RFCON&=~0x01;  // Ensure that bitmode is selected
    
            if (rfState & RF_STATE_MASTER) {
                // as a master we try to receive a signal
                // let's be pessimistic and compare the rssi value to a high
                // alone test value. there is a trade off between 
                tmp= RFArbitrationBit(FALSE, RF_RENDEZVOUS_ALONE_TEST_HI, RF_RENDEZVOUS_ALONE_TEST_LO);
                result= tmp < RF_ALONE_TEST_RSSI_THRESHOLD;
                //putchar('r');
                //sendByteToUart(tmp);
                //putchar((result) ? '+' : '-');
                //DEBUG_SPACE;
            } else {
                // as a slave, we send a signal
                RFArbitrationBit(TRUE, RF_RENDEZVOUS_ALONE_TEST_HI, RF_RENDEZVOUS_ALONE_TEST_LO);
                result= TRUE;
                //putchar('s');
            }

            RF_SET_MODE_SLEEP;   // shorter for halRFSetRxTxOff(RF_OFF, &RF_SETTINGS, &RF_CALDATA);
            ADC_POWER(FALSE);
            BLED= LED_OFF;
            return result;
        }
    #endif
        
    byte RFAloneRandomNumberOfSeconds() {
        // returns a number betwenn 10 and 25 (including both)
        return 10 + (RF_NEW_RANDOM_BYTE() >> 4);
    }
    
    unsigned short RFAloneRandomNumberOfSlots() {
        // returns a number betwenn 10 and 26 (including both)
        return 333 + ((RF_NEW_RANDOM_BYTE() << 8)+ RF_NEW_RANDOM_BYTE()) % 534;
    }   
    
    void RFLowPowerSleep(byte sleepTime) {
        byte i;
        
        sendByteToUart(sleepTime);
        DEBUG_NEWLINE;
        
        TIMER0_RUN(FALSE);
        RLED= GLED= LED_OFF;
        YLED= LED_OFF;

        // config timer 2 for a period of 1 second in X32 clock mode
        // this will result in calling the dummy isr ISR
        // set timer 2 to high prio so that it can interrupt the ISR of timer0 where we are currently in.
        INT_PRIORITY(INUM_TIMER2, INT_HIGH);
        halConfigTimer23(TIMER2 | TIMER23_INT_TIMER, 1000000, CC1010EB_LOW_CLKFREQ); 
        
        MAIN_CLOCK_SET_SOURCE(CLOCK_X32);
        XOSC_ENABLE(FALSE);

        // stay in 32kHz clock mode for for sleepTime seconds  
        INT_SETFLAG(INUM_TIMER2, INT_CLR);
        TIMER2_RUN(TRUE);
        for (i=0; i<sleepTime; i++) {
            RLED= ~RLED;
            // this inner loop needs 1 s to execute
            ENTER_IDLE_MODE();
        }
        TIMER2_RUN(FALSE);

        // Enable high speed XOSC, switch clock source, then disable 32kHz XOSC
        XOSC_ENABLE(TRUE);
        MAIN_CLOCK_SET_SOURCE(CLOCK_XOSC);

        INT_ENABLE(INUM_TIMER2, INT_OFF);
        INT_PRIORITY(INUM_TIMER2, INT_LOW);
        TIMER0_RUN(TRUE);
        
        RLED= LED_OFF;
        YLED= LED_ON;
    }

    void RFLowPowerSleepTillKeyPressed() {
        TIMER0_RUN(FALSE);
        RLED= GLED= LED_OFF;
        YLED= LED_OFF;
        
        INT_EXTERNAL0_TRIGGER_ON_EDGE();
        INT_ENABLE(INUM_EXTERNAL0, TRUE);

        MAIN_CLOCK_SET_SOURCE(CLOCK_X32);
        XOSC_ENABLE(FALSE);

        // stay in 32kHz clock mode for for sleepTime seconds  
        INT_SETFLAG(INUM_EXTERNAL0, INT_CLR);
        ENTER_IDLE_MODE();

        // Enable high speed XOSC, switch clock source, then disable 32kHz XOSC
        XOSC_ENABLE(TRUE);
        MAIN_CLOCK_SET_SOURCE(CLOCK_XOSC);

        INT_ENABLE(INUM_EXTERNAL0, FALSE);
        TIMER0_RUN(TRUE);
        
        RLED= LED_OFF;
        YLED= LED_ON;
        
    }
        
    
    byte RFScramble(byte b) {
        byte i, scrReg;
        
        scrReg= rfScramblerReg;
        RF_SCRAMBLE(b, scrReg, i);
        rfScramblerReg= scrReg;
        
        return b;
    }
    
    bool RFSendPacket(bool sync) {
        byte numPreambles, j, b, currentTHi, currentTLo;
        //unsigned short tEndCurrent;  // the start time for a sync packet
    
        // wait one ms to give the receivers time to prepare
        halWait(1, CC1010EB_CLKFREQ);
        numPreambles= RF_PREAMBLE_LENGTH_TX;
    
        // Turn on RF for TX, send packet
        RFSetModeTransmit();
        //halRFSetRxTxOff(RF_TX, &RF_SETTINGS, &RF_CALDATA);
    
        // Set the first byte to transmit & turn on TX
        RFCON|=0x01;                        // Ensure that bytemode is selected
        RF_SEND_BYTE(RF_PREAMBLE_BYTE);

        if (sync) {
            /* j= TH0;
            b= TL0;
            sendByteToUart(j);
            sendByteToUart(b);
            DEBUG_NEWLINE;
            RF_SET_MODE_SLEEP;
            return 1;  */

            // wait for the sync time start rendezvous point. the values for RF_SYNC_START_TIMER0_*
            // have been calibrated with the commented out code above
            WAIT_FOR_TIMER0_EXACT(RF_RENDEZVOUS_SYNC_START_HI, RF_RENDEZVOUS_SYNC_START_LO);
        } else {
            /*j= TH0;
            b= TL0; 
            sendByteToUart(j);
            sendByteToUart(b);
            DEBUG_NEWLINE;
            RF_SET_MODE_SLEEP;
            return 0;*/
            
            // synchronize
            // the value of this sync time has been measured with the commented out block above
            WAIT_FOR_TIMER0_EXACT(RF_RENDEZVOUS_DATA_PACKET_START_HI, RF_RENDEZVOUS_DATA_PACKET_START_LO);
        }
        BLED= LED_ON; // start sending

        // turn on transceiver
        RF_START_TX();
        //YLED= ~YLED;
        //BLED= ~BLED;
        
        if (sync) {
            // get current timer value of timer0
            currentTHi= TH0;
            currentTLo= TL0;
            currentTHi= ((currentTHi | currentTLo) + RF_SYNC_ADDITIONAL_OFFSET) >> 8;
            currentTLo= currentTLo + RF_SYNC_ADDITIONAL_OFFSET;
            j= currentTHi ^ currentTLo;
        }
    
        // Send remaining preambles
        while (--numPreambles) {
            RF_SPI_SEND_BYTE(RF_PREAMBLE_BYTE);
        }
    
        // Send start of packet byte
        RF_SPI_SEND_BYTE(RF_SUITABLE_SYNC_BYTE);
    
        // Send scrambler init
        //scrReg= rfScramblerReg;
        //RF_SPI_SEND_BYTE(scrReg);
        
        // send FF byte to train the receiver's descrambler
        b= RFScramble(0xFF);
        RF_SPI_SEND_BYTE(b);
    
        //YLED= ~YLED;
        //BLED= ~BLED;
        if (sync) {
            //BLED= ~BLED;
            // send rf options. 1 means beacon.
            b= RFScramble(1);
            RF_SPI_SEND_BYTE(b);

            // send timestamp
            // use redundant protection byte j (= tEndAvgLo xor tEndAvgHi) to detect transmission bit errors
            b= RFScramble(currentTHi);
            RF_SPI_SEND_BYTE(b);
            b= RFScramble(currentTLo);
            RF_SPI_SEND_BYTE(b);
            b= RFScramble(j);
            RF_SPI_SEND_BYTE(b);

            //YLED= ~YLED;
            //BLED= ~BLED;
            //tEndCurrent= (TH0<<8) | TL0;
        
            #ifdef DEBUG_USE_UART
            #ifdef DEBUG_DUMP_SYNC_VALUES
                j= TH0;
                b= TL0;
                sendByteToUart(currentTHi);
                sendByteToUart(currentTLo);
                DEBUG_SPACE;
                sendByteToUart(j);
                sendByteToUart(b);
                DEBUG_NEWLINE;
                
            #endif
            #endif
        } else {
            // send rf options. 0 means regular packet
            b= RFScramble(0);
            RF_SPI_SEND_BYTE(b);

            if (LL_payload_sendbuffer_length > 64)
                LL_payload_sendbuffer_length= 64;
    
            // Send physical payload length
            b= RFScramble(LL_payload_sendbuffer_length + LL_HEADER_SIZE + LL_TAIL_SIZE);
            RF_SPI_SEND_BYTE(b);
    
            b= RFScramble(LL_payload_sendbuffer[0]);
            RF_SPI_SEND_BYTE(b);
            b= RFScramble(LL_payload_sendbuffer[1]);
            RF_SPI_SEND_BYTE(b);

            // send 4 foo bytes to give receiver time to check subscriptions
            // use RF_PREAMBLE_BYTE because it's dc balanced
            RF_SPI_SEND_BYTE(BIN(11001010));
            //BLED= ~BLED;
            //BLED= ~BLED;
            RF_SPI_SEND_BYTE(BIN(11001010));
            //BLED= ~BLED;
            //BLED= ~BLED;
            RF_SPI_SEND_BYTE(BIN(11001010));
            //BLED= ~BLED;
            //BLED= ~BLED;
            RF_SPI_SEND_BYTE(BIN(11001010));
            //BLED= ~BLED;
            //BLED= ~BLED;

            // send ll header
            for (j=0; j<12; j++) {
                b= RFScramble(LL_header_sendbuffer[j]);
                RF_SPI_SEND_BYTE(b);
            }

            // send ll packet payload
            for (j=0; j<LL_payload_sendbuffer_length; j++) {
                b= RFScramble(LL_payload_sendbuffer[j]);
                RF_SPI_SEND_BYTE(b);
            }

            // send ll tail
            for (j=0; j<LL_TAIL_SIZE; j++) {
                b= RFScramble(LL_tail_sendbuffer[j]);
                RF_SPI_SEND_BYTE(b);
            }
        }
    
        RF_SPI_SEND_BYTE(0);
        RF_SPI_SEND_BYTE(0);
        //while (!RF_READY_TO_SEND());
        //YLED= ~YLED;
        //BLED= ~BLED;

        // turn transceiver off
        RF_SET_MODE_SLEEP;   // shorter for halRFSetRxTxOff(RF_OFF, &RF_SETTINGS, &RF_CALDATA);
        RFCON&=~0x01;  // Ensure that bitmode is selected
    
        // do exponential smoothing on the timer value when finished with sending
        // add an additional offset, because detection and timer setting on the slave
        // is slightly later than measurement on the master after after transmitting.
/*      if (sync) {
            //tEndAvg= tEndCurrent + RF_SYNC_ADDITIONAL_OFFSET;
            //tEndAvg= (((ulong)tEndCurrent + (ulong)RF_SYNC_ADDITIONAL_OFFSET) + 9*(ulong)tEndAvg) / 10;
            
            // dump the sync values just sent
            #ifdef DEBUG_DUMP_SYNC_VALUES
            #ifdef DEBUG_USE_UART
                // dump received tHi and tLo
                sendByteToUart(tEndCurrent >> 8);
                sendByteToUart(tEndCurrent & 0xFF);
                DEBUG_SPACE;
                sendByteToUart(tEndAvg >> 8);
                sendByteToUart(tEndAvg & 0xFF);
                DEBUG_NEWLINE; 
            #endif
            #endif

            // when dividing by 8 don't simply cut the last 3 bits (like a cast would do)
            // to improve accuracy, add 1 if last bit that is shifted out is 1
            // this is the binary equivalent to decimal rounding (down if next decimal place is <=4, up if next decimal place is >4)
            rfAverageTEndBuffer*= 7;
            rfAverageTEndBuffer/= 8;
            rfAverageTEndBuffer+= tEndCurrent + RF_SYNC_ADDITIONAL_OFFSET;
            j= (rfAverageTEndBuffer & 0x4);
            tEndAvg= rfAverageTEndBuffer / 8;
            if (j)
                tEndAvg++;
        } */
        
        BLED= LED_OFF;  // end RFSendPacket
        return TRUE;
    }
    
    bool RFLongSearchForMaster(unsigned short numTries) {
        bool success= FALSE;
    
        // let timer 0 (the slot timer) run, but turn off the interrupt
        INT_ENABLE(INUM_TIMER0, INT_OFF);
        //YLED= LED_ON;
        while (numTries-- > 0) {
            //YLED= ~YLED;
            //sendUlongToUart(numTries);
            //DEBUG_SPACE;
            // if it is a sync packet
            if (RFReceivePacket(&periodDataSlot, FALSE) == 2) {
                success= TRUE;
                break;
            }
        }
    
        // turn on the interrupt for timer 0 again
        INT_ENABLE(INUM_TIMER0, INT_ON);
        // clear the interrupt flag, because it is most probably set 
        INT_SETFLAG(INUM_TIMER0, INT_CLR);

        //YLED= LED_OFF;
        return success;
    }
    
    bool RFMasterRivalTest() {
        bool success= FALSE;
    
        //YLED= LED_ON;
        // the RFReceivePacket() function automagically returns if only 200us are left in
        // current timer0 slot.
        success= (RFReceivePacket(&periodDataSlot, FALSE) == 2); 
        //YLED= LED_OFF;
    
        return success;
    }
    
// end of RF Layer Functions


    byte LLGetIDFromHardware() {
        for (i=0;i<=7;i++) {
            LL_header_sendbuffer[3+0]= llEpromAddress.a1;
            LL_header_sendbuffer[3+1]= llEpromAddress.a2;
            LL_header_sendbuffer[3+2]= llEpromAddress.a3;
            LL_header_sendbuffer[3+3]= llEpromAddress.a4;
            LL_header_sendbuffer[3+4]= llEpromAddress.a5;
            LL_header_sendbuffer[3+5]= llEpromAddress.a6;
            LL_header_sendbuffer[3+6]= llEpromAddress.a7;
            LL_header_sendbuffer[3+7]= RF_NEW_RANDOM_BYTE();
        }

        return 1;       //both were invalid: there's no valid id
    }
    
    void LLInit() {
        LL_sequence_no=0;
    
        LL_header_sendbuffer[0]= LL_PROTOCOL_VERSION;
    
        LL_payload_send_length=0;   // set used ll payload to zero
        LL_payload_received_length= 0;
        llState= LL_STATE_RUNNING;
        LL_sequence_no= 0;
        
        LLGetIDFromHardware();  //take id from internal or external eeprom and set LL_header_sendbuffer
        
        #ifdef DEBUG_USE_UART
            sendStringToUart("Particle ID:\r\n");
            sendByteToUart(LL_header_sendbuffer[3+0]);
            putchar('.');
            sendByteToUart(LL_header_sendbuffer[3+1]);
            putchar('.');
            sendByteToUart(LL_header_sendbuffer[3+2]);
            putchar('.');
            sendByteToUart(LL_header_sendbuffer[3+3]);
            putchar('.');
            sendByteToUart(LL_header_sendbuffer[3+4]);
            putchar('.');
            sendByteToUart(LL_header_sendbuffer[3+5]);
            putchar('.');
            sendByteToUart(LL_header_sendbuffer[3+6]);
            putchar('.');
            sendByteToUart(LL_header_sendbuffer[3+7]);
            DEBUG_NEWLINE;
        #endif

        RFInit();
    }
    
    
    void LLStart() {
        RFStart();
    }
    
    
    void LLStop() {
        RFStop();   // handles the states
    }
    
    void LLSlotEnd() {

    }
    
    
    void LLAbortSending() {
        if (LLSendingBusy()) {
            if (llState & LL_STATE_CTRL_MESSAGE_INSERTED)   {
                llState&= ~LL_STATE_CTRL_MESSAGE_INSERTED;
            } else {
                llState&= ~LL_STATE_SEND_SUCCESS;
            } 
            // clear some llState flags
            llState&= ~(LL_STATE_SEND_SUCCESS|LL_STATE_NEED_TO_SEND);
        }
    }
    
    void LLSetSendingSuccess() {
        //update the states
        if (llState & LL_STATE_CTRL_MESSAGE_INSERTED)   {
            // no update of success flag
            llState&= ~LL_STATE_CTRL_MESSAGE_INSERTED;  // clear the control management bit
        } else {
            llState|= LL_STATE_SEND_SUCCESS;            // successful sent
        }       
        llState&= ~LL_STATE_NEED_TO_SEND;                   // busy is over
        LL_payload_send_length=0;                       // set used payload to zero
    }
    
    byte LLSendingBusy() {
        return ((llState & LL_STATE_NEED_TO_SEND) != 0);
    }
    
    byte LLGetSendSuccess() {
        return ((llState & LL_STATE_SEND_SUCCESS) != 0);
    }
    
    byte LLIsActive() {
        return ((llState & LL_STATE_RUNNING) != 0);
    }
    
    void LLSetDataToOld() {
        llState&= ~LL_STATE_NEW_DATA;
    }

    void LLLockReceiveBuffer() {
        llState|= LL_STATE_RECEIVE_BUFFER_LOCKED;
        LLSetDataToOld();
    }
    
    byte LLReceiveBufferLocked()    {
        return ((llState & LL_STATE_RECEIVE_BUFFER_LOCKED) != 0);
    }
    
    void LLReleaseReceiveBuffer() {
        llState&= ~LL_STATE_RECEIVE_BUFFER_LOCKED;
        LLSetDataToOld();
    }
    
    void LLSetDataToNew() {
        llState|= LL_STATE_NEW_DATA;
    }
    
    
    byte LLDataIsNew() {
        return ((llState & LL_STATE_NEW_DATA) != 0);
    }
    
    byte LLGetFieldStrength() {
        return rfFieldStrength;
    }
    
    void LLSetFieldStrength(byte value) {
        rfFieldStrength= value;
    }
    
    
    unsigned short LLCalcCRC16(byte *header_data, byte *payload_data, byte payload_size) {
        //calcs a crc on LL_header, ACL_data, LL_tail
        byte hb,lb,i,tmp;
        lb=0;
        hb=0;
    
        for(i=0;i<LL_HEADER_SIZE;i++) {
            tmp = lb;
            lb = hb;
            hb = tmp;
            lb ^= header_data[i];
            lb ^= lb >> 4;
            hb ^= lb << 4;
            hb ^= lb >> 3;
            lb ^= (lb << 4) << 1;
        }
    
        //len=header_data[1]-LL_HEADER_SIZE-LL_TAIL_SIZE;
        for(i=0;i<payload_size;i++) {
            tmp = lb;
            lb = hb;
            hb = tmp;
            lb ^= payload_data[i];
            lb ^= lb >> 4;
            hb ^= lb << 4;
            hb ^= lb >> 3;
            lb ^= (lb << 4) << 1;
        }
    
        return hb*256+lb;
    }
    
    
    byte LLSendPacket(byte slot_limit) {
        unsigned short crc;
        
        if (slot_limit==0) slot_limit=1;    // zero makes no sense
    
        // if rf is off, stop it
        if (!(rfState & RF_STATE_RUNNING)) return 0;
        // if ll is still trying to send the last packet, ignore
        if (llState & LL_STATE_NEED_TO_SEND) return 0;
    
        // complete the LLPacket
        //DebugGiveOut(LL_payload_send_length);
        
        // copy "send" variables to "sendbuffer" variables
        if (LL_payload_send_length > 64)
            LL_payload_send_length= 64;
        LL_payload_sendbuffer_length= LL_payload_send_length;
        for (i=0; i<LL_payload_send_length; i++)
            LL_payload_sendbuffer[i]= LL_payload_send[i];
        
        LL_header_sendbuffer[1]= LL_payload_sendbuffer_length;
        LL_header_sendbuffer[2]= rfFieldStrength;
        LL_header_sendbuffer[11]= LL_sequence_no;
    
        crc= LLCalcCRC16(LL_header_sendbuffer,LL_payload_sendbuffer, LL_payload_sendbuffer_length);
    
        LL_tail_sendbuffer[0]= (crc>>8);    //CRCh (implicit typecast; ´takes low byte from long
        LL_tail_sendbuffer[1]= crc & 0xFF;      //CRCl
    
        LL_slots_left= slot_limit;
        LL_sequence_no++;
    
        llState|= LL_STATE_NEED_TO_SEND;

        LL_payload_send_length= 0;  // set the used payload to 0, so that new data can be written
        
        return 1;
    }
    
    
    byte LLGetRemainingPayloadSpace() {
        return (LL_PAYLOAD_SIZE-LL_payload_send_length);
    }
    
    
    byte LLSentPacketInThisSlot() {
        return ((llState & LL_STATE_PACKET_JUST_SENT) != 0);
    }
    
// end of LL Layer Functions


    void ACLStartUp() {
        xdata byte result[10];
        byte selftest_result,i;

        selftest_result= AppSelfTest(result);       //runs the selftest
        
        GLED= LED_OFF;
        RLED= LED_OFF;
        halWait(100, CC1010EB_CLKFREQ);             // for stabilizing of power etc.
    
        ACLInit();                  // sets the pins in pic init correct (looks at selftest_active
        // GLED= LED_ON;
        // while(1);
        
        #ifdef DEBUG_DUMP_RF_STATISTICS
            // reset the statistics
            DebugResetStats();
        #endif
        
        if(selftest_result) {
            //send result ten times to get it
            for(i=0;i<10;i++) {
                //send packet
                ACLAddNewType(ACL_TYPE_CST_HI,ACL_TYPE_CST_LO);     //MST Self test
                ACLAddData(result[0]);
                ACLAddData(result[1]);
                ACLAddData(result[2]);
                ACLAddData(result[3]);
                ACLAddData(result[4]);
                ACLAddData(result[5]);
                ACLAddData(result[9]);

                ACLSendPacket(10);
                while(ACLSendingBusy());
            }
        }
    }
    
    
    void ACLInit() {
        ACLFlushSubscriptions();
        ACL_send_buffer_locked=false;
        ACL_write_position=0;
        ACL_subscribe_all=false;
        ACL_ACM_answers=true;
        ACL_ignore_control_messages=false;
        ACL_pass_control_messages=false;
    
        LL_payload_send_length=0;
        ACL_write_position=0;
    
        //APPSetLEDBehaviour(LEDS_NORMAL);          //setdefault
    
        LLInit();
        ACLStart();
    }
    
    
    byte ACLSubscribe(byte LL_type_h, byte LL_type_l) {
        byte i;
    
        for (i=0;i<ACL_SUBSCRIPTIONLIST_LENGTH;i++) {   // first test if already there
            if ((ACL_subscriptions[i][0]==LL_type_h) && (ACL_subscriptions[i][1]==LL_type_l)) return 1;
        }
    
        for (i=0;i<ACL_SUBSCRIPTIONLIST_LENGTH;i++) {
            if ((ACL_subscriptions[i][0]==0) && (ACL_subscriptions[i][1]==0)) {
                ACL_subscriptions[i][0]=LL_type_h;
                ACL_subscriptions[i][1]=LL_type_l;
                return 1;                               // successful subscribed
            }
        }
        return 0;                                       // subsriptions failed
    }
    
    byte ACLUnsubscribe(byte LL_type_h, byte LL_type_l) {
        byte i;
    
        for (i=0;i<ACL_SUBSCRIPTIONLIST_LENGTH;i++) { // if type is there, delete it
            if ((ACL_subscriptions[i][0]==LL_type_h) && (ACL_subscriptions[i][1]==LL_type_l)) {
                ACL_subscriptions[i][0]=0;
                ACL_subscriptions[i][1]=0;
                return 1;       // successful unsubscribed
            }
        }
        return 0;       // not found
    }
    
    
    void ACLFlushSubscriptions()    {
        byte i;
    
        for (i=0;i<ACL_SUBSCRIPTIONLIST_LENGTH;i++) {
            ACL_subscriptions[i][0]=0;
            ACL_subscriptions[i][1]=0;
        }
    
        ACL_subscribe_all=false;
        ACLSubscribeDefault();
        return;
    }
    
    void ACLSubscribeAll() {
        ACL_subscribe_all=true;
    }
    
    void ACLAnswerOnACM() {
        ACL_ACM_answers=true;
    }
    
    void ACLNoAnswerOnACM() {
        ACL_ACM_answers=false;
    }
    
    byte ACLSubscribeDefault() {
        byte result;
        result=ACLSubscribe(ACL_TYPE_ACM_H,ACL_TYPE_ACM_L);     //165 14 is CMA (Control and Management virtual Artifact)
        return result;
    }
    
    byte ACLVerifySubscription(byte type_h,byte type_l) {
        byte i;
    
        for (i=0;i<ACL_SUBSCRIPTIONLIST_LENGTH;i++) {
            if ((ACL_subscriptions[i][0]==type_h) && (ACL_subscriptions[i][1]==type_l)) return 1;
        }
        return 0;       //subscription not found
    }
    
    
    byte ACLProcessControlMessages() {
    
        if ((LL_payload_receivebuffer[0]==ACL_TYPE_ACM_H) && (LL_payload_receivebuffer[1]==ACL_TYPE_ACM_L)) {
        // there was a control msg
    
            // check a control msg, e.g. "1,1"
            //remote shutdown
            if ((LL_payload_receivebuffer[3]==172) && (LL_payload_receivebuffer[4]==224)) {
                if (ACLMatchesMyIP(LL_payload_receivebuffer,6)) {
                    return 4;
                }
            }
    
            // check syncrate setting
            if ((LL_payload_receivebuffer[3]==198) && (LL_payload_receivebuffer[4]==208)) {
                //RFSetSyncRate(LL_payload_receivebuffer[6]);
            }
    
            // check initial listen slots setting
            if ((LL_payload_receivebuffer[3]==159) && (LL_payload_receivebuffer[4]==192)) {
                //RFSetInitialListenSlots(LL_payload_receivebuffer[6]);
            }
    
            // check shutdown  (dirty hack; actually need ip check, different shutdown modes
            if ((LL_payload_receivebuffer[3]==204) && (LL_payload_receivebuffer[4]==232)) {
                RFStop();
            }
    
            // check modeswitch
            if ((LL_payload_receivebuffer[3]==1) && (LL_payload_receivebuffer[4]==1)) {
            }
    
            //check over the air programming
            if ((LL_payload_receivebuffer[3]==198) && (LL_payload_receivebuffer[4]==88)) {
                //OtapReceive();        // call over the airprogramming stuff
            }
    
            //check set ID
            if ((LL_payload_receivebuffer[3]==ACL_TYPE_CID_HI) && (LL_payload_receivebuffer[4]==ACL_TYPE_CID_LO) /* && selftest_active==true */) {
                //OtapSetID();
            }
    
            // no answering allowed; all messages below here are not allowed, if acl_acm_answer is false
            if (ACL_ACM_answers==false) return 0;   
    
            //check Helo
            if ((LL_payload_receivebuffer[3]==115) && (LL_payload_receivebuffer[4]==216)) {
                if (ACLMatchesMyIP(LL_payload_receivebuffer,6)) {   // does sent IP match my IP??
                    if (LLSendingBusy()) ACLAbortSending();         // interrupt any waiting stuff
    
                    // now set the whole packet by hand:
                    LL_payload_send[0]=ACL_TYPE_ACM_H;
                    LL_payload_send[1]=ACL_TYPE_ACM_L;
                    LL_payload_send[2]=0;
    
                    LL_payload_send[3]=134;
                    LL_payload_send[4]=32;
    
                    LL_payload_send[5]=8;
                    LL_payload_send[6]=LL_header_receivebuffer[3];      // put in origin adress from HELO
                    LL_payload_send[7]=LL_header_receivebuffer[4];
                    LL_payload_send[8]=LL_header_receivebuffer[5];
                    LL_payload_send[9]=LL_header_receivebuffer[6];
                    LL_payload_send[10]=LL_header_receivebuffer[7];
                    LL_payload_send[11]=LL_header_receivebuffer[8];
                    LL_payload_send[12]=LL_header_receivebuffer[9];
                    LL_payload_send[13]=LL_header_receivebuffer[10];
                    LL_payload_send_length=14;                              // give the correct len
    
                    if (LLSendPacket(ACL_CONTROL_MESSAGES_TIMEOUT)) {    // NEVER USE ACL FUNCTION here!!!
                        llState|= LL_STATE_CTRL_MESSAGE_INSERTED;           // this means that this msg if special concerning the update of the states
                    }
                }
            }
            // this was helo
            return 1;                                           // there was a control management msg
        }
        return 0;                                               // there was no control management msg
    }
    
    void ACLSetFieldStrength(byte power)    {
        LLSetFieldStrength(power);
    }
    
    byte ACLSendingBusy() {
        return LLSendingBusy();
    }
    
    byte ACLGetSendSuccess()    {
        return LLGetSendSuccess();
    }
    
    byte ACLMatchesMyIP(char *buffer,byte start) {
        byte i;
        bool res;
    
        // check if was my address      // ll_header_send [3..10] hold the myIP
        res= TRUE;
        for (i=0;i<8;i++) {
            if (buffer[start+i] != LL_header_sendbuffer[3+i]) {
                res= FALSE;
                break;
            }
        }
        if (res) return 1;
    
        // check if  was broadcast adress
        res= TRUE;
        for (i=0;i<8;i++) {
            if (buffer[start+i]!=255) {
                res= FALSE;
                break;
            }
        }
        if (res) return 1;
    
        return 0;
    }
    

    byte ACLSendPacket(byte slot_timeout)   {
        return LLSendPacket(slot_timeout);
    }

    void ACLAbortSending() {
        ACL_send_buffer_locked=false;
        ACL_write_position=0;
        LLAbortSending();
    }

    byte ACLClearSendData() {
        byte i;
        if (LLSendingBusy()) return 0;                  // dont clear if busy sending
        if (ACL_send_buffer_locked==true) return 0;     // dont clear if reservation is active

        for(i=0;i<LL_PAYLOAD_SIZE;i++)
            LL_payload_send[i]=0;
        LL_payload_send_length=0;
        ACL_write_position=0;

        return 1;
    }

    
    bool ACLAddNewType(byte type_h, byte type_l) {
        //if (LLSendingBusy()) return 2;  // not needed any more, we have a sendbuffer
        if ((LL_PAYLOAD_SIZE-LL_payload_send_length)<3) {
            return 1;       // not enough space
        } else {
            //place the new type
            LL_payload_send[LL_payload_send_length]=type_h;
            LL_payload_send[LL_payload_send_length+1]=type_l;
            LL_payload_send[LL_payload_send_length+2]=0;    //data length is zero
            ACL_write_position=LL_payload_send_length+2;
            LL_payload_send_length+=3;
            return 0;
        }
    }

    byte ACLAddData(byte newByte) {
        //if (LLSendingBusy()) return 2;
        if ((LL_PAYLOAD_SIZE-LL_payload_send_length)<1) {
            return 1;       // not enough space
        } else {
            LL_payload_send[ACL_write_position]++;      //increase length byte after type bytes
            LL_payload_send[LL_payload_send_length]= newByte;   //place the data
            LL_payload_send_length+=1;
            return 0;
        }
    }

    byte ACLGetRemainingPayloadSpace() {
        return LLGetRemainingPayloadSpace();
    }
    
    byte ACLGetReceivedPayloadLength() {
        return LL_header_received[1];
    }
    
    signed char ACLGetReceivedDataLength(byte type_h, byte type_l)  {
        byte i;
    
        for (i=0; i<=LL_header_received[1]-2; i++) {
            if ((LL_payload_received[i]==type_h) && (LL_payload_received[i+1]==type_l)) {
                return (LL_payload_received[i+2]);                                          //return valid length
            }
        }
        return -1;                                                                          // type not found
    }
    
    
    char* ACLGetReceivedData(byte type_h, byte type_l) {
        byte i;
    
        for (i=0;i<=LL_header_received[1]-2;i++) {
            if ((LL_payload_received[i]==type_h) && (LL_payload_received[i+1]==type_l)) {
                if (LL_payload_received[i+2]!=0) {
                    return (&(LL_payload_received[i+3]));   // if len is not zero: return valid pointer to data begin
                }
            }
        }
        return NULL;
    }
    
    
    char ACLGetReceivedByte(byte type_h, byte type_l, byte position) {
        byte i;
    
        for (i=0;i<=LL_header_received[1]-2;i++) {
            if ((LL_payload_received[i]==type_h) && (LL_payload_received[i+1]==type_l)) {
                if (LL_payload_received[i+2]!=0) {
                    return (LL_payload_received[i+3+position]);                                 // if len is not zero: return valid pointer to data begin
                }
    
            }
        }
        
        return 0;
        //attention!! if type wasn't found: return is undetermined!!
    }
    
    byte ACLFoundReceivedType(byte type_h, byte type_l) {
        return (ACLGetReceivedDataLength(type_h,type_l) != -1);     //not found
    }
    
    void ACLSetControlMessagesBehaviour(boolean ignore, boolean pass) {
        ACL_ignore_control_messages= ignore;        //all control messages are ignored
        ACL_pass_control_messages= pass;            // all control messages are as well copied to receivebuffer for application
    }
    
    
    byte ACLSentPacketInThisSlot() {
        return (LLSentPacketInThisSlot());
    }
    
    void ACLStart() {
        LLStart();
    }
    
    void ACLStop() {
        LLStop();
    }
    
    void ACLLockReceiveBuffer() {
        LLLockReceiveBuffer();
    }
    
    byte ACLReceiveBufferLocked() {
        return LLReceiveBufferLocked();
    }
    
    void ACLReleaseReceiveBuffer() {
        LLReleaseReceiveBuffer();
    }
    
    void ACLSetDataToOld() {
        LLSetDataToOld();
    }
    
    void ACLSetDataToNew() {
        LLSetDataToNew();
    }
    
    byte ACLDataIsNew() {
        return LLDataIsNew();
    }
    
    byte ACLDataReceivedInThisSlot()    {
        return LLSentPacketInThisSlot();
    }
    
    
    byte ACLDataIsNewNow() {
        return ACLDataReceivedInThisSlot();
    }
    
    
    byte ACLAdressedDataIsNew() {
        if (!ACLDataIsNew()) return 0;
    
        if (ACLFoundReceivedType(ACL_TYPE_CAD_HI,ACL_TYPE_CAD_LO)) {
            if (ACLMatchesMyIP( ACLGetReceivedData( ACL_TYPE_CAD_HI, ACL_TYPE_CAD_LO), 0 )) 
                return 1;
        }
        return 0;
    }
    
    byte ACLAdressedDataIsNewNow() {
        if (!ACLDataIsNewNow()) return 0;
    
        if (ACLFoundReceivedType(ACL_TYPE_CAD_HI,ACL_TYPE_CAD_LO)) {
            if (ACLMatchesMyIP( ACLGetReceivedData( ACL_TYPE_CAD_HI, ACL_TYPE_CAD_LO), 0 )) 
                return 1;
        }
        return 0;
    }
    
    
    byte ACLSendPacketAdressed(nodeAddrType *address, byte timeout) {
            
        if (ACLGetRemainingPayloadSpace()<11) 
            return 0;       //not enough space
    
        ACLAddNewType(ACL_TYPE_CAD_HI,ACL_TYPE_CAD_LO);
        ACLAddData(address->a1);
        ACLAddData(address->a2);
        ACLAddData(address->a3);
        ACLAddData(address->a4);
        ACLAddData(address->a5);
        ACLAddData(address->a6);
        ACLAddData(address->a7);
        ACLAddData(address->a8);
    
        if (ACLSendPacket(timeout)) return 1;
        return 0;
    }
// end of ACL Layer Functions


void isr_timer0() interrupt INUM_TIMER0 {
    byte length; //, time1H, time1L, time2H, time2L;
    bool arbitrationResult, recResult;
    unsigned short receiveResult;
    
    ISR_TIMER0_ADJUST(moduloTimer0);
    INT_SETFLAG(INUM_TIMER0, INT_CLR);
    // BLED= LED_ON;  // start isr
    // BLED= LED_OFF; // start isr
    // BLED= LED_ON;  // start isr
    // BLED= LED_OFF; // start isr
/*  time1H= TH0;
    time1L= TL0; */
    
    llState&= ~(LL_STATE_PACKET_JUST_RECEIVED | LL_STATE_PACKET_JUST_SENT);
    
    if (!(rfState & RF_STATE_RUNNING)) {
        TIMER0_RUN(FALSE);
        return;
    }
    
    // this is a slot-counter. every RF_SYNC_MAX_SLOT_COUNT slots, the node sends a sync packet
    // (if he is a master) or expects a sync packet to synchronize to.
    rfSlotCount++;
    rfSlotsWithoutSignalReceived++;
    //sendByteToUart(rfSlotCount);
    //DEBUG_NEWLINE;
    
    if (rfSlotCount >= RF_SYNC_MAX_SLOT_COUNT) {
        // we are in a sync slot. so let's send a sync packet or receive one
        //YLED= ~YLED;
        //BLED= ~BLED;
        if (!(rfState & RF_STATE_ALONE)) {
            if (rfState & RF_STATE_MASTER) {
                // we are master, so send sync
                RFSendPacket(TRUE);
                #ifdef RF_USE_ALONE_DETECTION
                    // try to receive an alone test signal, to know if other nodes are there
                    if (RFAloneTest()) 
                        rfSlotsWithoutSignalReceived= 0;
                #endif
                #ifdef RF_USE_TRAFFIC_INDICATION
                    RFTrafficIndication();
                #endif
                if (++rfSyncCount == RF_MASTER_RIVAL_TEST_SYNC_COUNT) {
                    // many beacon slots have passed, so let's check if we find another master
                    rfSyncCount= 0;
                    #ifndef DEBUG_ARBITRATION_TEST_ACTIVE
                        rfState|= RF_STATE_MASTER_RIVAL_TEST;
                        if (RFMasterRivalTest()) {
                            // clear rival test and master flags
                            rfState&= ~(RF_STATE_MASTER_RIVAL_TEST|RF_STATE_MASTER);
                            rfFailedSyncCount= 0;
                            rfSlotsWithoutSignalReceived= 0;
                        }
                    #endif
                } else {
                    rfState&= ~RF_STATE_MASTER_RIVAL_TEST;
                }
            } else {
                // we are a slave, so try to receive a sync packet
                recResult= RFReceivePacket(&periodDataSyncByteReceiveTimeout, FALSE);
                if (recResult == 2) {
                    #ifdef RF_USE_ALONE_DETECTION
                        RFAloneTest(); // sends the alone test signal to tell the master that we are there
                    #endif
                    #ifdef RF_USE_TRAFFIC_INDICATION
                        RFTrafficIndication();
                    #endif
                    rfFailedSyncCount= 0;
                    rfState|= RF_STATE_IN_SYNC;
                    putchar('R');
                    DEBUG_NEWLINE;
                    //YLED= ~YLED;
                } else {
                    rfState&= ~RF_STATE_IN_SYNC;
                    // if sync is lost for RF_MAX_FAILED_SYNC_COUNT times, we try to become master
                    if (++rfFailedSyncCount >= RF_MAX_FAILED_SYNC_COUNT) {
                        rfState|= RF_STATE_LONG_SEARCH_FOR_MASTER;
                        rfFailedSyncCount= 0;
                    } 
                    //YLED= LED_OFF;
                }
            }
        }
        rfSlotCount= 0;
    } else {
        // we are not in a sync slot (i.e. a regular slot for data transmission)
        // first, let's handle the alone stuff
        if (rfState & RF_STATE_ALONE) {
            #ifdef RF_USE_ALONE_DETECTION
                #ifdef RF_ALONE_DEEP_SLEEP
                    // the node thinks it is alone, and deep sleeping is activated,
                    // so we put it to sleep for 10-26 seconds.
                    RFLowPowerSleep(RFAloneRandomNumberOfSeconds());
                    rfState&= ~RF_STATE_ALONE;
                    if (RFLongSearchForMaster(RF_MASTER_SEARCH_SLOTS_AFTER_ALONE)) {
                        rfState&= ~RF_STATE_MASTER; // clear the master flag, become a slave
                    } else {
                        rfState|= RF_STATE_MASTER;      // set the master flag, become a master
                    }
                    // start the failed sync count and slot count from 0
                    rfFailedSyncCount= rfSlotCount= rfSlotsWithoutSignalReceived= 0;
                #else 
                    // the node thinks it is alone, only transmission supression is activated
                    if (( (rfSlotsInAloneModeLeft & 0xFF) % 32 ) == 0)
                        RLED= ~RLED;
                    //sendUshortToUart(rfSlotsInAloneModeLeft);
                    //sendByteToUart(rfSlotCount);
                    //DEBUG_SPACE;
                    if (rfSlotsInAloneModeLeft-- == 0) {
                        rfState&= ~RF_STATE_ALONE;
                        if (RFLongSearchForMaster(RF_MASTER_SEARCH_SLOTS_AFTER_ALONE)) {
                            rfState&= ~RF_STATE_MASTER; // clear the master flag, become a slave
                        } else {
                            rfState|= RF_STATE_MASTER;      // set the master flag, become a master
                        }
                        // start the failed sync count and slot count from 0
                        rfFailedSyncCount= rfSlotCount= rfSlotsWithoutSignalReceived= 0;
                    }
                #endif
            #endif
        } else if (rfState & RF_STATE_LONG_SEARCH_FOR_MASTER) {
            // node must do á long search for master. use random length because if a master gives
            // up and all slaves find themselves in this state, they shouldn't all at once try
            // to become master
            if (RFLongSearchForMaster(10)) {
                rfState&= ~RF_STATE_MASTER; // clear the master flag, become a slave
                #ifdef RF_USE_ALONE_DETECTION
                    RFAloneTest(); // send the alone test signal
                #endif
            } else {
                //rfState&= ~RF_STATE_MASTER; //just for testing
                rfState|= RF_STATE_MASTER;      // set the master flag, become a master
            }
            rfState&= ~RF_STATE_LONG_SEARCH_FOR_MASTER; // clear the long search flag
            // start the failed sync count and slot count from 0
            rfFailedSyncCount= rfSlotCount= 0;
        } else if (rfState & RF_STATE_MASTER_RIVAL_TEST) {
            // do a short search for master just within the protocol 
            if (RFMasterRivalTest()) {
                rfState&= ~RF_STATE_MASTER;
                rfState&= ~RF_STATE_MASTER_RIVAL_TEST;
                rfFailedSyncCount= rfSlotCount= 0;
            }
        } else if (rfState & (RF_STATE_IN_SYNC | RF_STATE_MASTER)) {
            // if we are in sync or a master and not alone we go on here.
            //
            // we do an arbitration for rf access. if we want to send a packet
            // we draw a random arbitration byte and compete for the medium. if we don't have
            // anything to send, choose 0 as arbitration byte so that arbitration can tell us
            // if the medium is busy or not.
            //
            // if node is alone or not in a traffic group, don't do arbitration pretend the 
            // medium is free.
            arbitrationResult= ((rfState & RF_STATE_ALONE) || !(rfState & RF_STATE_TRAFFIC_GROUP)) ? 
                TRUE : RFArbitration(llState & LL_STATE_NEED_TO_SEND);
            //putchar((arbitrationResult) ? 'y' : 'n');
            if (llState & LL_STATE_NEED_TO_SEND)
                statsRfSlotsNeedToSend++;
            if (arbitrationResult && (llState & LL_STATE_NEED_TO_SEND)) {
                statsRfArbitrationWon++;
                // if we are alone, we just pretend to send the packet and set the flags
                // if we are not in a traffic group we don't send anything and don't update the flags
                if ((rfState & RF_STATE_TRAFFIC_GROUP) && !(rfState & RF_STATE_ALONE))
                    RFSendPacket(FALSE);
                if (rfState & RF_STATE_TRAFFIC_GROUP) {
                    llState&= ~(LL_STATE_NEED_TO_SEND);
                    llState|= LL_STATE_SEND_SUCCESS | LL_STATE_PACKET_JUST_SENT;
                }
                putchar((llState & LL_STATE_NEED_TO_SEND) ? 'n' : 'y');
            } else {
                // only receive a packet if we neither detected a node that wants to send (arbitrationResult == false)
                // nor the receive buffer is locked
                if ( !(arbitrationResult || (llState & LL_STATE_RECEIVE_BUFFER_LOCKED)) ) {
                    // for return type of RFReceivePacket() see documentation of that function
                    // if we are an alone master, we don't need to receive a packet
                    receiveResult= (rfState & RF_STATE_ALONE) ? 0 : RFReceivePacket(&periodDataSyncByteReceiveTimeout, TRUE);
                    //sendByteToUart(receiveResult >> 8);
                    //sendByteToUart(receiveResult);
                    //DEBUG_SPACE;
                    if ((receiveResult & 0xFF) == 1) {
                        length= receiveResult >> 8;
                        /* #ifdef DEBUG_USE_UART
                            sendByteToUart(length);
                            DEBUG_NEWLINE;
                        #endif */
                        LL_payload_received_length= length;
                        statsRfDataPacketsReceivedNotNeedingToSend++;
                        llState|= LL_STATE_NEW_DATA | LL_STATE_PACKET_JUST_RECEIVED;
                        rfSlotsWithoutSignalReceived= 0;
                    }
                }
            }
            statsRfSlotsInSync++;
        } else {
            // if we are not in sync, only try to receive a packet because sending could damage 
            // other packets or disturb an arbitration procedure.
            if ( !(llState & LL_STATE_RECEIVE_BUFFER_LOCKED) ) {
                // for return type of RFReceivePacket() see documentation of that function
                // if we are an alone master, we don't need to receive a packet
                receiveResult= (rfState & RF_STATE_ALONE) ? 0 : RFReceivePacket(&periodDataSyncByteReceiveTimeout, TRUE);
                //sendByteToUart(receiveResult >> 8);
                //sendByteToUart(receiveResult);
                //DEBUG_SPACE;
                if ((receiveResult & 0xFF) == 1) {
                    length= receiveResult >> 8;
                    /* #ifdef DEBUG_USE_UART
                        sendByteToUart(length);
                        DEBUG_NEWLINE;
                    #endif */
                    LL_payload_received_length= length;
                    llState|= LL_STATE_NEW_DATA | LL_STATE_PACKET_JUST_RECEIVED;
                    rfSlotsWithoutSignalReceived= 0;
                }
            }
        }
    } // end of if that determines if current slot is a sync slot
    
    putchar((arbitrationResult) ? 'w' : 'l');
    DEBUG_NEWLINE;

    // check if packet has been sent or sending slot timeout occurred and set the right llState.
    // this used to be done in LLSlotEnd(), but has moved here for efficiency.
    if ((llState & LL_STATE_NEED_TO_SEND)) {
        if (--LL_slots_left == 0) {
            
            if (llState & LL_STATE_CTRL_MESSAGE_INSERTED)   {
                llState&= ~LL_STATE_CTRL_MESSAGE_INSERTED;  // in case it was switched on, switch it off and do NOT update the success state
            } else {
                llState&= ~LL_STATE_SEND_SUCCESS;   // busy is over
            } 
            
            llState&= ~LL_STATE_NEED_TO_SEND;
            LL_payload_sendbuffer_length= 0;        // set used payload to zero
        }
    }

    #ifdef RF_USE_ALONE_DETECTION
        if (rfSlotsWithoutSignalReceived > RF_ALONE_TEST_FAILED_THRESHOLD && !(rfState & RF_STATE_ALONE)) {
            rfState|= RF_STATE_ALONE;
            #ifndef RF_ALONE_DEEP_SLEEP
                rfSlotsInAloneModeLeft= RFAloneRandomNumberOfSlots();
            #endif
        }
    #endif
    
    #ifdef DEBUG_USE_UART
    #ifdef DEBUG_DUMP_RF_STATISTICS
        DebugDumpStats();
    #endif
    #ifdef DEBUG_DUMP_RF_STATE
        DebugDumpRfState();
    #endif
    #endif
    // BLED= LED_ON;  // end isr
    // BLED= LED_OFF; // end isr
    // BLED= LED_ON;  // end isr
    // BLED= LED_OFF; // end isr
} //end isr_timer0()


void isr_timer2() interrupt INUM_TIMER2 {
    INT_SETFLAG(INUM_TIMER2, INT_CLR);
} 

void isr_externalInterrupt() interrupt INUM_EXTERNAL0 {
    INT_SETFLAG(INUM_EXTERNAL0, INT_CLR);
} 


/*****************************************************************************
    MAIN PROGRAM
*****************************************************************************/
void main(void) {
    data unsigned long count=0;
    
    // sets up the board
    ParticleInit();
    
    // initializes and starts all communications layers
    ACLStartUp();
    //ACLSubscribeAll();
    
    while (TRUE) {
        if (!(rfState & RF_STATE_MASTER)) {
            rfState|= RF_STATE_IN_SYNC;
            
            // compose packet content
            count++;
            ACLAddNewType(ACL_TYPE_ASM_HI, ACL_TYPE_ASM_LO);
            ACLAddData(count >> 24);
            ACLAddData(count >> 16);
            ACLAddData(count >> 8);
            ACLAddData(count & 0xFF);
    
            // wait till packet can be sent
            ACLSendPacket(1);
            
            // wait till packet has been sent
            while (ACLSendingBusy())
                RF_LOW_POWER_SLEEP_UNTIL_NEXT_SLOT();
            
            RLED= GLED= LED_OFF;
            /* if (ACLGetSendSuccess())
                putchar('y');
            else
                putchar('n'); */
        }
        
        LLStop();
        //RFLowPowerSleepTillKeyPressed();
        RFLowPowerSleep(5);
        // start sync search
        LLStart();
        RF_LOW_POWER_SLEEP_UNTIL_NEXT_SLOT();
    }  
} // end of main()

---