android串口通信——身份证识别器

android串口通信——身份证识别器

本文主要解决的问题:
1.身份证识别器硬件的使用
2.读取到数据的解析

一、身份证识别器基础

1.调用身份证识别器的步骤

调用身份证识别器的步骤分为三步:
- 1.寻找身份证信息
- 2.选取身份证信息
- 3.读取身份证信息

2.波特率

身份证识别器的默认波特率是115200。

3.基本指令

  • 1、寻找身份证信息:
    寻卡命令: AA AA AA 96 69 00 03 20 01 22
    返 回 值: AA AA AA 96 69 00 08 00 00 9F 00 00 00 00 97

  • 2、选取身份证信息:
    选卡命令: AA AA AA 96 69 00 03 20 02 21
    返 回 值: AA AA AA 96 69 00 0C 00 00 90 00 00 00 00 00 00 00 00 9C

  • 3、读取身份证信息(文字+照片信息):
    读卡命令: AA AA AA 96 69 00 03 30 01 32
    返 回 值: 1295 字节数据身份证信息

  • 4 、 读取身份证信息(文字+照片+指纹特征点信息)
    读卡命令: AA AA AA 96 69 00 03 30 10 23
    返回 值: 2321 或 1809 或 1297 字节数据身份证信息

4. 身份证信息结构

  • 身份证信息(文字+照片)结构:
    AA AA AA 96 69 05 08 00 00 90 01 00 04 00 +( 256 字节文字信息 ) +( 1024 字节
    照片信息) +( 1 字节 CRC)

  • 身份证信息(文字+照片+指纹)结构:
    AA AA AA 96 69 09 0A 00 00 90 01 00 04 00 04 00 +( 256 字节文字信息) +
    ( 1024 字节图片信息) +( 1024 或 512 或 0 字节指纹信息) +1 字节校验位 指
    纹数据的具体大小由第十五和第十六字节判断 (04 00)=4*16*16=1024
    (02 00)=2*16*16=512

5.文字结构说明

文字信息采用 GB 13000 的 UCS-2 进行存储, 各项目分配如下:

项目长度(字节)说明
姓名30汉字
性别2代码
民族4代码
出生16年月日: YYYYMMDD
住址70汉字和数字
公民身份号码36数字和字母X(x)
签发机关30汉字
有效期起始日期16年月日: YYYYMMDD
有效期截止日期16年月日: YYYYMMDD 有效期为长期时存储 “长期”
备用36汉字

6.民族代码对照表

编号名族编号名族编号名族编号名族
0115土家29柯尔克孜43乌孜别克
02蒙古16哈尼3044俄罗斯
0317哈萨克31达斡尔45鄂温克
041832仫佬46德昂
05维吾尔193347保安
0620傈僳34布朗48裕固
072135撒拉49
082236毛南50塔塔尔
09布依23高山37仡佬51独龙
10朝鲜24拉祜38锡伯52鄂伦春
112539阿昌53赫哲
1226东乡40普米54门巴
1327纳西41塔吉克55珞巴
1428景颇4256基诺
97其他98外国血统中国籍人士

7.性别代码对照表

编号说明
0未知
1
2
9未说明

二、身份证的读取

首先需要知道身份证的波特率和硬件连接地址,身份证的波特率默认是115200

