Remote Access Control

comms.c File Reference

---

Detailed Description

Source file for communications public and support functions.

This file contains the function implementation for the communications control functions. Refer to the comms.h file for more details.

• File: comms.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

1686

Date

2007-04-30 12:01:30 +0200 (ma, 30 apr 2007)

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 comms.c.

#include "comms.h"
#include "common.h"
#include "config.h"

Include dependency graph for comms.c:

Go to the source code of this file.

Functions
void	continueTransmission (const byte *buffer, byte byteCount)
void	startTransmission (const byte *buffer, byte byteCount)
void	stopTransmission ()
__interrupt void	USIOverflowHandler (void)
void	waitForTransmission ()
Variables
static const byte __flash	manchesterNibble [16]
static byte	manchesterPartThree
static byte	manchesterPartTwo
static const byte *volatile	nextUSIByte
static volatile byte	USIBytesLeft

---

Function Documentation

void continueTransmission	(	const byte *	buffer,
		byte	byteCount
	)

Add 'byteCount' bytes from 'buffer' in SRAM to an already running transmission.

Definition at line 338 of file comms.c.

References nextUSIByte, and USIBytesLeft.

Referenced by transmitCommandMessage(), and transmitTeachMessage().

{
        // Prepare control variables.
        byte currentByte = *buffer++;
        nextUSIByte = buffer;
        USIBytesLeft = byteCount;

        // Prepare Manchester pattern.
        byte manchesterByte1 = manchesterNibble[ currentByte >> 4 ];
        byte manchesterByte2 = manchesterNibble[ currentByte & 0x0f ];

        // Put bit 0-6 of pattern at the end of USI data register.
        USIDR = USIDR & 0x80 | (manchesterByte1 >> 1);

        // Prepare part two of pattern, ie. bits 6-13.
        manchesterPartTwo = (manchesterByte1 << 6) | (manchesterByte2 >> 2);

        // Prepare part three of pattern, ie. bits 13-15 and 5 dummy zero bits.
        manchesterPartThree = (manchesterByte2 << 5);

        // Enable USI interrupts again.
        USICR |= (1<<USIOIE);
}

void startTransmission	(	const byte *	buffer,
		byte	byteCount
	)

Start transmitting 'byteCount' bytes from 'buffer' in SRAM using Manchester encoding.

Definition at line 266 of file comms.c.

References nextUSIByte, and USIBytesLeft.

Referenced by transmitCommandMessage(), and transmitTeachMessage().

{
        // Prepare control variables.
        byte currentByte = *buffer++;
        nextUSIByte = buffer;
        USIBytesLeft = byteCount;

        // Prepare Manchester pattern.
        byte manchesterByte1 = manchesterNibble[ currentByte >> 4 ];
        byte manchesterByte2 = manchesterNibble[ currentByte & 0x0f ];

        // Put idle bit value and bit 0-6 of pattern in USI data register.
        // This is the first part of the pattern. The output pin changes immediately.
        USIDR = 0x80 | (manchesterByte1 >> 1);

        // Prepare part two of pattern, ie. bits 6-13.
        manchesterPartTwo = (manchesterByte1 << 6) | (manchesterByte2 >> 2);

        // Prepare part three of pattern, ie. bits 13-15 and 5 dummy zero bits.
        manchesterPartThree = (manchesterByte2 << 5);

        // Clear overflow flag and seed USI timer
        // to overflow in 7 bit shifts, so that last bit of first part of pattern is left.
        USISR = (1<<USIOIF) | (16-7);

        // Start USI in Three-wire mode clocked by
        // Timer/Counter0 Compare Match A. Overflow interrupt enabled.
  #ifdef ASK
        USICR = (1<<USIOIE) |
                (0<<USIWM1) | (1<<USIWM0) |   // Three-wire mode, data output on PB1.
                (0<<USICS1) | (1<<USICS0);
  #endif
  #ifdef FSK
        USICR = (1<<USIOIE) |
                (1<<USIWM1) | (0<<USIWM0) |   // Two-wire mode, data output on PB0 (open collector).
                (0<<USICS1) | (1<<USICS0);
        DDRB |= (1<<PB0); // Enable data line output open collector driver.
        PORTB |= ((1<<PB1) | (1<<PB0)); // Turn on carrier wave and give data line to USI module.
  #endif

  #ifdef BPS_19200
        // Set data rate to 19200 bps (ie. 9600 bps with Manchester).
        TCNT0 = 0x00;
        OCR0A = 51; // approx. (8MHz/8/19200bps)-1, ref. CTC Mode in datasheet.
        TCCR0A = (1<<WGM01); // Clear on Compare Match.
        TCCR0B = (0<<CS02) | (1<<CS01) | (0<<CS00); // Prescaler factor 8.
  #endif
  #ifdef BPS_9600
        // Set data rate to 9600 bps (ie. 4800 bps with Manchester).
        TCNT0 = 0x00;
        OCR0A = 103; // approx. (8MHz/8/9600bps)-1, ref. CTC Mode in datasheet.
        TCCR0A = (1<<WGM01); // Clear on Compare Match.
        TCCR0B = (0<<CS02) | (1<<CS01) | (0<<CS00); // Prescaler factor 8.
  #endif
  #ifdef BPS_4800
        // Set data rate to 4800 bps (ie. 2400 bps with Manchester).
        TCNT0 = 0x00;
        OCR0A = 25; // approx. (8MHz/64/2400bps)-1, ref. CTC Mode in datasheet.
        TCCR0A = (1<<WGM01); // Clear on Compare Match.
        TCCR0B = (0<<CS02) | (1<<CS01) | (1<<CS00); // Prescaler factor 64.
  #endif
  #ifdef BPS_2400
        // Set data rate to 2400 bps (ie. 1200 bps with Manchester).
        TCNT0 = 0x00;
        OCR0A = 51; // approx. (8MHz/64/2400bps)-1, ref. CTC Mode in datasheet.
        TCCR0A = (1<<WGM01); // Clear on Compare Match.
        TCCR0B = (0<<CS02) | (1<<CS01) | (1<<CS00); // Prescaler factor 64.
  #endif
}

