bm019.cpp

00001 #include "bm019.h"
00002 
00003 volatile uint8_t rxBuffer[BM019_MAX_RX];
00004 
00005 uint8_t BM019_CMD_IDN[] = {2,0x01,0x00};
00006 
00007 uint8_t BM019_CMD_ECHO[] = {1,0x55};
00008 
00009 uint8_t BM019_CMD_PROTOCOL_START[] = {2,0x02,0x02};
00010 uint8_t BM019_CMD_PROTOCOL_ISO_IEC_15693[] = {2,0x01,0x00};
00011 uint8_t BM019_CMD_PROTOCOL_OFF[] = {2,0x00,0x00};
00012 
00013 uint8_t BM019_CMD_HYBERNATE[] = {15,
00014                                  0x07, //idle
00015                                  0x0E, //14 bytes
00016                                  0x08, //WU source low pulse irq
00017                                  0x04, 0x00, //Enter Control hybernate
00018                                  0x04, 0x00, //WU Control hybernate
00019                                  0x18, 0x00, //Leave Control hybernate
00020                                  0x00, //WU Period 0
00021                                  0x00, //Osc Start
00022                                  0x00, //DAC Start
00023                                  0x00, 0x00, //DAC Data
00024                                  0x00, //Swing Count
00025                                  0x00  //Max Sleep
00026                                 };
00027 
00028 uint8_t BM019_CMD_ISO_IEC_15693_INVENTORY[] = {5, 0x04, //send recieve
00029         0x03,//length
00030         0x26, //options:
00031         /*
00032          0 -> bit 0: Subcarrier 0 = ask, 1 =fsk
00033          1 -> bit 1: uplink data rate 0 = low, 1 = high
00034          1 -> bit 2: inventory flags 0 -> a), 1 -> b)
00035          0 -> bit 3: proto extension = 0
00036          a)
00037          bit 4: select flag 0 = if(bit 5 = 1 address mode)
00038          bit 5: address flag 1 = use address
00039          bit 6: for write = 1, else 0
00040          bit 7: future usage, always 0
00041          b)
00042          0 -> bit 4: afi flag 0 = no afi, 1 = afi (Application family identification)
00043          1 -> bit 5: slot flag, 0 -> 16 slots, 1 -> 1 slot
00044          0 -> bit 6: for write = 1, else 0
00045          0 -> bit 7: future usage, always 0
00046 
00047          */
00048         0x01, // inventory command
00049         0x00 // do not know why i sent it, maybe useless?
00050                                               };
00051 
00052 uint8_t BM019_CMD_READ[] = {5,
00053                             0x04, //send recieve
00054                             0x03, //length
00055                             0x02, //options
00056                             0x20, //read
00057                             0x00  //Address
00058 
00059                            };
00060 uint8_t BM019_CMD_READ_MULTI[] = {6,
00061                                   0x04, //send recieve
00062                                   0x00, //length
00063                                   0x02, //options
00064                                   0x23, //read
00065                                   0x00, //address
00066                                   0x00  //count
00067                                  };
00068 enum BM019_PROTOCOL {
00069     BM019_PROTOCOL_Field_OFF = 0x00,
00070     BM019_PROTOCOL_ISO_IEC_15693 = 0x01,
00071     //other not yet supported!
00072     BM019_PROTOCOL_ISO_IEC_14443_Type_A = 0x02,// also NFC Forum Tag Type 1 (Topaz), NFC Forum Tag Type 2, NFC Forum Tag Type 4A
00073     BM019_PROTOCOL_ISO_IEC_14443_Type_B = 0x03,// also NFC Forum Tag Type 4B
00074     BM019_PROTOCOL_ISO_IEC_18092 = 0x04 // also NFC Forum Tag Type 3
00075 };
00076 
00077 SPI spi(BM019_MOSI, BM019_MISO, BM019_CLK);
00078 
00079 DigitalOut ss(BM019_CS);
00080 DigitalOut wake(BM019_IRQ);
00081 
00082 BM019_STATE stateBM019 = BM019_STATE_UNKNOWN;
00083 
00084 int write_read(uint8_t *tx_buf, int tx_len, int timeout = BM019_READY_TIMEOUT); //write, poll, read
00085 
00086 /*bool stateAtLeast(BM019_STATE requiredState)
00087 {
00088     if(stateBM019 < requiredState)
00089     {
00090         DEBUG("required state %d, having state %d",requiredState,stateBM019);
00091         return false;
00092     }
00093     return true;
00094 }*/
00095 
00096 bool resetBM019()
00097 {
00098     if(stateBM019 < BM019_STATE_ANSWERING) {
00099         DEBUG("IDN failed, bm019 not answering\n");
00100         return false;
00101     }
00102     DEBUG("BM019: reset\n");
00103     ss=0;
00104     spi.write(0x01);
00105     ss=1;
00106     wait_ms(20);
00107     stateBM019 = BM019_STATE_UNKNOWN;
00108     return true;
00109 }
00110 
00111 bool echoBM019(int timeout, bool log)
00112 {
00113     if(log) {
00114         DEBUG("BM019: echo\n");
00115     }
00116     int len = write_read(&BM019_CMD_ECHO[1],BM019_CMD_ECHO[0], timeout);
00117     if(len>=1 && rxBuffer[0] == 0x55) {
00118         stateBM019 = stateBM019 > BM019_STATE_ANSWERING ? stateBM019 : BM019_STATE_ANSWERING;
00119         return true;
00120     } else {
00121         if(log) {
00122             DEBUG("recievedlen: %d \n",len);
00123 
00124             for(int i = 0; i < len; i++)
00125                 DEBUG("rx[%d]: %#x\n",i,rxBuffer[i]);
00126         }
00127     }
00128     stateBM019 = BM019_STATE_UNKNOWN;
00129     return false;
00130 }
00131 
00132 BM019_STATE getStateBM019()
00133 {
00134     return stateBM019;
00135 }
00136 
00137 bool wakeBM019(int timeout)
00138 {
00139     DEBUG("BM019: wake\n");
00140     ss=0;
00141     wake = 0;
00142     wait_ms(10);
00143     wake = 1;
00144     ss = 1;
00145 
00146     wait_ms(timeout);
00147     int t = 10;
00148 
00149     stateBM019 = BM019_STATE_UNKNOWN;
00150     while(!echoBM019(10,false) && t > 0) {
00151         wait_ms(10);
00152         t--;
00153     }
00154     if(t<0) {
00155         return false;
00156     }
00157     return true;
00158 }
00159 
00160 
00161 
00162 int waitReady(int timeoutMS = 0)
00163 {
00164     int ready = 0;
00165 
00166     if(timeoutMS) {
00167         Timer t;
00168         t.start();
00169         ss=0;
00170         while(!ready) {
00171             wait_ms(1);
00172             ready = spi.write(0x03) & 0x08;
00173             if(t.read_ms()>timeoutMS) {
00174                 break;
00175             }
00176         }
00177         ss = 1;
00178     } else {
00179         ss=0;
00180         while(!ready) {
00181             wait_ms(1);
00182             ready = spi.write(0x03);
00183             ready = ready & 0x08;
00184         }
00185         ss = 1;
00186     }
00187     return ready;
00188 }
00189 
00190 void write(uint8_t *tx_buf, int tx_len)
00191 {
00192     ss=0;
00193     spi.write(0x00);
00194     for(int i = 0; i < tx_len; i++) {
00195         spi.write(tx_buf[i]);
00196     }
00197     ss=1;
00198 }
00199 
00200 int readBM019()
00201 {
00202     ss=0;
00203     spi.write(0x02);
00204     rxBuffer[0] = spi.write(0x00);
00205     int len = 0;
00206     if(rxBuffer[0] != 0x55) {
00207         len = rxBuffer[1] = spi.write(0x00);
00208         for(int i = 0; i < len && i < BM019_MAX_RX; i++) {
00209             rxBuffer[i+2] = spi.write(0x00);
00210         }
00211         len += 2;
00212     } else {
00213         len = 1;
00214     }
00215     ss=1;
00216     return len;
00217 }
00218 
00219 int write_read(uint8_t *tx_buf, int tx_len, int timeout)
00220 {
00221     write(tx_buf, tx_len);
00222     waitReady(timeout);
00223     return readBM019();
00224 }
00225 
00226 bool setProtocolISO_EIC_15693BM019(BM019_PROTOCOL_ISO_IEC_15693_BYTE_0 configuration)
00227 {
00228     if(stateBM019 < BM019_STATE_ANSWERING) {
00229         DEBUG("SETTING Protocol failed, bm019 not answering\n");
00230         return false;
00231     }
00232     DEBUG("SETTING Protocol to iso/iec 15693: %#x\n",configuration);
00233 
00234     int len = BM019_CMD_PROTOCOL_START[0]+BM019_CMD_PROTOCOL_ISO_IEC_15693[0];
00235 
00236     uint8_t iso[BM019_CMD_PROTOCOL_START[0]+BM019_CMD_PROTOCOL_ISO_IEC_15693[0]];
00237     memcpy(iso,&BM019_CMD_PROTOCOL_START[1],BM019_CMD_PROTOCOL_START[0]);
00238     memcpy(&iso[BM019_CMD_PROTOCOL_START[0]],&BM019_CMD_PROTOCOL_ISO_IEC_15693[1],BM019_CMD_PROTOCOL_ISO_IEC_15693[0]);
00239     iso[len-1] = configuration;
00240 
00241     int recieved = write_read(iso,len,20);
00242     if(recieved  >= 2 && rxBuffer[0] == 0x00 && rxBuffer[1] == 0x00) {
00243         stateBM019 = stateBM019 > BM019_STATE_PROTOCOL ? stateBM019 : BM019_STATE_PROTOCOL;
00244         return true;
00245     } else {
00246         DEBUG("SETTING Protocol failed: %#x\n",rxBuffer[0]);
00247         stateBM019 = BM019_STATE_UNKNOWN;
00248         return false;
00249     }
00250 }
00251 
00252 bool setProtocolOFF()
00253 {
00254     if(stateBM019 < BM019_STATE_ANSWERING) {
00255         DEBUG("SETTING Protocol failed, bm019 not answering\n");
00256         return false;
00257     }
00258     DEBUG("SETTING Protocol to OFF\n");
00259 
00260     int len = BM019_CMD_PROTOCOL_START[0]+BM019_CMD_PROTOCOL_OFF[0];
00261     uint8_t off[BM019_CMD_PROTOCOL_START[0]+BM019_CMD_PROTOCOL_OFF[0]];
00262     memcpy(off,&BM019_CMD_PROTOCOL_START[1],BM019_CMD_PROTOCOL_START[0]);
00263     memcpy(&off[BM019_CMD_PROTOCOL_START[0]],&BM019_CMD_PROTOCOL_OFF[1],BM019_CMD_PROTOCOL_OFF[0]);
00264 
00265     int recieved = write_read(off,len,20);
00266     if(recieved  >= 2 && rxBuffer[0] == 0x00 && rxBuffer[1] == 0x00) {
00267         stateBM019 = BM019_STATE_ANSWERING;
00268         return true;
00269     } else {
00270         DEBUG("SETTING Protocol failed: %#x\n",rxBuffer[0]);
00271         stateBM019 = BM019_STATE_UNKNOWN;
00272         return false;
00273     }
00274 }
00275 
00276 bool idnBM019(BM019_IDN *idn)
00277 {
00278     if(stateBM019 < BM019_STATE_ANSWERING) {
00279         DEBUG("IDN failed, bm019 not answering\n");
00280         return false;
00281     }
00282     int len = write_read(&BM019_CMD_IDN[1],BM019_CMD_IDN[0]);
00283     if(len == 17) {
00284         memcpy(idn->deviceID,(const void *)&rxBuffer[2],13);
00285         memcpy(idn->romCRC,(const void *)&rxBuffer[15],2);
00286         return true;
00287     }
00288     return false;
00289 
00290 }
00291 
00292 bool hybernateBM019()
00293 {
00294     if(stateBM019 < BM019_STATE_ANSWERING) {
00295         DEBUG("SETTING HYBERNATE failed, bm019 not answering\n");
00296         return false;
00297     }
00298 
00299     DEBUG("HYBERNATE bm019 (FIELD_OFF and POWER_DOWN)\n");
00300     if(setProtocolOFF()) {
00301         write(&BM019_CMD_HYBERNATE[1],BM019_CMD_HYBERNATE[0]);
00302         stateBM019 = BM019_STATE_UNKNOWN;
00303         return true;
00304     }
00305     return false;
00306 }
00307 
00308 
00309 bool inventoryISO_IES_15693BM019(BM019_TAG *tag, int timeout)
00310 {
00311     if(stateBM019 < BM019_STATE_PROTOCOL) {
00312         DEBUG("inventory failed, bm019 not in protocol\n");
00313         return false;
00314     }
00315 
00316     DEBUG("inventory..");
00317 
00318     int len = write_read(&BM019_CMD_ISO_IEC_15693_INVENTORY[1],BM019_CMD_ISO_IEC_15693_INVENTORY[0]);
00319 
00320     DEBUG("got answer len()=%d\n",len);
00321     for(int i = 0; i < len; i++) {
00322         DEBUG("%#04x ",rxBuffer[i]);
00323     }
00324     DEBUG("\n");
00325 
00326     if(rxBuffer[0] != EFrameRecvOK) {
00327         DEBUG("got error %#04x\n",rxBuffer[0]);
00328         return false;
00329     }
00330 
00331     int tlen = rxBuffer[1];
00332     if(tlen < 11) {
00333         DEBUG("to few bytes recieved \n");
00334         return false;
00335     }
00336     /* this does not work very good, maybe something misinterpreted from docs
00337     if(rxBuffer[tlen-1] & 0x01) {
00338         DEBUG("got collision \n");
00339         return false;
00340     }
00341     if(rxBuffer[tlen-1] & 0x02) {
00342         DEBUG("got bad crc \n");
00343         return false;
00344     }*/
00345     tag->crc[0] = rxBuffer[tlen-2];
00346     tag->crc[1] = rxBuffer[tlen-3];
00347 
00348     for(int i = 0; i < 9; i++) {
00349         tag->uid[i] = rxBuffer[11-i];
00350     }
00351     return true;
00352 
00353 }
00354 
00355 int readBM019(uint8_t adr, uint8_t *buf, int len, int timeout)
00356 {
00357     if(stateBM019 < BM019_STATE_PROTOCOL) {
00358         DEBUG("read failed, bm019 not in protocol\n");
00359         return -1;
00360     }
00361     uint8_t cmd[BM019_CMD_READ[0]];
00362     memcpy(cmd,&BM019_CMD_READ[1],BM019_CMD_READ[0]);
00363     cmd[BM019_CMD_READ[0]-1] = adr & 0xFF;
00364 
00365     DEBUG("read at %#4X..\n",adr);
00366     for(int i = 0; i < BM019_CMD_READ[0]; i++) {
00367         DEBUG("%#04x ",cmd[i]);
00368     }
00369     int tx = write_read(cmd,BM019_CMD_READ[0]);
00370 
00371     DEBUG("got answer len()=%d\n",tx);
00372     for(int i = 0; i < tx; i++) {
00373         DEBUG("%#04x ",rxBuffer[i]);
00374     }
00375     DEBUG("\n");
00376     if(rxBuffer[0] != EFrameRecvOK) {
00377         DEBUG("got error %#04x\n",rxBuffer[0]);
00378         return -1;
00379     }
00380 
00381     DEBUG("flags: %#04x\n",rxBuffer[2]);
00382     int tlen = rxBuffer[1]-4;
00383     if(tlen <=0)
00384         return -1;
00385     DEBUG("read resultet in %d bytes, copying %d bytes\n",rxBuffer[1],(tlen < len ? tlen : len));
00386     tlen = (tlen < len ? tlen : len);
00387     memcpy(buf,(const void *)&rxBuffer[3],tlen);
00388 
00389     return tlen;
00390 }
00391 
00392 int readMultiBM019(uint8_t adr, int count, uint8_t *buf, int len, int timeout)
00393 {
00394     if(stateBM019 < BM019_STATE_PROTOCOL) {
00395         DEBUG("multi read failed, bm019 not in protocol\n");
00396         return -1;
00397     }
00398     uint8_t cmd[BM019_CMD_READ_MULTI[0]];
00399     memcpy(cmd,&BM019_CMD_READ_MULTI[1],BM019_CMD_READ_MULTI[0]);
00400     cmd[BM019_CMD_READ_MULTI[0]-2] = adr & 0xFF;
00401     cmd[BM019_CMD_READ_MULTI[0]-1] = (count-1) & 0xFF;
00402 
00403     DEBUG("multi read at %#4X for %d..\n",adr, count & 0xFF);
00404     for(int i = 0; i < BM019_CMD_READ_MULTI[0]; i++) {
00405         DEBUG("%#04x ",cmd[i]);
00406     }
00407     int tx = write_read(cmd,BM019_CMD_READ_MULTI[0]);
00408 
00409     DEBUG("got answer len()=%d\n",tx);
00410     for(int i = 0; i < tx; i++) {
00411         DEBUG("%02x ",rxBuffer[i]);
00412     }
00413     DEBUG("\n");
00414     if(rxBuffer[0] != EFrameRecvOK) {
00415         DEBUG("got error %#04x\n",rxBuffer[0]);
00416         return -1;
00417     }
00418 
00419     DEBUG("flags: %#04x\n",rxBuffer[2]);
00420     int tlen = rxBuffer[1]-4;
00421     if(tlen <=0)
00422         return -1;
00423     DEBUG("read resultet in %d bytes, copying %d bytes\n",rxBuffer[1],(tlen < len ? tlen : len));
00424     tlen = (tlen < len ? tlen : len);
00425     memcpy(buf,(const void *)&rxBuffer[3],tlen);
00426 
00427     return tlen;
00428 }
00429 bool initBM019()
00430 {
00431     DEBUG("BM019: init\n");
00432     spi.format(8,3);
00433     spi.frequency(1000000);
00434     stateBM019 = BM019_STATE_UNKNOWN;
00435     return true;
00436 }