Remote Access Control

radio.c

Go to the documentation of this file.

// This file has been prepared for Doxygen automatic documentation generation.
#include "radio.h"
#include "common.h"
#include "config.h"
#include <stddef.h>



/* --- Internal definitions for RF recevier programming timing --- */

#define RX_BASIC_CLK_US ( RX_PRESCALE / (RX_XTAL_HZ / 1000000) )

#define PROG_START_PULSE_CYCLES 5000 // Approx. 10% less than max. (t1 in datasheet).
#define PROG_START_RESET_PULSE_CYCLES 8700 // Approx. 10% more than min. (t1 in datasheet).
#define PROG_WINDOW_DELAY_CYCLES 76 // Approx. 20% more than min. (t4 in datasheet).
#define PROG_BIT_PULSE_CYCLES 70 // Approx. 10% more than min. (t7 in datasheet).
#define PROG_RESET_MARKER_PERIOD_CYCLES 4096 // Exact value (f_RM in datasheet).



/* --- Delay macros for RF recevier programming timing --- */

#define DELAY_US( delay ) \
        __delay_cycles( (delay) * (CPU_F / 1000000) )

#define PROG_START_DELAY() \
        DELAY_US( RX_BASIC_CLK_US * PROG_START_PULSE_CYCLES )
#define PROG_START_RESET_DELAY() \
        DELAY_US( RX_BASIC_CLK_US * PROG_START_RESET_PULSE_CYCLES )
#define PROG_WINDOW_DELAY() \
        DELAY_US( RX_BASIC_CLK_US * PROG_WINDOW_DELAY_CYCLES )
#define PROG_BIT_DELAY() \
        DELAY_US( RX_BASIC_CLK_US * PROG_BIT_PULSE_CYCLES )
#define PROG_RESET_MARKER_QUARTER_PERIOD_DELAY() \
        DELAY_US( RX_BASIC_CLK_US * (PROG_RESET_MARKER_PERIOD_CYCLES / 4) )
#define PROG_RESET_MARKER_HALF_PERIOD_DELAY() \
        DELAY_US( RX_BASIC_CLK_US * (PROG_RESET_MARKER_PERIOD_CYCLES / 2) )



/* --- Macros for controlling the RF recevier data line --- */

#define RELEASE_RX_DATA() \
        RX_DATA_DDR_REG &= ~(1<<RX_DATA_BIT_POS);
#define DRIVE_RX_DATA() \
        RX_DATA_DDR_REG |= (1<<RX_DATA_BIT_POS);
#define WAIT_RX_DATA_FALLING( timeoutCountdownVar ) \
        do {} while( (GET_RX_DATA() == 0) && (--timeoutCountdownVar > 0) ); \
        if( timeoutCountdownVar > 0 ) { \
                do {} while( (GET_RX_DATA() != 0) && (--timeoutCountdownVar > 0) ); \
        }
#define WAIT_RX_DATA_RISING( timeoutCountdownVar ) \
        do {} while( (GET_RX_DATA() != 0) && (--timeoutCountdownVar > 0) ); \
        if( timeoutCountdownVar > 0 ) { \
                do {} while( (GET_RX_DATA() == 0) && (--timeoutCountdownVar > 0) ); \
        }
#define WAIT_RX_DATA_EDGE( timeoutCountdownVar ) \
        { \
                unsigned char tempValue = GET_RX_DATA(); \
                do {} while( (GET_RX_DATA() == tempValue) && (--timeoutCountdownVar > 0) ); \
        }



/* --- Functions for programming the RF recevier --- */

typedef unsigned int rx_timeout_t;
#define RX_TIMEOUT_VALUE (RX_BASIC_CLK_US * PROG_RESET_MARKER_PERIOD_CYCLES)



bool rx_WriteRegister( unsigned int value, bool longStartPulse, bool * equivalenceValue )
{
        unsigned char bitCount = 15;
        rx_timeout_t timeoutCountdown;

        DRIVE_RX_DATA(); // Begin 'programming start' pulse.
        if( longStartPulse == true ) {
                PROG_START_RESET_DELAY();
        } else {
                PROG_START_DELAY();
        }
        RELEASE_RX_DATA(); // End 'programming start' pulse.

        do {
                timeoutCountdown = RX_TIMEOUT_VALUE;
                WAIT_RX_DATA_FALLING( timeoutCountdown ) // Wait for synch. pulse begin edge.
                if( timeoutCountdown == 0 ) return false; // Timed out!
                timeoutCountdown = RX_TIMEOUT_VALUE;
                WAIT_RX_DATA_RISING( timeoutCountdown ) // Wait for synch. pulse end edge.

                if( timeoutCountdown == 0 ) return false; // Timed out!

                PROG_WINDOW_DELAY(); // Wait for programming window.
                if( !(value & 0x8000) ) {
                        DRIVE_RX_DATA(); // Drive data line low to indicate logic 0.
                        PROG_BIT_DELAY(); // Bit pulse duration.
                        RELEASE_RX_DATA(); // Release line after bit pulse.
                } else {
                        PROG_BIT_DELAY(); // Bit pulse duration for logic 1.
                }

                value <<= 1; // Move next bit into MSB of word.
        } while( --bitCount );

        bool equivalenceBit;
        timeoutCountdown = RX_TIMEOUT_VALUE;
        WAIT_RX_DATA_FALLING( timeoutCountdown ); // Wait for equivalence pulse begin egde.
        if( timeoutCountdown == 0 ) {
                equivalenceBit = false; // Timed out => no pulse.
        } else {
                timeoutCountdown = RX_TIMEOUT_VALUE;
                WAIT_RX_DATA_RISING( timeoutCountdown ) // Wait for equivalence pulse end edge.
                if( timeoutCountdown == 0 ) return false; // Timed out!
                equivalenceBit = true; // No timeout => pulse present.
        }

        // If pointer is supplied, store equivalence bit.
        if( equivalenceValue ) {
                *equivalenceValue = equivalenceBit;
        }

        return true; // Success!
}



