树莓派：基于物联网做的指纹打卡器

　　今天我就分享一波自己的成果。

　　心心念念的想做一个物联网的东西出来，终于在上个月搞定了，虽说肯定是有些漏洞（目前我是没有找出来的），但是效果看起来还不错。学了这么久的Python、Qt、liunx命令总算派上用场了。

材料：

• 树莓派一台
• 指纹模块（AS608光学指纹识别模块）
• OLED液晶屏
• usb转TTL
• 杜邦线

 

先说明一下

博客园无法分享附件就只能这样分享了

如果想要附件可以点击下面 链接，我在csdn上注册了一个号可以去下载：

树莓派上的源码下载

电脑上的上位机源码下载

oled上的字体

 

先上个最终成果的图

 

           

 

看起来感觉还可以，基本完成了电脑和手机都可以获得日志的效果

 

大家最期待的过程了

　　现在我来说是我的想法和思路

　　刚开始看到隔壁实验室的指纹打卡机时好像是那种用usb读取数据的（好像是节约成本吧），我就想能这也太不智能了吧，就想着能不能让它智能些，比如通过电脑看到它的日志啊，或者用手机看到它的日志啊什么的（后来我才知道淘宝上TM已经出现这种完善的成品指纹考勤机了）。光想没用啊，还是要靠实践来检验真理。于是我就想到了手上的树莓派，想想就有些兴奋，可以向网上那些大佬一样DIY一个东西出来了，由于我的知识有限，无法自己搞个指纹打卡模块，就到网上买了一个，先开始买的正点原子的指纹模块，原子哥不愧是我原子哥，和他讨论问题时真是尽心尽力。文档很好，不过他那个和模块通信的程序不是很全，就几个，可以能是直接储存在模块里的缘故，可是我不想储存在模块里啊，我学了Python加上Mysql，我想直接存在数据库里，这样更加安全可靠。于是我就开始解决通信问题，将他发回来的数据解码，捣鼓了2天才完成，有点心酸。

先把配置文件分享了，下面代码会用到

# 用户root 给电脑连接的
[root]
pwd = 123

# 数据库
[db]
db_port = 3306
db_user = root
db_host = 127.0.0.1
db_pwd = 123456
db_database = finger
db_table = test1

# smtpServer 发送请求服务
# popServer 接收请求服务
# smtpSrcAddr 服务端的地址
# smtpSrcAddrPwd 服务端的密码
# smtpDstAddr 发送的目的邮箱
# smtpPort 端口号  qq端口号为 465
[email]
smtpServer = smtp.qq.com
popServer = pop.qq.com
smtpSrcAddr = 发送请求的你的邮箱
smtpSrcAddrPwd = 允许的密码
smtpDstAddr = 目的邮箱
smtpPort = 465

# TCP服务
[TCP]
ip = 192.168.137.249
port = 9090

# 串口服务
[serial]
port = /dev/ttyAMA0  （先不用这个串口，这个是我配置过的，你可以先用usb转ttl连接树莓派的usb口和指纹模块）
baudrate = 57600
timeout = 10

# 乐联网 网关信息
[lewei]
ip = tcp.lewei50.com
port = 9960
userKey =  你自己的userKey
gatewayNode = 02

 

1.首先要在电脑上调通指纹发送数据的所有命令

 分享一波代码

要用电脑和指纹模块通信首先要装

python要serial模块，在cmd命令行中用命令 pip install serial 就可以下载serial 了

# -*-coding=utf8-*-

import serial
import serial.tools.list_ports

import os, sys
PATH=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(PATH)

SureCore = {
    0x00: True,  # 表示指令执行完毕或OK；
    0x01: 101,  # 表示数据包接收错误；
    0x02: 102,  # 表示传感器上没有手指；
    0x03: 103,  # 表示录入指纹图像失败；
    0x06: 202,  # 表示指纹图像太乱而生不成特征；
    0x07: 203,  # 表示指纹图像正常，但特征点太少而生不成特征；
    0x15: 204,  # 表示图像缓冲区内没有有效原始图而生不成图像；
    0x08: 302,  # 表示指纹不匹配；
    0x09: 402,  # 表示没搜索到；此时页码与得分为 0
    0x0a: 502,  # 表示合并失败（两枚指纹不属于同一手指）；
    0x0d: 802,  # 表示指令执行失败；
    0x0f: 1002,  # 表示不能发送后续数据包；
}
'''返回= 999 校验和错误'''


class DealBuff:
    """切割收到的数据"""
    HEAD = [0xEF, 0x01, 0xFF, 0xFF, 0xFF, 0xFF]

    def __init__(self, buff):
        self.buff = buff
        """处理读出的指纹数据用到"""
        self.tag = list()  # 包标识
        self.data = list()
        self.check = list()
        pass

    def read(self):
        buff = [x for x in bytes(self.buff)]
        check = self.slit(buff)
        return self.tag, self.data, check

    def listCut(self, buff, num):
        """切割数组"""
        rec = list()
        for i in range(num):
            bytes_buf = (buff.pop(0))
            # rec.append(buff.pop(0))
            rec.append(bytes_buf)
        return rec, buff
        pass

    def slit(self, buff):
        """"选择数据"""
        # 初始化中间变量
        popList = list()
        check_Num = 0
        check = list()
        head = list()

        if len(buff) < 6:  # 判断是否有效数据
            return True

        head, buff = self.listCut(buff, 6)  # 选择出头及判断
        for i in range(6):
            if head[i] != self.HEAD[i]:
                return False

        popList, buff = self.listCut(buff, 1)  # 取出包标识
        self.tag.append(popList)
        check_Num += popList[0]  # 计算校验和

        popList, buff = self.listCut(buff, 2)  # 取出包长度
        check_Num += popList[0] + popList[1]  # 计算校验和

        popList, buff = self.listCut(buff, popList[0] * 16 + popList[1])  # 取出包数据
        check.append(popList.pop())  # 取出校验数据
        check.append(popList.pop())
        for i in popList:  # 计算校验和
            check_Num += i

        self.data.extend(popList)  # 导入有用数据
        if check_Num % 65535 != check[0] + check[1]*256:  # 检验校验和
            return False

        rec = self.slit(buff)  # 得到是否正确分析完数据
        return rec
        pass

    def write(self):
        """要写的数据打包"""
        pack = self.dataSeparate(self.buff, 128)   # 将数据分成每组128个元素
        return pack
        pass

    def dataSeparate(self, buff, numPart):
        """把数据分组打包"""
        num = int(len(buff) / numPart)
        newData = list()
        for i in range(num):
            newData.append(buff[i * numPart:(i+1) * numPart])

        packData = list()
        for i in range(num-1):
            data = self.packData(newData[i], 0x02)  # 数据包没结束
            packData.extend(data)

        packData.extend(self.packData(newData[num-1], 0x08))  # 数据包结束
        return packData
        pass

    def packData(self, buff, flage):
        num = len(buff) + 2
        senddata = [flage, int(num / 256), int(num % 256)] + buff
        sum = 0
        for i in senddata:
            sum += i
        senddata = self.HEAD + senddata
        senddata.append(int(sum / 256))
        senddata.append(int(sum % 256))
        return senddata
        pass

    pass


class DealFingeer:
    """和指纹模块交互"""
    HEAD = [0xEF, 0x01, 0xFF, 0xFF, 0xFF, 0xFF]
    tag = list()  # 包标识
    cmd = list()  #
    data = list()
    ser = serial.Serial()
    def __init__(self, cmd, data=None, server=None):
        """初始化函数"""
        self.cmd = cmd
        self.data = data
        self.server = server
        pass

    def run(self):
        if hasattr(self, self.cmd):
            func = getattr(self, self.cmd)
            return func(self.data)
        pass

    def link(self):
        """连接串口"""
        self.ser.port = "COM5"
        self.ser.baudrate = 57600
        self.ser.bytesize = 8
        self.ser.parity = 'N'
        self.ser.xonxoff = 0
        self.ser.rtscts = 0
        self.ser.close()
        self.ser.open()
        pass

    def finger(self, data):
        self.link()
        check = self.getImage()  # 检测获取图像
        if check is not True:
            return check, []

        self.link()
        check = self.genChar(data)  # 检测生成特征值
        if check is not True:
            return check, []
        # ================= 生成特征值时图像会清除，所以要重新采集 ========================== #
        self.link()
        check = self.getImage()  # 检测获取图像
        if check is not True:
            return check, []

        if self.server is not None:
            self.server.send("True".encode("utf8"))  # 发送数据说明准备好了

        self.link()
        check = self.upImage()  # 上传图像
        if check is not True:    # 校验和错误
            return check, []
        self.tag, self.data = self.getUpImage()

        if len(self.tag) is 0 and len(self.data) is 0:  # 得到数据错误
            return False, []
        return True, []

    def save(self, data=None):
        self.link()
        check = self.regModel()
        if check is not True:    # 校验和错误
            return check, []

        self.link()
        check = self.upChar(data)  # 上传特征值
        if check is not True:  # 校验和错误
            return check, []
        self.tag, self.data = self.getUpChar()

        if len(self.tag) is 0 and len(self.data) is 0:  # 得到数据错误
            return False, []
        return True, []
        pass

    def check(self, data=None):
        """检验指纹, 生成特征值"""
        self.link()
        check = self.match()   # 比较指纹特征
        if check is not True:
            return check, []
        score = self.data[1]*255 + self.data[2]  # 返回的分数值

        self.link()
        check = self.regModel()  # 合成指纹特征值
        if check is not True:
            return check, []
        return True, score
        pass

    def isFinger(self, data=None):
        """判断现在的指纹和下载的指纹是否相同"""
        self.link()
        check = self.downCharCheck()
        if check is not True:    # 判断是否可以发送数据
            return check, []
        """下载指纹"""
        self.link()
        self.downCharData(data)
        """检验指纹"""
        self.link()
        check = self.match()
        if check is not True:
            return check, []
        score = self.data[1] * 255 + self.data[2]  # 返回的分数值
        return True, score
        pass

    def getImage(self, data=None):
        """获取图像"""
        cmd = self.HEAD + [0x01, 0x00, 0x03, 0x01, 0x00, 0x05]   # 发送命令获取内容
        return self.isOk(cmd, 12)
        pass

    def genChar(self, data=None):
        """生成特征文件"""
        if data == "1":
            cmd = self.HEAD + [0x01, 0x00, 0x04, 0x02, 0x01, 0x00, 0x08]  # 发送命令
            return self.isOk(cmd, 12)  # 图像接收数据 12 大小
        elif data == "2":
            cmd = self.HEAD + [0x01, 0x00, 0x04, 0x02, 0x02, 0x00, 0x09]  # 发送命令
            return self.isOk(cmd, 12)  # 图像接收数据 12 大小
        pass

    def match(self, data=None):
        """比较指纹特征"""
        cmd = self.HEAD + [0x01, 0x00, 0x03, 0x03, 0x00, 0x07]   # 发送命令获取内容
        return self.isOk(cmd, 14)
        pass

    def regModel(self, data=None):
        """合成指纹特征值"""
        cmd = self.HEAD + [0x01, 0x00, 0x03, 0x05, 0x00, 0x09]   # 发送命令获取内容
        return self.isOk(cmd, 12)
        pass

    def upChar(self, data=None):
        """上传特征模块检测"""
        buff = bytes()
        if data == "1":
            cmd = self.HEAD + [0x01, 0x00, 0x04, 0x08, 0x01, 0x00, 0x0e]  # 发送命令
            return self.isOk(cmd, 12, False)
        elif data == "2":
            cmd = self.HEAD + [0x01, 0x00, 0x04, 0x08, 0x02, 0x00, 0x0F]  # 发送命令
            return self.isOk(cmd, 12, False)
        pass

    def getUpChar(self, data=None):
        """上传特征模块数据"""
        buff = self.ser.read(834)
        self.ser.close()
        subpackage = DealBuff(buff)   # 分割内容
        self.tag, self.data, check = subpackage.read()
        if check is not True:    # 校验和错误
            return 999
        return self.tag, self.data

    def downCharCheck(self, data=None):
        """
        下载特征值检测
        先要初始化,发送获取图像命令
        """
        self.getImage()
        self.link()
        cmd = self.HEAD + [0x01, 0x00, 0x04, 0x09, 0x02, 0x00, 0x10]  # 发送命令 下载的数据放在buff2中
        return self.isOk(cmd, 12)
        pass

    def downCharData(self, data):
        """下载特征值的数据"""
        self.writeRead(data, 0)  # 发送数据 接收为0
        pass


    def upImage(self, data=None):
        """上传图像检测"""
        cmd = self.HEAD + [0x01, 0x00, 0x03, 0x0a, 0x00, 0x0e]  # 发送命令
        return self.isOk(cmd, 12, False)
        pass

    def getUpImage(self, data=None):
        """获取后续的图像数据"""
        buff = self.ser.read(40032)
        self.ser.close()
        subpackage = DealBuff(buff)   # 分割内容
        self.tag, self.data, check = subpackage.read()
        if check is not True:    # 校验和错误
            return [], []
        return self.tag, self.data

    def writeRead(self, cmd, length, close=True):
        """发送命令读取原始字节"""
        cmd = bytes(cmd)
        self.ser.write(cmd)
        buff = self.ser.read(length)   # 图像接收数据
        if close:
            self.ser.close()    # 接受完数据断开com
        return buff
        pass

    def isOk(self, cmd, length, close=True):
        """判断数据是否合格"""
        buff = self.writeRead(cmd, length, close)  # 图像接收数据 12 大小
        subpackage = DealBuff(buff)   # 分割内容
        self.tag, self.data, check = subpackage.read()
        # 检验数据是否可靠
        if check is not True:   # 校验和错误
            return 999
        return self.check_code(self.data)
        pass

    def check_code(self, data):
        """检验指令码"""
        return SureCore[data[0]]
        pass

    pass