1.读取的方法调用

       /**
     * 读取 身份证信息
     *
     * @param view
     */
    public void readIdCard(View view) {
        //1.硬件地址判断
        String adress = addressTv.getText().toString().trim();
        if ("".equals(adress)) {
            Toast.makeText(this, "请选择硬件地址", Toast.LENGTH_SHORT).show();
            return;
        }
        //2.波特率判断
        String bauteStr = bauteRateTv.getText().toString().trim();
        if ("".equals(bauteStr)) {
            Toast.makeText(this, "请选择波特率", Toast.LENGTH_SHORT).show();
            return;
        }
        new IDCardReadUtils(this).queryIdCardInfo(adress, Integer.parseInt(bauteStr), new IDCardReadUtils.IDCardListener() {
            @Override
            public void onInfo(IdCardBean bean) {
                //输出身份证信息
                infoTv.setText(bean.word.toMyString());
                //头像的显示
                decodeImagexxx(bean.headImage);
            }
        });
    }

   public String bmpPath =   "/sdcard/photo.bmp";
    public String wltPath =  "/sdcard/photo.wlt";

    public void decodeImagexxx(byte[] wlt) {
        if (wlt == null) {
            return;
        }
        try {
            File wltFile = new File(wltPath);
            FileOutputStream fos = new FileOutputStream(wltFile);
            fos.write(wlt);
            fos.close();

            DecodeWlt dw = new DecodeWlt();
            int result = dw.Wlt2Bmp(wltPath, bmpPath);

            if (result == 1) {
                File f = new File(bmpPath);
                if (f.exists())
                    headIv.setImageBitmap(BitmapFactory
                            .decodeFile(bmpPath));
                else {
//                    imageViewPhoto.setImageResource(R.drawable.photo);
                }
            } else {
//                imageViewPhoto.setImageResource(R.drawable.photo);
            }
        } catch (IOException ioe) {
            ioe.printStackTrace();
        }

    }

2.身份证的工具类(IDCardReadUtils)

这个类主要处理
1.读取身份证信息
①寻找身份证信息
②选取身份证信息
③读取身份证信息
2.把读取到信息进行处理,封装bean

package com.qwm.idcarddemo.utils;

import android.annotation.SuppressLint;
import android.content.Context;
import android.util.Log;
import android.widget.Toast;


import com.qwm.idcarddemo.bean.IdCardBean;
import com.qwm.idcarddemo.bean.SerialPortSendData;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

/**
 * @author qiwenming
 * @date 2016/1/19 0019 下午 6:02
 * @ClassName: IDCardReadUtils
 * @ProjectName: 
 * @PackageName: com.qwm.idcarddemo.utils
 * @Description:  读取的工具类
 *
 */
public class IDCardReadUtils {
    private final Context context;

    private IDCardListener listener;

    public IDCardReadUtils(Context context){
        this.context = context;

    }


    private IDCardDevicesUtils device;
    private boolean isIdCardOk;



    /**
     * 获取错误的字符
     * @return
     */
    private String getFialStr(){
        StringBuilder sb = new StringBuilder();
        sb.append("(");
        sb.append("000010|");
        sb.append("000011|");
        sb.append("000010|");
        sb.append("000021|");
        sb.append("000023|");
        sb.append("000024|");
//        sb.append("31|");
//        sb.append("32|");
        sb.append("000033|");
        sb.append("40|");
        sb.append("41|");
        sb.append("47|");
        sb.append("000060|");
        sb.append("000066|");
        sb.append("000080|");
        sb.append("000081|");
        sb.append("000091");
        sb.append(")");
        return sb.toString();
    }

    private int ii=0;
    public String getSSSS(){
        String ss = Integer.toHexString(ii);
        ii++;
        if(ss.length()<2)
            ss = "0"+ss;
        return ss;
    }