bool rx_CheckResetMarker( unsigned char checkCycles )
{
        rx_timeout_t timeoutCountdown;

        timeoutCountdown = RX_TIMEOUT_VALUE;
        WAIT_RX_DATA_EDGE( timeoutCountdown ); // Wait for first edge.
        if( timeoutCountdown == 0 ) return false; // Timed out => no reset marker.
        PROG_RESET_MARKER_QUARTER_PERIOD_DELAY(); // Wait until the middle of the half-period.

        unsigned char tempValue = GET_RX_DATA();
        do {
                PROG_RESET_MARKER_HALF_PERIOD_DELAY(); // Wait until next half of period.

                if( GET_RX_DATA() == tempValue ) {
                        // No change on data line => no reset marker.
                        return false;
                } else {
                        // Change => Store value and check next half-period.
                        tempValue = GET_RX_DATA();
                }
        } while( --checkCycles );

        return true; // Yes, we found the reset marker.
}



bool rx_WriteOFF( bool longStartPulse )
{
        rx_timeout_t timeoutCountdown;

        DRIVE_RX_DATA(); // Begin 'programming start' pulse.
        if( longStartPulse == true ) {
                PROG_START_RESET_DELAY();
        } else {
                PROG_START_DELAY();
        }
        RELEASE_RX_DATA(); // End 'programming start' pulse.

        timeoutCountdown = RX_TIMEOUT_VALUE;
        WAIT_RX_DATA_FALLING( timeoutCountdown ); // Wait for synch. pulse begin edge.
        if( timeoutCountdown == 0 ) return false; // Timed out!
        timeoutCountdown = RX_TIMEOUT_VALUE;
        WAIT_RX_DATA_RISING( timeoutCountdown ); // Wait for synch. pulse end edge.
        if( timeoutCountdown == 0 ) return false; // Timed out!

        PROG_WINDOW_DELAY(); // Wait for programming window.
        PROG_BIT_DELAY(); // Bit pulse duration for logic 1.

        return true; // Success!
}



bool rx_WriteOPMODE( const rx_OPMODE_t * settings, bool longStartPulse, bool * equivalenceValue )
{
        if( settings == NULL ) {
                return false; // Invalid input.
        }

        // Check that no fields exceed their bitfield's max value.
        if( settings->baudRateRange >= (1<<2) ||
                        settings->bitCheck >= (1<<2) ||
                        settings->amplitudeModulation >= (1<<1) ||
                        settings->sleepValue >= (1<<5) ||
                        settings->sleepExtension >= (1<<1) ||
                        settings->noiseSuppression >= (1<<1) ) {
                return false; // Invalid input.
        }

        unsigned int registerValue = 0x4000; // Blank OPMODE frame.
        // Place fields correctly in frame.
        // Shift amount = register value bits (16) - position from right - field size in bits.
        registerValue |= settings->baudRateRange << (16-2-2);
        registerValue |= settings->bitCheck << (16-4-2);
        registerValue |= settings->amplitudeModulation << (16-6-1);
        registerValue |= settings->sleepValue << (16-7-5);
        registerValue |= settings->sleepExtension << (16-12-1);
        registerValue |= settings->noiseSuppression << (16-13-1);

        return rx_WriteRegister( registerValue, longStartPulse, equivalenceValue );
}



bool rx_WriteLIMIT( const rx_LIMIT_t * settings, bool longStartPulse, bool * equivalenceValue )
{
        if( settings == NULL ) {
                return false; // Invalid input.
        }

        if( settings->limMin >= (1<<6) || settings->limMax >= (1<<6) ) {
                return false; // Invalid input.
        }

        unsigned int registerValue = 0x0000; // Blank LIMIT frame.
        // Place fields correctly in frame.
        // Shift amount = register value bits (16) - position from right - field size in bits.
        registerValue |= settings->limMin << (16-2-6);
        registerValue |= settings->limMax << (16-8-6);

        return rx_WriteRegister( registerValue, longStartPulse, equivalenceValue );
}



bool rx_WriteVerifySleep( const rx_OPMODE_t * opmode, const rx_LIMIT_t * limit )
{
        bool success;
        bool equivalent;

        success = rx_WriteOPMODE( opmode, true, NULL );
        if( !success ) {
                // Try again of no success on first try.
                success = rx_WriteOPMODE( opmode, true, NULL );
                if( !success ) return false;
        }
        success = rx_WriteOPMODE( opmode, false, &equivalent );
        if( !success || !equivalent ) {
                // Try again of no success on first try.
                success = rx_WriteOPMODE( opmode, false, &equivalent );
                if( !success || !equivalent ) return false;
        }

        success = rx_WriteLIMIT( limit, false, NULL );
        if( !success ) {
                // Try again of no success on first try.
                success = rx_WriteLIMIT( limit, false, NULL );
                if( !success ) return false;
        }
        success = rx_WriteLIMIT( limit, false, &equivalent );
        if( !success || !equivalent ) {
                // Try again of no success on first try.
                success = rx_WriteLIMIT( limit, false, &equivalent );
                if( !success || !equivalent ) return false;
        }

        success = rx_WriteOFF( false );
        if( !success ) {
                // Try again of no success on first try.
                success = rx_WriteOFF( false );
                if( !success ) return false;
        }

        return true;
}