Remote Access Control

main.c

Go to the documentation of this file.

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


static volatile bool learnModeRequest = false;



#pragma vector = LEARN_MODE_PCINT_VECT
__interrupt void learnModeSwitchHandler(void)
{
        // Only signal on falling edge.
        if( (LEARN_MODE_INPUT_REG & (1<<LEARN_MODE_INPUT_BIT)) == 0 ) {
                learnModeRequest = true;
        }
}



#pragma vector = WDT_vect
__interrupt void watchdogInterrupt(void)
{
        // Do nothing. Just wake up.
}



void initCommand( void )
{
        DDRC |= (1<<PC0) | (1<<PC1) | (1<<PC2) | (1<<PC3) | (1<<PC4);
        PORTC |= (0<<PC0) | (1<<PC1) | (1<<PC2) | (1<<PC3) | (1<<PC4);
}



void executeCommand( byte commandCode )
{
        byte oldValue = PORTC;
        byte LEDMask = (1<<PC0) | (1<<PC1) | (1<<PC2) | (1<<PC3) | (1<<PC4);
        byte oldLEDs = oldValue & LEDMask;

        oldValue &= ~LEDMask;

        if( commandCode == (1<<1) ) {
                PORTC = oldValue |
                                ( ((oldLEDs << 1) | (oldLEDs >> 4)) & LEDMask );
        } else if( commandCode == (1<<2) ) {
                PORTC = oldValue |
                                ( ((oldLEDs >> 1) | (oldLEDs << 4)) & LEDMask );
        }
}



void setupLearnModeIO(void)
{
        PCICR |= (1<<LEARN_MODE_PCINT_ENABLE_BIT);
        LEARN_MODE_PCINT_MASK_REG |= (1<<LEARN_MODE_PCINT_MASK_BIT);
        LEARN_MODE_INPUT_DDR &= ~(1<<LEARN_MODE_INPUT_BIT);
        LEARN_MODE_INPUT_PULLUP_REG |= (1<<LEARN_MODE_INPUT_BIT);

        LEARN_MODE_OUTPUT_DDR |= (1<<LEARN_MODE_OUTPUT_BIT);
        LEARN_MODE_OUTPUT_HIGH();
}



