Benutzer Diskussion:Jems

2012-01-30T09:00:57Z

Jems: Drigend :RFID-Tag mit Atmega644 auslesen.

Guten Tag zuerst,
ich bin neu in diesem Forum und ich hoffe, dass jemand mir helfen könnte.
Ich soll mit dem Atmega644 RFID-Tag auslesen.Ich habe schon die Funktion geschrieben die den ManchesterCode dekodieren soll und die, die die Paritäten überprüfen und gegebenfalls die Daten extrahieren soll. Aber seit Freitag passiert einfach nichts.Ich kann sogar den Header( 9 einsen) nicht erkennen.
Ich bin ein bisschen verwirrt und frage mich sogar, ob dies überhaupt deterministisch ist.
Ich habe nämlich am Mittwoch meinen Versuch an der UNI und falls ich überhaupt nichts auslesen kann, falle ich bestimmt durch.

Im folgenden finden Sie meinen Code.
Beachte : ich bin kein Expert in Sachen Microcontroller.
Das Grundgerüst haben wir vom Lehrstuhl bekommen , wir sollten nur die Funktionen decodeManchester() und getData() udn receive().
Danke im Voraus für die Hilfe.

//-------------------------Code beginnt hier---------------------------
#include "os_rfid.h"

#include "defines.h"

#include "util.h"
#include "lcd.h"
#include "os_memory.h"
#include "os_core.h"

#include <string.h>
#include "os_scheduler.h"

//! if set to 1 a received Tag will be written as HEX-String to the LCD
#define DISPLAY_RFID_TAG_AFTER_RECEIVE 1

//----------------------------------------------------------------------------
// RFID Constants
//----------------------------------------------------------------------------

//! Frequency of the RFID tag in Hz
#define F_RFID_OSC 125000
//! Ratio of RFID Tag Frequency to RFID data rate
#define RFID_SCALER 64
//! Prescaler used for the timer
#define TIMER_SCALER 256
//! Number of timer ticks for a long edge
#define TICKSRATIO ( ( F_CPU * RFID_SCALER ) / ( F_RFID_OSC * TIMER_SCALER ) )

//! Noise threshold for the RFID Reader
#define NOISE_THRESHOLD (TICKSRATIO / 4) /* Minimum noise threshold*/

//! Length of Bit Record Buffer
#define RECORD_NUM (3*64) /* Number of records*/
//! Pin MOD
#define MOD PD5
//! Pin DEMOD_OUT
#define DEMOD_OUT PD6
//! Pin SHD
#define SHD PD7

//----------------------------------------------------------------------------
// Globals
//----------------------------------------------------------------------------

typedef struct {
uint16_t time;
uint16_t ovfCount;
} Edge;

typedef uint64_t RFID_Tag;

typedef struct {
RFID_Tag volatile tagBuffer;
uint64_t lastReceivedTag;
Edge volatile edge[2];
MemAddr signalTimes;
uint8_t signalStartEdge : 1;
uint8_t lastManchesterSkipped : 1;
uint8_t head;
uint8_t tail;
} RFID;

RFID rfid;

// shows how many items are in the buffer
uint8_t pufferFuellstand = 0;

// debug.................
volatile uint64_t anzahl = 0;
volatile uint8_t tempisBit;
volatile uint8_t head;
volatile uint8_t tail;
volatile uint16_t temprec;
volatile uint8_t templevel;
volatile uint64_t tempBuffer0;
volatile uint64_t tempFuellstand;

//----------------------------------------------------------------------------
// ISR
//----------------------------------------------------------------------------

/*!
* This ISR counts the Timer 1 Overflows to enable exact Measurements of Signal Level Lengths
*/

ISR (TIMER1_OVF_vect) {
rfid.edge[0].ovfCount++;
rfid.edge[1].ovfCount++;
}

/*!
* This ISR Analyzes the Signals from the RFID reader board
* and saves the Signal levels together with their durations
* in the global RFID_recTime and RFID_recLevel arrays
*/

ISR(TIMER1_CAPT_vect) {
static uint16_t sp;
sp = SP;
SP = BOTTOM_OF_ISR_STACK;
unsigned char counts;

uint8_t const e = (PIND >> PD6) & 1;
rfid.edge[e].time = ICR1;
counts = rfid.edge[e].time - rfid.edge[!e].time + rfid.edge[!e].ovfCount*(1ul<<16);
rfid.edge[e].ovfCount = 0;

if (counts > NOISE_THRESHOLD) {
intSRAM->write(rfid.signalTimes + rfid.head, counts);

if (!rfid.head){
rfid.signalStartEdge = e;
}
rfid.head = (rfid.head + 1) % RECORD_NUM;
//.....................
anzahl++;
head = rfid.head;

TCCR1B = (TCCR1B & ~(1<<ICES1)) | ((!e) << ICES1);
}

SP = sp;
}

