Probleme beim RFid lesen mit EM4095

[Ich S. (random_user789)]

Hallo zusammen,
ich moechte an meinem AtMega1280 in einem Mikroelektronika BigAVR6 board 
einen RFid Reader anschliessen. Dafuer habe ich mir das passende 
Erweiterungsboard mit einem EM4095 gekauft und mich ans programmieren 
gesetzt, das dauert jetzt leider schon mehrere Wochen. Ich schaffs 
einfach nicht das Teil ordentlich zum laufen zu bringen.

Mein Ansatz:

RFid board an PORTK.
Interrupt auf out-pin.
Wenn fallende Flanke erkannt, interrupt auf clk-pin.
ab da zaehle ich im interrupt die clk zyklen. Jeden 64. Interrupt lese 
ich ein Datenbit, und zwar einmal das untere und das naechste mal das 
obere. Sind die beiden Bits unterschiedlich, steht die Information im 
unteren Bit (invertierte Manchaster codierung).
Dann warte ich auf weitere acht einsen, das waere dann das startpaket. 
Liegt eine null dazwischen, lege ich den Interrupt wieder auf den 
out-pin und versuche mich neu zu synchronisieren.
Konnten 9 Einsen gelesen werden, starte ich die Daten zu lesen und in 
einem Array abzulegen. Dabei ueberpruefe ich mit jedem 5. Bit die 
paritaet der vorherigen 4 bits und zum schluss das Stop-bit.
Wenn bis zum Ende keine Paritaet verletzt wurde und das Stop-bit 0 ist, 
uebergebe ich die Daten einem Handler der damit machen kann was er 
moechte, ansonsten wird der Handler mit einem Fehlerstatus aufgerufen.

Das ganze scheint aber nicht zu funktionieren (der Handler wird nur sehr 
selten mit SUCCESS aufgerufen und wenn dann mit falschen Daten). Ich 
sitz jetzt schon 2 Wochen lang am debuggen und kann den Fehler einfach 
nicht finden.
Wenn mir vielleicht jemand Helfen koennte? Vielleicht ist mein Ansatz ja 
auch komplett falsch?

Header:

#ifndef RFID_H
#define RFID_H

#define RFID_PORT (PORTK)
#define RFID_PIN (PINK)
#define RFID_DDR (DDRK)
#define RFID_INT_CR (PCICR)
#define RFID_INT_MSK (PCMSK2)
#define RFID_INT_VECT (PCINT2_vect)

#include "util.h"
#include <avr/io.h>
#include <stdlib.h>
#include <stdbool.h>
#include <avr/interrupt.h>
#include <avr/sleep.h>

typedef enum {
  VALID,
  INVALID,
} status_t;

//configuration and Handler registration
error_t rfid_init(void (*decodeEvent)(status_t, uint8_t*));

//interrupt enable and wake up RFid reader
error_t rfid_enable(void);

//put RFid reader to sleep and disable interrupts
void rfid_disable(void);

#endif

Code:

#include "rfid.h"

static void (*handler)(status_t, uint8_t*);

static volatile uint8_t one_cnt = 0;
static volatile uint8_t clk_cnt = 0;
static volatile uint8_t data_cnt = 0;
static volatile uint8_t row_cnt = 0;
static volatile uint8_t lower_level = 0;
static volatile uint8_t *data;
static volatile uint8_t prev = 0;
static volatile uint8_t checked = 1;

error_t rfid_init(void (*_handler)(status_t, uint8_t*))
{
  RFID_DDR = 0xFC;
  RFID_PORT = 0x07;
  RFID_INT_MSK = 0x01;
  handler = _handler;
  return SUCCESS;
}

error_t rfid_enable(void)
{
  if(((RFID_INT_CR & 0x04) != 0) || ((RFID_PIN & 0x04) == 0))
  {
    return ERROR;
  }
  one_cnt = 0;
  clk_cnt = 0;
  data_cnt = 0;
  row_cnt = 0;
  lower_level = 0;
  prev = 0;
  checked = 1;
  RFID_INT_MSK = 0x01;
  RFID_INT_CR |= 0x04;
  RFID_PORT &= 0xFB;
  return SUCCESS;
}