void learnMode(void)
{
        LEARN_MODE_OUTPUT_LOW();

        startLongTimeout();

#ifndef DONT_ERASE_TRANSMITTERS
        bool transmittersErasedYet = false;
        while( !longTimeout && (transmittersErasedYet == false || transmitterCount < MAX_TRANSMITTERS) ) {
#else
        while( !longTimeout && transmitterCount < MAX_TRANSMITTERS) {
#endif
                // Restart watchdog if it timed out.
                __watchdog_reset();
                WDTCSR |= (1<<WDIE);

                enableReception( sizeof( LearnMessage ) );
                while( !messageComplete() && !receiverTimedOut() && !longTimeout ) {
                        // Restart watchdog if it timed out.
                        if( !(WDTCSR & (1<<WDIE)) ) {
                                __watchdog_reset();
                                WDTCSR |= (1<<WDIE);
                        }
                        __sleep();
                }

                if( messageComplete() ) {
                        initCRC();
                        byte i;
                        for( i = 0; i < sizeof( LearnMessage ); ++i ) {
                                calcCRC( ( (byte *) &receiveBuffer.learnMessage )[ i ] );
                        }
                        if( (CRCReg[0] == 0) && (CRCReg[1] == 0) ) {
                                LEARN_MODE_OUTPUT_HIGH();
                                copyBytesFromEEPROM( tempKeyStorage, sharedKey, KEY_SIZE );
                                prepareInvCipher( scheduleBuffer, tempKeyStorage );
                                invCipher( receiveBuffer.learnMessage.secretKey,
                                                scheduleBuffer );
#if KEY_SIZE == 24 || KEY_SIZE == 32
                                prepareInvCipher( scheduleBuffer, tempKeyStorage );
                                invCipher( receiveBuffer.learnMessage.secretKey + BLOCK_SIZE,
                                                scheduleBuffer );
#endif
#ifndef DONT_ERASE_TRANSMITTERS
                                if( transmittersErasedYet == false ) {
                                        eraseTransmitters();
                                        transmittersErasedYet = true;
                                }
#endif

                                transmitters[ transmitterCount ].serialNo =
                                        receiveBuffer.learnMessage.serialNo;
                                transmitters[ transmitterCount ].lastCounterValue =
                                        receiveBuffer.learnMessage.lastCounterValue;
                                copyBytesToEEPROM( transmitters[ transmitterCount ].secretKey,
                                                receiveBuffer.learnMessage.secretKey, KEY_SIZE );
                                ++transmitterCount;
                                LEARN_MODE_OUTPUT_LOW();

                                startLongTimeout();
                        }
                }
        }

        stopTimer();
        LEARN_MODE_OUTPUT_HIGH();
}





void errorLoop( byte blinkCount )
{
        // Initialize Watchdog Timer.
        __watchdog_reset();
        WDTCSR = (1<<WDCE) | (1<<WDE);
        WDTCSR = (1<<WDCE) | (1<<WDE) | (1<<WDP3) | (1<<WDP0);
        WDTCSR |= (1<<WDIF) | (1<<WDIE);

        // Enable Power Down Sleep Mode.
        SMCR = (0<<SM2) | (1<<SM1) | (0<<SM0) | (1<<SE);;

        // Start blinking.
        __enable_interrupt();
        LEARN_MODE_OUTPUT_DDR |= (1<<LEARN_MODE_OUTPUT_BIT);
        for(;;) {
                __sleep();
                __watchdog_reset();
                WDTCSR |= (1<<WDIE);
                byte blinks;
                for( blinks = 0; blinks < blinkCount; ++blinks ) {
                        LEARN_MODE_OUTPUT_LOW();
                        __delay_cycles( (CPU_F/1000)*50 ); // 50ms
                        LEARN_MODE_OUTPUT_HIGH();
                        __delay_cycles( (CPU_F/1000)*50 ); // 50ms
                }
        }
}



void handleResetFlags( void )
{
        static __no_init byte __eeprom watchdogResetCount; // Will be set to 0 on first Power-up.

        // Read and clear reset flags.
        byte resetFlags = MCUSR;
        MCUSR = 0x00;

        // Check for reset sources.
        if( resetFlags & (1<<PORF) ) {
                // Clear watchdog reset count on power on reset, e.g. battery change.
                watchdogResetCount = 0;
        }
        if( resetFlags & (1<<WDRF) ) {
                if( watchdogResetCount >= MAX_WATCHDOG_RESETS ) {
                        errorLoop( 1 );
                } else {
                        ++watchdogResetCount;
                }
        }
        // We don't handle Brown-out Resets specially.
}



void setupPeripherals( void )
{
        // Initialize Watchdog Timer.
        __watchdog_reset();
        WDTCSR = (1<<WDCE) | (1<<WDE);
        WDTCSR = (1<<WDCE) | (1<<WDE) | (1<<WDP3) | (1<<WDP0);
        WDTCSR |= (1<<WDIF) | (1<<WDIE);

        // Turn off unused modules to save power/oomph.
        ACSR = (1<<ACD);
// Disabling modules using PRR doesn't work with debugWIRE.
//      PRR = (1<<PRTWI) | (1<<PRTIM2) | (1<<PRTIM0) | (0<<PRTIM1) |
//              (1<<PRSPI) | (0<<PRUSART0) | (1<<PRADC);

        // Enable Idle Sleep Mode.
        SMCR = (0<<SM2) | (0<<SM1) | (0<<SM0) | (1<<SE);
}



void main( void )
{
        handleResetFlags();
        __delay_cycles( 8000000 ); // Allow RF receiver to power up.
        if( !initReceiver() ) {
                errorLoop( 3 );
        }
        setupPeripherals();
        setupLearnModeIO();
        initCommand();
        __enable_interrupt();
        
        for(;;) { // Loop forever.
                // Wait for reception of serial number.
                stopTimer(); // Save power while we wait for something to happen.
                enableReception( sizeof( CommandMessage ) );

                // Restart watchdog.
                __watchdog_reset();
                WDTCSR |= (1<<WDIE);

                // Wait for reception, timeout or learn mode request.           
                while( messageBytesReceived() < SERIAL_NO_BYTES &&
                                !receiverTimedOut() &&
                                !learnModeRequest) {
                        // If watchdog times out, restart it since there's nothing
                        // wrong now, and issue an OFF command to the RF receiver in
                        // case external RF noise woke it up.
                        if( !(WDTCSR & (1<<WDIE)) ) {
                                __watchdog_reset();
                                WDTCSR |= (1<<WDIE);
                                rx_WriteOFF( false );
                        }
                        __sleep();
                }

                // Enter learn mode if button is pressed. Ignore any received messages.
                if( learnModeRequest ) {
                        learnMode();
                        learnModeRequest = false;
                        continue;
                }

                if( receiverTimedOut() ) {
                        continue; // Restart loop on timeout.
                }

                // Search for transmitter serial number.
                byte transmitterIdx = 0;
                TransmitterInfo __eeprom * transmitter = transmitters;
                bool found = false;
                while( transmitterIdx < transmitterCount && !found) {
                        if( receiveBuffer.commandMessage.serialNo ==
                                        transmitter->serialNo ) {
                                found = true;
                        } else {
                                ++transmitterIdx;
                                ++transmitter;
                        }
                }

                // Invalid serial numer => ignore rest of transmission and restart loop.
                if( !found ) {
                        while( !messageComplete() && !receiverTimedOut() ) {
                                __sleep();
                        }

                        continue;
                }
                
                // Get transmitter's secret key from table.
                copyBytesFromEEPROM( tempKeyStorage,
                                transmitter->secretKey,
                                KEY_SIZE );

                // Calculate subkey for CMAC generation.
                calcCMACSubkey( CMACSubkey, scheduleBuffer,
                                tempKeyStorage );

                // Wait for reception of counter value.
                while( messageBytesReceived() <
                                SERIAL_NO_BYTES + SEQ_COUNTER_BYTES &&
                                !receiverTimedOut() ) {
                        __sleep();
                }

                if( receiverTimedOut() ) {
                        continue; // Restart loop on timeout.
                }

                // If counter value outside window, ignore rest of transmission and restart loop.
                if( receiveBuffer.commandMessage.counterValue -
                                (transmitter->lastCounterValue + 1) >=
                                WINDOW_SIZE ) {
                        while( !messageComplete() && !receiverTimedOut() ) {
                                __sleep();
                        }

                        continue;
                }

                // Wait for whole message except MAC.
                while( messageBytesReceived() <
                                SERIAL_NO_BYTES + SEQ_COUNTER_BYTES +
                                COMMAND_CODE_BYTES &&
                                !receiverTimedOut() ) {
                        __sleep();
                }

                if( receiverTimedOut() ) {
                        continue; // Restart loop on timeout.
                }

                // Calculate CMAC.
                calcCMAC( (const byte *) &receiveBuffer.commandMessage.serialNo,
                                CMACSubkey,
                                scheduleBuffer,
                                tempKeyStorage,
                                cryptoBlock );

                // Wait for whole message, ie. the CMAC value.
                while( !messageComplete() && !receiverTimedOut() ) {
                        __sleep();
                }

                if( receiverTimedOut() ) {
                        continue; // Restart loop on timeout.
                }
                
                // Compare generated CMAC with received CMAC.
                byte MACIdx = 0;
                bool stillMatches = true;
                byte * generatedMAC = cryptoBlock;
                byte * receivedMAC = receiveBuffer.commandMessage.MAC;
                while( MACIdx < MAC_BYTES && stillMatches ) {
                        if( *generatedMAC++ != *receivedMAC++ ) {
                                stillMatches = false;
                        }
                        ++MACIdx;
                }

                // If MAC is ok, execute command and update counter value for this transmitter.
                if( stillMatches ) {
                        executeCommand( receiveBuffer.commandMessage.
                                        commandCode );
                        transmitter->lastCounterValue =
                                receiveBuffer.commandMessage.counterValue;
                }
        }
}