if __name__ == "__main__":
    # HEAD = [0xEF, 0x01, 0xFF, 0xFF, 0xFF, 0xFF]
    # data = [0xEF, 0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0x01, 0x00, 0x03, 0x0A, 0x00, 0x0E]
    # data = HEAD + [0x01, 0x00, 0x03, 0x01, 0x00, 0x05]
    # data = HEAD + [0x01, 0x00, 0x03, 0x05, 0x00, 0x09]
    # data = HEAD + [0x01, 0x00, 0x04, 0x08, 0x02, 0x00, 0x0f]

 注意：

1. 可以先在串口调试助手上输入命令，看看数据是怎么样子的然后在分析数据，最后写程序处理数据
2. 按照说明书提示最好不要改 模块的地址和密码，不然可能会成为砖头
3. 非常重要！！！本人是吃了亏的，真是日了狗， 指纹模块中有个设置波特率的，说明书上是说波特率可以设置为9600倍数，其实并不是这样的，我先开始觉得速度太慢了就设置了先开始是12倍，觉得可以用还是太慢，就设置了24倍，还是可以用，但是还是慢，我一冲动就设置成了96倍，我的个乖乖，然后就是不管怎么唤它都没反应，为此我还和原子哥讨论了很久，结果就是这东西成板砖了。 然后不得已就又买了个便宜的（原子哥虽然服务好，技术支持好，就是东西太贵了，弄懂原理了就不用再买贵的了）。

2.就是写一个服务器和客户端啦

我是用Qt写的客户端，用python写的服务器，模拟两个电脑通信（虽然只要一个自己的电脑）

 先来一波服务器的代码

里面用到了mySql, 用来存储指纹数据

 同时为了上传图像到客户端还要下载numpy, PIL 模块，其中python3中没有PIL 要下pillow

用到的cmd命令 pip install numpy，  pip install pillow

# -*-coding=utf8-*-

import socketserver
from collections import Iterable
import json

import os, sys
PATH = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(PATH)

from core import dealFinger
from core.dealFinger import DealFinger
from core.dealSql import mySqlDeal
from core import dealFile
from core import clockIn
import core

import configparser

check = {
    0x00: True,  # 表示指令执行完毕或OK；
    0x01: 101,  # 表示数据包接收错误；
    0x02: 102,  # 表示传感器上没有手指；
    0x03: 103,  # 表示录入指纹图像失败；
    0x06: 202,  # 表示指纹图像太乱而生不成特征；
    0x07: 203,  # 表示指纹图像正常，但特征点太少而生不成特征；
    0x15: 204,  # 表示图像缓冲区内没有有效原始图而生不成图像；
    0x08: 302,  # 表示指纹不匹配；
    0x09: 402,  # 表示没搜索到；此时页码与得分为 0
    0x0a: 502,  # 表示合并失败（两枚指纹不属于同一手指）；
    0x0d: 802,  # 表示指令执行失败；
    0x0f: 1002,  # 表示不能发送后续数据包；
    "occupyError": "occupyError",  # 占用指纹资源失败
    "releaseError": "releaseError",  # 释放指纹资源失败
    "getLogError": "getLogError",  # 获取日志失败
    "findError": "findError",  # 查找人失败
    "outPutError": "outPutError"  # 导出数据库失败
}

isTcpOccupy = 0

class JudgeLoad:
    """判断是否是合理的用户登陆"""
    def __init__(self, server, addrIP):
        self.server = server
        self.addrIP = addrIP
        pass

    def isLoad(self, data, addr):
        """判断是否登陆成功"""
        if isinstance(data, dict):
            isTrue1 = self.isFind("userName", data.keys())   # 判断类型是否符合
            isTrue2 = self.isFind("passWord", data.keys())   # 判断类型是否符合
            if isTrue1 is True and isTrue2 is True:
                return self.isUser(data["userName"], data["passWord"], addr)
            else:
                isTrue = self.isFind(self.addrIP, addr)  # 判断是否有登陆过
                if isTrue is not True:
                     return False
                isTrue1 = self.isFind("cmd", data.keys())  # 判断类型是否符合
                isTrue2 = self.isFind("value", data.keys())  # 判断类型是否符合
                if isTrue1 is True and isTrue2 is True:
                    return True
            return False
        return False
        pass

    def isUser(self, user, pwd, addr):
        """判断用户名和密码是否正确"""
        try:
            cf = configparser.ConfigParser
            cf = dealFile.readConf(cf)
            pwdconf = cf.get(user, "pwd")
            if pwd == pwdconf:
                ischeck = self.isFind(self.addrIP, addr)
                if ischeck is not True:
                    addr.append(self.addrIP)  # 添加主机ip 确定登陆成功
                self.server.send("True".encode("utf8"))
                return "loadSuccess"
        except Exception as e:
            print(e)
        return "loadFalse"
        pass

    def isFind(self, child, parent):
        """寻找parent 中是否有 child"""
        if isinstance(parent, Iterable) is not True:   # 判断是否是可迭代类型
            return False
        for i in parent:
            if child == i:
                return True
        return False
        pass

    pass


class SeverHandle(socketserver.BaseRequestHandler):
    """
    任务分发
    将客户端的请求分发下去
    """
    # addr = ["127.0.0.1"]
    addr = list()
    Occupy = list()
    def init(self):
        self.Finger = None
        pass

    def handle(self):
        """连接的一个客户端"""
        self.init()
        print("------------------连接成功-----------------")
        print("conn :", self.request)
        print("addr :", self.client_address)
        # 接收客户端数据
        buff = self.request.recv(1024).decode("utf8")
        data = eval(buff)

        judgeLode = JudgeLoad(self.request, self.client_address[0])
        isTrue = judgeLode.isLoad(data, self.addr)  # 判断是否登陆
        if isTrue is not True:
            if isTrue is "loadSuccess":
                return
            elif isTrue is "loadFalse":
                print("error")
                self.request.send("error".encode("utf8"))
                return
            elif isinstance(data, dict):
                    isTrue1 = judgeLode.isFind("cmd", data.keys())  # 判断类型是否符合
                    isTrue2 = judgeLode.isFind("value", data.keys())  # 判断类型是否符合
                    if isTrue1 is True and isTrue2 is True:
                        print("error")
                        self.request.send("error".encode("utf8"))
            return

        print(data)
        if hasattr(self, data["cmd"]):     # 命令分发
            func = getattr(self, data["cmd"])
            func(data["cmd"], data["value"])
        pass

    def finger(self, cmd, value):
        """采集手指数据"""
        self.Finger = DealFinger(cmd, value, self.request)
        check, buff = self.Finger.run()
        if check is not True:
            self.request.send(str(check).encode("utf8"))
            return
        print(self.Finger.data)
        fileName = dealFile.createImage(self.Finger.data, "finger.bmp")
        self.sendData(fileName)

    def check(self, cmd, value):
        """检验指纹是否合格"""
        self.Finger = DealFinger(cmd, value, self.request)
        check, score = self.Finger.run()

        if check is not True:
            self.request.send(str(check).encode("utf8"))
            return
        senddata = "%s##%s" % ("True", score)   # 拼接发送格式
        self.request.send(senddata.encode("utf8"))
        pass

    def save(self, cmd, data):
        """储存数据到数据库"""
        self.Finger = DealFinger(cmd, "2")   # 读取buff2 中的模板
        check, buff = self.Finger.run()

        if check is not True:
            self.request.send(str(check).encode("utf8"))
            return
        """储存到硬件"""
        dataFinger = list()
        dataFinger.append(self.Finger.data)
        self.Finger = DealFinger("saveToHard")   # 读取buff2 中的模板
        check, buff = self.Finger.run()
        if check is not True:
            self.request.send(str(check).encode("utf8"))
            return
        print(buff)
        num = buff[1] * 256 + buff[2]
        print(num)
        """储存到数据库里"""
        print(data)
        buff = data.split("##")
        data = {
            "num": num,
            "id": buff[0],
            "name": buff[1],
            "date": buff[2],
            "finger": str(dataFinger[0])
        }
        sql = mySqlDeal("insertData", data)   # 储存指纹
        sql.run()
        print("save True......")
        self.request.send("True".encode("utf8"))  # 发送成功信息
        """发送更新检测指纹"""
        core.qIsNewSql.put(True)
        pass

    def occupy(self, cmd, data):
        global isTcpOccupy
        """抢占指纹"""
        if isTcpOccupy is 1:
            senddata = "%s" % (check["occupyError"])  # 拼接发送格式
            self.request.send(senddata.encode("utf8"))
            return

        core.qToClockOccupy.put(True)

        if isTcpOccupy is 2:
            pop = self.Occupy.pop()
            print(pop)
            if pop != self.client_address[0]:
                senddata = "%s" % (check["occupyError"])  # 拼接发送格式
                self.request.send(senddata.encode("utf8"))
                return
        self.Occupy.append(self.client_address[0])  # 记录哪个客户端

        isTcpOccupy = 2   # 标记客户端抢占的
        self.request.send("True".encode("utf8"))  # 发送成功信息

    def release(self, cmd, data):
        """释放指纹"""
        global isTcpOccupy

        core.qToClockOccupy.put(False)

        if isTcpOccupy is 0:
            senddata = "%s" % (check["releaseError"])  # 拼接发送格式
            self.request.send(senddata.encode("utf8"))
            return
        isTcpOccupy = 0
        self.Occupy.pop()
        self.request.send("True".encode("utf8"))  # 发送成功信息

    def getLog(self, cmd, data):
        """获取日志"""
        fileName = dealFile.getFilePath("log.txt")
        if fileName is False:
            self.request.send(check["getLogError"].encode("utf8"))  # 发送成功信息
            return
        self.request.send("True".encode("utf8"))  # 发送成功信息
        self.sendData(fileName)
        pass

    def findPeople(self, cmd, data):
        """查找人"""
        sql = mySqlDeal("selectId", data)   # 查找
        ch, data = sql.run()
        if ch is False:
            self.request.send(check["findError"].encode("utf8"))  # 发送成功信息
            return
        self.request.send("True".encode("utf8"))  # 发送成功信息
        fileName = dealFile.createFindFile(data, "find.txt")
        self.sendData(fileName)
        pass

    def delectPeople(self, cmd, data):
        """删除数据"""
        sql = mySqlDeal("selectNum", data)   # 删除
        check, fingerNum = sql.run()
        for i in fingerNum:
            num = int(i[0])
            self.Finger = DealFinger("psDeletChar", num)
            self.Finger.run()
        sql = mySqlDeal("delectId", data)   # 删除
        sql.run()
        self.request.send("True".encode("utf8"))  # 发送成功信息
        pass

    def databaseBack(self, cmd, data):
        ch, fileName = dealFile.outPutSql("fingerSql.sql")
        if ch is False:
            self.request.send(check["outPutError"].encode("utf8"))  # 发送成功信息
            return
        self.request.send("True".encode("utf8"))  # 发送成功信息
        self.sendData(fileName)
        pass

    def updateDatabase(self, cmd, data):
        buff = data.split("##")
        fileName = buff[0]
        fileSize = int(buff[1])
        self.request.send("True".encode("utf8"))  # 发送成功信息
        self.getFile(fileName, fileSize)
        check = dealFile.creatSql(fileName)
        if check is not True:
            return None
        mysql = mySqlDeal("selectAll")
        check, data = mysql.run()
        if check is not True:
            return None
        """储存指纹"""
        self.Finger = DealFinger("creatFinger", data)
        self.Finger.run()

        pass

    def close(self, cmd, data):
        """客户端退出"""
        for i in self.addr:
            if i is self.client_address[0]:
                self.addr.remove(i)
        pass

    def sendData(self, path):
        """发送文件"""
        fizeSize = os.path.getsize(path)
        fileName = os.path.basename(path)
        senddata = "{fileName}##{fileSize}" .format(fileName=fileName, fileSize=fizeSize)  # 拼接发送格式
        self.request.send(senddata.encode("utf8"))
        check = self.request.recv(1024).decode("utf8")
        print("send......")
        print(check)
        if check != "True":     # 确定用户接收到了数据
            self.request.send("error".encode("utf8"))
            return
        print("send......again")
        with open(path, "rb") as f:   # 开始发送文件
            num = 0
            while num < fizeSize:
                data = f.read(1024)
                self.request.sendall(data)
                num += len(data)
        print("send  ok")
        pass

    def getFile(self, path, size):
        fileName = dealFile.getFilePath(path)
        fileSize = size
        with open(fileName, "w") as f:  # 得到上传的文件
            num = 0
            while num < fileSize:
                data = self.request.recv(1024)
                num = num + len(data)
                data = data.decode("utf8")
                f.write(data)
        print("get OK")
    pass


