NFC Tag UID auslesen.

Diskutiere NFC Tag UID auslesen. im Plattformprogrammierung Forum; Hallo, ich will mich zuerst mal vorstellen, ich bin der Marius, 16 Jahre alt und neu hier im Java-Forum. Ich programmiere Java seit ungefähr 1-2...

  1. RealHDLPX
    RealHDLPX Neues Mitglied
    Hallo, ich will mich zuerst mal vorstellen, ich bin der Marius, 16 Jahre alt und neu hier im Java-Forum. Ich programmiere Java seit ungefähr 1-2 Jahren und gehe nebenbei noch zur Schule.

    Ich habe zwei NFC-Reade/Writer einmal einen, der per USB angeschlossen wird
    (ACR122U KKMoon) und noch einen der per SPI an den Raspberry Pi angeschlossen (RFIO-RC522) wird, nun habe ich, das mit dem ACR122U schon hinbekommen nur spuckt mir der Pi beim Auslesen, eine andere Adresse aus als der ACR122U also die UID ist nicht dieselbe, trotz derselben Karte. Eigentlich ist die UID immer gleich aber eventuell mache ich ja was falsch.

    Main (open)
    Code (Java):

    package de.RealHDLPX.PI4J;
    public class ReadRFID
    {
        public static void main(String[] args) throws InterruptedException
        {
            RaspRC522 rc522=new RaspRC522();
            String strUID;
            byte tagid[]=new byte[] { (byte) 0xFF, (byte) 0xCA, (byte) 0x00, (byte) 0x00, (byte) 0x00 };
            rc522.Select_MirareOne(tagid);
            strUID= Convert.bytesToHex(tagid);
            System.out.println(strUID);
            System.out.println("Card Read UID1:" + tagid[0] + "," + tagid[1] + "," + tagid[2] + "," + tagid[3]);
            System.out.println("Card Read UID2:" + strUID.substring(0,2) + "," +
                    strUID.substring(2,4) + "," +
                    strUID.substring(4,6) + "," +
                    strUID.substring(6,8));
            System.out.println(rc522.Select_Tag(tagid));
        }
    }


    RaspRC522 Klasse (open)
    Code (Java):

    package de.RealHDLPX.PI4J;
    import com.pi4j.wiringpi.Gpio;
    import com.pi4j.wiringpi.Spi;

    public class RaspRC522
    {
        private int NRSTPD = 22;    
        private int Speed=500000;
        private int SPI_Channel=0;

        private final int MAX_LEN = 16;

        public static final byte PCD_IDLE       = 0x00;
        public static final byte PCD_AUTHENT    = 0x0E;
        public static final byte PCD_RECEIVE    = 0x08;
        public static final byte PCD_TRANSMIT   = 0x04;
        public static final byte PCD_TRANSCEIVE = 0x0C;
        public static final byte PCD_RESETPHASE = 0x0F;
        public static final byte PCD_CALCCRC    = 0x03;

        public  static final byte PICC_REQIDL    = 0x26;
        public  static final byte PICC_REQALL    = 0x52;
        public  static final byte PICC_ANTICOLL  = (byte)0x93;
        public  static final byte PICC_SElECTTAG = (byte)0x93;
        public  static final byte PICC_AUTHENT1A = 0x60;
        public  static final byte PICC_AUTHENT1B = 0x61;
        public  static final byte PICC_READ      = 0x30;
        public  static final byte PICC_WRITE     = (byte)0xA0;
        public  static final byte PICC_DECREMENT = (byte)0xC0;
        public  static final byte PICC_INCREMENT = (byte)0xC1;
        public  static final byte PICC_RESTORE   = (byte)0xC2;
        public  static final byte PICC_TRANSFER  = (byte)0xB0;
        public  static final byte PICC_HALT      = 0x50;

        public static final int MI_OK       = 0;
        public static final int MI_NOTAGERR = 1;
        public static final int MI_ERR      = 2;

        public static final byte Reserved00     = 0x00;
        public static final byte CommandReg     = 0x01;
        public static final byte CommIEnReg     = 0x02;
        public static final byte DivlEnReg      = 0x03;
        public static final byte CommIrqReg     = 0x04;
        public static final byte DivIrqReg      = 0x05;
        public static final byte ErrorReg       = 0x06;
        public static final byte Status1Reg     = 0x07;
        public static final byte Status2Reg     = 0x08;
        public static final byte FIFODataReg    = 0x09;
        public static final byte FIFOLevelReg   = 0x0A;
        public static final byte WaterLevelReg  = 0x0B;
        public static final byte ControlReg     = 0x0C;
        public static final byte BitFramingReg  = 0x0D;
        public static final byte CollReg        = 0x0E;
        public static final byte Reserved01     = 0x0F;

        public static final byte Reserved10     = 0x10;
        public static final byte ModeReg        = 0x11;
        public static final byte TxModeReg      = 0x12;
        public static final byte RxModeReg      = 0x13;
        public static final byte TxControlReg   = 0x14;
        public static final byte TxAutoReg      = 0x15;
        public static final byte TxSelReg       = 0x16;
        public static final byte RxSelReg       = 0x17;
        public static final byte RxThresholdReg = 0x18;
        public static final byte DemodReg       = 0x19;
        public static final byte Reserved11     = 0x1A;
        public static final byte Reserved12     = 0x1B;
        public static final byte MifareReg      = 0x1C;
        public static final byte Reserved13     = 0x1D;
        public static final byte Reserved14     = 0x1E;
        public static final byte SerialSpeedReg = 0x1F;

        public static final byte Reserved20        = 0x20;
        public static final byte CRCResultRegM     = 0x21;
        public static final byte CRCResultRegL     = 0x22;
        public static final byte Reserved21        = 0x23;
        public static final byte ModWidthReg       = 0x24;
        public static final byte Reserved22        = 0x25;
        public static final byte RFCfgReg          = 0x26;
        public static final byte GsNReg            = 0x27;
        public static final byte CWGsPReg          = 0x28;
        public static final byte ModGsPReg         = 0x29;
        public static final byte TModeReg          = 0x2A;
        public static final byte TPrescalerReg     = 0x2B;
        public static final byte TReloadRegH       = 0x2C;
        public static final byte TReloadRegL       = 0x2D;
        public static final byte TCounterValueRegH = 0x2E;
        public static final byte TCounterValueRegL = 0x2F;

        public static final byte Reserved30      = 0x30;
        public static final byte TestSel1Reg     = 0x31;
        public static final byte TestSel2Reg     = 0x32;
        public static final byte TestPinEnReg    = 0x33;
        public static final byte TestPinValueReg = 0x34;
        public static final byte TestBusReg      = 0x35;
        public static final byte AutoTestReg     = 0x36;
        public static final byte VersionReg      = 0x37;
        public static final byte AnalogTestReg   = 0x38;
        public static final byte TestDAC1Reg     = 0x39;
        public static final byte TestDAC2Reg     = 0x3A;
        public static final byte TestADCReg      = 0x3B;
        public static final byte Reserved31      = 0x3C;
        public static final byte Reserved32      = 0x3D;
        public static final byte Reserved33      = 0x3E;
        public static final byte Reserved34      = 0x3F;


        public RaspRC522(int Speed,int PinReset)
        {
            this.NRSTPD=PinReset;
            if(Speed < 500000 || Speed > 32000000)
            {
                System.out.println("Speed *");
                return;
            }
            else this.Speed=Speed;
            RC522_Init();
        }

        public RaspRC522()
        {
            this.Speed=500000;
            RC522_Init();
        }

        public void RC522_Init()
        {
            Gpio.wiringPiSetup();
            int fd=Spi.wiringPiSPISetup(SPI_Channel,Speed);
            if (fd <= -1)
            {
                System.out.println(" --> Konnte SPI nicht laden");
                return;
            }
            else
            {
                System.out.println(" --> SPI geladen");
            }

            Gpio.pinMode(NRSTPD, Gpio.OUTPUT);
            Gpio.digitalWrite(NRSTPD, Gpio.HIGH);
            Reset();
            Write_RC522(TModeReg, (byte)0x8D);
            Write_RC522(TPrescalerReg, (byte)0x3E);
            Write_RC522(TReloadRegL, (byte) 30);
            Write_RC522(TReloadRegH, (byte) 0);
            Write_RC522(TxAutoReg, (byte) 0x40);
            Write_RC522(ModeReg, (byte) 0x3D);
            AntennaOn();
        }

        private void Reset()
        {
            Write_RC522(CommandReg, PCD_RESETPHASE);
        }

        private void Write_RC522(byte address,byte value)
        {
            byte data[]=new byte[2];
            data[0]=(byte) ((address << 1) & 0x7E);
            data[1]=value;
            int result=Spi.wiringPiSPIDataRW(SPI_Channel, data);
            if(result == -1)
                System.out.println("Device write  error,address="+address+",value="+value);
        }

        private byte Read_RC522(byte address)
        {
            byte data[]=new byte[2];
            data[0]=(byte) (((address << 1) & 0x7E) | 0x80);
            data[1]=0;
            int result=Spi.wiringPiSPIDataRW(SPI_Channel, data);
            if(result == -1)
                System.out.println("Device read  error,address="+address);
            return data[1];
        }

        private void SetBitMask(byte address,byte mask)
        {
            byte value=Read_RC522(address);
            Write_RC522(address,(byte)(value|mask));
        }

        private void ClearBitMask(byte address,byte mask)
        {
            byte value=Read_RC522(address);
            Write_RC522(address,(byte)( value&(~mask)));
        }

        private void AntennaOn()
        {
            Read_RC522(TxControlReg);
         //   if((value & 0x03) != 0x03)
            SetBitMask(TxControlReg,(byte) 0x03);
        }

        private int Write_Card(byte command,byte []data,int dataLen,byte[]back_data,int[]back_bits,int[]backLen)
        {
            int status=MI_ERR;
            byte irq=0,irq_wait=0,lastBits=0;
            int n=0,i=0;

            backLen[0]=0;
            if(command == PCD_AUTHENT)
            {
                irq = 0x12;
                irq_wait=0x10;
            }
            else if(command == PCD_TRANSCEIVE)
            {
                irq = 0x77;
                irq_wait=0x30;
            }

            Write_RC522(CommIEnReg, (byte)(irq|0x80));
            ClearBitMask(CommIrqReg, (byte)0x80);
            SetBitMask(FIFOLevelReg, (byte)0x80);

            Write_RC522(CommandReg,PCD_IDLE);

            for(i=0;i<dataLen;i++)
                Write_RC522(FIFODataReg, data[i]);

            Write_RC522(CommandReg, command);
            if(command == PCD_TRANSCEIVE)
                SetBitMask(BitFramingReg, (byte)0x80);

            i=2000;
            while (true)
            {
                n = Read_RC522(CommIrqReg);
                i--;
                if ((i == 0) || (n & 0x01) > 0 || (n & irq_wait) > 0)
                {

                    break;
                }
            }
            ClearBitMask(BitFramingReg, (byte)0x80);

            if(i != 0)
            {
                if ((Read_RC522(ErrorReg) & 0x1B)==0x00)
                {
                    status = MI_OK;
                    if ((n & irq & 0x01) > 0)
                        status = MI_NOTAGERR;
                    if (command == PCD_TRANSCEIVE)
                    {
                        n = Read_RC522(FIFOLevelReg);
                        lastBits = (byte) (Read_RC522(ControlReg) & 0x07);
                        if (lastBits != 0)
                            back_bits[0] = (n - 1) * 8 + lastBits;
                        else
                            back_bits[0] = n * 8;

                        if (n == 0) n = 1;
                        if (n > this.MAX_LEN) n = this.MAX_LEN;
                        backLen[0] = n;
                        for (i = 0; i < n; i++)
                            back_data[i] = Read_RC522(FIFODataReg);
                    }
                }
                else
                    status = MI_ERR;
            }
            return  status;
        }

        public int Request(byte req_mode,int []back_bits)
        {
            int status;
            byte tagType[]=new byte[1];
            byte data_back[]=new byte[16];
            int backLen[]=new int[1];

            Write_RC522(BitFramingReg, (byte)0x07);

            tagType[0]=req_mode;
            back_bits[0]=0;
            status=Write_Card(PCD_TRANSCEIVE,tagType,1,data_back,back_bits,backLen);
            if (status != MI_OK || back_bits[0] != 0x10)
            {

                status = MI_ERR;
            }

            return status;
        }

        public int AntiColl(byte[]back_data)
        {
            int status;
            byte []serial_number = new byte[2];
            int serial_number_check = 0;
            int backLen[]=new int[1];
            int back_bits[]=new int[1];
            int i;

            Write_RC522(BitFramingReg, (byte)0x00);
            serial_number[0]=PICC_ANTICOLL;
            serial_number[1]=0x20;
            status=Write_Card(PCD_TRANSCEIVE,serial_number,2,back_data,back_bits,backLen);
            if(status == MI_OK)
            {
                if(backLen[0] == 5)
                {
                    for(i=0;i<4;i++)
                        serial_number_check ^=back_data[i];
                    if(serial_number_check != back_data[4])
                    {
                        status = MI_ERR;
                        System.out.println("check error");
                    }
                }
                else
                {
                    status = MI_OK;
                    System.out.println("backLen[0]="+backLen[0]);
                }
            }
            return status;
        }

        private void Calculate_CRC(byte []data)
        {
            int i,n;
            ClearBitMask(DivIrqReg, (byte)0x04);
            SetBitMask(FIFOLevelReg, (byte)0x80);

            for(i=0;i<data.length-2;i++)
                Write_RC522(FIFODataReg, data[i]);
            Write_RC522(CommandReg, PCD_CALCCRC);
            i = 255;
            while(true)
            {
                n = Read_RC522(DivIrqReg);
                i--;
                if ((i == 0) || ((n & 0x04)>0))
                    break;
            }
            data[data.length-2]=Read_RC522(CRCResultRegL);
            data[data.length-1]=Read_RC522(CRCResultRegM);
        }

        public int Select_Tag(byte []uid)
        {
            int status;
            byte data[]=new byte[9];
            byte back_data[]=new byte[this.MAX_LEN];
            int back_bits[]=new int[1];
            int backLen[]=new int[1];
            int i,j;

            data[0]=PICC_SElECTTAG;
            data[1]=0x70;
            for(i=0,j=2;i<5;i++,j++)
                data[j]=uid[i];
            Calculate_CRC(data);

            status=Write_Card(PCD_TRANSCEIVE, data,9,back_data,back_bits,backLen);
            if (status == MI_OK && back_bits[0] == 0x18) return back_data[0];
            else return 0;
        }

        public int Auth_Card(byte auth_mode,byte block_address,byte []key,byte []uid)
        {
            int status;
            byte data[]=new byte[12];
            byte back_data[]=new byte[this.MAX_LEN];
            int back_bits[]=new int[1];
            int backLen[]=new int[1];
            int i,j;

            data[0]=auth_mode;
            data[1]=block_address;
            for(i=0,j=2;i<6;i++,j++)
                data[j]=key[i];
            for(i=0,j=8;i<4;i++,j++)
                data[j]=uid[i];

            status=Write_Card(PCD_AUTHENT, data,12,back_data,back_bits,backLen);
            if((Read_RC522(Status2Reg) & 0x08)== 0) status=MI_ERR;
            return status;
        }

        //
        public int Auth_Card(byte auth_mode,byte sector,byte block,byte []key,byte []uid)
        {
            return Auth_Card(auth_mode,Sector2BlockAddress(sector,block),key,uid);
        }

        public void Stop_Crypto()
        {
            ClearBitMask(Status2Reg, (byte) 0x08);
        }

        public int Read(byte block_address,byte[]back_data)
        {
            int status;
            byte data[]=new byte[4];
            int back_bits[]=new int[1];
            int backLen[]=new int[1];
            data[0]=PICC_READ;
            data[1]=block_address;
            Calculate_CRC(data);
            status=Write_Card(PCD_TRANSCEIVE, data,data.length,back_data,back_bits,backLen);
            if(backLen[0] == 16) status=MI_OK;
            return status;
        }

        //
        public int Read(byte sector,byte block,byte[]back_data)
        {
            return Read(Sector2BlockAddress(sector,block),back_data);
        }

        public int Write(byte block_address,byte[]data)
        {
            int status;
            byte buff[]=new byte[4];
            byte buff_write[]=new byte[data.length+2];
            byte back_data[]=new byte[this.MAX_LEN];
            int back_bits[]=new int[1];
            int backLen[]=new int[1];
            int i;

            buff[0]=PICC_WRITE;
            buff[1]=block_address;
            Calculate_CRC(buff);
            status=Write_Card(PCD_TRANSCEIVE, buff,buff.length,back_data,back_bits,backLen);
            //System.out.println("write_card  status="+status);
            //System.out.println("back_bits[0]="+back_bits[0]+",(back_data[0] & 0x0F)="+(back_data[0] & 0x0F));
            if(status != MI_OK || back_bits[0] !=4 || (back_data[0] & 0x0F) != 0x0A) status=MI_ERR;
            if(status == MI_OK)
            {
                for (i=0;i<data.length;i++)
                    buff_write[i]=data[i];
                Calculate_CRC(buff_write);
                status=Write_Card(PCD_TRANSCEIVE, buff_write,buff_write.length,back_data,back_bits,backLen);

                if(status != MI_OK ||back_bits[0] !=4 || (back_data[0] & 0x0F) != 0x0A) status=MI_ERR;
            }
            return  status;
        }

        //
        public int Write(byte sector,byte block,byte[]data)
        {
            return Write(Sector2BlockAddress(sector,block),data);
        }

        public byte[] DumpClassic1K(byte []key, byte[]uid)
        {
            int i,status;
            byte []data=new byte[1024];
            byte []buff=new byte[16];

            for(i=0;i<64;i++)
            {
                status=Auth_Card(PICC_AUTHENT1A, (byte) i, key, uid);
                if(status == MI_OK)
                {
                    status=Read((byte) i,buff);
                    if(status == MI_OK)
                        System.arraycopy(buff,0,data,i*64,16);
                }
            }
            return data;
        }
       
        private byte Sector2BlockAddress(byte sector,byte block)
        {
            if(sector <0 || sector >15 || block <0 || block >3) return (byte)(-1);
            return (byte)(sector*4+block);
        }

        //uid-5 bytes
        public int Select_MirareOne(byte[]uid)
        {
            int back_bits[]=new int[1];
            byte tagid[]=new byte[5];
            int status;

            status=Request(RaspRC522.PICC_REQIDL, back_bits);
            if(status != MI_OK) return status;
            status=AntiColl(tagid);
            if(status != MI_OK) return status;
            Select_Tag(tagid);
            System.arraycopy(tagid,0,uid,0,5);

            return status;
        }

    }
     


    Convert Klasse (open)
    Code (Java):
    package de.RealHDLPX.PI4J;

    import java.math.BigDecimal;
    import java.math.BigInteger;
    import java.sql.Date;
    import java.sql.Time;
    import java.sql.Timestamp;
    import java.sql.Types;

    public class Convert
    {
        public static Object String2Object(String strValue,int type)
        {
            Object value=null;
            switch(type)
            {
            case Types.INTEGER:
                value=Integer.parseInt(strValue);
                break;
            case Types.VARCHAR:
            case Types.CHAR:  
            case Types.NVARCHAR:          
                value=strValue;
                break;
            case Types.DOUBLE:
                value=Double.parseDouble(strValue);
                break;
            case Types.FLOAT:
                value=Float.parseFloat(strValue);
                break;
            case Types.BOOLEAN:
                value=Boolean.parseBoolean(strValue);
                break;
            case Types.DATE:
                value=Date.valueOf(strValue);
                break;
            case Types.DECIMAL:
            case Types.NUMERIC:          
                value=new BigDecimal(strValue);
                break;
            case Types.BIGINT:
                value=new BigInteger(strValue);
                break;
            case Types.TIMESTAMP:
                value=Timestamp.valueOf(strValue);
                break;
            case Types.TIME:
                value=Time.valueOf(strValue);
                break;
            case Types.SMALLINT:
                value=Integer.parseInt(strValue);
                break;
            case Types.LONGVARCHAR:
            case Types.LONGNVARCHAR:
                value=strValue;          
                break;
            }
            return value;
        }

        public static String bytesToHex(byte[] bytes)
        {
            final char[] hexArray = { '0', '1', '2', '3', '4', '5', '6', '7', '8',
                    '9', 'A', 'B', 'C', 'D', 'E', 'F' };
            char[] hexChars = new char[bytes.length * 2];
            int v;
            for (int j = 0; j < bytes.length; j++)
            {
                v = bytes[j] & 0xFF;
                hexChars[j * 2] = hexArray[v >>> 4];
                hexChars[j * 2 + 1] = hexArray[v & 0x0F];
            }
            return new String(hexChars);
        }
    }
     
     
  2. Vielleicht hilft dir dieser Java-Kurs hier weiter --> (hier klicken)
  3. RealHDLPX
    RealHDLPX Neues Mitglied
    Man benötigt die "PI4J" API: http://pi4j.com/download.html
     
  4. RealHDLPX
    RealHDLPX Neues Mitglied
    Danke für die ganzen Antworten :D
     
Die Seite wird geladen...

NFC Tag UID auslesen. - Ähnliche Themen

Position von Pixeln in Bilder auslesen
Position von Pixeln in Bilder auslesen im Forum Allgemeine Java-Themen
ResultSet vollständig auslesen
ResultSet vollständig auslesen im Forum Datenbankprogrammierung
String erste Zahl mit LKZ auslesen lassen
String erste Zahl mit LKZ auslesen lassen im Forum Java Basics - Anfänger-Themen
XML Datei erstellen und Daten daraus in Java auslesen
XML Datei erstellen und Daten daraus in Java auslesen im Forum XML und Co.
aktive WLAN Teilnehmer auslesen?
aktive WLAN Teilnehmer auslesen? im Forum Allgemeine Java-Themen
Thema: NFC Tag UID auslesen.