www.open-tager.ru

/**************************************************************
 *****          Mouse-Implanted RFID Project            *******
 *****               Base Station Code                  *******
 *****                                                  *******
 *****                 By Dan Golden                    *******
 *****                  09/11/2004                      *******
 **************************************************************/


/* This code is for the Atmel Mega32 Microcontroller */

/************************************
 *****    Port Description    *******
 ************************************

Inputs:
D[2]         Base Station Data Output

Outputs:
C[0:7]         LEDs (for testing)


/************************************
 *****    Encoding Notes      *******
 ************************************

Manchester encoding is used to communicate from the transponder to the base station.
Traditionally, in manchester encoding, the data ALWAYS contains an edge on the
clock's falling edge; a logic 1 is a rising edge, a logic 0 is a falling edge.
However, this base station INVERTS the received data; hence, a logic 1 is a falling
edge on the falling clock edge, and a logic 0 is a rising edge on the falling clock
edge.

Ex.
            _   _   _   _   _   _   _   _
CLK          |_| |_| |_| |_| |_| |_| |_| |_
            _   _     _   ___     ___   _
DATA Sent    |_| |___| |_|   |___|   |_| |_
              _   ___   _     ___     _   _
DATA Rec'd  _| |_|   |_| |___|   |___| |_|

           | 0 | 0 | 1 | 1 | 0 | 1 | 0 | 0 |
           
Obviously, the received data is what is parsed.

Clock Periods of Note:
Width of one half clock period:       256 us   =   64 CLK/64 cycles
Width of one full clock period:       513 us   =   128 CLK/64 cycles
Width of four clock periods (1/2 byte):   2.05 ms   =   512 CLK/64 cycles
*/

/************************************
 *****         Includes      *******
 ************************************/

#include <Mega32.h>
#include <stdio.h>
#include <stdlib.h>     
#include <string.h> 

/************************************
 *****        Definitions     *******
 ************************************/

#define dataInput PIND.2
#define debugOut PORTA.0
#define LEDs PORTC

/************************************
 *****     Global Variables   *******
 ************************************/

unsigned char count;         // General indexing variable

unsigned char bitStream[3];   // Used to parse input data
unsigned char bitNumber, byteNumber;
unsigned char lastEdge, thisEdge, CLKedge, getData;

unsigned char data;         /* The data byte received at the Base Station from the
                  transponder. */
unsigned char dataReady;      // True when the data is ready
unsigned char junkByte;      // True if the current byte is invalid
unsigned char junkCounter;   // # of successive junk bytes since last sync

char sync;              // Sync level
                      // 0: not syncing (receiving data)
                      // -1: not synced (waiting for sync pulse)

/************************************
 *****   Function Prototypes  *******
 ************************************/

void initialize(void);

/************************************
 *****       Interrupts       *******
 ************************************/

/* This interrupt is used only for FINDING the clock from the initial clock sync
   byte. Parsing DATA is done separately. */