def checkOccupy():
    global isTcpOccupy
    while True:
        if isTcpOccupy == 0:
            if core.qToTcpOccupy.empty() is not True:
                isTcpOccupy = core.qToTcpOccupy.get()
    pass


if __name__ == "__main__":

    ip_port = ("192.168.137.249", 9090)
    print("----等待连接.............")
    s = socketserver.ThreadingTCPServer(ip_port, SeverHandle)

    s.serve_forever()

 

 下面是服务器可能用到的

# -*- coding:utf8 -*-

import numpy as np
from PIL import Image

import os, sys
import configparser

PATH = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(PATH)

"""存放文件的目录"""
path = PATH + "/static/"

"""
对文件的一下操作
"""


def readConf(cf):
    """读取conf文件"""
    fileName = PATH + "/conf/" + "conf.conf"
    cf = configparser.ConfigParser()
    cf.read(fileName)
    return cf


def createImage(data, fileName):
    """创建图像"""
    if isinstance(data, list) is not True:
        return False
    """得到指纹图像的灰度bmp图"""
    ByteArray = bytearray(data)  # 将数组转换成 字节数组
    NumpyArray = np.array(ByteArray)
    grayImage = NumpyArray.reshape(288, 128)  # 得到灰度图像字节数组
    image = Image.fromarray(grayImage)
    fileName = path + fileName   # 文件存放路径
    image.save(fileName)  # 得到指纹图像
    return fileName
    pass


def textLog(data, fileName):
    """写日志"""
    fileName = path + fileName  # 文件存放路径
    with open(fileName, "a+") as f:
        f.write(data)
    return
    pass

def getFilePath(fileName):
    """回取文件路径"""
    fileName = path + fileName
    if os.path.isfile(fileName) is False:
        return False
    return fileName
    pass

def createFindFile(data, fileName):
    """生成查找文件"""
    fileName = path + fileName
    with open(fileName, "w+") as f:
        for i in data:
            id = "id  : " + i[0] + "\r\n"
            name = "name: " + i[1] + "\r\n"
            date = "date: " + i[2] + "\r\n"
            f.write(id + name + date + "\r\n")
    return fileName


cf = configparser.ConfigParser()
cf = readConf(cf)
host = cf.get("db", "db_host")
port = cf.getint("db", "db_port")
user = cf.get("db", "db_user")
passwd = cf.get("db", "db_pwd")
db = cf.get("db", "db_database")
table = cf.get("db", "db_table")

"""导出数据库"""
def outPutSql(fileName, host=host, port=port, user=user, passwd=passwd, db=db, table=table):
    """导出mysql脚本"""
    fileName = path + fileName
    sqlStr = "mysqldump -u{user} -p{passwd} {db}> {fileName}"\
        .format(user=user, passwd=passwd, db=db, table=table, fileName=fileName)
    try:
        os.system(sqlStr)
    except Exception as e:  # 找不到数据库
        return False, None
    # print(os.path.getsize(fileName))
    return True, fileName
    pass


"""创建数据库"""
def creatSql(fileName,  host=host, port=port, user=user, passwd=passwd, db=db, table=table):
    """创建数据库表"""
    fileName = path + fileName
    sqlStrDelect = "mysqladmin -u{user} -p{passwd} drop {db} -f"\
        .format(user=user, passwd=passwd, db=db)
    sqlStrCreat = "mysqladmin -u{user} -p{passwd} create {db}" \
        .format(user=user, passwd=passwd, db=db, fileName=fileName)
    sqlStrInsert = "mysql -u{user} -p{passwd} {db} < {fileName}" \
        .format(user=user, passwd=passwd, db=db, fileName=fileName)
    try:
        """删除数据库"""
        a = os.system(sqlStrDelect)
        print(a)
        """创建数据库"""
        a = os.system(sqlStrCreat)
        print(a)
        """插入数据库"""
        a = os.system(sqlStrInsert)
        print(a)
    except Exception as e:  # 找不到数据库
        print(e)
        return False, None
    return True


def backFile(fileName, backName):
    """备份文件"""
    fileName = path + fileName
    backName = path + backName
    logcontent = path + "logContent.txt"
    with open(fileName, "rb") as f1, open(backName, "wb") as f2:
        data = f1.read()
        f2.write(data)
    with open(fileName, "w") as f1:
        pass
    """添加log目录"""
    with open(logcontent, "a+") as f1:
        f1.write(backName + "\r\n")
    return True
    pass


def joinFile():
    """拼接日志"""
    log = path + "log.txt"
    logcontent = path + "logContent.txt"
    logback = path + "logback.txt"
    with open(logback, "w") as f2:
        pass
    with open(logcontent) as f1, open(logback, "a+") as f2:
        data = f1.read().strip()
        num = len(data)
        if num == 0:   # 判断文科是否为空
            with open(log) as f3:
                filestream = f3.read()
                f2.write(filestream)
            return
        data = data.split("\n")
        print(data)
        for i in data:
            with open(i) as f3:
                filestream = f3.read()
                f2.write(filestream)
        with open(log) as f3:
            filestream = f3.read()
            f2.write(filestream)
    pass


def cleanFile():
    """清空无用的日志文件"""
    filename = path + "log_*"
    logcontent = path + "logContent.txt"
    with open(logcontent, "w"):  # 文件目录清空
        pass
    cmd = "rm {filename}".format(filename=filename)
    data = os.system(cmd)
    pass

if __name__ == "__main__":
    # print(PATH)
    # print(type(PATH))
    # print(path)
    # print(type(path))
    # print(createImage(123, 456))
    # fileName = outPutSql("my.sql")
    # print(fileName)
    # print(os.path.getsize(fileName[1]))

    # backFile("simsun.ttc", "backsimsun.ttc")
    joinFile()
    # creatSql("123")
    # cleanFile()
    # logconvim tent = path + "logContent.txt"
    # with open(logcontent) as f1:
    #     data = f1.read().strip()
    #     print(data)
    #     num = len(data)
    #
    #     data = data.split("\n")
    #     print(data)

 

 

服务器完成后就可以写客户端端了。（其实是两个同时进行然后相互补充）

下面是Qt代码

主要是通讯，其他的界面其实都还好，就按照自己的想法

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "QDebug"
#include "QPainter"
#include "QBrush"
#include "QPaintDevice"
#include "QMessageBox"
#include "QSqlDatabase"
#include "QSqlError"
#include "QString"
#include "QFileDialog"

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    initData();//初始化数据函数
    initTcp();
}

MainWindow::~MainWindow()
{
    delete ui;
}


//初始化数据函数
void MainWindow::initData()
{
    /* ================== 初始化登陆 ==================*/
    showImage = 3;
    //设置当前显示页面
    ui->stackedWidget->setCurrentWidget(ui->pageLog);
    //没登陆不使能菜单,设置密码不可见
    ui->menuO->setEnabled(false);
    //设置编辑框模式
    ui->lineEditUserName->setEnabled(true);
    ui->lineEditPassward->setEnabled(true);
    ui->lineEditPassward->setEchoMode(QLineEdit::Password);
    ui->pB_logoChangelink->setStyleSheet("#pB_logoChangelink{border: 0px;}"
                                         "#pB_logoChangelink:hover{color:rgb(0, 170, 255)};");
    isChangeLink=false;
    /* ================== 初始化界面1 ==================*/
    //显示文本框
    ui->textEdit_1_Show->setEnabled(true);
    ui->pushButton_1_get->setEnabled(true);
    ui->pushButton_1_show->setEnabled(true);
    ui->progressBar_1_get->setValue(0);
    ui->progressBar_1_get->hide();
    /* ================== 初始化界面2 ==================*/
    //button
    isOccupy = false;
    ui->pushButton_2_Start->setText("开启");
    ui->pushButton_2_Start->setEnabled(true);
    ui->pushButtonConcel->setEnabled(false);
    ui->pushButtonSure->setEnabled(false);
    ui->pushButtoncheckfinger->setEnabled(false);
    ui->pushButtonSavefinger1->setEnabled(false);
    ui->pushButtonSavefinger2->setEnabled(false);
    //label
    ui->label_2_info->setText("请放入手指！");
    ui->label_2_info->hide();
    //progressBar
    ui->progressBar_2_fingerImage->hide();

    /* ================ 初始化界面3 ====================== */
    findWhat = "id";
    ui->pushButton_3_findName->setText("查找id：");
    ui->pushButton_3_find->setEnabled(true);
    ui->lineEdit_3_findId->setEnabled(true);
    ui->pushButton_3_delect->setEnabled(false);
    ui->pushButton_3_back->setEnabled(true);  // 备份
    ui->pushButton_3_Updata->setEnabled(true); // 上传
    ui->progressBar_3_show->setValue(0);
    ui->progressBar_3_show->hide();
    ui->pushButton_3_findName->setStyleSheet("#pushButton_3_findName{border: 0px;}"
                                         "#pushButton_3_findName:hover{color:rgb(0, 170, 255)};");


    /*===================== tcp数据 ======================*/
    //文件接收
    isStart = true;
    //初始化tcp登陆
    isLoad = false;
    callFunc = 0;
    recWhat = 0;
    showInfo = false; 
}

