Remote Access Control

main.c File Reference

---

Detailed Description

Main application source file.

This file contains the setup and main control code for the Remote Keyless Entry application.

• File: main.c
• Compiler: IAR EWAVR 4.11B
• Supported devices: ATtiny45/85
• AppNote: AVR411 - Secure Rolling Code Algorithm for Wireless Link

Author:

Atmel Corporation: http://www.atmel.com
Support email: avr@atmel.com

Name

Revision

1193

Date

2006-10-31 14:21:08 +0100 (ti, 31 okt 2006)

Copyright (c) 2006, Atmel Corporation All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

3. The name of ATMEL may not be used to endorse or promote products derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY ATMEL ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Definition in file main.c.

#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"

Include dependency graph for main.c:

Go to the source code of this file.

Functions
void	errorLoop (byte blinkCount)
void	executeCommand (byte commandCode)
void	handleResetFlags (void)
void	initCommand (void)
void	learnMode (void)
__interrupt void	learnModeSwitchHandler (void)
void	main (void)
void	setupLearnModeIO (void)
void	setupPeripherals (void)
__interrupt void	watchdogInterrupt (void)
Variables
static volatile bool	learnModeRequest = false

---

Function Documentation

void errorLoop

(

byte

blinkCount

)

Loop forever, blinking a LED.

Definition at line 202 of file main.c.

References CPU_F, LEARN_MODE_OUTPUT_BIT, LEARN_MODE_OUTPUT_DDR, LEARN_MODE_OUTPUT_HIGH, and LEARN_MODE_OUTPUT_LOW.

Referenced by handleResetFlags(), and main().

{
        // 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 executeCommand

(

byte

commandCode

)

Perform desired operation based on the given command code.

Definition at line 95 of file main.c.

Referenced by main().

{
        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 handleResetFlags

(

void

)

Read reset flags and act accordingly.

Definition at line 233 of file main.c.

References errorLoop(), and MAX_WATCHDOG_RESETS.

Referenced by main().

{
        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.
}

Here is the call graph for this function:

void initCommand

(

void

)

Initialize IO-pins used by the 'executeCommand' function.

Definition at line 86 of file main.c.

Referenced by main().

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

void learnMode

(

void

)

Enter learn mode loop, exit when long timeout expires.

Definition at line 129 of file main.c.

References BLOCK_SIZE, calcCRC(), copyBytesFromEEPROM(), copyBytesToEEPROM(), CRCReg, enableReception(), eraseTransmitters(), initCRC(), invCipher(), KEY_SIZE, LearnMessage::lastCounterValue, TransmitterInfo::lastCounterValue, LEARN_MODE_OUTPUT_HIGH, LEARN_MODE_OUTPUT_LOW, ReceiveBuffer::learnMessage, longTimeout, MAX_TRANSMITTERS, messageComplete(), prepareInvCipher(), receiveBuffer, receiverTimedOut(), scheduleBuffer, LearnMessage::secretKey, LearnMessage::serialNo, TransmitterInfo::serialNo, sharedKey, startLongTimeout(), stopTimer(), tempKeyStorage, and transmitters().

Referenced by main().

{
        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();
}

Here is the call graph for this function:

__interrupt void learnModeSwitchHandler

(

void

)

ISR called when learn mode input pin changes.

Definition at line 66 of file main.c.

References LEARN_MODE_INPUT_BIT, LEARN_MODE_INPUT_REG, and learnModeRequest.

{
        // Only signal on falling edge.
        if( (LEARN_MODE_INPUT_REG & (1<<LEARN_MODE_INPUT_BIT)) == 0 ) {
                learnModeRequest = true;
        }
}

void main

(

void

)

Definition at line 279 of file main.c.

References calcCMAC(), calcCMACSubkey(), CMACSubkey, COMMAND_CODE_BYTES, ReceiveBuffer::commandMessage, copyBytesFromEEPROM(), CommandMessage::counterValue, cryptoBlock, enableReception(), errorLoop(), executeCommand(), handleResetFlags(), initCommand(), initReceiver(), KEY_SIZE, learnMode(), learnModeRequest, CommandMessage::MAC, MAC_BYTES, messageBytesReceived(), messageComplete(), receiveBuffer, receiverTimedOut(), rx_WriteOFF(), scheduleBuffer, SEQ_COUNTER_BYTES, SERIAL_NO_BYTES, CommandMessage::serialNo, setupLearnModeIO(), setupPeripherals(), stopTimer(), tempKeyStorage, transmitters(), and WINDOW_SIZE.

{
        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;
                }
        }
}

Here is the call graph for this function:

void setupLearnModeIO

(

void

)

Initialize IO-pins and Pin-change interrupt used by learn mode switch and LED.

Definition at line 115 of file main.c.

References LEARN_MODE_INPUT_BIT, LEARN_MODE_INPUT_DDR, LEARN_MODE_INPUT_PULLUP_REG, LEARN_MODE_OUTPUT_BIT, LEARN_MODE_OUTPUT_DDR, LEARN_MODE_OUTPUT_HIGH, LEARN_MODE_PCINT_ENABLE_BIT, LEARN_MODE_PCINT_MASK_BIT, and LEARN_MODE_PCINT_MASK_REG.

Referenced by main().

{
        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 setupPeripherals

(

void

)

Initial setup of misc. peripherals in the AVR.

Definition at line 259 of file main.c.

Referenced by main().

{
        // 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);
}

__interrupt void watchdogInterrupt

(

void

)

ISR called when watchdog times out with interrupts enabled.

Definition at line 78 of file main.c.

{
        // Do nothing. Just wake up.
}

---

Variable Documentation

volatile bool learnModeRequest = false [static]

Set to true by interrupt handler when learn mode swith is activated.

Definition at line 60 of file main.c.

Referenced by learnModeSwitchHandler(), and main().