//----------------------------------------------------------------------------
// Function definitions
//----------------------------------------------------------------------------

/*!
* This function initializes the RFID Driver.
* The ports are set, then the RFID Chip on the reader board is initialized
* by a sequence of signals. In the end, Timer 1 is set.
* Afterwards, the global variables are set to their initialization values
* This also initializes our Memory als NULL pointers.
*/
void rfid_init() {
memset(&rfid,0,sizeof(RFID));
// rfid.signalTimes = os_malloc(intSRAM, RECORD_NUM);
rfid.signalTimes = os_malloc(intHeap, RECORD_NUM);
//Ports
PORTD = 0xA0; // PD7=SHD,PD6=DEMOD-OUT,PD5=MOD
DDRD = 0xFF;
DDRD |= (1<<SHD)|(1<<MOD);
DDRD &= ~(1<<DEMOD_OUT);
PORTD |= (1<<DEMOD_OUT); // Pull up (input)

// Boot up the RFID reader chip
PORTD |= (1<<SHD); // EM4095 shot down
PORTD |= (1<<MOD); // EM4095 max outut
delayMs(500); // delay 500ms

PORTD &= ~(1<<SHD); // EM4095 ready
PORTD &= ~(1<<MOD); // EM4095 min output
delayMs(500); // delay 500ms

//Timer
//enable overflow and input capture interrupts
TIMSK1 = 0x21;

//Noise canceller, 256 prescaler, rising edge
TCCR1B = 0x84;

// zum Start, keine Flanke akzeptiert.
rfid.lastManchesterSkipped = 0;
rfid.head = rfid.tail = 0;

lcd_writeProgString(PSTR("RFID go! "));
}

typedef uint8_t ManchesterDecode;

/*!
* This function decodes the manchester code that is used to transmit
* Databytes from the RFID tag to our RFID reader.
* To do so, it analyzes signal level times and edges in the signal sent by the tag.
* \param level state of the edge under analysys (rising or falling)
* \param last_rec The duration of the previous edge
* \param now_rec The duration of the current edge
* \returns 1 if we found a '1' bit, 0 if we found a '0' bit and a value > 1 if we could not idedentify a valid bit.
*/
// selber geschrieben......
ManchesterDecode rfid_decodeManchester(uint8_t level, uint16_t last_rec, uint16_t now_rec) {

if( now_rec > ((TICKSRATIO * 3)/4)){
// lange Flanken.
if( level ){
return (ManchesterDecode)0;
}else{
return (ManchesterDecode)1;
}
}else{
// aktuelle Flanke ist kurze Flanke.
if( last_rec > ((TICKSRATIO * 3)/4)){ //vorherige Flanke ist lang.
// aktuelle Flane ist eine Fuellflanke
rfid.lastManchesterSkipped = 0;
return 0xFF;
}else{
// vorherige Flanke ist eine kurze Flanke
if( rfid.lastManchesterSkipped){
// vorherige Flanke wurde verarbeitet.Verwerfe die aktuelle Flanke
rfid.lastManchesterSkipped = 0;
return 0xFF;
}else{
rfid.lastManchesterSkipped = 1;
if( level){
return (ManchesterDecode)0;
}else{
return (ManchesterDecode)1;
}
}
}
}
}

// selber geschrieben
bool pruefePaketParitaet(uint8_t paket){

uint8_t paketParitaet = paket & 0b1;
paket = paket >>1;
uint8_t ergParitaet = 0;
uint8_t i;
for( i = 0; i < 4; i++){
ergParitaet ^= (paket & 0b1);
paket = paket>>1;
}
if( ergParitaet != paketParitaet){
return false;
}
return true;
}

// selber geschrieben............
bool checkHeader(){
if( pufferFuellstand == (uint8_t)0){
return true;
}
if( pufferFuellstand <= 9 ){
if( (rfid.tagBuffer >> (64 - pufferFuellstand)) & 0b1 ){
return true;
}else{
return false;
}
}
return true;
}

