Skip to content

Fingerprint Implementation #1774

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom
Open
matigarowel opened this issue Jan 14, 2022 · 0 comments
Open

Fingerprint Implementation #1774

matigarowel opened this issue Jan 14, 2022 · 0 comments

Comments

@matigarowel
Copy link

Hi @dtex I would like to work with Fingerprint Module below product:

Fingerprint sensor https://www.adafruit.com/product/751_ (Product ID: 751)
Panel Mount Fingerprint sensor https://www.adafruit.com/product/4651_ (Product ID: 4651)

This is my code to extend it in Johnnyfive

const SerialPort = require('serialport')
const Readline = require('@serialport/parser-readline')
// const Readline = SerialPort.parsers.Readline
const fs = require('fs')
const prompt = require("prompt-sync")();

class Fingerprint {
#uart = SerialPort
#password = [0, 0, 0, 0]
#address = [0xFF, 0xFF, 0xFF, 0xFF]
#startCode = 0xEF01
#acknowledgePacket = 0x7
#cmdPacket = 0x1
#dataPacket = 0x2
#endPacket = 0x8

finger_id = null
confidence = null
templates = []
template_count = null
library_size = null
security_level = null
device_address = null
data_packet_size = null
baudrate = null
system_id = null
status_register = null

constructor(port, passWord = [0, 0, 0, 0]){
    if(port){
        this.#uart = port
    }
    else{
        //Default
        this.#uart = new SerialPort('/dev/ttyS0', {
            baudRate: 57600,
        }) 
    }

    // this.init(passWord)
}

async init(passWord){
    this.#password = passWord
    let vfyPwd = await this.vfyPwd()
    if(vfyPwd.type != 0) throw vfyPwd.message

    let readSysPara = await this.readSysPara()
    if(readSysPara.type != 0) throw readSysPara.message
}

getPacket(packet, expected, log) {
    return new Promise(async (resolve, reject) => {
        let buff = []
        let completeBuff

        await this.#uart.on('data', (data) => {
            buff = buff.concat(data)
            completeBuff =  Buffer.concat(buff)

            if(log == 1){
                console.log(completeBuff.length)
            }

            if(completeBuff.length >= expected){
                let srtCode = completeBuff.slice(0, 2).toString('hex')
                let addrs = completeBuff.slice(2, 6).toString('hex')
                let ackldge = parseInt(completeBuff.slice(6, 7).toString('hex'), 16)
                let confirmCode = completeBuff.slice(9, 10).toString('hex')
                let adress = this.#address.map(x => { return x.toString(16) }).join('')

                // if(srtCode != this.#startCode.toString(16)) throw `${srtCode}:${this.#startCode.toString(16)}Incorect header`
                // if(addrs != adress) throw   `${addrs}:${adress}Incorect module adress`
                // if(ackldge != this.#acknowledgePacket) throw `${ackldge}:${this.#acknowledgePacket}Incorect package identifier`
                
                resolve({confirmCode: confirmCode, buff: completeBuff})
            }
        })
        
        
        this.#uart.on('error', function(err) {
            reject(err);
        })

        
        this.#uart.write(Buffer.from(packet), (err =>{
            if(err){
                reject(err);
                return
            }
        }))
    })
}

setPacket(data){
    let packet = [];
    packet = [this.#startCode >> 8, this.#startCode & 0xFF]
    packet = packet.concat(this.#address)
    packet.push(this.#cmdPacket)
    let length = data.length + 2
    packet.push(length >> 8)
    packet.push(length & 0xFF)
    packet = packet.concat(data)
    let checksum =  packet.slice(6).reduce((a,b) => b + a )
    packet.push(checksum >> 8)
    packet.push(checksum & 0xFF)
    return packet
}

sendData(data){
    try{
        let packet = data.slice(24, -1)

        this.#uart.write(Buffer.from(packet, 'hex'), (err =>{
            if(err){
                console.log(err);
                return false
            }
        }))
        
        this.#uart.on('error', function(err) {
            throw err
        })
        return true
    }
    catch(err){
        throw err
    }
}

//System related instruction