    /**
     * 第一步:寻找身份证信息
     * @param devicessAddress  设备地址
     * @param bauteRate  波特率
     * @param listener  回调
     * 获取身份证信息
     * 分为三步走:
     * 1.寻找身份证信息
     *   AA AA AA 96 69 00 03 20 01 22
     *   返回 AA AA AA 96 69 00 08 00 00 9F 00 00 00 00 97
     * 2.选取身份证信息
     *   AA AA AA 96 69 00 03 20 02 21
     *   返回AA AA AA 96 69 00 0C 00 00 90 00 00 00 00 00 00 00 00 9C
     * 3.获取
     AA AA AA 96 69 00 03 30 01 32
     返回1295  字节数据身份证信息
     */
    public void queryIdCardInfo(String devicessAddress,int bauteRate,IDCardListener listener) {
        this.listener = listener;
        Log.i("queryIdCardInfo", "queryIdCardInfo--------");
        device = new IDCardDevicesUtils();
        SerialPortSendData sendData = new SerialPortSendData("/dev/ttyS3",115200,  "AAAAAA96690003200122",
                "9f", getFialStr(),"97", true);
        device.toSend(context, sendData, new IDCardDevicesUtils.ReciverListener() {
            @Override
            public void onReceived(String receviceStr) {
                choiceIdCardInfo();
            }

            @Override
            public void onFail(String fialStr) {
                //mHandler.sendEmptyMessageDelayed(GETIDCARD, 1000);
                try{
                    Toast.makeText(context, "请放入或 重放身份证", Toast.LENGTH_SHORT).show();
                }catch(Exception e){
                    e.printStackTrace();

                }

            }
            @Override
            public void onErr(Exception e) {
                try{
//                    MyToast.shortShow(getActivity(), "请放入或 重放身份证");
                }catch(Exception e2){
                    e2.printStackTrace();
                }
                //    mHandler.sendEmptyMessageDelayed(GETIDCARD, 1000);
            }

//            @Override
//            public void onFinished(Exception e) {
//
//            }
        });
    }

    /**
     * 第二步:选取身份证
     */
    public void choiceIdCardInfo(){
        device = new IDCardDevicesUtils();
        Log.i("choiceIdCardInfo", "choiceIdCardInfo--------");
        SerialPortSendData sendData = new SerialPortSendData("/dev/ttyS3",115200,  "AAAAAA96690003200221","90", getFialStr(),"9c", true);
        device.toSend(context, sendData, new IDCardDevicesUtils.ReciverListener() {
            @Override
            public void onReceived(String receviceStr) {
                getIdCardInfo();
            }

            @Override
            public void onFail(String fialStr) {
                //mHandler.sendEmptyMessageDelayed(GETIDCARD, 1000);
//                MyToast.shortShow(getActivity(), "选取失败");
            }

            @Override
            public void onErr(Exception e) {
//                MyToast.shortShow(getActivity(), "选取失败");
                //    mHandler.sendEmptyMessageDelayed(GETIDCARD, 1000);
            }

//            @Override
//            public void onFinished(Exception e) {
//
//            }
        });
    }



    /**
     * 第三步:获取身份证信息
     */
    public void getIdCardInfo(){
        Log.i("getIdCardInfo", "getIdCardInfo--------");
        device = new IDCardDevicesUtils();
        SerialPortSendData sendData = new SerialPortSendData("/dev/ttyS3",115200,"AAAAAA96690003300132",1295);
        device.toSend(context, sendData, new IDCardDevicesUtils.ReciverListener() {
            @Override
            public void onReceived(String receviceStr) {
                IdCardBean bean = getIdCardDataBean(receviceStr);
                listener.onInfo(bean);
            }

            @Override
            public void onFail(String fialStr) {
//                MyToast.shortShow(getActivity(), "身份证读取失败");
            }

            @Override
            public void onErr(Exception e) {
//                MyToast.shortShow(getActivity(), "身份证读取失败");
            }

//            @Override
//            public void onFinished(Exception e) {
//
//            }
        });
    }