//初始化有关tcp connect
void MainWindow::initTcp()
{
    //ip和端口
//    ip = "127.0.0.1";
//    port = 8080;

    ip = "192.168.137.249";
    port = 9090;
    //套接字
    tcpSocket = new QTcpSocket(this);
    //接收到服务器后发数据
    connect(tcpSocket, &QTcpSocket::connected, this, &MainWindow::sendDataToServe);
    //收信号
    connect(tcpSocket, &QTcpSocket::readyRead, this, &MainWindow::dealReceiveData);
    //对话框 × 掉
//    connect(this, &MainWindow::destroyed, this, &MainWindow::on_actionClose_triggered);
     connect(this, &MainWindow::destroyed, this,
             [=]()
             {
                 qDebug() << "distory";
             }
     );
}

//设置tcp连接
bool MainWindow::tcpLink(int mode)
{
    //tcp连接等待超时
    tcpSocket->disconnectFromHost();
    tcpSocket->close();
    tcpSocket->connectToHost(QHostAddress(ip), port);

    if(!tcpSocket->waitForConnected(100))  //等待5s
    {
        if(0 == mode)
        {
            recCheck("link_error");
        }
        return false;
    }
    return true;
}

//成功连接服务器后的响应
void MainWindow::sendDataToServe()
{
    switch (callFunc) {
    case 1: {//登陆请求
        //给对方发送数据,使用套接字是tcpSocket;  QString->QByteArray->char*
        QString userName = ui->lineEditUserName->text();
        QString passWord = ui->lineEditPassward->text();
        QString sendData = QString("{'userName':'%1', 'passWord':'%2'}")
                .arg(userName).arg(passWord);
        tcpSocket->write(sendData.toUtf8().data());
    }
        break;
    case 2: {//发送录制指纹1
        QString cmd = "finger";
        QString data = "1";
        QString sendData = QString("{'cmd':'%1', 'value':'%2'}").arg(cmd).arg(data);
        tcpSocket->write(sendData.toUtf8().data());
    }
        break;
    case 3: {//发送录制指纹2
        QString cmd = "finger";
        QString data = "2";
        QString sendData = QString("{'cmd':'%1', 'value':'%2'}").arg(cmd).arg(data);
        tcpSocket->write(sendData.toUtf8().data());
    }
        break;
    case 4: {//发送校验信息
        QString cmd = "check";
        QString data = "None";
        QString sendData = QString("{'cmd':'%1', 'value':'%2'}").arg(cmd).arg(data);
        tcpSocket->write(sendData.toUtf8().data());
    }
        break;
    case 5: {//存储有效指纹数据
        QString cmd = "save";
        QString name = ui->lineEditname->text();
        QString id = ui->lineEditID->text();
        QString date = ui->lineEditdate->text();
        QString data = QString("%1##%2##%3").arg(id).arg(name).arg(date);
        QString sendData = QString("{'cmd':'%1', 'value':'%2'}").arg(cmd).arg(data);
        tcpSocket->write(sendData.toUtf8().data());
    }
        break;
    case 6:{ // 发送占用指纹资源
        QString cmd = "occupy";
        QString data = "None";
        QString sendData = QString("{'cmd':'%1', 'value':'%2'}").arg(cmd).arg(data);
        tcpSocket->write(sendData.toUtf8().data());
    }
        break;
    case 7:{ // 发送释放指纹资源
        QString cmd = "release";
        QString data = "None";
        QString sendData = QString("{'cmd':'%1', 'value':'%2'}").arg(cmd).arg(data);
        tcpSocket->write(sendData.toUtf8().data());
    }
        break;
    case 8:{ // 界面1获取log
        QString cmd = "getLog";
        QString data = "None";
        QString sendData = QString("{'cmd':'%1', 'value':'%2'}").arg(cmd).arg(data);
        tcpSocket->write(sendData.toUtf8().data());
    }
        break;
    case 9:{ // 查找人
        QString cmd = "findPeople";
        QString data = QString("%1:%2").arg(findWhat).arg(ui->lineEdit_3_findId->text());
        QString sendData = QString("{'cmd':'%1', 'value':'%2'}").arg(cmd).arg(data);
        tcpSocket->write(sendData.toUtf8().data());
    }
        break;
    case 10:{ // 删除信息
        QString cmd = "delectPeople";
        QString data = QString("%1:%2").arg(findWhat).arg(ui->lineEdit_3_findId->text());
        QString sendData = QString("{'cmd':'%1', 'value':'%2'}").arg(cmd).arg(data);
        tcpSocket->write(sendData.toUtf8().data());
    }
        break;
    case 11:{ // 备份数据库
        QString cmd = "databaseBack";
        QString data = "None";
        QString sendData = QString("{'cmd':'%1', 'value':'%2'}").arg(cmd).arg(data);
        tcpSocket->write(sendData.toUtf8().data());
    }
        break;
    case 12:{ // 上传数据库
        QString cmd = "updateDatabase";
        QString data = QString("%1##%2").arg(upDateFileName).arg(upDateFileSize);
        QString sendData = QString("{'cmd':'%1', 'value':'%2'}").arg(cmd).arg(data);
        tcpSocket->write(sendData.toUtf8().data());
    }
        break;
    case 20: {//发送退出程序信号
        QString cmd = "close";
        QString data = "None";
        QString sendData = QString("{'cmd':'%1', 'value':'%2'}").arg(cmd).arg(data);
        tcpSocket->write(sendData.toUtf8().data());
        tcpSocket->disconnectFromHost(); //关闭tcp
        tcpSocket->close();
        QMainWindow::close();
    }
        break;
    default:
        break;
    }
}

//接收事件槽函数
void MainWindow::dealReceiveData()
{
    //接收的数据
    switch (callFunc) {
    case 1: {// 登陆获取信息
        QByteArray buf = tcpSocket->readAll();
        QString check = QString(buf);
        tcpSocket->disconnectFromHost(); //关闭tcp
        tcpSocket->close();
        if(check != "True")  // 登陆失败或连接错误
        {
            recCheck(check);
            return ;
        }
        //登陆成功
        showImage = 1;
        isLoad = true;
        ui->menuO->setEnabled(true);
        ui->stackedWidget->setCurrentWidget(ui->pageShowInfo);

    } break;

    case 2:{ //接收录制指纹1
        QByteArray buf = tcpSocket->readAll();
        QString check = QString(buf);
        if(check != "True")
        {
            recCheck(check);
            tcpSocket->disconnectFromHost(); //关闭tcp
            tcpSocket->close();
            break ;
        }
        ui->label_2_info->setText("请等待---");
        ui->label_2_info->show();
        ui->progressBar_2_fingerImage->show();
        callFunc = 20;
    } break;

    case 3:{ //接收录制指纹2
        QByteArray buf = tcpSocket->readAll();
        QString check = QString(buf);
        if(check != "True")
        {
            recCheck(check);
            tcpSocket->disconnectFromHost(); //关闭tcp
            tcpSocket->close();
            break ;
        }
        ui->label_2_info->setText("请等待---");
        ui->label_2_info->show();
        ui->progressBar_2_fingerImage->show();
        callFunc = 20;
    } break;

    case 4:{  //两次指纹对比度
        QByteArray buf = tcpSocket->readAll();
        QString str = QString(buf);
        //解析返回值
        QString check = QString(str).section("##", 0, 0);
        QString score = QString(str).section("##", 1, 1);
        tcpSocket->disconnectFromHost(); //关闭tcp
        tcpSocket->close();

        if("True" != check)
            return recCheck(check);
        //检验合格
        QMessageBox::information(this, "检验", QString("检验合格，分数：%1").arg(score));
        ui->pushButtonSure->setEnabled(true);
    } break;

    case 5:{  //存储
        QByteArray buf = tcpSocket->readAll();
        QString check = QString(buf);
        tcpSocket->disconnectFromHost(); //关闭tcp
        tcpSocket->close();

        if("True" != check)
            return recCheck(check);
        QMessageBox::information(this, "save", QString("储存成功！"));

        on_pushButtonConcel_clicked();

    } break;

    case 6:{  // 接收占用指纹资源是否成功
        QByteArray buf = tcpSocket->readAll();
        QString check = QString(buf);
        tcpSocket->disconnectFromHost(); //关闭tcp
        tcpSocket->close();

        if("True" != check)
            return recCheck(check);
        //开启后使能和显示提示
        ui->label_2_info->show();
        ui->label_2_info->setText("开启成功");
        ui->pushButtonSavefinger1->setEnabled(true);
        ui->pushButton_2_Start->setText("关闭");
    } break;

    case 7:{  // 接收释放指纹资源是否成功
        QByteArray buf = tcpSocket->readAll();
        QString check = QString(buf);
        tcpSocket->disconnectFromHost(); //关闭tcp
        tcpSocket->close();

        if("True" != check)
            return recCheck(check);
        QMessageBox::information(this, "release", QString("关闭成功！"));
        //关闭后隐藏和禁止button
        ui->label_2_info->hide();
        ui->progressBar_2_fingerImage->hide();
        ui->pushButton_2_Start->setText("开启");

    } break;

    case 8:{  // 获取接收log
        QByteArray buf = tcpSocket->readAll();
        QString check = QString(buf);
        if("True" != check){
            tcpSocket->disconnectFromHost(); //关闭tcp
            tcpSocket->close();
            return recCheck(check);
        }
        callFunc = 20;

    } break;

    case 9:{ // 查找人
        QByteArray buf = tcpSocket->readAll();
        QString check = QString(buf);
        if("True" != check){
            tcpSocket->disconnectFromHost(); //关闭tcp
            tcpSocket->close();
            return recCheck(check);
        }
        callFunc = 20;
    } break;

    case 10:{ // 删除人
        QByteArray buf = tcpSocket->readAll();
        QString check = QString(buf);
        if("True" != check){
            tcpSocket->disconnectFromHost(); //关闭tcp
            tcpSocket->close();
            return recCheck(check);
        }
        QMessageBox::information(this, "删除", QString("删除成功！"));
    } break;

    case 11:{ // 备份数据库
        QByteArray buf = tcpSocket->readAll();
        QString check = QString(buf);
        if("True" != check){
            tcpSocket->disconnectFromHost(); //关闭tcp
            tcpSocket->close();
            return recCheck(check);
        }
        callFunc = 20;
    } break;

    case 12:{  // 上传数据库
        QByteArray buf = tcpSocket->readAll();
        QString check = QString(buf);
        if("True" != check){
            tcpSocket->disconnectFromHost(); //关闭tcp
            tcpSocket->close();
            return recCheck(check);
        }
        qDebug() << buf;
        sendDataFile();
        //callFunc = 21;
    } break;

    case 20:{
        recData();
        //显示进度条
        switch (recWhat){
        case 1:{
            ui->progressBar_1_get->setValue((100 * recvSize) / fileSize);
        } break;
        case 2:{
            ui->progressBar_2_fingerImage->setValue((100 * recvSize) / fileSize);
        } break;
        case 3:{
            ui->progressBar_2_fingerImage->setValue((100 * recvSize) / fileSize);
        } break;
        case 4:{
        } break;
        case 5:{
            ui->progressBar_3_show->setValue((100 * recvSize) / fileSize);
        } break;
        default: break;
        }
        //传输完成后
        if(showInfo == true)
        {
            showInfo = false;
            callFunc = 0;
            QMessageBox::information(this, "完成", "接收完成");
            switch (recWhat) {
            case 1:{
                recWhat = 0;
                ui->pushButton_1_get->setEnabled(true);
                ui->progressBar_1_get->hide();
            } break;
            case 2:{
                ui->pushButtonSavefinger2->setEnabled(true);
                showImage = 2;
                update();
                recWhat = 0;
            } break;
            case 3:{
                ui->pushButtoncheckfinger->setEnabled(true);
                showImage = 2;
                update();
                recWhat = 0;
            } break;
            case 4:{
                ui->textEdit_3_show->clear();
                QString str = showFile("find.txt");
                ui->textEdit_3_show->append(str);
                ui->pushButton_3_find->setEnabled(true);
                ui->lineEdit_3_findId->setEnabled(true);
                ui->pushButton_3_delect->setEnabled(true);
                recWhat = 0;
            } break;
            case 5:{
                ui->pushButton_3_back->setEnabled(true);
                ui->progressBar_3_show->hide();
                recWhat = 0;
            } break;
            default: break;
            }
        }
    } break;


    case 21:{ // 发送文件
        sendDataFile();
    } break;

//    case 22:{ // 等待发送文件后的回应
//        QByteArray buf = tcpSocket->readAll();;
//        QString check = QString(buf).section("##", 0, 0);
//        fileSize = QString(buf).section("##", 1, 1).toInt();
//        if("True" != check){
//            tcpSocket->disconnectFromHost(); //关闭tcp
//            tcpSocket->close();
//            return recCheck(check);
//        }
//        callFunc = 23;
//    } break;

//    case 23:{  //等待对方更新完成

//    } break;

    default: break;
    }

}