async vfyPwd(){
    const vfyPwd = 0x13
    let buff = [vfyPwd].concat(this.#password)
    let packet = this.setPacket(buff)
    let rtn
    await this.getPacket(Buffer.from(packet), 12)
    .then((data) =>{
        // console.log('vfyPwd', data)
        let result = parseInt(data.confirmCode, 16)
        if(result == 0){
            rtn = ({ message: 'Correct password', type: result })
        }
        if(result == 1){
            rtn = ({ message: 'Error when receiving package', type: result })
        }
        if(result == 19){
            rtn = ({ message: 'Wrong password', type: result })
        }
    })
    .catch((err)=> {
        rtn = err
    })

    return rtn
}

async setPwd(passWord){
    const setPwd = 0x12
    let buff = [setPwd].concat(passWord)
    let packet = this.setPacket(buff)
    let rtn
    await this.getPacket(Buffer.from(packet), 12)
    .then((data) =>{
        console.log('setpass', data)
        let result = parseInt(data.confirmCode, 16)
        if(result == 0){
            rtn = ({ message: 'Password setting complete', type: result })
        }
        if(result == 1){
            rtn = ({ message: 'Error when receiving package', type: result })
        }
    })
    .catch((err)=> {
        rtn = err
    })

    return rtn
}

async setAdder(address){
    const setAdder = 0x15
    let buff = [setAdder, address]
    let packet = this.setPacket(buff)
    let rtn
    await this.getPacket(Buffer.from(packet), 12)
    .then((data) =>{
        console.log('setAdder', parseInt(data, 16))
        let result = parseInt(data.confirmCode, 16)
        if(result == 0){
            rtn = ({ message: 'Address setting complete', type: result })
        }
        if(result == 1){
            rtn = ({ message: 'Error when receiving package', type: result })
        }
    })
    .catch((err)=> {
        rtn = err
    })

    return rtn
}

async setSysPara(param_num, content){
    const setSysPara = 0x0E
    let buff = [setSysPara, param_num, content]
    let packet = this.setPacket(buff)
    let rtn
    await this.getPacket(Buffer.from(packet), 12)
    .then((data) =>{
        // console.log('setSysPara', data)
        let result = parseInt(data.confirmCode, 16)

        if(param_num == 4){
            this.baudrate = content
        }
        else if(param_num == 5){
            this.security_level = content
        }
        else if(param_num == 6){
            this.data_packet_size = content
        }

        if(result == 0){
            rtn = ({ message: 'Address setting complete', type: result })
        }
        if(result == 1){
            rtn = ({ message: 'Error when receiving package', type: result })
        }
        if(result == 26){
            rtn = ({ message: 'Wrong register number', type: result })
        }
    })
    .catch((err)=> {
        rtn = err
    })

    return rtn
}

async readSysPara(){
    const readSysPara = 0x0F
    let buff = [readSysPara]
    let packet = this.setPacket(buff)
    let rtn
    await this.getPacket(Buffer.from(packet), 28)
    .then((data) =>{
        // console.log('readSysPara', data)
        let result = parseInt(data.confirmCode, 16)
        this.status_register = parseInt(data.buff.slice(11, 12).toString('hex'), 16)
        this.system_id = parseInt(data.buff.slice(12, 15).toString('hex'), 16)
        this.library_size = parseInt(data.buff.slice(15, 16).toString('hex'), 16)
        this.security_level = parseInt(data.buff.slice(16, 18).toString('hex'), 16)
        this.device_address = parseInt(data.buff.slice(18, 22).toString('hex'), 16)
        this.data_packet_size = parseInt(data.buff.slice(22, 24).toString('hex'), 16)
        this.baudrate = parseInt(data.buff.slice(24, 26).toString('hex'), 16)

        if(result == 0){
            rtn = ({ message: 'Read complete', type: result })
        }
        if(result == 1){
            rtn = ({ message: 'Error when receiving package', type: result })
        }
    })
    .catch((err)=> {
        rtn = err
    })

    return rtn
}

async templeteNum(){
    const templeteNum = 0x1D
    let buff = [templeteNum]
    let packet = this.setPacket(buff)
    let rtn
    await this.getPacket(Buffer.from(packet), 14)
    .then((data) =>{
        // console.log('templeteNum', data)
        let result = parseInt(data.confirmCode, 16)

        this.template_count = parseInt(data.buff.slice(11, 12).toString('hex'), 16)

        if(result == 0){
            rtn = ({ message: 'Read success', type: result })
        }
        if(result == 1){
            rtn = ({ message: 'Error when receiving package', type: result })
        }
    })
    .catch((err)=> {
        rtn = err
    })

    return rtn
}

async readIndexTable(){
    this.templates = []
    await this.readSysPara()
    let data

    for(let j = 0; j < Math.round(this.library_size / 256); j++){
        const readIndexTable = 0x1F
        let buff = [readIndexTable, j]
        let packet = this.setPacket(buff)
        data = await this.getPacket(Buffer.from(packet), 44)
        let r = data.buff.slice(10, 42)

        if(parseInt(data.confirmCode, 16) == 0){
            for(let i = 0; i < 32; i++){
                let byte = r[i]
                for(let bit = 0; bit < 8; bit++){
                    if(byte & (1 << bit)){
                        this.templates.push((i * 8) + bit + (j * 256))
                    }
                }
            }
        }
    }

    // console.log('readIndexTable', data)
    let result = parseInt(data.confirmCode, 16)
    let rtn
    if(result == 0){
        rtn = ({ message: 'Read complete', type: result })
    }
    if(result == 1){
        rtn = ({ message: 'Error when receiving package', type: result })
    }
    
    return rtn
}

async genImg(){
    const genImg = 0x01
    let buff = [genImg]
    let packet = this.setPacket(buff)
    let rtn
    await this.getPacket(Buffer.from(packet), 12)
    .then((data) =>{
        // console.log('genImg', data)
        let result = parseInt(data.confirmCode, 16)
        if(result == 0){
            rtn = ({ message: 'Finger collection successs', type: result })
        }
        if(result == 1){
            rtn = ({ message: 'Error when receiving package', type: result })
        }
        if(result == 2){
            rtn = ({ message: 'Can’t detect finger', type: result })
        }
        if(result == 3){
            rtn = ({ message: 'Fail to collect finger', type: result })
        }
    })
    .catch((err)=> {
        rtn = err
    })

    return rtn
}

async upImage(){
    const upImage = 0x0A
    let buff = [upImage]
    let packet = this.setPacket(buff)
    let rtn
    await this.getPacket(Buffer.from(packet), 20028, 1)
    .then(async (data) =>{
        // console.log('upImage', data)
        let result = parseInt(data.confirmCode, 16)
        if(result == 0){
            // let packet = await this.getData(data.buff)
            rtn = ({ message: 'Ready to transfer the following data packet', type: result, data: data.buff })
        }
        if(result == 1){
            rtn = ({ message: 'Error when receiving package', type: result })
        }
        if(result == 15){
            rtn = ({ message: 'Fail to transfer the following data packet', type: result })
        }
    })
    .catch((err)=> {
        rtn = err
    })

    return rtn
}

async downImage(){
    const downImage = 0x0B
    let buff = [downImage]
    let packet = this.setPacket(buff)
    let rtn
    await this.getPacket(Buffer.from(packet), 12)
    .then((data) =>{
        console.log('downImage', parseInt(data, 16))
        let result = parseInt(data.confirmCode, 16)
        if(result == 0){
            rtn = ({ message: 'Ready to transfer the following data packet', type: result })
        }
        if(result == 1){
            rtn = ({ message: 'Error when receiving package', type: result })
        }
        if(result == 14){
            rtn = ({ message: 'Fail to transfer the following data packet', type: result })
        }
    })
    .catch((err)=> {
        rtn = err
    })

    return rtn
}

async img2Tz(bufferID = 1){
    const img2Tz = 0x02
    let buff = [img2Tz, bufferID]
    let packet = this.setPacket(buff)
    let rtn
    await this.getPacket(Buffer.from(packet), 12)
    .then((data) =>{
        // console.log('img2Tz', data)
        let result = parseInt(data.confirmCode, 16)
        if(result == 0){
            rtn = ({ message: 'Generate character file complete', type: result })
        }
        if(result == 1){
            rtn = ({ message: 'Error when receiving package', type: result })
        }
        if(result == 6){
            rtn = ({ message: 'Fail to generate character file due to the over-disorderly fingerprint image', type: result })
        }
        if(result == 7){
            rtn = ({ message: 'Fail to generate character file due to lackness of character point or over-smallness of fingerprint image', type: result })
        }
        if(result == 21){
            rtn = ({ message: 'Fail to generate the image for the lackness of valid primary image', type: result })
        }
    })
    .catch((err)=> {
        rtn = err
    })

    return rtn
}

async regModel(){
    const regModel = 0x05
    let buff = [regModel]
    let packet = this.setPacket(buff)
    let rtn
    await this.getPacket(Buffer.from(packet), 12)
    .then((data) =>{
        // console.log('regModel', data)
        let result = parseInt(data.confirmCode, 16)
        if(result == 0){
            rtn = ({ message: 'Operation success', type: result })
        }
        if(result == 1){
            rtn = ({ message: 'Error when receiving package', type: result })
        }
        if(result == 10){
            rtn = ({ message: 'Fail to combine the character files. That’s, the character files don’t belong to one finger', type: result })
        }
    })
    .catch((err)=> {
        rtn = err
    })

    return rtn
}

async upChar(bufferID){
    const upChar = 0x08
    let buff = [upChar, bufferID]
    let packet = this.setPacket(buff)
    let rtn
    await this.getPacket(Buffer.from(packet), 1680)
    .then(async (data) =>{
        // console.log('upChar', data)
        let result = parseInt(data.confirmCode, 16)
        if(result == 0){
            // let packet = await this.getData(data.buff)
            rtn = ({ message: 'Ready to transfer the following data packet', type: result, data: data.buff })
        }
        if(result == 1){
            rtn = ({ message: 'Error when receiving package', type: result })
        }
        if(result == 13){
            rtn = ({ message: 'Error when uploading template', type: result })
        }
    })
    .catch((err)=> {
        rtn = err
    })

    return rtn
}

async downChar(charBufferID, dataPacket){
    const downChar = 0x09
    let buff = [downChar, charBufferID]
    let packet = this.setPacket(buff)
    let rtn
    await this.getPacket(Buffer.from(packet), 12)
    .then(async (data) =>{  
        // console.log('downChar', data)
        let result = parseInt(data.confirmCode, 16)
        if(result == 0){
            rtn = { message: 'Ready to transfer the following data packet', type: result }
            await this.sendData(dataPacket)
        }
        if(result == 1){
            rtn = { message: 'Error when receiving package', type: result }
        }
        if(result == 14){
            rtn = { message: 'Can not receive the following data packet', type: result }
        }
    })
    .catch((err)=> {
        rtn = err
    })

    return rtn
}

async store(pageID){
    const store = 0x06
    let buff = [store, pageID, pageID >> 8, pageID & 0xFF]
    let packet = this.setPacket(buff)
    let rtn
    await this.getPacket(Buffer.from(packet), 12)
    .then((data) =>{
        // console.log('store', data)
        let result = parseInt(data.confirmCode, 16)
        if(result == 0){
            rtn = ({ message: 'Storage success', type: result })
        }
        if(result == 1){
            rtn = ({ message: 'Error when receiving package', type: result })
        }
        if(result == 11){
            rtn = ({ message: 'Addressing PageID is beyond the finger library', type: result })
        }
        if(result == 24){
            rtn = ({ message: 'Error when writing Flash', type: result })
        }
    })
    .catch((err)=> {
        rtn = err
    })

    return rtn
}

async loadChar(charBufferID, pageID){
    const loadChar = 0x07
    let buff = [loadChar, charBufferID, pageID]
    let packet = this.setPacket(buff)
    let rtn
    await this.getPacket(Buffer.from(packet), 12)
    .then((data) =>{
        console.log('loadChar', parseInt(data, 16))
        let result = parseInt(data.confirmCode, 16)
        if(result == 0){
            rtn = ({ message: 'Load success', type: result })
        }
        if(result == 1){
            rtn = ({ message: 'Error when receiving package', type: result })
        }
        if(result == 12){
            rtn = ({ message: 'Error when reading template from library or the readout template is invalid', type: result })
        }
        if(result == 11){
            rtn = ({ message: 'Addressing PageID is beyond the finger library', type: result })
        }
    })
    .catch((err)=> {
        rtn = err
    })

    return rtn
}

async deletChar(pageID){
    const deletChar = 0x0C
    // let buff = [deletChar, pageID, n]
    let buff = [deletChar, pageID >> 8, pageID & 0xFF, 0x00, 0x01]
    let packet = this.setPacket(buff)
    let rtn
    await this.getPacket(Buffer.from(packet), 12)
    .then((data) =>{
        // console.log('deletChar', data)
        let result = parseInt(data.confirmCode, 16)
        if(result == 0){
            rtn = ({ message: 'Delete success', type: result })
        }
        if(result == 1){
            rtn = ({ message: 'Error when receiving package', type: result })
        }
        if(result == 16){
            rtn = ({ message: 'Fail to delete templates', type: result })
        }
    })
    .catch((err)=> {
        rtn = err
    })

    return rtn
}

async empty(){
    const empty = 0x0D
    let buff = [empty]
    let packet = this.setPacket(buff)
    let rtn
    await this.getPacket(Buffer.from(packet), 12)
    .then((data) =>{
        console.log('empty', parseInt(data, 16))
        let result = parseInt(data.confirmCode, 16)
        if(result == 0){
            rtn = ({ message: 'Empty success', type: result })
        }
        if(result == 1){
            rtn = ({ message: 'Error when receiving package', type: result })
        }
        if(result == 17){
            rtn = ({ message: 'Fail to clear finger library', type: result })
        }
    })
    .catch((err)=> {
        rtn = err
    })

    return rtn
}

async match(){
    const match = 0x03
    let buff = [match]
    let packet = this.setPacket(buff)
    let rtn
    await this.getPacket(Buffer.from(packet), 14)
    .then((data) =>{
        // console.log('match', data)
        let result = parseInt(data.confirmCode, 16)
        // this.confidence = parseInt(data.buff.slice(12, 14).toString('hex'), 16)

        if(result == 0){
            rtn = ({ message: 'Templates of the two buffers are matching!', type: result })
        }
        if(result == 1){
            rtn = ({ message: 'Error when receiving package', type: result })
        }
        if(result == 8){
            rtn = ({ message: 'Templates of the two buffers aren’t matching', type: result })
        }
    })
    .catch((err)=> {
        rtn = err
    })

    return rtn
}

async search(){
    await this.readSysPara();
    let capacity = this.library_size
    const search = 0x04
    let buff = [search, 0x01, 0x00, 0x00, capacity >> 8, capacity & 0xFF]
    let packet = this.setPacket(buff)
    let rtn
    await this.getPacket(Buffer.from(packet), 16)
    .then((data) =>{
        // console.log('search', data)
        let result = parseInt(data.confirmCode, 16)
        this.finger_id = parseInt(data.buff.slice(11, 12).toString('hex'), 16)
        this.confidence = parseInt(data.buff.slice(12, 14).toString('hex'), 16)
        
        if(result == 0){
            rtn = ({ message: 'Found the matching finger', type: result })
        }
        if(result == 1){
            rtn = ({ message: 'Error when receiving package', type: result })
        }
        if(result == 9){
            rtn = ({ message: 'No matching in the library (both the PageID and matching score are 0)', type: result })
        }
    })
    .catch((err)=> {
        rtn = err
    })

    return rtn
}

async fastSearch(){
    await this.readSysPara();
    let capacity = this.library_size
    const search = 0x1B
    let buff = [search, 0x01, 0x00, 0x00, capacity >> 8, capacity & 0xFF]
    let packet = this.setPacket(buff)
    let rtn
    await this.getPacket(Buffer.from(packet), 12)
    .then((data) =>{
        // console.log('search', data)
        let result = parseInt(data.confirmCode, 16)
        this.finger_id = parseInt(data.buff.slice(11, 12).toString('hex'), 16)
        this.confidence = parseInt(data.buff.slice(12, 14).toString('hex'), 16)
        rtn = result

        // if(result == 252){
        //     rtn = ({ message: 'Found the matching finger', type: result })
        // }
        // if(result == 1){
        //     rtn = ({ message: 'Error when receiving package', type: result })
        // }
        // if(result == 9){
        //     rtn = ({ message: 'No matching in the library (both the PageID and matching score are 0)', type: result })
        // }
    })
    .catch((err)=> {
        rtn = err
    })

    return rtn
}

async getImageEx(){
    const getImageEx = 0x28
    let buff = [getImageEx]
    let packet = this.setPacket(buff)
    let rtn
    await this.getPacket(Buffer.from(packet), 12)
    .then((data) =>{
        console.log('getImageEx', data)
        let result = parseInt(data.confirmCode, 16)
        if(result == 0){
            rtn = ({ message: 'Read success', type: result })
        }
        if(result == 1){
            rtn = ({ message: 'Error when receiving package', type: result })
        }
        if(result == 2){
            rtn = ({ message: 'No fingers on the sensor', type: result })
        }
        if(result == 3){
            rtn = ({ message: 'Unsuccessful entry', type: result })
        }
        if(result == 7){
            rtn = ({ message: 'Poor image quality', type: result })
        }
    })
    .catch((err)=> {
        rtn = err
    })

    return rtn
}

async cancel(){
    const cancel = 0x30
    let buff = [cancel]
    let packet = this.setPacket(buff)
    let rtn
    await this.getPacket(Buffer.from(packet), 12)
    .then((data) =>{
        console.log('cancel', data)
        let result = parseInt(data.confirmCode, 16)
        if(result == 0){
            rtn = ({ message: 'Cancel setting successful', type: result })
        }
        else{
            rtn = ({ message: 'Cancel setting failed', type: result })
        }
    })
    .catch((err)=> {
        rtn = err
    })

    return rtn
}

async handShake(){
    const handShake = 0x40
    let buff = [handShake]
    let packet = this.setPacket(buff)
    let rtn
    await this.getPacket(Buffer.from(packet), 12)
    .then((data) =>{
        console.log('handShake', data)
        let result = parseInt(data.confirmCode, 16)
        if(result == 0){
            rtn = ({ message: 'The device is normal and can receive instructions', type: result })
        }
        else{
            rtn = ({ message: 'The device is abnormal', type: result })
        }
    })
    .catch((err)=> {
        rtn = err
    })

    return rtn
}

async checkSensor(){
    const checkSensor = 0x36
    let buff = [checkSensor]
    let packet = this.setPacket(buff)
    let rtn
    await this.getPacket(Buffer.from(packet), 12)
    .then((data) =>{
        console.log('checkSensor', data)
        let result = parseInt(data.confirmCode, 16)
        if(result == 0){
            rtn = ({ message: 'The sensor is normal', type: result })
        }
        if(result == 41){
            rtn = ({ message: 'The sensor is abnormal', type: result })
        }
    })
    .catch((err)=> {
        rtn = err
    })

    return rtn
}

async getAlgVer(){
    const getAlgVer = 0x39
    let buff = [getAlgVer]
    let packet = this.setPacket(buff)
    let rtn
    await this.getPacket(Buffer.from(packet), 12)
    .then((data) =>{
        console.log('getAlgVer', data)
        let result = parseInt(data.confirmCode, 16)
        if(result == 0){
            rtn = ({ message: 'Success', type: result })
        }
        if(result == 1){
            rtn = ({ message: 'Error when receiving package', type: result })
        }
    })
    .catch((err)=> {
        rtn = err
    })

    return rtn
}

async getFwVer(){
    const getFwVer = 0x3A
    let buff = [getFwVer]
    let packet = this.setPacket(buff)
    let rtn
    await this.getPacket(Buffer.from(packet), 12)
    .then((data) =>{
        console.log('getFwVer', data)
        let result = parseInt(data.confirmCode, 16)
        if(result == 0){
            rtn = ({ message: 'Success', type: result })
        }
        if(result == 1){
            rtn = ({ message: 'Error when receiving package', type: result })
        }
    })
    .catch((err)=> {
        rtn = err
    })

    return rtn
}

async readProdInfo(){
    const readProdInfo = 0x3C
    let buff = [readProdInfo]
    let packet = this.setPacket(buff)
    let rtn
    await this.getPacket(Buffer.from(packet), 12)
    .then((data) =>{
        console.log('readProdInfo', data)
        let result = parseInt(data.confirmCode, 16)
        if(result == 0){
            rtn = ({ message: 'Success', type: result })
        }
        if(result == 1){
            rtn = ({ message: 'Error when receiving package', type: result })
        }
    })
    .catch((err)=> {
        rtn = err
    })

    return rtn
}

async softRst(){
    const softRst = 0x3D
    let buff = [softRst]
    let packet = this.setPacket(buff)
    let rtn
    await this.getPacket(Buffer.from(packet), 12)
    .then((data) =>{
        console.log('softRst', data)
        let result = parseInt(data.confirmCode, 16)
        if(result == 0){
            rtn = ({ message: 'Success', type: result })
        }
        else{
            rtn = ({ message: 'Device is abnormal', type: result })
        }
    })
    .catch((err)=> {
        rtn = err
    })

    return rtn
}

async auraLedConfig(mode = 2, speed = 80, color = 1, cycles = 0){
    const auraLedConfig = 0x35
    let buff = [auraLedConfig, mode, speed, color, cycles];
    let packet = this.setPacket(buff)
    let rtn
    await this.getPacket(Buffer.from(packet), 12)
    .then((data) =>{
        // console.log('auraLedConfig', data)
        let result = parseInt(data.confirmCode, 16)
        if(result == 0){
            rtn = { message: 'Success', type: result }
        }
        if(result == 1){
            rtn = { message: 'Error when receiving package', type: result }
        }
    })
    .catch((err)=> {
        rtn = err
    })
    

    return rtn
}

async getRandomCode(){
    const getRandomCode = 0x14
    let buff = [getRandomCode];
    let packet = this.setPacket(buff)
    let rtn
    await this.getPacket(Buffer.from(packet), 12)
    .then((data) =>{
        console.log('getRandomCode', data)
        let result = parseInt(data.confirmCode, 16)
        if(result == 0){
            rtn = ({ message: 'Generation success', type: result })
        }
        if(result == 1){
            rtn = ({ message: 'Error when receiving package', type: result })
        }
    })
    .catch((err)=> {
        rtn = err
    })

    return rtn
}

async readInfPage(){
    const readInfPage = 0x16
    let buff = [readInfPage];
    let packet = this.setPacket(buff)
    let rtn
    await this.getPacket(Buffer.from(packet), 12)
    .then((data) =>{
        console.log('readInfPage', data)
        let result = parseInt(data.confirmCode, 16)
        if(result == 0){
            rtn = ({ message: 'Ready to transfer the following data packet', type: result })
        }
        if(result == 1){
            rtn = ({ message: 'Error when receiving package', type: result })
        }
        if(result == 15){
            rtn = ({ message: 'Can not transfer the following data packet', type: result })
        }
    })
    .catch((err)=> {
        rtn = err
    })

    return rtn
}

async writeNotepad(n, content){
    const writeNotepad = 0x18
    let buff = [writeNotepad, n, content];
    let packet = this.setPacket(buff)
    let rtn
    await this.getPacket(Buffer.from(packet), 12)
    .then((data) =>{
        console.log('writeNotepad', data)
        let result = parseInt(data.confirmCode, 16)
        if(result == 0){
            rtn = ({ message: 'Write success', type: result })
        }
        if(result == 1){
            rtn = ({ message: 'Error when receiving package', type: result })
        }
    })
    .catch((err)=> {
        rtn = err
    })

    return rtn
}

async readNotepad(n){
    const writeNotepad = 0x19
    let buff = [writeNotepad, n];
    let packet = this.setPacket(buff)
    let rtn
    await this.getPacket(Buffer.from(packet), 12)
    .then((data) =>{
        console.log('writeNotepad', data)
        let result = parseInt(data.confirmCode, 16)
        if(result == 0){
            rtn = ({ message: 'Read success', type: result })
        }
        if(result == 1){
            rtn = ({ message: 'Error when receiving package', type: result })
        }
    })
    .catch((err)=> {
        rtn = err
    })

    return rtn
}

}