/*!
* If a header was previously found, this function does the data packet
* and column parity checks. If the checks were successful, the Tag data
* is returned after cleaning up.
* \returns 0 if the parity checks failed, and the Tag data if they succeeded.
*/
//selber geschrieben.........
uint64_t rfid_getData() {

// pruefe das Stopbit.
if( (rfid.tagBuffer & 0b1) != 0){
return 0;
}

uint8_t i;

// prüft die Paritäten der Datenpakete
uint8_t paket;
// eliminiert die Spaltenparitaeten und das Stopbit.
uint64_t tempBuffer = rfid.tagBuffer >> 5;

for( i = 0; i< 10; i++){
paket = (uint8_t)(tempBuffer & (uint64_t)0b11111);
if( !(pruefePaketParitaet(paket))){
return 0; // paketparitaet stimmt nicht.
}
tempBuffer = tempBuffer>> 5;
}

//prüft die Spaltenparitäten.
uint8_t ergParitaet = 0;
uint8_t spaltenParitaet = (rfid.tagBuffer >> 1) & 0b1111;

tempBuffer = rfid.tagBuffer;
uint64_t tagID= 0;

for( i =0; i < 10; i++){
paket = (tempBuffer>>(50 - (5 * i))) & 0b11111; // ermittle ein Datenpaket;
paket = paket>>1; // elimiert die Paketparitaet.
ergParitaet^= paket;
tagID |= ((uint64_t)paket << (36 - ( 4 * i)));
}
if( ergParitaet != spaltenParitaet ){
return 0;
}
return tagID;
}

//ID am LCD anzeigen

// selber geschrieben.............
void showID(uint64_t tagID){
uint8_t i;
lcd_writeProgString("Tag-ID: ");
lcd_line2();
uint8_t output;
for( i = 0 ; i< 10; i++){
output = (tagID >> ( 36 - ( 4 * i))) & 0b1111;
lcd_writeHex(output);
}
}
/*!
* This function performs the whole process of receiving a RFID Tags Data.
* The function only terminates when a complete ID was received.
* \returns The actually received Tag ID.
*/
// selber geschrieben.............
uint64_t rfid_receive(void) {
os_enterCriticalSection();

ManchesterDecode isBit;
uint8_t level;
uint16_t last_rec,now_rec;
uint64_t tagId = 0;
bool status;

while(true){
if( tagId){
status = false;
rfid.lastReceivedTag = tagId;
break;
}
status = true;
// TagBuffer initialisieren.
rfid.tagBuffer = 0;
pufferFuellstand = 0;
while( status ){
if( rfid.head != rfid.tail){

//................................
//head = rfid.head;

now_rec = intSRAM->read(rfid.signalTimes + rfid.tail);
//................................
temprec = now_rec;

if( !rfid.tail){
last_rec = intSRAM->read(rfid.signalTimes + RECORD_NUM - 1);
}else{
last_rec = intSRAM->read(rfid.signalTimes + rfid.tail-1);
}
// bestimme ob steigende oder fallende Flanke.
if(!(rfid.tail % 2) ){
level = rfid.signalStartEdge;
}else{
level = 1 - rfid.signalStartEdge;
}
//.......................................

templevel = level;

rfid.tail = (rfid.tail + 1) % RECORD_NUM;

//..........................................
tail = rfid.tail;

isBit = rfid_decodeManchester(level,last_rec,now_rec);

//........................................
tempisBit = isBit;

if( isBit == (uint8_t)0){
rfid.tagBuffer &= ~((uint64_t)1<< (63 - pufferFuellstand));
pufferFuellstand++;
}
if( isBit == (uint8_t)1){
//rfid.tagBuffer |= ((uint64_t)1 << pufferFuellstand);
rfid.tagBuffer |= ((uint64_t)1 << (63 - pufferFuellstand));
pufferFuellstand++;
}

// pruefe den Header.
if( !(checkHeader())){
status = false;
}

//..................................
tempFuellstand = pufferFuellstand;
tempBuffer0 = rfid.tagBuffer;

if( pufferFuellstand == (uint8_t)64 ){
tagId = rfid_getData();
status = false;
}
}
}

}

if( DISPLAY_RFID_TAG_AFTER_RECEIVE ){
lcd_clear();
showID(rfid.lastReceivedTag);
}
os_leaveCriticalSection();
return rfid.lastReceivedTag;
}

//... Code endet hier........................................

Mikrocontroller.net - Benutzerbeiträge [de]

Benutzer Diskussion:Jems