void stopTransmission

(

)

Stop transmission module and restore previous port states.

Definition at line 368 of file comms.c.

Referenced by transmitCommandMessage(), and transmitTeachMessage().

{
        USICR = 0x00;
  #ifdef FSK
        PORTB &= ~((1<<PB1) | (1<<PB0)); // Turn off carrier wave and release data line.
        DDRB &= ~(1<<PB0); // Disable data line output open collector driver.
  #endif
}

__interrupt void USIOverflowHandler

(

void

)

Put next byte into USI Data Register or stop transmitting.

Definition at line 209 of file comms.c.

References nextUSIByte, and USIBytesLeft.

{
        // 'manchesterPartTwo' is non-zero if part two has not been sent.
        if( manchesterPartTwo != 0x00 ) {
                USISR = (1<<USIOIF) | (16-7);
                USIDR = manchesterPartTwo;
                manchesterPartTwo = 0x00;

                // 'manchesterPartThree' is non-zero if part three has not been sent.
        } else if( manchesterPartThree != 0x00 ) {
                USISR = (1<<USIOIF) | (16-2);
                USIDR = manchesterPartThree;
                manchesterPartThree = 0x00;

                // If part two and three are zero, it's time to prepare next byte.
        } else {
                // Clear overflow flag and seed USI counter.
                // to overflow in 7 bit shifts. It is important to
                // seed the timer this early, so that the computations
                // below does not affect the transmission timing.
                USISR = (1<<USIOIF) | (16-7);

                --USIBytesLeft; // One less byte left to transmit.

                // If bytes left, prepare for sending the next.
                if( USIBytesLeft > 0 ) {
                        byte currentByte = *nextUSIByte++;
                        byte manchesterByte1;
                        byte manchesterByte2;

                        // Prepare Manchester pattern.
                        manchesterByte1 = manchesterNibble[ currentByte >> 4 ];
                        manchesterByte2 = manchesterNibble[ currentByte & 0x0f ];

                        // Put bit 0-6 of pattern at the end of USI data register.
                        USIDR = USIDR & 0x80 | (manchesterByte1 >> 1);

                        // Prepare part two of pattern, ie. bits 6-13.
                        manchesterPartTwo = (manchesterByte1 << 6) | (manchesterByte2 >> 2);

                        // Prepare part three of pattern, ie. bits 13-15 and 5 dummy zero bits.
                        manchesterPartThree = (manchesterByte2 << 5);
                } else {
                        // No bytes left => turn off further interrupts, in case
                        // the call to stopTransmission is delayed.
                        // The USI module will continue transmittion zeros.
                        // We cannot stop the whole USI module, since the user
                        // might want to continue transmitting. In that case, the
                        // user must call continueTransmission as soon as possible
                        // after returning from waitForTransmission.
                        USICR &= ~(1<<USIOIE); // Disable interrupts.
                }
        }
}

void waitForTransmission

(

)

Sleep and wait for a running transmission to finish.

Definition at line 379 of file comms.c.

References USIBytesLeft.

Referenced by transmitCommandMessage(), and transmitTeachMessage().

{
        // Enter Idle sleep mode while waiting for transmission to finish.
        MCUCR = (1<<SE) | (0<<SM1) | (0<<SM0);
        while( USIBytesLeft ) { __sleep(); }
}

---

Variable Documentation

const byte __flash manchesterNibble[16] [static]

Lookup table for converting 4 bits to Manchester encoding.

Definition at line 161 of file comms.c.

byte manchesterPartThree [static]

Part three of Manchester encoded byte.

Definition at line 158 of file comms.c.

byte manchesterPartTwo [static]

Part two of Manchester encoded byte.

Definition at line 156 of file comms.c.

const byte* volatile nextUSIByte [static]

Pointer to next byte to be transmitted.

Definition at line 55 of file comms.c.

Referenced by continueTransmission(), startTransmission(), and USIOverflowHandler().

volatile byte USIBytesLeft [static]

Number of bytes left to transmit.

Definition at line 57 of file comms.c.

Referenced by continueTransmission(), startTransmission(), USIOverflowHandler(), and waitForTransmission().