    /**
     * 身份证信息处理
     * 身份证信息(文字+照片)结构:
     * AA AA AA 96 69 05 08 00 00 90 01 00 04 00 +(256  字节文字信息 )+(1024 字节  照片信息)+(1  字节 CRC)
     * @param dataStr
     */
    @SuppressLint("NewApi")
    public IdCardBean getIdCardDataBean(String dataStr){
        Log.i("idcard_str",dataStr);
        IdCardBean idCard = new IdCardBean();
        byte[] data = StringUtils.hexStringToBytes(dataStr);
        Log.i("--------------dataStr-------------",dataStr.length()+"");
        if(data.length>=1295){
            //1.文字信息处理
            byte[] idWordbytes = Arrays.copyOfRange(data, 14, 270);
            //2.头像处理
           String headStr = dataStr.substring(540,2588);
            idCard.headImage = hex2byte(headStr);//Arrays.copyOfRange(data,270, 1294);
            try {
                idCard.word.name = new String(Arrays.copyOfRange(idWordbytes,0, 30),"UTF-16LE").trim().trim();
                idCard.word.gender = new String(Arrays.copyOfRange(idWordbytes,30, 32),"UTF-16LE").trim();
                idCard.word.nation = new String(Arrays.copyOfRange(idWordbytes,32, 36),"UTF-16LE").trim();
                idCard.word.birthday = new String(Arrays.copyOfRange(idWordbytes,36, 52),"UTF-16LE").trim();
                idCard.word.address = new String(Arrays.copyOfRange(idWordbytes,52, 122),"UTF-16LE").trim();
                idCard.word.idCard = new String(Arrays.copyOfRange(idWordbytes,122, 158),"UTF-16LE").trim();
                idCard.word.issuingAuthority = new String(Arrays.copyOfRange(idWordbytes,158, 188),"UTF-16LE").trim();
                idCard.word.startTime = new String(Arrays.copyOfRange(idWordbytes,188, 204),"UTF-16LE").trim();
                idCard.word.startopTime = new String(Arrays.copyOfRange(idWordbytes,204, 220),"UTF-16LE").trim();
                //名族的特殊处理
                idCard.word.nation = NationUtils.getNationNameById(idCard.word.nation);

            } catch (UnsupportedEncodingException e) {
            }
        }
//        if(data.length>=1294){
//            //照片信息处理
//            idCard.headImage = Arrays.copyOfRange(data,270, 1295);
//        }
        return idCard;
    }

    /**
     *    项目  长度(字节)  说明
     姓名  30              汉字
     性别  2              代码
     民族  4              代码
     出生  16             年月日:YYYYMMDD
     住址  70              汉字和数字
     公民身份号码 36  数字
     签发机关 30  汉字
     有效期起始日期 16 年月日:YYYYMMDD
     有效期截止日期 16 年月日:YYYYMMDD 有效期为长期时存储 “长期”
     备用 36
     */

    /**
     * 读取成功以后,身份证信息的回调接口
     */
    public interface IDCardListener{
        void onInfo(IdCardBean bean);
    }


    public static byte[] hex2byte(String hex) {
        int len = (hex.length() / 2);
        byte[] result = new byte[len];
        char[] achar = hex.toCharArray();
        for (int i = 0; i < len; i++) {
            int pos = i * 2;
            result[i] = (byte) (toByte(achar[pos]) << 4 | toByte(achar[pos + 1]));
        }
        Log.i("===========result--length===========",result.length+"");
        return result;
    }

    private static byte toByte(char c) {
        byte b = (byte) "0123456789ABCDEF".indexOf(c);
        return b;
    }

//    public static byte[] hex2byte(String str) { // 字符串转二进制
//        if (str == null)
//            return null;
//        str = str.trim();
//        int len = str.length();
//        if (len == 0 || len % 2 == 1)
//            return null;
//        byte[] b = new byte[len / 2];
//        try {
//            for (int i = 0; i < str.length(); i += 2) {
//                b[i / 2] = (byte) Integer.decode("0X" + str.substring(i, i + 2)).intValue();
//            }
//            return b;
//        } catch (Exception e) {
//            return null;
//        }
//    }
}

三、硬件读取类(IDCardDevicesUtils)

package com.qwm.idcarddemo.utils;

import android.content.Context;
import android.util.Log;
import android.widget.Toast;

import com.qwm.idcarddemo.MainActivity;
import com.qwm.idcarddemo.bean.SerialPortSendData;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.security.InvalidParameterException;

import android_serialport_api.SerialPort;
import android_serialport_api.SerialPortFinder;

/**
 * @author qiwenming
 * @date 2016/1/19 0019 下午 5:27
 * @ClassName: IDCardDevicesUtils
 * @ProjectName: 
 * @PackageName: com.qwm.idcarddemo.utils
 * @Description:  身份证识别 硬件调用
 */
