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 "crc.h"



#pragma vector = PCINT0_vect
static __interrupt void pinChangeHandler(void)
{
        COMMAND_CODE_TYPE lastButtonState;
        COMMAND_CODE_TYPE newButtonState;
        unsigned char equalCount = 0;

        lastButtonState = PINB & BUTTON_MASK;
        do {
                __delay_cycles( 8000 ); // Allow for debounce and human slowness. Empirical value.
                newButtonState = PINB & BUTTON_MASK;
                if( newButtonState == lastButtonState ) {
                        ++equalCount;
                } else {
                        equalCount = 0;
                        lastButtonState = newButtonState;
                }
        } while( equalCount < 10 ); // 10 is empirical value.
}



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



COMMAND_CODE_TYPE sleepAndGetCommand(void)
{
        COMMAND_CODE_TYPE buttonState;

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

        // Enable Pin Change Interrupt.
        __delay_cycles( 100 ); // Wait for RF TX ctrl pins to settle. Empirical value.
        GIFR |= (1<<PCIF);
        GIMSK |= (1<<PCIE);

        do {
#ifndef NOWDT
                // Restart watchdog if it timed out.
                if( !(WDTCR & (1<<WDIE)) ) {
                        __watchdog_reset();
                        WDTCR |= (1<<WDIE);
                }
#endif
                __sleep(); // Wait for Pin-Change Interrupt.

                // Read pins and mask out unused inputs according pin change mask.
                buttonState = PINB & BUTTON_MASK;
        } while( !buttonState );

        GIMSK &= ~(1<<PCIE); // Good practice to turn off interrupt.

        return buttonState;
}




void errorLoop( byte blinkCount )
{
        // Initialize Watchdog Timer.
        __watchdog_reset();
        WDTCR = (1<<WDCE) | (1<<WDE);
        WDTCR = (1<<WDCE) | (1<<WDE) | (1<<WDP3) | (1<<WDP0);
        WDTCR |= (1<<WDTIF) | (1<<WDTIE);

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

        // Start blinking.
        __enable_interrupt();
        DDRB = (1<<PB3);
        PORTB = (0<<PB3);
        for(;;) {
                __sleep();
                __watchdog_reset();
                WDTCR |= (1<<WDTIE);
                byte blinks;
                for( blinks = 0; blinks < blinkCount; ++blinks ) {
                        PORTB = (1<<PB3);
                        __delay_cycles( (8000000/1000)*50 ); // 50ms
                        PORTB = (0<<PB3);
                        __delay_cycles( (8000000/1000)*50 ); // 50ms
                }
        }
}



void transmitCommandMessage( COMMAND_CODE_TYPE command )
{
        const byte preburst = 0xff;
        byte i;

        createMessage( command );
        startTransmission( &preburst, 1 );
        for( i = 0; i < PREBURST_BYTES-1; ++i ) {
                waitForTransmission();
                continueTransmission( &preburst, 1 );
        }
        waitForTransmission();
        continueTransmission( (const byte *)
                        &sharedBlock.messagePayload,
                        sizeof( struct MessagePayload ) );
        calcCMAC( (const byte *)
                        &sharedBlock.messagePayload.serialNo,
                        cryptoBlock );
        waitForTransmission();
        
        // Send MAC bytes and one extra byte to make sure all Manchester edges are recognized
        // at the receiver. Actually only one extra edge after the last MAC byte would be enough,
        // but it is more convenient to just add another byte in the transmission.
        cryptoBlock[ MAC_BYTES ] = 0x00; // Don't reveal more MAC bytes than necessary.
        continueTransmission( cryptoBlock, MAC_BYTES + 1 );

        startCounterUpdate();
        waitForTransmission();
        stopTransmission();
        waitForCounterUpdate();
}



