main.cpp

00001 #include "mbed.h"
00002 #include "MFRC522.h"
00003 #include "qnode.h"
00004 #include "Buffer.h"
00005 #include "eeprom.h"
00006 #define eepr_addr 0x50
00007 #define max_size 300
00008 uint16_t const count_address=0x0000;
00009 
00010 I2C i2c(p28,p27);
00011 DigitalOut led4(LED4);
00012 DigitalOut led3(LED3);
00013 DigitalOut led1(LED1);
00014 DigitalOut enable(p19);
00015 Serial pc(USBTX, USBRX);
00016 Serial disp_uno(p9, p10);  // tx, rx
00017 MFRC522    RfChip   (p5, p6, p7, p8, p21);
00018 circular_buf_t buf; // ---->BUFFER CIRCULAR buf
00019 InterruptIn event(p16);
00020 InterruptIn reset(p15,PullDown);
00021 bool flag1=false;
00022 bool flag2=false;
00023 bool flag3=false;
00024 bool flag4=false;
00025 volatile bool buf1ready=false;
00026 volatile bool buf2ready=false;
00027 
00028 
00029 typedef union reg{
00030     uint8_t     uid_reg[4];
00031     uint32_t    clave;
00032     }reg;
00033     
00034     reg dtb[max_size];
00035     
00036 void insertionSort(reg *regs, uint8_t count);
00037 void interrupcion();
00038 void disp_unoTx_isr();
00039 void disp_unoRx_isr();
00040 void flush_memory();
00041 
00042 int main()
00043 {
00044     uint16_t adr=0x0001;    
00045     freq(400000);
00046     event.rise(&interrupcion);
00047     reset.rise(&flush_memory);
00048     disp_uno.attach(&disp_unoRx_isr,Serial::RxIrq);
00049     disp_uno.attach(&disp_unoTx_isr,Serial::TxIrq);
00050     struct Queue *q = createQueue();
00051     buf.size = 5;
00052     buf.buffer = (uint8_t*) malloc(buf.size);
00053     enable=0;
00054     RfChip.PCD_Init();
00055     //count = 0x0001; //-------->>>>>>para iniciar el conteo en 0 de la memoria de cantidad de uid registrados
00056     //write_data(eepr_addr, count_address,&count);//---->>>
00057     uint8_t count = data_read(eepr_addr, count_address);
00058     uint16_t uid=0x00;
00059     if (count>0) {
00060         //uint16_t array[count];
00061         pc.printf("\n%x UID's registrados en memoria\n",count);
00062         for(uid=0x00; uid<count; uid++) {
00063             //array[uid]=0;
00064             for(uint8_t byte_uid=0; byte_uid<4; byte_uid++) {
00065                 //printf("Suma %x",array[uid]);
00066                 printf("%02X",data_read(eepr_addr, (uid*4)+byte_uid+0x01));
00067                 //array[uid] = array[uid]+ data_read(eepr_addr, (uint16_t(uid*4)+uint16_t(byte_uid)+0x0001));
00068                 dtb[uid].uid_reg[byte_uid] = data_read(eepr_addr,(uid*4)+byte_uid+0x01);   
00069             }
00070             //insertionSort(&dtb[0], count);
00071             printf("\n");
00072             //printf("Posicion del arreglo:%d  valor:%03X",uid+1,array[uid]);
00073         }
00074 
00075         
00076         pc.printf("\nValores Ordenados ");
00077         insertionSort(&dtb[0], count);
00078         for(uint8_t d=0x00; d<count; d++) {
00079             for(int i=0;i<4;i++){
00080                 pc.printf("%02X",dtb[d].uid_reg[i]);
00081             }
00082             pc.printf("\n");
00083         }
00084 
00085         /*
00086         pc.printf("\nValores Ordenados ");
00087         insertionSort(dtb, count);
00088         for(uint8_t d=0x00; d<count; d++) {
00089             pc.printf("%03X ",dtb[d]);
00090         }
00091         */
00092     }
00093     else{
00094         pc.printf("%x UID's registrados en memoria\n",count);
00095         }
00096     adr = (4*uint16_t(count)+1);//--->>Crear posicion de escritura actual
00097     
00098     while(1) {
00099         while(flag4==true) {
00100             if(!RfChip.PICC_IsNewCardPresent())
00101                 continue;
00102             if (!RfChip.PICC_ReadCardSerial())
00103                 continue;
00104             pc.printf("Tarjeta Numero: ");
00105             uint8_t *c = &RfChip.uid.uidByte[0];
00106             //enQueue(q,c);
00107             //count = data_read(eepr_addr, count_address);
00108             write_data(eepr_addr, adr,c);//---->>>guardar UID en memoria
00109             for(int j=0; j<4; j++) {
00110                 uint8_t car = data_read(eepr_addr, (adr+j));
00111                 pc.printf("%02X",car);
00112             }
00113             pc.printf("\n");
00114             count++;//------>>>>sumar 1 al contador de UID's
00115             adr = (4*uint16_t(count)+1);//--->>actualizar posicion de escritura
00116             write_data(eepr_addr, count_address,&count);///---->>actualizar en memoria el contador
00117             pc.printf("\n");
00118             flag4=false;
00119         }
00120     }
00121 }
00122 
00123 
00124 void flush_memory()
00125 {
00126     led4=1;
00127     uint8_t data = 0x00;
00128     for(uint16_t k=0x0000; k<0x003f; k++) {
00129         write_data(eepr_addr,k,&data);
00130     }
00131     int j=0;
00132     while(j<1) {
00133         for(uint16_t i=0x0000; i<0x003f; i++) {
00134             uint8_t count = data_read(eepr_addr, i);
00135             pc.printf("Posicion de memoria:%d   dato:%02X\n",i,count);
00136 
00137         }
00138         j++;
00139     }
00140     printf("Memoria borrada\n");
00141     led4=0;
00142 }
00143 
00144 
00145 
00146 
00147 
00148 void interrupcion()
00149 {
00150 
00151     flag4=true;
00152 }
00153 
00154 void disp_unoTx_isr()
00155 {
00156     enable=0;
00157 }
00158 
00159 void disp_unoRx_isr()
00160 {
00161     uint8_t b = disp_uno.getc();
00162 
00163     if(b!=NULL) {
00164         circular_buf_put(&buf, b);
00165     } else {
00166         uint8_t a;
00167         circular_buf_get(&buf,&a);
00168         if(a=='1') {
00169             circular_buf_get(&buf,&a);
00170             if(a=='S') {
00171                 flag1=true;
00172             } else if(a=='Y') {
00173                 flag2=true;
00174             } else if(a=='N') {
00175                 flag3=true;
00176             }
00177         } else
00178             circular_buf_reset(&buf);
00179 
00180     }
00181 
00182 }
00183 
00184 
00185 
00186 void insertionSort(reg *regs, uint8_t count)
00187 {
00188     uint32_t i, key;
00189     int j;
00190     for (i = 1; i < count; i++) {
00191         key = regs[i].clave;
00192         j = i-1;
00193 
00194         /* Move elements of arr[0..i-1], that are
00195             greater than key, to one position ahead
00196             of their current position */
00197         while ((j>=0) && (regs[j].clave> key)) {
00198             regs[j+1].clave = regs[j].clave;
00199             j = j-1;
00200         }
00201         regs[j+1].clave = key;
00202     }
00203 }