public class IDCardDevicesUtils {
    protected OutputStream mOutputStream;
    private InputStream mInputStream;
    private ReadThread mReadThread;
    public SerialPortFinder mSerialPortFinder = new SerialPortFinder();
    private SerialPort mSerialPort;
    private Context context;

    /**
     * @author qiwenming
     * @creation 2015-6-18 下午4:38:54
     * @instruction 串口读取类
     */
    private class ReadThread extends Thread {
        private ReciverListener listener;
        private SerialPortSendData sendData;
        public boolean isReadData = false;
        public boolean isOK = true;

        public ReadThread(SerialPortSendData sendData, ReciverListener listener) {
            this.listener = listener;
            this.sendData = sendData;
        }

        @Override
        public void run() {
            StringBuffer sb = new StringBuffer();
            StringBuffer sb2 = new StringBuffer();
            super.run();
            while (!isInterrupted()) {
                int size;
                try {
                    byte[] buffer = new byte[1024];
                    if (mInputStream == null)
                        return;
                    size = mInputStream.read(buffer);
                    Log.i("--------------", "---------------mInputStream---------------" + mInputStream.available());
                    if (size > 0) { // 读取数据 数据c
                        String str = StringUtils.bytesToHexString(buffer, size).trim().toLowerCase();
                        sb2.append(str);
                        if (sendData.isOnlyLenght) {//这里我们只按照长度读取
                            sb.append(str);

                            if(sb2.toString().matches("\\w+"+sendData.failStr+"\\w+")){
                                closeDevice();
                                if (null == context)
                                    return;
                                ((MainActivity) context)
                                        .runOnUiThread(new Runnable() {
                                            @Override
                                            public void run() {
                                                listener.onFail(sendData.failStr);
                                            }
                                        });
                            } else if(sb.toString().length()>=(2*sendData.readByteCount)){
                                final String data = sb.toString();
                                closeDevice();
                                if (null == context)
                                    return;
                                ((MainActivity) context)
                                        .runOnUiThread(new Runnable() {
                                            @Override
                                            public void run() {
                                                listener.onReceived(data);
                                            }
                                        });
                            }
                        } else {//下面的处理是不安长度读取的
                            Log.i("onDataReceived", str);
                                if (sb2.toString().contains(sendData.stopStr)) {
                                    // 根据结束标志获取字符消息
                                    String[] strs = str.split(sendData.stopStr);
                                    if (strs.length > 1)
                                        for (int i = 0; i < strs.length - 1; i++)
                                            sb.append(strs[i]);

                                    final String data = sb.toString();
                                    sb = new StringBuffer();
                                    Log.i("onDataReceived_stop", data);
                                    Log.i("onDataReceived_stop_ascii",  StringUtils.convertHexToString(data));
                                    isReadData = false;
                                    closeDevice();
                                    if (null == context)
                                        return;
                                    ((MainActivity) context)
                                            .runOnUiThread(new Runnable() {
                                                @Override
                                                public void run() {
                                                    if (isOK)
                                                        listener.onReceived(data);
                                                    else
                                                        listener.onFail(sendData.failStr);
                                                }
                                            });
                                }
                                if (isReadData) {
                                    sb.append(str);
                                }
                                if (sb2.toString().contains(sendData.okStr)) {
                                    isReadData = true;
                                    isOK = true;
                                    String[] datas = str.split(sendData.okStr);
                                    for (int i = 1; i < datas.length; i++) {
                                        sb.append(str);
                                    }
                                }
                                if (sb2.toString().matches("\\w+"+sendData.failStr+"\\w+")) {
//                                    sb = new StringBuffer();
                                    isReadData = false;
                                    isOK = false;
                                    closeDevice();
                                    if (null == context)
                                        return;
                                    ((MainActivity) context)
                                            .runOnUiThread(new Runnable() {
                                                @Override
                                                public void run() {
                                                    listener.onFail(sendData.failStr);
                                                }
                                            });
                                }

                        }

                    }
                } catch (Exception e) {
                    listener.onErr(e);
                    return;
                }
            }
        }
    }

