File content as of revision 11:da25ed58aab0:

#include "mbed.h"
#include "MFRC522.h"
#include "qnode.h"
#include "Buffer.h"
#include "eeprom.h"
#define eepr_addr 0x50
#define max_size 300
uint16_t const count_address=0x0000;

I2C i2c(p28,p27);
DigitalOut led4(LED4);
DigitalOut led3(LED3);
DigitalOut led1(LED1);
DigitalOut enable(p19);
Serial pc(USBTX, USBRX);
Serial disp_uno(p9, p10);  // tx, rx
MFRC522    RfChip   (p5, p6, p7, p8, p21);
circular_buf_t buf; // ---->BUFFER CIRCULAR buf
InterruptIn event(p16);
InterruptIn reset(p15,PullDown);
bool flag1=false;
bool flag2=false;
bool flag3=false;
bool flag4=false;
volatile bool buf1ready=false;
volatile bool buf2ready=false;


typedef union reg{
    uint8_t     uid_reg[4];
    uint32_t    clave;
    }reg;
    
    reg dtb[max_size];
    
void insertionSort(reg *regs, uint8_t count);
void interrupcion();
void disp_unoTx_isr();
void disp_unoRx_isr();
void flush_memory();

int main()
{
    uint16_t adr=0x0001;    
    freq(400000);
    event.rise(&interrupcion);
    reset.rise(&flush_memory);
    disp_uno.attach(&disp_unoRx_isr,Serial::RxIrq);
    disp_uno.attach(&disp_unoTx_isr,Serial::TxIrq);
    struct Queue *q = createQueue();
    buf.size = 5;
    buf.buffer = (uint8_t*) malloc(buf.size);
    enable=0;
    RfChip.PCD_Init();
    //count = 0x0001; //-------->>>>>>para iniciar el conteo en 0 de la memoria de cantidad de uid registrados
    //write_data(eepr_addr, count_address,&count);//---->>>
    uint8_t count = data_read(eepr_addr, count_address);
    uint16_t uid=0x00;
    if (count>0) {
        //uint16_t array[count];
        pc.printf("\n%x UID's registrados en memoria\n",count);
        for(uid=0x00; uid<count; uid++) {
            //array[uid]=0;
            for(uint8_t byte_uid=0; byte_uid<4; byte_uid++) {
                //printf("Suma %x",array[uid]);
                printf("%02X",data_read(eepr_addr, (uid*4)+byte_uid+0x01));
                //array[uid] = array[uid]+ data_read(eepr_addr, (uint16_t(uid*4)+uint16_t(byte_uid)+0x0001));
                dtb[uid].uid_reg[byte_uid] = data_read(eepr_addr,(uid*4)+byte_uid+0x01);   
            }
            //insertionSort(&dtb[0], count);
            printf("\n");
            //printf("Posicion del arreglo:%d  valor:%03X",uid+1,array[uid]);
        }

        
        pc.printf("\nValores Ordenados ");
        insertionSort(&dtb[0], count);
        for(uint8_t d=0x00; d<count; d++) {
            for(int i=0;i<4;i++){
                pc.printf("%02X",dtb[d].uid_reg[i]);
            }
            pc.printf("\n");
        }

        /*
        pc.printf("\nValores Ordenados ");
        insertionSort(dtb, count);
        for(uint8_t d=0x00; d<count; d++) {
            pc.printf("%03X ",dtb[d]);
        }
        */
    }
    else{
        pc.printf("%x UID's registrados en memoria\n",count);
        }
    adr = (4*uint16_t(count)+1);//--->>Crear posicion de escritura actual
    
    while(1) {
        while(flag4==true) {
            if(!RfChip.PICC_IsNewCardPresent())
                continue;
            if (!RfChip.PICC_ReadCardSerial())
                continue;
            pc.printf("Tarjeta Numero: ");
            uint8_t *c = &RfChip.uid.uidByte[0];
            //enQueue(q,c);
            //count = data_read(eepr_addr, count_address);
            write_data(eepr_addr, adr,c);//---->>>guardar UID en memoria
            for(int j=0; j<4; j++) {
                uint8_t car = data_read(eepr_addr, (adr+j));
                pc.printf("%02X",car);
            }
            pc.printf("\n");
            count++;//------>>>>sumar 1 al contador de UID's
            adr = (4*uint16_t(count)+1);//--->>actualizar posicion de escritura
            write_data(eepr_addr, count_address,&count);///---->>actualizar en memoria el contador
            pc.printf("\n");
            flag4=false;
        }
    }
}


void flush_memory()
{
    led4=1;
    uint8_t data = 0x00;
    for(uint16_t k=0x0000; k<0x003f; k++) {
        write_data(eepr_addr,k,&data);
    }
    int j=0;
    while(j<1) {
        for(uint16_t i=0x0000; i<0x003f; i++) {
            uint8_t count = data_read(eepr_addr, i);
            pc.printf("Posicion de memoria:%d   dato:%02X\n",i,count);

        }
        j++;
    }
    printf("Memoria borrada\n");
    led4=0;
}





void interrupcion()
{

    flag4=true;
}

void disp_unoTx_isr()
{
    enable=0;
}

void disp_unoRx_isr()
{
    uint8_t b = disp_uno.getc();

    if(b!=NULL) {
        circular_buf_put(&buf, b);
    } else {
        uint8_t a;
        circular_buf_get(&buf,&a);
        if(a=='1') {
            circular_buf_get(&buf,&a);
            if(a=='S') {
                flag1=true;
            } else if(a=='Y') {
                flag2=true;
            } else if(a=='N') {
                flag3=true;
            }
        } else
            circular_buf_reset(&buf);

    }

}



void insertionSort(reg *regs, uint8_t count)
{
    uint32_t i, key;
    int j;
    for (i = 1; i < count; i++) {
        key = regs[i].clave;
        j = i-1;

        /* Move elements of arr[0..i-1], that are
            greater than key, to one position ahead
            of their current position */
        while ((j>=0) && (regs[j].clave> key)) {
            regs[j+1].clave = regs[j].clave;
            j = j-1;
        }
        regs[j+1].clave = key;
    }
}