/// Testing
const port = new SerialPort('/dev/ttyS0', {
baudRate: 57600,
parser: SerialPort.parsers.raw
})
let test = new Fingerprint(port)

async function init(){
// while(true){
let readIndexTable = await test.readIndexTable()
if(readIndexTable.type != 0) throw readIndexTable.message
console.log('Fingerprint templates: ', test.templates)

    let templeteNum = await test.templeteNum()
    if(templeteNum.type != 0) throw templeteNum.message
    console.log('Number of templates found: ', test.template_count)

    let setSysPara = await test.setSysPara(6, 2)
    if(setSysPara.type != 0) throw setSysPara.message

    let readSysPara = await test.readSysPara()
    if(readSysPara.type != 0) throw readSysPara.message
    console.log('Package size (x128): ', test.data_packet_size)
    console.log('Size of template library: ', test.library_size)

    console.log(` 1) enroll to device \n 2) search from device \n 3) delete print from device \n 4) generate image \n 5) enroll to database \n 6) search from database`);
    const option = prompt(">");
    // console.log(`Oh, so your name is ${input}`);
    if(option == 1){
        const pageID = prompt("Please choose 0-255> ");
        enrollFinger(pageID)
    }
    else if(option == 2){
        searchFinger()
    }
    else if(option == 3){
        deleteFinger()
    }
    else if(option == 4){
        saveFingerToIamge()
    }
    else if(option == 5){
        saveFingerToFile()
    }
    else if(option == 6){
        compareFingerToFile()
    }
// }

}