//获取文件
void MainWindow::recData()
{
    QByteArray buf = tcpSocket->readAll();
    QString check = QString(buf);

    if(true == isStart)
    {
        qDebug() << buf;
        isStart = false;
        //解析传回的头文件
        fileName = QString(buf).section("##", 0, 0);
        fileSize = QString(buf).section("##", 1, 1).toInt();
        recvSize = 0;  //初始化接收数据大小

        qDebug() << fileName << fileSize;
        if (0 == fileSize){  // 文件大小为0
            tcpSocket->disconnectFromHost();
            tcpSocket->close();
            return recCheck("fileError");
        }

        fileTransport.setFileName(fileName);

        bool isOk = fileTransport.open(QIODevice::WriteOnly);
        if(false == isOk)
        {
            qDebug() << "WriteOnly error 40";
        }
        tcpSocket->write(QString("True").toUtf8().data());


    }
    else
    {
        qint64 len = fileTransport.write(buf);
        recvSize += len;
        if(recvSize == fileSize)  //判断是否传输完成
        {
            fileTransport.close();
            tcpSocket->disconnectFromHost();
            tcpSocket->close();
            //准备新的传输
            isStart = true;
            showInfo = true;
        }
    }
}

//发送文件
void MainWindow::sendDataFile()
{
    qint64 len = 0;
    do
    {
        //每次发送数据的大小
        char buf[4*1024] = {0};
        len = 0;

        //往文件中读数据
        len = fileTransport.read(buf, sizeof(buf));

        //发送数据，读多少，发多少
        len = tcpSocket->write(buf, len);
        //发送数据要累加
        sendSize += len;
        ui->progressBar_3_show->setValue(sendSize*100/upDateFileSize);

    }while(len >0 );
    //是否发送文件完毕
    if(sendSize == upDateFileSize)
    {
        QMessageBox::about(this, "传输", "文件发送完成");
        fileTransport.close();

        //把客户端关闭
        ui->textEdit_3_show->append("连接断开");
        tcpSocket->disconnectFromHost();
        tcpSocket->close();


        ui->pushButton_3_Updata->setEnabled(true);
        ui->pushButton_3_back->setEnabled(true);
        ui->menuO->setEnabled(true);
        ui->pushButton_3_find->setEnabled(true);
        ui->progressBar_3_show->setValue(0);
        ui->progressBar_3_show->hide();
        //callFunc = 22;
    }
}

//接收的信号做检测
void MainWindow::recCheck(QString check)
{
    qDebug() << check;
    if ("error" == check){// 连接失败或者是登陆失败
        if(false == isLoad)
            QMessageBox::warning(this, "连接信息", "用户名或者密码错误!");
        else
            QMessageBox::warning(this, "连接信息", "连接断开，重新登陆!");
        initData();
    }
    else if("102" == check){// 没有检测到手指
        ui->label_2_info->setText("请放入手指！");
        ui->label_2_info->show();
        switch (callFunc) {
        case 2:{
            ui->pushButtonSavefinger1->setEnabled(true);
        } break;
        case 3:{
            ui->pushButtonSavefinger2->setEnabled(true);
        }break;
        default: break;
        }
    }
    else if ("302" == check) { // 校验失败
        QMessageBox::warning(this, "校验信息", "两次指纹不匹配!");
        this->on_pushButtonConcel_clicked();
    }
    else if("link_error" == check) // 找不到服务器
    {
        QMessageBox::about(this, "连接信息", "连接失败......");
        initData();
    }
    else if("occupyError" == check) //抢占失败
    {
        QMessageBox::about(this, "占用信息", "设备正忙......");
        isOccupy = false;
    }
    else if("getLogError" == check)
    {
        QMessageBox::about(this, "获取日志", "失败！");
        ui->progressBar_1_get->hide();
        ui->pushButton_1_get->setEnabled(true);
    }
    else if("findError" == check)
    {
        QMessageBox::about(this, "查找", "失败！没这个人");
        ui->pushButton_3_find->setEnabled(true);
        ui->lineEdit_3_findId->setEnabled(true);
        ui->textEdit_3_show->clear();
    }
    else if("delectError" == check)
    {
        QMessageBox::about(this, "删除", "删除失败！");
    }
    else if("outPutError" == check)
    {
        QMessageBox::about(this, "导出数据库", "导出失败！");
        ui->pushButton_3_back->setEnabled(true);
    }
    else if("fileError" == check)
    {
        QMessageBox::about(this, "文件错误", "文件错误！");
    }
}

//绘图事件
void MainWindow::paintEvent(QPaintEvent *)
{

    QPainter p;
    //QPaintDevice pD;
    p.begin(this);//指定当前出窗口为绘图设备

    /* *
     * showImage
     * 1,显示页面颜色绘图
     * 2,指纹页面绘图
     * 3,查询页面绘图
     * */
    switch (showImage) {
    case 1:      
//        ui->pageShowInfo->setStyleSheet("#pageShowInfo{"
//                                       "border-image:url(:/image/image/car.jpg);"
//                                       "}"
//                                       );
//        break;

    case 2:{
        QString str = QString("QWidget{"
                      "border-image:url(finger.bmp);"
                      "}");
        ui->widgetFinger->setStyleSheet(str);
    }
        break;

    case 3:

        break;

    default:
        break;
    }

    p.end();
}

//显示文本
QString MainWindow::showFile(QString fileName)
{
    QFile file(fileName);
    ui->textEdit_1_Show->clear();
    bool isOk = file.open(QIODevice::ReadOnly);
    if(false == isOk)
    {
        qDebug() << "WriteOnly error 40";
    }
    QByteArray buff = file.readAll();
    QString str = QString(buff);
    return str;
}
/***================= 菜单函数 ===================***/
//显示界面
void MainWindow::on_actionShow_triggered()
{
    ui->stackedWidget->setCurrentWidget(ui->pageShowInfo);
    showImage = 1;
    update();

}

//录指纹界面
void MainWindow::on_actionSave_triggered()
{
    ui->stackedWidget->setCurrentWidget(ui->pageSave);
    showImage = 2;
    update();
}

//查找界面
void MainWindow::on_actionFind_triggered()
{
    ui->stackedWidget->setCurrentWidget(ui->pageFind);
    showImage = 3;
    update();
}

//菜单栏退出
void MainWindow::on_actionClose_triggered()
{
    /***********连接服务器发送数据***********/
    callFunc = 20;
    bool check = tcpLink(1);    //不要默认模式 0
    if(false == check)
    {
        MainWindow::close();
    }
}

/*** ===================界面登陆的函数========================== ***/
//登陆函数
void MainWindow::on_pushButtonReg_clicked()
{
    //禁止输入
    ui->lineEditUserName->setEnabled(false);
    ui->lineEditPassward->setEnabled(false);

    tcpSocket->disconnectFromHost();
    tcpSocket->close();
    //连接服务器
    callFunc = 1;
    tcpLink();  //默认模式 0

}


//退出函数
void MainWindow::on_pushButtonClose_clicked()
{
    QMainWindow::close();
}

//改变连接端口
void MainWindow::on_pB_logoChangelink_clicked()
{
    if(false == isChangeLink)
    {
        isChangeLink = true;
        ui->pB_logoChangelink->setText("返回？");
        //清楚编辑行文本
        ui->lineEditUserName->clear();
        ui->lineEditPassward->clear();
        //设置端口和ip
        ui->label_logo_name->setText("ip :");
        ui->label_logo_passwd->setText("port :");
        ui->lineEditPassward->setEchoMode(QLineEdit::Normal);  //设置正常显示
        //隐藏登陆
        ui->pushButtonReg->hide();

        qDebug() << ip << port;
    }
    else
    {
        isChangeLink = false;
        ui->pB_logoChangelink->setText("更改登陆连接？");
        //设置端口和ip
        ip = ui->lineEditUserName->text();
        port = ui->lineEditPassward->text().toInt();
        //清楚编辑行文本
        ui->lineEditUserName->clear();
        ui->lineEditPassward->clear();
        //设置为登陆模式
        ui->label_logo_name->setText("用户名：");
        ui->label_logo_passwd->setText("密 码：");
        ui->lineEditPassward->setEchoMode(QLineEdit::Password);
        //显示登陆
        ui->pushButtonReg->show();

        qDebug() << ip << port;
    }
}
/*** ===================界面1的函数========================== */
//在窗口显示信息
void MainWindow::on_pushButton_1_show_clicked()
{
    QString str = showFile("log.txt");
    ui->textEdit_1_Show->append(str);
}
//下载更新log
void MainWindow::on_pushButton_1_get_clicked()
{
    ui->pushButton_1_get->setEnabled(false);
    //显示进度条
    ui->progressBar_1_get->setValue(0);
    ui->progressBar_1_get->show();
    /***********连接服务器发送数据***********/
    recWhat = 1;
    callFunc = 8;
    tcpLink();  //默认模式 0
}
/*** ===================界面2的函数========================== */
//开启录制，占用资源
void MainWindow::on_pushButton_2_Start_clicked()
{
    if(false == isOccupy)  //开启占用
    {
        isOccupy = true;
        /***********连接服务器发送数据***********/
        callFunc = 6;
        //tcp连接
        tcpLink();
    }
    else  // 释放
    {
        isOccupy = false;
        //禁止button
        ui->pushButtonSavefinger1->setEnabled(false);
        ui->pushButtonConcel->setEnabled(false);
        ui->pushButtonSavefinger2->setEnabled(false);
        ui->pushButtonSure->setEnabled(false);
        ui->pushButtoncheckfinger->setEnabled(false);
        //隐藏进度条
        ui->progressBar_2_fingerImage->setValue(0);
        ui->progressBar_2_fingerImage->hide();
        /***********连接服务器发送数据***********/
        callFunc = 7;
        //tcp连接
        tcpLink();
    }
}

//录制指纹 1 Button
void MainWindow::on_pushButtonSavefinger1_clicked()
{
    //使能返回button和禁止录制button
    ui->pushButtonSavefinger1->setEnabled(false);
    ui->pushButtonConcel->setEnabled(true);
    //禁止输入
    ui->lineEditname->setEnabled(false);
    ui->lineEditID->setEnabled(false);
    ui->lineEditdate->setEnabled(false);
    //隐藏进度条
    ui->progressBar_2_fingerImage->setValue(0);
    ui->progressBar_2_fingerImage->hide();
    /***********连接服务器发送数据***********/
    callFunc = 2;
    recWhat = 2;
    tcpLink();  //默认模式 0

}

