Remote Access Control

comms.c

Go to the documentation of this file.

// This file has been prepared for Doxygen automatic documentation generation.
#include "comms.h"
#include "common.h"
#include "config.h"
#include "timer.h"
#include "radio.h"



#ifdef USE_UART



#define BAUD_RATE 19200
#define BRREG_VALUE ((CPU_F/16/BAUD_RATE)-1)



static volatile byte * messageBufferPtr;
static volatile byte messageBytesLeft;
static volatile byte messageByteCount;



#pragma vector = USART_RX_vect
__interrupt void receiveHandler(void)
{
        // Store incoming byte in buffer and move ptr.
        *messageBufferPtr++ = UDR0;
        ++messageByteCount;

        // Is buffer full?
        if( --messageBytesLeft == 0 ) {
                // Disable receive interrupts.
                UCSR0B &= ~(1<<RXCIE0);
        } else {
                // Restart timeout.
                startShortTimeout();
        }
}



bool initReceiver(void)
{
        // Pull up input line.
        PORTD |= (1<<PD0);

        // Initialize UART receiver.
        UCSR0B = (1<<RXEN0);
        UBRR0 = BRREG_VALUE;

        return true; // Always succeeds.
}



void enableReception( byte messageSize )
{
        messageBufferPtr = (byte *) &receiveBuffer;
        messageBytesLeft = messageSize;
        messageByteCount = 0;
        UCSR0A |= (1<<RXC0);
        UCSR0B |= (1<<RXCIE0);
}



bool messageComplete(void)
{
        return messageBytesLeft == 0;
}



byte messageBytesReceived(void)
{
        // Don't count preamble.
        if( messageByteCount >= 1 ) {
                return messageByteCount - 1;
        } else {
                return 0;
        }
}



bool receiverTimedOut(void)
{
        if( shortTimeout == true && !messageComplete() ) {
                // Disable reception.
                UCSR0B &= ~(1<<RXCIE0);
                // Indicate timeout.
                return true;
        } else {
                return false;
        }
}



#else



static volatile byte * messageBufferPtr;
static volatile byte messageBytesLeft;
static volatile byte messageByteCount;
static volatile byte messageCurrentByte;
static volatile byte messageBitCount;
static volatile bool messageWaitForStartBit;



#pragma vector = RF_CLOCK_PCINT_VECT
__interrupt void rxClockLineHandler(void)
{
        // Return if it was not a rising edge in clock input pin.
        if( GET_RX_CLOCK() == 0 ) {
                return;
        }

        // Check that data is 0 if we are waiting for start bit.
        if( messageWaitForStartBit ) {
                if( GET_RX_DATA() == 0 ) {
                        messageWaitForStartBit = false;
                        startShortTimeout();
                }
                return;
        }

        // Insert bit into current byte and copy to buffer if 8 bits are received.
        messageCurrentByte <<= 1;
  #ifdef INVERTED_MANCHESTER
        if( GET_RX_DATA() != 0 ) {
  #else
        if( GET_RX_DATA() == 0 ) {
  #endif
                messageCurrentByte |= 0x01;
        }
        if( ++messageBitCount == 8 ) {
                *messageBufferPtr++ = messageCurrentByte;
                messageCurrentByte = 0;
                messageBitCount = 0;
                ++messageByteCount;

                // Disable further interrupts if all bytes are received,
                // else restart the timeout for next byte.
                if( --messageBytesLeft == 0 ) {
                        RF_CLOCK_PCINT_MASK_REG &= ~(1<<RF_CLOCK_PCINT_MASK_BIT);
                        rx_WriteOFF( false );
                } else {
                        startShortTimeout();
                }
        }
}



bool initReceiver(void)
{
        INIT_RX_DATA();
        INIT_RX_CLOCK();

        PCICR |= (1<<RF_CLOCK_PCINT_ENABLE_BIT);

        // Consult receiver datasheet for details on settings.
        rx_OPMODE_t opmode;
        opmode.baudRateRange = 2; // XLim = 3.2 - 5.6 kBaud
        opmode.bitCheck = 1; // 3 valid 1-bits required to wake up receiver.
#ifdef FSK
        opmode.amplitudeModulation = false;
#endif
#ifdef ASK
        opmode.amplitudeModulation = true;
#endif
        opmode.sleepValue = 1; // ~2ms sleep.
        opmode.sleepExtension = false;
        opmode.noiseSuppression = true;

        rx_LIMIT_t limit;
        limit.limMin = RX_LIM_MIN; // 4800 Baud - 20%
        limit.limMax = RX_LIM_MAX; // 4800 Baud + 20%

        bool success = rx_WriteVerifySleep( &opmode, &limit );
        return success;
}



void enableReception( byte messageSize )
{
        messageBufferPtr = (byte *) &receiveBuffer;
        messageBytesLeft = messageSize;
        messageByteCount = 0;
        messageCurrentByte = 0;
        messageBitCount = 0;
        messageWaitForStartBit = true;
        RF_CLOCK_PCINT_MASK_REG |= (1<<RF_CLOCK_PCINT_MASK_BIT);
}



bool messageComplete(void)
{
        return messageBytesLeft == 0;
}



byte messageBytesReceived(void)
{
        return messageByteCount;
}



bool receiverTimedOut(void)
{
        if( shortTimeout == true && !messageComplete() && !messageWaitForStartBit ) {
                // Disable reception.
                RF_CLOCK_PCINT_MASK_REG &= ~(1<<RF_CLOCK_PCINT_MASK_BIT);
                rx_WriteOFF( false );
                // Indicate timeout.
                return true;
        } else {
                return false;
        }
}



#endif