async function enrollFinger(pageID){
// await test.auraLedConfig(1, 80, 2, 0)

for(let i = 1; i < 3; i ++){
    if(i == 1) console.log('Place finger on sensor...')
    else console.log('Place same finger again...')

    let genImg = await test.genImg()

    while(genImg.type != 0){
        genImg = await test.genImg()
    }

    await test.auraLedConfig(1, 5, 2, 0)

    console.log('Templating...') 
    let img2Tz = await test.img2Tz(i)
    
    if(img2Tz.type == 0){
        console.log('Templated') 
    }
    else{
        console.log(img2Tz.message) 
        await test.auraLedConfig(2, 30, 1, 3)
        return false
    }

    console.log('Remove Finger') 
    await test.auraLedConfig(1, 30, 2, 0)

    // let genImg1 = await test.genImg()
    while(genImg.type != 2){
        genImg = await test.genImg()
    }
    await test.auraLedConfig(1, 80, 2, 0)
}
console.log('Creating model...')

let regModel = await test.regModel()

if(regModel.type == 0){
    console.log('Created')
}
else{
    console.log(regModel.message)
    await test.auraLedConfig(2, 30, 1, 3)
    return false
}

console.log('Storing model...')

let store = await test.store(pageID)

if(store.type == 0){
    console.log('store.message', store.message)
}
else{
    console.log(store.message)
    await test.auraLedConfig(2, 30, 1, 3)
    return false
}
await test.auraLedConfig(2, 80, 3, 3)

}