//录制指纹 2 Button
void MainWindow::on_pushButtonSavefinger2_clicked()
{
    //禁止button
    ui->pushButtonSavefinger2->setEnabled(false);
    //隐藏进度条
    ui->progressBar_2_fingerImage->setValue(0);
    ui->progressBar_2_fingerImage->hide();
    /***********连接服务器发送数据***********/
    callFunc = 3;
    recWhat = 3;
    tcpLink();  //默认模式 0


}

//检验两次录取准确度
void MainWindow::on_pushButtoncheckfinger_clicked()
{
    ui->pushButtoncheckfinger->setEnabled(false);
    /***********连接服务器发送数据***********/
    callFunc = 4;    
    tcpLink();  //默认模式 0
}


//取消录取操作
void MainWindow::on_pushButtonConcel_clicked()
{
    //开启输入
    ui->lineEditname->setEnabled(true);
    ui->lineEditID->setEnabled(true);
    ui->lineEditdate->setEnabled(true);
    //button功能转换
    ui->pushButtonSavefinger1->setEnabled(true);
    ui->pushButtonConcel->setEnabled(false);
    ui->pushButtonSavefinger2->setEnabled(false);
    ui->pushButtonSure->setEnabled(false);
    //隐藏显示信息
    ui->label_2_info->hide();
    ui->progressBar_2_fingerImage->hide();
    //关闭连接主机
    tcpSocket->disconnectFromHost();
    tcpSocket->close();
    //关闭文件
    fileTransport.close();
    isStart = true;
    showInfo = false;
}

//更新数据库
void MainWindow::on_pushButtonSure_clicked()
{
    ui->pushButtonSure->setEnabled(false);
    //弹出对话框提醒用户是否更新
    QString str = "是否跟新到数据库";
    int isOk = QMessageBox::information(this, "issave", str, QMessageBox::Ok, QMessageBox::Cancel);

    if (QMessageBox::Cancel == isOk)
    {
        on_pushButtonConcel_clicked();
        return;
    }

//    /*================== 数据库的操作 ==============*/
//    //添加MySql数据库
//    QSqlDatabase db = QSqlDatabase::addDatabase("QMYSQL");
//    //连接数据库
//    db.setHostName("127.0.0.1"); //数据库服务器IP
//    db.setUserName("root"); //数据库用户名
//    db.setPassword("123456"); //密码
//    db.setDatabaseName("myinfo"); //使用哪个数据库

//    //打开数据库
//    if(false == db.open()) //数据库打开失败
//    {
//        QMessageBox::warning(this, "错误", db.lastError().text());
//        return;

//    }

//    db.close();
    callFunc = 5;
    tcpLink();  //默认模式 0

}

/*** ===================界面3的函数========================== */
//查找人
void MainWindow::on_pushButton_3_find_clicked()
{
    ui->pushButton_3_find->setEnabled(false);
    ui->lineEdit_3_findId->setEnabled(false);
    /***********连接服务器发送数据***********/
    callFunc = 9;
    recWhat = 4;
    tcpLink();  //默认模式 0
}

//删除信息
void MainWindow::on_pushButton_3_delect_clicked()
{
    ui->pushButton_3_delect->setEnabled(false);
    /***********连接服务器发送数据***********/
    callFunc = 10;
    tcpLink();  //默认模式 0
}
//输入框变化
void MainWindow::on_lineEdit_3_findId_textChanged(const QString &arg1)
{
    ui->pushButton_3_delect->setEnabled(false);
}

//备份数据库
void MainWindow::on_pushButton_3_back_clicked()
{
    ui->pushButton_3_back->setEnabled(false);
    ui->progressBar_3_show->setValue(0);
    ui->progressBar_3_show->show();
    /***********连接服务器发送数据***********/
    callFunc = 11;
    recWhat = 5;
    tcpLink();  //默认模式 0

}
//按查找的名字
void MainWindow::on_pushButton_3_findName_clicked()
{
    ui->lineEdit_3_findId->setEnabled(true);
    QString txt = ui->pushButton_3_findName->text();
    if("查找id：" == txt)
    {
        ui->pushButton_3_findName->setText("查找name：");
        findWhat = "name";
    }
    else if("查找name：" == txt)
    {
        ui->pushButton_3_findName->setText("查找date：");
        findWhat = "time";
    }
    else if("查找date：" == txt)
    {
        ui->pushButton_3_findName->setText("查找all：");
        findWhat = "id";
//        ui->lineEdit_3_findId->setEnabled(false);
    }
//    else if("查找all：" == txt)
//    {
//        ui->pushButton_3_findName->setText("查找id：");
//        findWhat = "id";
//    }
}

//上传.sql 文件 并更新模块
void MainWindow::on_pushButton_3_Updata_clicked()
{
    QString filePath = QFileDialog::getOpenFileName(this, "open", "./");
    //如果路径有效
    if(false == filePath.isEmpty()){
        upDateFileName.clear(); // 上传文件名字
        upDateFileSize = 0;//文件大小
        sendSize = 0; // 发送文件的大小
        //获取信息
        QFileInfo info(filePath);
        upDateFileName = info.fileName();
        upDateFileSize = info.size();

        //打开文件
        fileTransport.setFileName(filePath);
        bool isOk = fileTransport.open(QIODevice::ReadOnly);
        if(false == isOk){
            qDebug() << "打开失败 62";
        }

        ui->textEdit_3_show->setText(filePath);

        ui->pushButton_3_Updata->setEnabled(false);
        ui->pushButton_3_back->setEnabled(false);
        ui->menuO->setEnabled(false);
        ui->pushButton_3_delect->setEnabled(false);
        ui->pushButton_3_find->setEnabled(false);
        ui->progressBar_3_show->setValue(0);
        ui->progressBar_3_show->show();

    }
    else{
        qDebug() << "选择文件路径出错 62";


    }


    /***********连接服务器发送数据***********/
    callFunc = 12;
    recWhat = 6;
    tcpLink();  //默认模式 0
}

 

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include "QTcpServer"
#include "QTcpSocket"
#include "QPaintEvent"

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();

    //初始化数据
    void initData();
    //初始化tcp
    void initTcp();
    //设置tcp连接
    bool tcpLink(int mode = 0);

    //发送数据给服务器
    void sendDataToServe();
    //处理接收的数据
    void dealReceiveData();
    //接收文件
    void recData();
    //处理接收的返回值检测
    void recCheck(QString check);
    //画图事件
    void paintEvent(QPaintEvent *);
    //显示文本
    QString showFile(QString fileName);
    //发送文件
    void sendDataFile();

signals:
    void connectSuccess();

private slots:
    //菜单显示事件
    void on_actionShow_triggered();

    void on_actionSave_triggered();

    void on_actionFind_triggered();

    void on_actionClose_triggered();  // 菜单退出

    //button事件
    void on_pushButtonSavefinger1_clicked(); //录指纹1

    void on_pushButtonConcel_clicked(); //取消录指纹

    void on_pushButtonSure_clicked(); //确定录取

    void on_pushButtonReg_clicked(); //登陆服务器

    void on_pushButtonClose_clicked(); //关闭窗口

    void on_pushButtonSavefinger2_clicked(); //录制指纹 2

    void on_pushButtoncheckfinger_clicked(); //检验两次录取准确度

    void on_pB_logoChangelink_clicked();  // 登陆界面改变link

    void on_pushButton_2_Start_clicked();  //申请资源

    void on_pushButton_1_get_clicked();   //获取日志

    void on_pushButton_1_show_clicked();  //显示日志

    void on_pushButton_3_find_clicked();  //查找人

    void on_lineEdit_3_findId_textChanged(const QString &arg1);

    void on_pushButton_3_delect_clicked(); //删除信息

    void on_pushButton_3_back_clicked(); //备份数据库

    void on_pushButton_3_findName_clicked();  // 更改查找选项

    void on_pushButton_3_Updata_clicked();  // 上传数据库

private:
    Ui::MainWindow *ui;

    //tcp套接字指针
    QTcpSocket *tcpSocket;
    QString ip;
    quint16 port;

    int showImage; //显示哪个界面
    bool isLoad; //是否登陆
    bool isChangeLink;
    int recWhat; //接收的什么数据
    bool isOccupy; //是否占用指纹资源
    /* *
     * 哪个函数发送的tcp请求
     * 1,登陆
     * */
    int callFunc;

    QString filePath; //文件路径
    QFile fileTransport;//文件对象
    QString fileName;//文件名字
    qint64 fileSize;//文件大小
    qint64 recvSize;//已经发送的文件的大小
    bool isStart;  //接收头文件
    bool showInfo; //接收完成后

    QString upDateFileName; // 上传文件名字
    qint64 upDateFileSize;//文件大小
    qint64 sendSize; // 发送文件的大小

    QString findWhat; //按什么查找数据库
};

#endif // MAINWINDOW_H

 

3.然后就是数据库储存了

 就是一些简单的mysql语句

#!/usr/local/opt/python-3.5.2/bin/python3.5
#-*- coding:utf8 -*-

import pymysql
import os, sys
import configparser

PATH = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(PATH)

from core import dealFile


class mySqlDeal:
    """数据库的操作"""
    def __init__(self, cmd=None, data=None, host="127.0.0.1", port=3306, user="root", passwd="123456", db="finger", table="test"):
        cf = configparser.ConfigParser()
        cf = dealFile.readConf(cf)
        host = cf.get("db", "db_host")
        port = cf.getint("db", "db_port")
        user = cf.get("db", "db_user")
        passwd = cf.get("db", "db_pwd")
        db = cf.get("db", "db_database")
        table = cf.get("db", "db_table")
        """初始化数据"""
        self.cmd = cmd
        self.data = data
        self.host = host
        self.port = port
        self.user = user
        self.passwd = passwd
        self.db = db
        self.table = table
        pass

    def link(self):
        """连接数据库"""
        self.conn = pymysql.connect(host=self.host, port=self.port, user=self.user, passwd=self.passwd, db=self.db)
        self.cursor = self.conn.cursor()
        pass

    def run(self, cmd=None, table=None):
        """执行cmd"""
        self.link()
        if hasattr(self, self.cmd):
            func = getattr(self, self.cmd)
            return func(data=self.data, table=self.table)
        self.endSql()
        return False, None

    def creatDatabase(self, data, table):
        """创建数据库"""
        pass

    def creatTable(self, data, table):
        """创建表"""
        pass

    def insertData(self, data, table):
        """插入数据到数据库"""
        if isinstance(data, dict) is not True:   # 判断data是不是字典类型
            return False, None
        # 拼接sql语句  执行
        sqlStr = "INSERT INTO {table} VALUES ('{num}', '{id}', '{name}', '{date}', '{finger}');"\
            .format(table=table, num=data['num'], id=data["id"], name=data["name"], date=data["date"], finger=data["finger"])
        self.cursor.execute(sqlStr)

        self.endSql()  # 结束sql
        return True, None
        pass

    def selectAll(self, data=None, table=None):
        """选择数据库中的数据  所有"""
        # 拼接sql语句  执行
        sqlStr = "SELECT * FROM {table};".format(table=table)
        self.cursor.execute(sqlStr)
        data = self.cursor.fetchall()   # 寻找所有数据

        self.endSql()   # 结束sql
        return True, data
        pass

    def selectData(self, data=None, table=None):
        """选择数据库中的数据"""
        # 拼接sql语句  执行
        data = data.split(":")
        sqlStr = "SELECT * FROM {table} WHERE {what}={find};".format(table=table, what=data[0], find=data[1])
        self.cursor.execute(sqlStr)
        data = self.cursor.fetchall()   # 寻找所有数据

        self.endSql()   # 结束sql
        return True, data
        pass

    def selectId(self, data, table):
        """
        :param data: 固定格式必须要  what:find
        :param table:
        :return:
        """
        # 拼接sql语句  执行
        data = data.split(":")
        if data[0] == "all":
            sqlStr = "SELECT id, name, time FROM {table};".format(table=table)
        else:
            sqlStr = "SELECT id, name, time FROM {table} WHERE {what} REGEXP '^{find}';"\
                .format(table=table, what=data[0], find=data[1])
        self.cursor.execute(sqlStr)
        data = self.cursor.fetchall()   # 寻找所有数据
        self.endSql()  # 结束sql
        if len(data) is 0:
            return False, None
        return True, data

    def selectNum(self, data, table):
        data = data.split(":")
        sqlStr = "SELECT num FROM {table} WHERE {what} REGEXP '^{find}';"\
            .format(table=table, what=data[0], find=data[1])
        self.cursor.execute(sqlStr)
        data = self.cursor.fetchall()  # 寻找所有数据
        self.endSql()  # 结束sql
        if len(data) is 0:
            return False, None
        return True, data
        pass

    def delectId(self, data, table):
        """
        :param data: 固定格式必须要  what:find
        :param table:
        :return:
        """
        # 拼接sql语句  执行
        data = data.split(":")
        if data[0] == "all":
            sqlStr = "DELETE FROM {table};".format(table=table)
        else:
            sqlStr = "DELETE FROM {table} WHERE {what} REGEXP '^{find}';".format(table=table, what=data[0], find=data[1])
        self.cursor.execute(sqlStr)
        self.endSql()  # 结束sql
        return True, None

    def endSql(self):

        """提交和关闭sql"""
        self.conn.commit()
        self.cursor.close()
        self.conn.close()

    pass