void transmitTeachMessage( void )
{
        const byte preburst = 0xff;
        byte i;

        calcKeySchedule( sharedKey );
        initCRC();
        startTransmission( &preburst, 1 );
        for( i = 0; i < PREBURST_BYTES-1; ++i ) {
                waitForTransmission();
                continueTransmission( &preburst, 1 );
        }
        waitForTransmission();
        continueTransmission( (const byte*)
                        &sharedBlock.messagePayload,
                        SERIAL_NO_BYTES + SEQ_COUNTER_BYTES + 1 );
        for( i = 0; i < SERIAL_NO_BYTES + SEQ_COUNTER_BYTES; ++i ) {
                calcCRC( ((byte *) &sharedBlock.messagePayload.serialNo)[ i ] );
        }
        copyBytesFromEEPROM( cryptoBlock,
                        secretKey, BLOCK_SIZE );
        cipherLookup( cryptoBlock );
        waitForTransmission();
        continueTransmission( cryptoBlock, BLOCK_SIZE );
        for( i = 0; i < BLOCK_SIZE; ++i ) {
                calcCRC( cryptoBlock[ i ] );
        }
#if KEY_SIZE > BLOCK_SIZE
        copyBytesFromEEPROM( sharedBlock.cryptoBlock,
                        secretKey + BLOCK_SIZE,
                        KEY_SIZE - BLOCK_SIZE );
#if KEY_SIZE < (2*BLOCK_SIZE)

        for( i = KEY_SIZE - BLOCK_SIZE; i < BLOCK_SIZE; ++i ) {
                sharedBlock.cryptoBlock[ i ] = 0x00;
        }
#endif
        cipherLookup( sharedBlock.cryptoBlock );
        waitForTransmission();
        continueTransmission( sharedBlock.cryptoBlock,
                        BLOCK_SIZE );
        for( i = 0; i < BLOCK_SIZE; ++i ) {
                calcCRC( sharedBlock.cryptoBlock[ i ] );
        }
#endif

        calcCRC( 0x00 );
        calcCRC( 0x00 );
        waitForTransmission();
        continueTransmission( CRCReg, 3 ); // Transmit one extra byte, see comment for MAC transmission in transmitCommandMessage(...).
        calcKeySchedule( secretKey );
        initializeMessage();
        waitForTransmission();
        stopTransmission();
}



void handleResetFlags( void )
{
#ifndef NOWDT
        static __no_init byte __eeprom watchdogResetCount; // Will be set to 0 or 0xff on first Power-up.
        if( watchdogResetCount == 0xff ) {
                watchdogResetCount = 0x00;
        }
#endif

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

        // Check for reset sources.
        if( resetFlags & ((1<<PORF)|(1<<EXTRF)) ) { // Power-on or External Reset?
#ifndef NOWDT
                watchdogResetCount = 0;
#endif
        }
#ifndef NOWDT
        if( resetFlags & (1<<WDRF) ) { // Watchdog Reset?
                if( watchdogResetCount >= MAX_WATCHDOG_RESETS ) {
                        errorLoop( 2 );
                } else {
                        ++watchdogResetCount;
                }
        }
#endif
#ifndef NOBOD   
        if( resetFlags & (1<<BORF) ) { // Brown Out Reset?
                errorLoop( 1 );
        }
#endif
}



void setupPeripherals( void )
{
#ifndef NOWDT
        // Initialize Watchdog Timer.
        __watchdog_reset();
        WDTCR = (1<<WDCE) | (1<<WDE);
        WDTCR = (1<<WDCE) | (1<<WDE) | (1<<WDP3) | (1<<WDP0);
        WDTCR |= (1<<WDIF) | (1<<WDIE);
#endif

        // Setup Pin-change input mask.
        PCMSK = BUTTON_MASK;

        // Setup IO ports.
        PORTB = (0<<PB0) |
                (0<<PB1) |
                (0<<PB2) |
                (0<<PB3) |
                (0<<PB4) |
                (0<<PB5);
        DDRB |= (1<<PB4); // Transmitter Enable signal is output.

        // Turn off unused modules to save power/oomph.
        ACSR |= (1<<ACD);
        PRR = (1<<PRTIM1) | (1<<PRADC);

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



void main(void)
{
        handleResetFlags();
        setupPeripherals();
        initializeMessage();
        calcKeySchedule( secretKey );
        calcCMACSubkey( cryptoBlock );
        __enable_interrupt();

        for(;;) { // Loop for ever.

                PORTB &= ~(1<<PB4); // Disable transmitter.
                DDRB &= ~(1<<PB1); // PB1 back to input for button input.

                COMMAND_CODE_TYPE command = sleepAndGetCommand();

                PORTB |= (1<<PB4); // Enable transmitter.
                DDRB |= (1<<PB1); // PB1 to output for both ASK and FSK.

                // Allow time for transmitter to start up.
                __delay_cycles( 8000000 / 1000 * 5 ); // 5ms, given in datasheet.

                if( command != TEACH_COMMAND ) {
                        transmitCommandMessage( command );
                } else {
                        transmitTeachMessage();
                }
        }
}