async function searchFinger(){
console.log('Place finger on sensor...')
// await test.auraLedConfig(1, 80, 2, 0)
let genImg = await test.genImg()

while(genImg.type != 0){
    genImg = await test.genImg()
}

console.log('Templating...') 
let img2Tz = await test.img2Tz(1)

if(img2Tz.type != 0){
    console.log(img2Tz) 
    await test.auraLedConfig(2, 30, 1, 3)
    return false
}
console.log('Searching...')
let search = await test.search()

console.log(search.message)
if(search.type !=0){
    await test.auraLedConfig(2, 30, 1, 3)
    return false
}
console.log('confidence', test.confidence)
console.log('finger_id', test.finger_id)
await test.auraLedConfig(2, 80, 3, 3)

}

async function deleteFinger(){
console.log('Place finger on sensor...')
// await test.auraLedConfig(1, 80, 2, 0)
let genImg = await test.genImg()

while(genImg.type != 0){
    genImg = await test.genImg()
}

console.log('Templating...') 
let img2Tz = await test.img2Tz(1)

if(img2Tz.type != 0){
    console.log(img2Tz) 
    await test.auraLedConfig(1, 80, 1, 3)
    return false
}
console.log('Searching...')
let search = await test.search()

console.log(search.message)
let finger_id = test.finger_id
console.log('finger_id', finger_id)

await test.auraLedConfig(2, 80, 3, 3)

console.log('Deleting...')

let deletChar = await test.deletChar(finger_id)

console.log(deletChar.message)

}