    /**
     * 发送数据
     *
     * @param context
     * @param sendData
     * @param listener
     */
    public void toSend(Context context, SerialPortSendData sendData,
                       ReciverListener listener) {
        this.context = context;
        if ("".equals(sendData.path) || "/dev/tty".equals(sendData.path)) {
            Toast.makeText(context, "设备地址不能为空", 0).show();
            return;
            // devStr = "/dev/ttyS1";
        }
        if ("".equals(sendData.commandStr)) {
            Toast.makeText(context, "指令不能为空", 0).show();
            return;
        }
        try {
            mSerialPort = getSerialPort(sendData.path, sendData.baudRate);
            mOutputStream = mSerialPort.getOutputStream();
            mInputStream = mSerialPort.getInputStream();

            /* Create a receiving thread */
            mReadThread = new ReadThread(sendData, listener);
            mReadThread.start();
        } catch (SecurityException e) {
            // DisplayError(R.string.error_security);
        } catch (IOException e) {
            // DisplayError(R.string.error_unknown);
        } catch (InvalidParameterException e) {
            // DisplayError(R.string.error_configuration);
        }

        // 上面是获取设置而已 下面这个才是发送指令
        byte[] text = StringUtils.hexStringToBytes(sendData.commandStr);
        try {
            mOutputStream.write(text);
            //mOutputStream.write('\n');
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取到串口通信的一个示例
     *
     * @param path
     * @param baudrate
     * @return
     * @throws SecurityException
     * @throws IOException
     * @throws InvalidParameterException
     */
    public SerialPort getSerialPort(String path, int baudrate)
            throws SecurityException, IOException, InvalidParameterException {
        // if (mSerialPort == null) {
        /* Check parameters */
        if ((path.length() == 0) || (baudrate == -1)) {
            throw new InvalidParameterException();
        }
        /* Open the serial port */
        mSerialPort = new SerialPort(new File(path), baudrate, 0);// 打开这个串口
        // }

        return mSerialPort;
    }

    public void closeDevice() {
        if (mReadThread != null)
            mReadThread.interrupt();
        // mApplication.closeSerialPort();
        closeSerialPort();
        // mSerialPort = null;
    }

    public void closeSerialPort() {// 关闭窗口
        if (mSerialPort != null) {
            mSerialPort.close();
            mSerialPort = null;
        }
    }

    /**
     * @author qiwenming
     * @creation 2015-7-20 上午10:16:54
     * @instruction 接受回调类
     */
    public interface ReciverListener {

        /**
         * 接受以后的处理方法
         *
         * @param string
         * @param headBytes
         */
        public abstract void onReceived(String receviceStr);

        /**
         * 出错
         *
         * @param string
         */
        public abstract void onFail(String fialStr);

        /**
         * 出现异常
         *
         * @param e
         */
        public abstract void onErr(Exception e);

    }

    /**
     * @author qiwenming
     * @creation 2015-7-20 下午2:34:28
     * @instruction 这个是我们用于存储读取的数据
     */
    public class RecevedData {
        public ReturnType returnType;
        /**
         * 数据
         */
        public String receviedData;
    }

    /**
     * @author qiwenming
     * @creation 2015-7-20 下午2:36:21
     * @instruction 使用辨识返回的数据的
     */
    public enum ReturnType {
        ERR, // 错误
        OK, // OK
        Exception
    }
}

四、图示

默认
这里写图片描述

五、源码下载

https://github.com/qiwenming/IDCardDemo

<script type="text/javascript"> $(function () { $('pre.prettyprint code').each(function () { var lines = $(this).text().split('\n').length; var $numbering = $('<ul/>').addClass('pre-numbering').hide(); $(this).addClass('has-numbering').parent().append($numbering); for (i = 1; i <= lines; i++) { $numbering.append($('<li/>').text(i)); }; $numbering.fadeIn(1700); }); }); </script>
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值