interrupt [EXT_INT0] void data_edge(void)
{
   thisEdge = dataInput;
   
   // If the detected period is too low (T < 200 us), then label
   // this byte as junk.
   if(TCNT1 < 50)
      junkByte = 1;      // Label the byte as junk.

   // 200 us < T < 384 us. This period occurs after a clock edge or a same-bit
   // boundary (e.g., 1-1 or 0-0).
   else if (TCNT1 < 96)
   {
      // If we're at a clock edge...
      if (CLKedge)
      {
         CLKedge = 0;
         getData = 1;
        }
      else
         CLKedge = 1;
   }
   // 384 us < T < 600 us.
   // This period occurs after an opposing-bit boundary ONLY.
   else if (TCNT1 < 150)
   {
      CLKedge = 0;
      getData = 1;
   }
   // If the pulse period is too different from any legal values, the byte is junk.
   else
   {
      junkByte = 1;
   }
   
   // Reset timer1
   TCNT1 = 0;
   
   // If we're on a rising clock edge, it's time to get the data
   if (getData)
   {
      getData = 0;
      
      // Shift bitstream down
      bitStream[0] >>= 1;
      bitStream[0] |= (bitStream[1] << 7);
      bitStream[1] >>= 1;
      bitStream[1] |= (bitStream[2] << 7);
      bitStream[2] >>= 1;
      
      // Insert the most recent bit into bitStream
      bitStream[2] |= ((!dataInput) << 7);

      bitNumber++;
   }
      
   // If we have sync, and we've just updated bitStream and bitStream has
   // all 8 bits of data, then read the data. If the data has been
   // marked as junk for any reason, then set it to 0xff.
   if ((~CLKedge) && (sync != -1) && (bitNumber == 8))
   {   
      // If the data is junk, make it 0xff.
      if (junkByte)
      {
         data = 0xff;
         junkCounter++;
      }
      else
      {
         data = bitStream[2];
         junkCounter = 0;
      }
         
      byteNumber++;

      // Force a sync every 100 data bytes, or if we get three junk
      // bytes in a row.
      if ((byteNumber == 100) || (junkCounter > 2))
      {
         sync = -1;
         TCNT0 = 0;
         TIMSK |= 0b00000010;   // Send 0xff's while syncing
      }
      
      dataReady = 1;
      bitNumber = 0;
      junkByte = 0;
   }
   // If we're searching for the sync stream...
   else if ((~CLKedge) && (sync == -1))
   {
      // If we've found the sync, stop searching and get ready for data.
      if ((bitStream[0] == 0x00) && (bitStream[1] == 0xff) &&
         (bitStream[2] == 0xff))
      {
         sync = 0;
         TIMSK &= 0b11111101;   // Stop sending 0xff's
         bitNumber = 0;
         byteNumber = 0;
      }
   }
}

interrupt [TIM0_COMP] void timer0_compare(void)
{
   data = 0xff;
   dataReady = 1;
}


/************************************
 *****         Main           *******
 ************************************/

void main(void)
{
   initialize();
   
   while(1)
   {
      if (dataReady)         // If we have received data...
      {
         LEDs = ~data;
         dataReady = 0;      // Prepare for new data
         printf("%c", data);   // send data to USART
      }


      if (TIFR & 0x04)      // If timer 1 has overflowed (T = 0.26 sec)...
      {
         TIFR = TIFR | 0x04;   // Clear TOV1.
         sync = -1;         // Start syncing.
         TCNT0 = 0;
         TIMSK |= 0b00000010;   // Send 0xff's while syncing.
      }

   }
}

/************************************
 *****  Function Definitions  *******
 ************************************/

/************************************
 *****     Initialization     *******
 ************************************/

void initialize(void)
{
   /**** Port initialization ****/
   DDRD = 0x00;   // D.2 is data input
   DDRA = 0x01;   // A.0 is debug output
   DDRC = 0xff;   // Port C is LED output
   LEDs = 0xff;   // All off initially
   
   /**** Interrupt initialization ****/
   MCUCR = 0b00000001;   // Any edge on INT0 triggers interrupt
   GICR = 0b01000000;   // Enable INT0
   
   /* Timer 1 is used for synchronizing with the transponder's data clock,
      which should run at around (125e3/64) = 1.95 KHz, which means that
      edges appear at 3.91 KHz (no opposing bit boundary) or 1.95KHz
      (at opposing bit boundaries). */
   TCCR1B = 0b00000011;   // CLK/64 (250 KHz)
   
    /* Timer 0 is used to output 0xff data points at the same frequency as
       the usual data rate when the base is searching for the sync stream. */
    TCCR0 = 0b00001101;      // CTC on, CLK/1024 (15.6 KHz)
    OCR0 = 65;            // f = 240 Hz (almost 238.5 Hz, the data rate)
    TIMSK = 0b00000010;      // Enable OCIE0
   
   /**** USART initialization ****/
   UCSRB = 0b00011000 ; // TXC, RXC enabled
   UBRRL = 16 ; // 57.6 kbaud @ 16MHz

   /**** Variable initialization ****/
   lastEdge = 0;
   CLKedge = 0;
   bitNumber = 0;
   byteNumber = 0;
   junkByte = 0;
   for (count = 0; count < 3; count++)
      bitStream[count] = 0;
   
   data = 0;
   dataReady = 0;
   sync = -1;      // Initially, we don't have sync
   
   /**** Get this party started (enable interrupts) ****/
   #asm("sei");

}