async function saveFingerToIamge(){
console.log('Place finger on sensor...')
// await test.auraLedConfig(1, 80, 2, 0)
let genImg = await test.genImg()

while(genImg.type != 0){
    genImg = await test.genImg()
}
console.log('Capturing finger')
await test.auraLedConfig(1, 5, 2, 0)

let upImage = await test.upImage()

console.log('Generating image')

if(upImage.type == 0){
    console.log(upImage.message)

    try {
        let packet = Buffer.from(upImage.data.slice(24, -1), 'hex').toString('hex').replace('ef01ffffffff020082','').replace('ef01ffffffff080082','')
        console.log(Buffer.from(packet, 'base64'))
        fs.writeFileSync('test.png', Buffer.from(packet, 'base64'))
        
        console.log('file written successfully')
    }
    catch (err) {
        console.error(err)
        await test.auraLedConfig(2, 30, 1, 3)
        return false
    }
}
else{
    console.log(upImage.message)
    await test.auraLedConfig(2, 30, 1, 3)
    return false
}
await test.auraLedConfig(2, 80, 3, 3)

}

async function saveFingerToFile(){
// await test.auraLedConfig(1, 80, 2, 0)

for(let i = 1; i < 3; i ++){
    if(i == 1) console.log('Place finger on sensor...')
    else console.log('Place same finger again...')

    let genImg = await test.genImg()

    while(genImg.type != 0){
        genImg = await test.genImg()
    }

    await test.auraLedConfig(1, 5, 2, 0)

    console.log('Templating...') 
    let img2Tz = await test.img2Tz(i)
    
    if(img2Tz.type == 0){
        console.log('Templated') 
    }
    else{
        console.log(img2Tz.message) 
        await test.auraLedConfig(2, 30, 1, 3)
        return false
    }

    console.log('Remove Finger') 
    await test.auraLedConfig(1, 30, 2, 0)

    // let genImg = await test.genImg()
    while(genImg.type != 2){
        genImg = await test.genImg()
    }
    await test.auraLedConfig(1, 80, 2, 0)
}

console.log('Creating model...')

let regModel = await test.regModel()

if(regModel.type == 0){
    console.log('Created')
}
else{
    console.log(regModel.message)
    await test.auraLedConfig(2, 30, 1, 3)
    return false
}

console.log('Downloading template...')

let upChar = await test.upChar(1)

if(upChar.type == 0){
    try {
        // console.log(Buffer.from(upChar.data, 'hex').toString('hex'))
        fs.writeFileSync('test.matigs', Buffer.from(upChar.data, 'hex'), 'binary')
        console.log('file written successfully')
    } 
    catch (err) {
        console.error(err)
        await test.auraLedConfig(2, 30, 1, 3)
        return false
    }
}
else{
    console.log(upChar.message)
    await test.auraLedConfig(2, 30, 1, 3)
    return false
}
await test.auraLedConfig(2, 80, 3, 3)

}