void rfid_disable(void)
{
  RFID_PORT |= 0x04;
  RFID_INT_CR &= 0xFB;
}

void inline __attribute__((always_inline)) use_data(void)
{
  //parity
  if(checked != 1 && ((data_cnt & 0x03) == 0x00))
  {
    uint8_t val = data[row_cnt];
    if(((((val)^(val >> 1))^((val >> 2)^(val >>3)))&0x01) == lower_level)
    {
      data[row_cnt] &= 0x0F;
      row_cnt++;
      data[row_cnt] = 0;
    }
    else
    {
      handler(INVALID, (uint8_t*)data);
      one_cnt = 0;
      RFID_INT_MSK = 0x01;
    }
    //last parity
    if(data_cnt > 42)
    {
      val = 0;
      for(row_cnt = 0; row_cnt < 10; row_cnt++)
        val ^= data[row_cnt];
      if((lower_level == 0x00) && (((val ^ (data[10])) & 0x0F) == 0x00))
      {
        handler(VALID, (uint8_t*)(&data[2]));
      }
      else
      {
        handler(INVALID, (uint8_t*)data);
      }
      one_cnt = 0;
      RFID_INT_MSK = 0x01;
    }
    checked = 1;
  }
  else
  {
    data[row_cnt] = (data[row_cnt] << 1) | lower_level;
    //save data
    data_cnt++;
    checked = 0;
  }
}


ISR(RFID_INT_VECT, ISR_BLOCK){
  clk_cnt++;
  //Already had a one
  if(one_cnt != 0){
    //every 64th clk
    if((clk_cnt & 0x3F) == 0)
    {
      //second manchester bit
      if((clk_cnt & 0x40) == 0)
      {
        //toggle
        if(lower_level != (RFID_PIN & 0x01))
        {
          //need more ones
          if(one_cnt != 9)
          {
            //found another one
            if((RFID_PIN & 0x01) == 0x00)
            {
              one_cnt++;
              //last sync one?
              if(one_cnt == 9)
              {
                PORTL++;
                data_cnt = 0;
                data = malloc(11*sizeof(uint8_t));
                data[0] = 0;
                row_cnt = 0;
                data[0] = 0;
                checked = 1;
              }
            }
            //synchronisation lost
            else
            {
              one_cnt = 0;
              RFID_INT_MSK = 0x01;
              free((void*)data);
            }
          }
          else
          {
            use_data();
          }
        }
      }
      //first manchester bit
      else
      {
        lower_level = (RFID_PIN & 0x01);
      }
    }
  }
  else if((RFID_PIN & 0x01) == 0)
  {
    //first one. Needed to synchronize
    clk_cnt = 0x40;
    one_cnt = 1;
    lower_level = 0x01;
    //disable interrupt on out pin, synchronisation is done via clk
    RFID_INT_MSK = 0x02;
  }
}

[Marc V. (Firma: Vescomp) (logarithmus)]

Ich Selbst schrieb:
> Wenn mir vielleicht jemand Helfen koennte? Vielleicht ist mein Ansatz ja
> auch komplett falsch?

 Ich kann mich jetzt nicht mehr genau erinnern, aber ich habe das mit
 OCR0A gemacht, wenn der gefeuert hat war es Timeout, ansonsten
 war es zwischen 20 und 45 Shortbit, zwischen 50 und 80 Longbit, alles
 andere war Fehler.
 Statemachine aufbauen mit PrevState, FlankenArt und PrevBit.

[Ich S. (random_user789)]

Hi,
also du hast den interrupt am out-pin und machst die synchronisation 
ueber einen Timer? Ich habe gesehen die frequenz am clk kann start 
variieren, deshalb wollte ich mich nicht auf einen Timer verlassen.
Mein naechster Ansatz waere gewesen clk an einen Counter zu haengen, 
dann spar ich mir die lange ISR beim interrupt den ich beim clk hatte 
und hab die selbe information wie du von wegen timeout.
Werds mal sauber implementieren, mit state machine und so, und meld mich 
wieder zurueck obs geklappt hat!