if __name__ == "__main__":
    # delectId
    # A = mySqlDeal("selectWhat", "name")
    A = mySqlDeal("selectId", "name:12")
    check, data = A.run()
    # print(check)
    # for i in data:
    #     print(i)
    print(check)
    print(data)

    pass

 

 4.可以用Pycharm远程调试树莓派啦

 网上有很多远程调试的例子，如果还是不会可以留言

首先用编写打卡的程序，用到树莓派GPIO口

# -*- coding:utf8 -*-

import RPi.GPIO as GPIO

import os,sys

PATH=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(PATH)
# import core
from core.dealSql import mySqlDeal
from core import dealFinger
# from core import clockIn
from core import dealFile
from core import oledshow
# from core import Tcpserver
import time

isOccupy = False

class ClockCheck:

    def __init__(self, queueOled, queueToTcp, queueToClock, queueIsNewSql):
        self.flage = False
        self.queueOled = queueOled
        self.queueToTcp = queueToTcp
        self.queueToClock = queueToClock
        self.queueIsNewSql = queueIsNewSql
        """初始化GPIO"""
        self.GPIO_Pin = 18
        GPIO.setmode(GPIO.BCM)
        GPIO.setwarnings(False)
        GPIO.setup(self.GPIO_Pin, GPIO.IN)
        """引入其他模块"""
        # self.mysql = mySqlDeal()
        self.myFinger = dealFinger.DealFinger()
        self.check = 0

        # check, self.data = self.mysql.run()
        pass

    def run(self):
        while True:
            """判断是否串口可用"""
            check = self.isOk()
            if check is not True:
                continue
            """获取数据库的值"""
            self.flage = True

            a = time.time()
            check = self.getChar()  # 判断是否获取成功
            if check is not True:
                print(check)
                self.release()
                continue
            """判断是否有指纹存在"""
            check = self.checkFinger(0)
            self.release()
            print(time.time() - a)
            if check is not True:
                print("ERROR")
                continue
            print("success!")
        pass

    def isOk(self):
        """判断是否串口可用"""
        if GPIO.input(self.GPIO_Pin) is GPIO.LOW:
            if self.queueIsNewSql.empty() is not True:  # 是否跟新数据
                self.queueIsNewSql.get()
                self.renewData()
            """判断是否有指纹按下"""
            if self.flage is True:
                self.flage = False
            return False
        """有指纹按下判断是否可抢占"""
        check = self.occupy()
        if check is not True:
            return False

        if self.check is 102:  # 清除没指纹意外
            self.check = 0
            self.flage = False
        if self.flage is not False:
            self.release()  # 释放
            return False
        return True
        pass

    def occupy(self):
        """抢占指纹资源"""
        global isOccupy
        if self.queueToClock.empty() is not True:
            isOccupy = self.queueToClock.get()

        if isOccupy is True:
            # print("occupyError")
            return False
        self.queueToTcp.put(1)
        return True
        pass

    def release(self):
        """释放指纹资源"""
        self.queueToTcp.put(0)

    def renewData(self):
        # check, self.data = self.mysql.run()
        # return check
        pass

    def checkFinger(self, data):
        """和数据库中的指纹匹配"""
        self.myFinger.link()
        check, buff = self.myFinger.checkPSIdentify()
        if check is True:
            """获取数据库中的相应值"""
            num = buff[1]*256 + buff[2]
            numStr = "num:%s" % num
            print(numStr)
            mysql = mySqlDeal("selectData", numStr)
            check, data = mysql.run()
            for i in data:
                fingerData = eval(i[4])
                fingerData = dealFinger.DealBuff(fingerData)
                fingerData = fingerData.write()
                check, score = self.myFinger.isFinger(fingerData)
                if check is True:
                    self.writeLog(i[1] + " " + i[2], "log.txt")
                    qDir ={
                        "check": True,
                        "id": i[1],
                        "name": i[2]
                    }
                    self.queueOled.put(qDir)
                    time.sleep(0.2)
                    return True
        print(check)
        qDir = {
            "check": False
        }
        self.queueOled.put(qDir)
        time.sleep(0.2)
        return False

    def writeLog(self, data, fileName):
        date = time.strftime("%Y-%m-%d %X  ")
        data = date + data + "\r\n\r\n"
        dealFile.textLog(data, fileName)
        pass

    def getChar(self):
        """获取现在按下的指纹的信息"""
        self.myFinger.link()
        check = self.myFinger.getImage()  # 检测获取图像
        if check is not True:
            self.check = check
            return check

        self.myFinger.link()
        check = self.myFinger.genChar("1")  # 检测生成特征值 放如模块1
        if check is not True:
            return check

        return True
    pass


if __name__ == "__main__":
    import core
    A = ClockCheck(core.qOledClock, core.qToTcpOccupy, core.qToClockOccupy, core.qIsNewSql)
    A.run()
    pass

 

当能够正常打卡后就需要在液晶屏上显示了

import time
import Adafruit_GPIO.SPI as SPI
import Adafruit_SSD1306
from PIL import Image, ImageDraw, ImageFont

import os, sys

PATH=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(PATH)

path = PATH + "/static/"

# 引脚配置，按照上面的接线来配置
RST = 17
DC = 27
# 因为连的是CE0，这里的PORT和DEVICE也设置为0
SPI_PORT = 0
SPI_DEVICE = 0
disp = Adafruit_SSD1306.SSD1306_128_64(rst=RST, dc=DC, spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE, max_speed_hz=8000000))
class Oled:
    """oled显示"""
    def __init__(self, queue):
        self.queue = queue
        # 根据自己的oled型号进行初始化，我的是128X64、SPI的oled，使用SSD1306_128_64初始化
        self.disp = disp
        self.disp.begin()
        self.disp.clear()
        self.disp.display()
        self.width = self.disp.width
        self.height = self.disp.height
        # image ，显示一些文字
        self.image = Image.new('1', (self.width, self.height))
        self.draw = ImageDraw.Draw(self.image)

        self.fontDate = ImageFont.truetype(path + "simsun.ttc", 16)
        self.fontTime = ImageFont.truetype(path + "EXEPixelPerfect.ttf", 50)
        self.fontNum = ImageFont.truetype(path + "EXEPixelPerfect.ttf", 35)
        self.fontName = ImageFont.truetype(path + "simsun.ttc", 28)
        pass

    def run(self):
        """显示界面"""
        while True:
            date = time.ctime()
            date = date.split(" ")
            num = len(date)   # 当日期小于10时  日期为" num"  大于10为"num"
            self.draw.text((0, 0), date[0], font=self.fontDate, fill=1)  # 星期几
            if num == 6:
                self.draw.text((80, 0), date[1] + " " + date[3], font=self.fontDate, fill=1)  # 月份
            else:
                self.draw.text((80, 0), date[1] + " " + date[2], font=self.fontDate, fill=1)  # 月份
            self.draw.text((0, 20), date[-2], font=self.fontTime, fill=1)    # 时间
            """显示"""
            self.disp.image(self.image)
            self.disp.display()
            """清屏"""
            self.draw.rectangle((0, 0, self.width, self.height), outline=0, fill=0)
            """显示"""
            self.showPeple()

            pass

    def showPeple(self):
        """显示人"""
        if self.queue.empty() is True:  # 没有人按
            # time.sleep(0.2)
            return
        data = self.queue.get()
        if data["check"] is False:    # 有人按匹配错误
            self.draw.text((15, 20), "ERROR", font=self.fontTime, fill=1)
            """显示"""
            self.disp.image(self.image)
            self.disp.display()
            """清屏"""
            self.draw.rectangle((0, 0, self.width, self.height), outline=0, fill=0)
            time.sleep(2)
            return
        self.draw.text((0, 0), data["id"], font=self.fontNum, fill=1)
        self.draw.text((25, 30), data["name"], font=self.fontName, fill=1)
        """显示"""
        self.disp.image(self.image)
        self.disp.display()
        """清屏"""
        self.draw.rectangle((0, 0, self.width, self.height), outline=0, fill=0)
        time.sleep(2)
        pass

    pass


if __name__ == "__main__":
    from multiprocessing import Queue
    q = Queue()
    A = Oled(q)
    A.run()

 

 

5.怎么实现物联呢

这就要用到公网平台了，应为我们都是“私网”，

刚开始想用yeelink的，但是发现好像没人维护用不了了，我就发现了“乐为物联”这个平台，操作简单

你首先得在上面注册一个用户，他上面有api的介绍，很容易看懂

再分享一波

我是想在微信上发送命令

# -*- coding:utf8 -*-

import configparser
from core import dealFile
from core import emailSendReceive

import optparse
import os, sys
import socket
import json,re
import time

PATH=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(PATH)

cf = configparser.ConfigParser()
cf = dealFile.readConf(cf)
ip = cf.get("lewei", "ip")
port = cf.getint("lewei", "port")
userKey = cf.get("lewei", "userKey")
gatewayNode = cf.get("lewei", "gatewayNode")


# ip = "tcp.lewei50.com"
# port = 9960
# userKey = "9701daf039574b199602b4958252dc19"
# gatewayNode = "02"

head = "&^!"