async function compareFingerToFile(){
// await test.auraLedConfig(1, 80, 2, 0)
console.log('Place finger on sensor...')

let genImg = await test.genImg()

while(genImg.type != 0){
    genImg = await test.genImg()
}

await test.auraLedConfig(1, 5, 2, 0)

console.log('Templating...') 
let img2Tz = await test.img2Tz(1)

if(img2Tz.type == 0){
    console.log('Templated') 
}
else{
    console.log(img2Tz.message) 
    await test.auraLedConfig(2, 30, 1, 3)
    return false
}

console.log('Loading file template...')
let binary
try{
    binary = fs.readFileSync('test.matigs', 'hex');
    console.log('Succesfully read')
}
catch(err){
    console.error(err)
    await test.auraLedConfig(2, 30, 1, 3)
    return false
}

let downChar= await test.downChar(2, binary)
if(downChar.type != 0){
    console.log(downChar.message)
    await test.auraLedConfig(2, 30, 1, 3)
    return false
}
console.log("Comparing...")

let match = await test.match()
console.log(match.message)
if(match.type != 0){
    await test.auraLedConfig(2, 30, 1, 3)
    return false
}
await test.auraLedConfig(2, 80, 3, 3)

}

// init()
// enrollFinger(0)
// searchFinger()
// deleteFinger()
// saveFingerToIamge()
// saveFingerToFile()
compareFingerToFile()
@matigarowel matigarowel changed the title How to extend Fingerprint Fingerprint Implementation Oct 25, 2022
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Assignees
No one assigned
Labels
None yet
Projects
None yet
Milestone
No milestone
Development

No branches or pull requests
1 participant
@matigarowel