class ClientHandler():

    def __init__(self):

        self.bufsize = 1024
        # self.op = optparse.OptionParser()
        # option,args = self.op.parse_args()
        #
        # self.verify_args(option,args)
        self.connect()

    def verify_args(self,option,args):
        '启动命令处理'
        cmd = args[0]
        if hasattr(self,cmd):
            func = getattr(self,cmd)
            func()
        else:
            exit("No parameter")

    def connect(self):
        '连接网路'
        self.loadToServer()
        oldTime = time.time()
        while True:
            nowTime = time.time()
            if nowTime - oldTime > 40:
                oldTime = nowTime
                self.loadToServer()
            self.interactive()

    def interactive(self):
        self.rev_deal()

    def loadToServer(self):
        '发送数据登陆服务器'
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.sock.connect((ip, port))
        cmd={
            'method': "update",
            'gatewayNo': gatewayNode,
            'userkey': userKey
        }
        self.sendData(cmd)

    def rev_deal(self):
        '处理接收的数据做命令分类'
        """调用该命令时会调用该设备的API地址传递参数f=方法名，p1=参数1，p2=参数2......"""
        data = self.sock.recv(self.bufsize).decode("gbk")
        if data:
            print(data)
            data = re.split("[&^!]", data) # 去掉数据尾巴
            data = eval(data[0]) # 转换成字典
            self.data = data
            # print(data)
            if hasattr(self, data["f"]):
                func = getattr(self, data["f"])
                func()

    """=======================================  f = message  ==========================================="""
    def message(self):
        print("message")
        pass

    """=======================================  f = sendemail  ==========================================="""
    def sendEmail(self):
        data = str.lower(self.data["p1"])
        if data:
            if hasattr(self, data):
                func = getattr(self, data)
                func()
        self.sendSuccess()
        pass

    def getlog(self):
        """得到日志"""
        a = emailSendReceive.SendEmail()
        a.run(self.data["p1"])
        self.sendSuccess()
        pass

    def backlog(self):
        """备份日志"""
        backname = "log_{date}.txt".format(date=time.strftime("%Y.%m.%d.%X"))
        dealFile.backFile("log.txt", backname)
        pass

    def getlogall(self):
        """得到所有日志"""
        a = emailSendReceive.SendEmail()
        a.run(self.data["p1"])
        self.sendSuccess()
        pass

    def clean(self):
        """清除所有日志"""
        dealFile.cleanFile()  # 清除日志
        pass

    """=======================================  f = getAllSensors  ==========================================="""
    def getAllSensors(self):
        '上传传感器数据给服务器，让它知道传感器状态'
        data={
                 "method": "response",
                 "result":{
                     "successful": True,
                     "message": "xxxx",
                     "data":[{
                             "id": "POWER",
                             "value": 0
                         },
                         {
                             "id": "ledLight",
                             "value": 0
                         }
                     ]
                 }
        }  # 固定格式
        self.sendData(data)

    """=========================================  f = updateSensor  =============================================="""
    def updateSensor(self):
        '区分传感器标识'
        data = str.lower(self.data["p1"])
        if data:
            if hasattr(self, data):
                func = getattr(self, data)
                func()

    def power(self):
        '传感器power标识'
        if self.data["p2"] == "1":
            self.sendSuccess()
            # conf.LED_STATUS = 1
            print("open led")
        elif self.data["p2"] == "0":
            self.sendSuccess()
            # conf.LED_STATUS = 0
            print("close led")

    def ledlight(self):
        '传感器ledlignt标识'
        self.sendSuccess()
        # conf.LED_VALUE = self.data["p2"]
        print("led亮度为",self.data["p2"])

    def sendSuccess(self):
        '返回接收数据成功'
        data = {
            "method": "response",
            "result":
                {
                    "successful": True,
                    "message": "发送成功！"
                }
        }
        self.sendData(data)

    def sendData(self,data):
        data = json.dumps(data)
        data += head
        self.sock.send(data.encode("gbk"))



if __name__ == '__main__':
    ch = ClientHandler()
# cd F:\tmp\python_date1\myDevice\bin
# python tcp_client.py connect

 

 

如果你不想在注册或者嫌麻烦也可以通过邮箱来发送命令

邮箱的代码在下面

# -*- coding:utf8 -*-

import smtplib
from poplib import POP3_SSL
from email.parser import Parser
from email.header import Header
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from email.utils import formataddr

from core import dealFile
import time
import configparser
import os, sys
PATH = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))


cf = configparser.ConfigParser()
cf = dealFile.readConf(cf)

smtpServer = cf.get("email", "smtpServer")  # 发送请求服务
popServer = cf.get("email", "popServer")     # 接收请求服务

# smtpSrcAddr = "270176392@qq.com"    # 发送的源邮箱
# smtpSrcAddrPwd = "tromtljvidhgbibj"  # 发送源邮箱的请求码 密码
smtpSrcAddr = cf.get("email", "smtpSrcAddr")
smtpSrcAddrPwd = cf.get("email", "smtpSrcAddrPwd")

smtpDstAddr = cf.get("email", "smtpDstAddr")    # 发送的目的邮箱
smtpPort = cf.get("email", "smtpPort")



def sendEmailTxt(msg):
    """发送文本内容"""
    massage = MIMEText(msg, "plain", "utf8")
    return massage


def sendEmailFile(filename):
    """发送附件"""
    fileName = dealFile.getFilePath(filename)
    massage = MIMEText(open(fileName).read(), "base64", "utf8")
    massage['Content-Type'] = "application/octet-stream"
    massage['Content-Disposition'] = "attachment; filename = {name}".format(name=filename)
    return massage


class SendEmail:
    """发送邮件类"""
    def __init__(self):
        """初始化"""
        self.massage = MIMEMultipart()
        self.massage['From'] = formataddr(["实验室", smtpSrcAddr])
        self.massage['To'] = formataddr(["to", smtpDstAddr])
        self.massage['Subject'] = Header("回复邮件", "utf8")
        self.server = smtplib.SMTP_SSL(smtpServer, smtpPort)
        pass

    def run(self, cmd):
        """解析命令"""
        if isinstance(cmd, str):
            if hasattr(self, cmd):
                cmd = cmd.lower()
                func = getattr(self, cmd)
                func()
                self.login(self.massage)
            self.quit()
        elif isinstance(cmd, list):
            for i in cmd:
                if hasattr(self, i):
                    i = i.lower()
                    func = getattr(self, i)
                    func()
            if len(self.massage.get_payload())is 0:
                return self.quit()
            self.login(self.massage)
            self.quit()
    pass

    def getlog(self):
        """得到日志"""
        sendStr = "{date} 最新日志\r\n".format(date=time.strftime("%Y-%m-%d"))
        massage = sendEmailTxt(sendStr)
        self.massage.attach(massage)
        massage = sendEmailFile("log.txt")
        print(massage)
        self.massage.attach(massage)
        pass

    def backlog(self):
        """备份日志"""
        backname = "log_{date}.txt".format(date=time.strftime("%Y.%m.%d.%X"))
        dealFile.backFile("log.txt", backname)
        sendStr = "备份成功\r\n"
        massage = sendEmailTxt(sendStr)
        self.massage.attach(massage)
        pass

    def getlogall(self):
        """得到所有日志"""
        dealFile.joinFile()  # 拼接所有日志

        sendStr = "{date} 前的所有日志\r\n".format(date=time.strftime("%Y-%m-%d"))
        massage = sendEmailTxt(sendStr)
        self.massage.attach(massage)
        massage = sendEmailFile("logback.txt")
        print(massage)
        self.massage.attach(massage)
        pass

    def help(self):
        """帮助文档"""
        sendStr = "帮助文档！\r\n"
        massage = sendEmailTxt(sendStr)
        self.massage.attach(massage)
        massage = sendEmailFile("help.txt")
        print(massage)
        self.massage.attach(massage)
        pass

    def clean(self):
        """清除所有日志"""
        dealFile.cleanFile()   # 清除日志

        sendStr = "清除成功！\r\n"
        massage = sendEmailTxt(sendStr)
        self.massage.attach(massage)
        pass

    def login(self, msg):
        """登陆发送"""
        self.server.login(smtpSrcAddr, smtpSrcAddrPwd)
        self.server.sendmail(smtpSrcAddr, smtpDstAddr, msg.as_string())
        pass

    def quit(self):
        """退出"""
        self.server.quit()
        pass
    pass


class GetEmail:
    """获取邮件并解析"""
    def __init__(self):
        self.server = POP3_SSL(popServer)
        pass

    def run(self):

        self.login()
        cmd = self.getEmail()
        self.deleEmail()
        self.quit()
        return cmd

    def getEmail(self):
        """获取最新消息"""
        num, size = self.server.stat()
        if num > 0:
            resp, list, octets = self.server.retr(num)
            """分开list, 将信息变为emailMassger"""
            msg = b"\r\n".join(list).decode("utf8")
            msg = Parser().parsestr(msg)
            """解析出命令"""
            cmd = self.analyze(msg)
            try:
                cmd = cmd.split(",")
                return cmd
            except Exception as e:
                print(e)
        return False
        pass

    def deleEmail(self):
        num, size = self.server.stat()
        if num > 0:
            for i in range(num):
                self.server.dele(i+1)
        pass

    def analyze(self, msg):
        """解析出msg中的文本内"""
        if msg.is_multipart():
            print("is_multipart")
            parts = msg.get_payload()
            part = parts[0]    # 得到第一个
            content = part.get_payload(decode=True)
            charset = self.gussCharset(part)  # 得到编码格式
            if charset:
                content = content.decode(charset)
                return content
        else:
            print("is_not_multipart")
            content_type = msg.get_content_type()
            if content_type == 'text/plain' or content_type == 'text/html':
                content = msg.get_payload(decode=True)
                charset = self.gussCharset(msg)    # 得到编码格式
                if charset:
                    content = content.decode(charset)
                    return content
            else:
                print("Attachment.........................")
        pass

    def gussCharset(self, msg):
        """获取编码格式"""
        charset = msg.get_charset()
        if charset is None:
            content_type = msg.get("Content-Type", "").lower()
            pos = content_type.find("charset=")
            if pos > 0:
                charset = content_type[pos+8:]
            return charset
        pass

    def login(self):
        self.server.user(smtpSrcAddr)
        self.server.pass_(smtpSrcAddrPwd)
        pass

    def quit(self):
        self.server.quit()
        pass

    pass


if __name__ == "__main__":
    while True:
        A = GetEmail()
        cmd = A.run()
        print(cmd)
        time.sleep(10)
        if cmd is not False:
            B = SendEmail()
            B.run(cmd)
            time.sleep(10)
    pass

 

6.最后看看主程序把

 分别写两个脚本运行就好了

# -*- coding:utf8 -*-

import os,sys
import socketserver
import threading
import time
from multiprocessing import Process

PATH=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(PATH)

from core import Tcpserver
from core import clockIn
from core import oledshow
from core import emailSendReceive
from core import dealFile
import configparser
import core

def TCP():
    """tcp进程"""
    # check = threading.Thread(target=Tcpserver.checkOccupy)
    # check.start()
    cf = configparser.ConfigParser()
    cf = dealFile.readConf(cf)
    ip = cf.get("TCP", "ip")
    port = cf.getint("TCP", "port")
    ip_port = (ip, port)
    print("----等待连接.............")
    s = socketserver.ThreadingTCPServer(ip_port, Tcpserver.SeverHandle)
    s.serve_forever()
    pass


def CLOCK(queueOled, queueToTcp, queueToClock, queueIsNewSql):
    """检验进程"""
    gpio = clockIn.ClockCheck(queueOled, queueToTcp, queueToClock, queueIsNewSql)
    gpio.run()
    pass


def OLED(queue):
    """oled进程"""
    oled = oledshow.Oled(queue)
    oled.run()
    pass


def EMAIL():
    """邮件进程"""
    while True:
        A = emailSendReceive.GetEmail()
        cmd = A.run()
        print(cmd)
        time.sleep(10)
        if cmd is not False:
            B = emailSendReceive.SendEmail()
            B.run(cmd)
            time.sleep(10)


def main():
    # A = Process(target=TCP)
    # B = Process(target=EMAIL)
    C = threading.Thread(target=CLOCK, args=(core.qOledClock, core.qToTcpOccupy, core.qToClockOccupy, core.qIsNewSql))
    D = threading.Thread(target=OLED, args=(core.qOledClock,))

    # A.start()
    # B.start()
    C.start()
    D.start()
    # A.join()
    TCP()


if __name__ == "__main__":
    main()
    # TCP()

# -*- coding:utf8 -*-

from core import weChat

def main():
    a = weChat.ClientHandler()


if __name__ == "__main__":
    main()
    # TCP()

 逻辑结构图如下

 

 

 

 

 未经本人许可不得转载 谢谢！！！