DataNodeFrequencyTest1/DN101_NFC.py

from ctypes import *
import time

class Nfc_Reader(object):
    def __init__(self, nfc_dev):
        self.nfc_reader = nfc_dev
        # self.nfc_reader = serial.Serial("com6")
        self.dev_info = NFC_INFO()
        self.dev_conf = NFC_CONF()
        self.init_nfc_message()

        self.rfidm_c2_wpack = RFIDM_C2_WRITE_HEADER()
        self.rfidm_c2_rpack = RFIDM_C2_READ_HEADER()

        self.nfc_uuid = None

    def write_info(self, info_data):
        info_bytes = bytes(info_data) +b'\x00'

        ret = self.rfidm_c2_multi_write(0, 10, info_bytes)

        return ret

    def write_conf(self, conf_data):
        conf_bytes = bytes(conf_data) + bytes([0, 0, 0])
        print("配置信息", conf_bytes)
        ret1 = self.rfidm_c2_multi_write(16, 15, conf_bytes[:60])
        ret2 = self.rfidm_c2_multi_write(31, 15, conf_bytes[60:])

        return ret1&ret2

    def read_info(self):
        # info_pack = NFC_INFO()

        ret = self.rfidm_c2_multi_read(0,  10, timout=2)
        # print("nfc info:", str(ret))
        if ret:
            memmove(addressof(self.dev_info), ret, sizeof(self.dev_info))
            # self.dev_info_analysis()
            return True
        else:
            return False

    def read_conf(self):
        # conf_pack = NFC_CONF()

        ret1 = self.rfidm_c2_multi_read(16, 15, timout=2)
        ret2 = self.rfidm_c2_multi_read(31, 15, timout=2)
        # print("nfc info:", str(ret1), str(ret2))
        if ret1:
            if ret2:
                ret = ret1+ret2
                memmove(addressof(self.dev_conf), ret, sizeof(self.dev_conf))
                print("测点名称：", list(self.dev_conf.node_name))
                # self.dev_conf_analysis()
                return True

        return False

    def close(self):
        self.nfc_reader.close()

    def default(self):
        conf_file = open("conf.txt", 'r')

    def rfidm_c2_single_write(self, cmd, data):

        pass

    #自动搜索NFC标签
    def rfidm_c2_search(self):
        tagpack = RFIDM_C2_TAG_INFO_PACK()
        self.nfc_reader.timeout = 0.5
        self.nfc_reader.reset_output_buffer()
        self.nfc_reader.reset_input_buffer()

        self.nfc_reader.write([0x00, 0x00, 0x02, 0x11, 0x13]) #清查NFC
        ret = self.nfc_reader.read(14)
        print(ret)

        if len(ret)==14:
            memmove(addressof(tagpack), ret, sizeof(tagpack))
            self.nfc_uuid = tagpack.uuid
        else:
            self.nfc_uuid = False

    def rfidm_c2_conf(self):
        self.nfc_reader.write([0x00, 0x00, 0x03, 0x02, 0x01, 0x00]) #打开天线，关闭自动寻卡
        self.nfc_reader.write([0x00, 0x00 , 0x03 , 0x0C , 0x00 , 0x0F]) #打开主动输出卡ID

    def senser_unative(self): #将激活标志置零
        conf_data = bytes([0x00, 0x05, 0x00, 0x78])
        ret = self.rfidm_c2_multi_write(16, 1, conf_data)
        return ret

    def rfidm_c2_multi_write(self, block_index, block_count, wdata, timeout=2):
        wpack = self.rfidm_c2_multi_write_pack(block_index, block_count, wdata)

        self.nfc_reader.reset_input_buffer()
        self.nfc_reader.reset_output_buffer()

        self.nfc_reader.write(wpack)


        #检查返回的信息，是否写入成功
        retpack = RFIDM_C2_RET_PACK()
        ret = self.nfc_reader.read(sizeof(retpack))
        memmove(addressof(retpack), ret, sizeof(retpack))

        if retpack.sucess_flag == 0xE7:
            return False
        else:
            return True

    def rfidm_c2_multi_read(self, block_index, block_count, timout=0.5):
        read_info_cmd = self.rfidm_c2_multi_read_pack(block_index, block_count)

        self.nfc_reader.reset_input_buffer()
        self.nfc_reader.reset_output_buffer()
        self.nfc_reader.write(read_info_cmd)
        print("read info cmd:", [hex(data) for data in list(read_info_cmd)])
        self.nfc_reader.timeout = timout

        ret = self.nfc_reader.read(4*block_count+4)
        print(ret)
        if len(ret) == (4*block_count+4):
            return ret[3:-1]
        else:
            return None


    def rfidm_c2_single_read(self, cmd, retlen, timout=0.5):
        cmdpack = RFIDM_C2_WRITE_HEADER()
        cmdpack.adress = 0
        cmdpack.dlen = 0x02
        cmdpack.cmd = cmd

        crc = self.bcc_check(bytes(cmdpack)[2:-1])
        cmdpack.crc = crc

        self.nfc_reader.reset_input_buffer()
        self.nfc_reader.reset_output_buffer()

        self.nfc_reader.write(bytes(cmdpack))
        self.nfc_reader.timeout = 0.5
        ret = self.nfc_reader.read(retlen)

        if len(ret)==retlen:
            return ret
        else:
            print(ret)
            return None

    def get_uuid(self):
        tagpack = RFIDM_C2_TAG_INFO_PACK()

        ret = self.rfidm_c2_single_read(0x11, sizeof(tagpack)) #获取标签命令

        if ret:
            memmove(addressof(tagpack), ret, sizeof(tagpack))
            self.nfc_uuid = tagpack.uuid
        else:
            self.nfc_uuid = False

    def rfidm_c2_multi_write_pack(self, start_block, block_count, data):
        """
        写多个block 数据格式
        :param start_block: 起始块序号
        :param block_count: 一共要写的块
        :param data: 要写的数据
        :return: bytes格式数据包
        """
        mwrite_pack = RFIDM_C2_MULTI_WRITE_PACK()
        wpack = RFIDM_C2_WRITE_HEADER()

        wpack.address = 0
        wpack.dlen = sizeof(wpack) + sizeof(mwrite_pack) + len(data) - 3
        wpack.cmd = 0x24

        # memmove(addressof(mwrite_pack.uuid), self.nfc_uuid, sizeof(mwrite_pack.uuid))
        mwrite_pack.uuid = self.nfc_uuid
        mwrite_pack.flag = 0x22
        mwrite_pack.start_block = start_block
        mwrite_pack.block_len = block_count

        wdata = bytes(wpack)[:-1] + bytes(mwrite_pack)+data
        crc = self.bcc_check(wdata[2:])

        wpack.crc = crc

        wdata = bytes(wpack)[:-1] + bytes(mwrite_pack) + data + bytes(wpack)[-1:]

        return wdata

    def rfidm_c2_single_write_pack(self, block_index, data):
        """
        写入单个数据块
        :param block_index: 块序号
        :param data: 要写入的数据
        :return: bytes数据包
        """
        wpack = RFIDM_C2_SINGLE_WRITE_PACK()

        wpack.address = 0
        wpack.dlen = 0x10
        wpack.cmd  = 0x21

        # memmove(addressof(wpack.uuid), self.nfc_uuid, sizeof(wpack.uuid))
        wpack.uuid = self.nfc_uuid
        wpack.flag = 0x22
        wpack.block_index = block_index
        memmove(addressof(wpack.data), data, sizeof(wpack.data))

        crc = self.bcc_check(bytes(wpack[2:-1]))
        wpack.crc = crc

        return bytes(wpack)

    def rfidm_c2_multi_read_pack(self, block_index, block_count):
        rpack = RFIDM_C2_MULTI_READ_PACK()

        rpack.address = 0
        rpack.dlen = 0x0C
        rpack.cmd  = 0x23
        rpack.uuid = self.nfc_uuid

        rpack.block_index = block_index
        rpack.block_count = block_count

        crc = self.bcc_check(bytes(rpack)[2:-1])
        rpack.crc = crc

        return bytes(rpack)

    def rfidm_c2_single_read_pack(self, block_index):
        rpack = RFIDM_C2_SINGLE_READ_PACK()

        rpack.address = 0
        rpack.dlen = 0x0B
        rpack.cmd = 0x20

        memmove(addressof(rpack.uuid), self.nfc_uuid, sizeof(rpack.uuid))
        rpack.block_index = block_index

        crc = self.bcc_check(bytes(rpack[2:-1]))
        rpack.crc = crc

        return bytes(rpack)


    def bcc_check(self, data):
        bcc = 0
        for d in data:
            bcc = bcc^d

        return bcc

    def rfidm_c2_init(self):
        wpack = RFIDM_C2_CMD_PACK()
        wpack.address = 0
        wpack.dlen = 0x03
        wpack.cmd  = 0x02
        wpack.conf = 0x01
        wpack.crc  = 0x00

        self.nfc_reader.reset_input_buffer()
        self.nfc_reader.reset_output_buffer()
        self.nfc_reader.write(bytes(wpack))
        time.sleep(0.2)

        wpack.cmd = 0x0D
        wpack.conf = 0x01
        wpack.crc = 0x0F

        self.nfc_reader.reset_input_buffer()
        self.nfc_reader.reset_output_buffer()
        self.nfc_reader.write(bytes(wpack))
        time.sleep(0.2)

        wpack.cmd = 0x0E
        wpack.conf = 100
        wpack.crc = self.bcc_check(bytes(wpack)[2:-1])

        self.nfc_reader.reset_input_buffer()
        self.nfc_reader.reset_output_buffer()
        self.nfc_reader.write(bytes(wpack))
        time.sleep(0.2)

    def dev_info_analysis(self):
        self.dev_info_msg["初始化标志"] = self.dev_info.uInitFlag
        self.dev_info_msg["加速度传感器状态"] = self.dev_info.uAccSta
        self.dev_info_msg["Zigbee模块状态"] = self.dev_info.uZigbeeSta
        self.dev_info_msg["设备温度传感器状态"] = self.dev_info.uLowerTempSta
        self.dev_info_msg["环境温度传感器状态"] = self.dev_info.uUpperTempSta
        self.dev_info_msg["设备运行状态"] = self.dev_info.uRunningFlag
        self.dev_info_msg["MAC地址"] = hex(self.dev_info.zigbeeMac)[2:].zfill(16)
        self.dev_info_msg["硬件版本"] = self.dev_info.hwVersion/10
        self.dev_info_msg["软件版本"] = self.dev_info.sfVersion/10
        self.dev_info_msg["生产批号"] = self.dev_info.pn
        self.dev_info_msg["生产序列号"] = self.dev_info.sn
        self.dev_info_msg["首次上电日期"] = self.dev_info.sTime
        self.dev_info_msg["唤醒次数"] = self.dev_info.wakeupTimes
        self.dev_info_msg["特征值发送次数"] = self.dev_info.tzTimes
        self.dev_info_msg["原始波形发送次数"] = self.dev_info.wvTimes
        self.dev_info_msg["电池电压"] = self.dev_info.batVol
        self.dev_info_msg["产品型号"] = self.dev_info.productType
        self.dev_info_msg["无线信号强度"] = self.dev_info.rss
        print(bytes(self.dev_conf.node_name))

        try:
            self.dev_info_msg["测点名称"] = bytes(self.dev_conf.node_name).decode('GB18030')
        except:
            self.dev_info_msg["测点名称"] = "解析错误"

    def dev_conf_analysis(self):
        self.dev_conf_msg["配置标志"] = self.dev_conf.active_flag
        self.dev_conf_msg["唤醒周期"] = self.dev_conf.wakeup_period
        self.dev_conf_msg["原始波形发送周期"] = self.dev_conf.wave_period
        self.dev_conf_msg["Zigbee PID"] = hex(self.dev_conf.zig_panid)[2:]
        self.dev_conf_msg["Zigbee 信道"] = self.dev_conf.zig_channel
        # self.dev_conf_msg["Zigbee 本地地址"] = hex(self.dev_conf.zig_local_addr)[2:]
        self.dev_conf_msg["Zigbee 本地地址"] = format(int(hex(self.dev_conf.zig_local_addr), 16), '04x')
        self.dev_conf_msg["Zigbee 目标地址"] = hex(self.dev_conf.zig_dst_addr)[2:]
        self.dev_conf_msg["Zigbee 发射功率"] = self.dev_conf.zig_power_level
        self.dev_conf_msg["Zigbee 重试次数"] = self.dev_conf.zig_retry_num
        self.dev_conf_msg["Zigbee 重试间隔"] = self.dev_conf.zig_retry_time
        self.dev_conf_msg["ACC采样率"] = self.acc_freq_cal(self.dev_conf.acc_acq_freq)
        self.dev_conf_msg["ACC量程"] = self.acc_range_cal(self.dev_conf.acc_acq_range)
        self.dev_conf_msg["ACC采样率时间"] = self.dev_conf.acc_acq_time
        self.dev_conf_msg["频带能量参数1 START"] = self.dev_conf.freq_power1_start
        self.dev_conf_msg["频带能量参数1 END"] = self.dev_conf.freq_power1_stop
        self.dev_conf_msg["频带能量参数2 START"] = self.dev_conf.freq_power2_start
        self.dev_conf_msg["频带能量参数2 END"] = self.dev_conf.freq_power2_stop
        self.dev_conf_msg["频带能量参数3 START"] = self.dev_conf.freq_power3_start
        self.dev_conf_msg["频带能量参数3 END"] = self.dev_conf.freq_power3_stop
        self.dev_conf_msg["频带能量参数4 START"] = self.dev_conf.freq_power4_start
        self.dev_conf_msg["频带能量参数4 END"] = self.dev_conf.freq_power4_stop
        self.dev_conf_msg["频带能量参数5 START"] = self.dev_conf.freq_power5_start
        self.dev_conf_msg["频带能量参数5 END"] = self.dev_conf.freq_power5_stop
        self.dev_conf_msg["冲击带通频率START"] = self.dev_conf.envel_freq_start
        self.dev_conf_msg["冲击带通频率END"] = self.dev_conf.envel_freq_stop
        self.dev_conf_msg["故障频率1"] = self.dev_conf.fail_freq1
        self.dev_conf_msg["故障频率2"] = self.dev_conf.fail_freq2
        self.dev_conf_msg["故障频率3"] = self.dev_conf.fail_freq3
        self.dev_conf_msg["故障频率4"] = self.dev_conf.fail_freq4
        self.dev_conf_msg["配置时间"] = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(self.dev_conf.conf_date))
        self.dev_conf_msg["速度积分滤波频率"] = self.dev_conf.speed_freq_start


    def init_nfc_message(self):
        self.dev_info_msg = {"测点名称": None,
                             "初始化标志": None,
                             "加速度传感器状态": None,
                             "Zigbee模块状态": None,
                             "设备温度传感器状态": None,
                             "环境温度传感器状态": None,
                             "设备运行状态": None,
                             "MAC地址": None,
                             "硬件版本": None,
                             "软件版本": None,
                             "生产批号": None,
                             "生产序列号": None,
                             "首次上电日期": None,
                             "唤醒次数": None,
                             "特征值发送次数": None,
                             "原始波形发送次数": None,
                             "电池电压": None,
                             "产品型号": None,
                             "无线信号强度": None,
                             }

        self.dev_conf_msg = {"配置标志": None,
                             "唤醒周期": None,
                             "原始波形发送周期": None,
                             "Zigbee PID": None,
                             "Zigbee 信道": None,
                             "Zigbee 本地地址": None,
                             "Zigbee 目标地址": None,
                             "Zigbee 发射功率": None,
                             "Zigbee 重试次数": None,
                             "Zigbee 重试间隔": None,
                             "ACC采样率": None,
                             "ACC量程": None,
                             "ACC采样率时间": None,
                             "频带能量参数1 START": None,
                             "频带能量参数1 END": None,
                             "频带能量参数2 START": None,
                             "频带能量参数2 END": None,
                             "频带能量参数3 START": None,
                             "频带能量参数3 END": None,
                             "频带能量参数4 START": None,
                             "频带能量参数4 END": None,
                             "频带能量参数5 START": None,
                             "频带能量参数5 END": None,
                             "冲击带通频率START": None,
                             "冲击带通频率END": None,
                             "故障频率1": None,
                             "故障频率2": None,
                             "故障频率3": None,
                             "故障频率4": None,
                             "配置时间": None,
                             "速度积分滤波频率": None
                             }

    def acc_range_cal(self, sdata):
        if sdata == 0b00:
            return "±8g"
        elif sdata == 0b01:
            return "±16g"
        elif sdata == 0b10:
            return "±32g"
        elif sdata == 0b11:
            return "±64g"

    def acc_freq_cal(self, sdata):
        if sdata == 0b00:
            return "3.2kHz"
        elif sdata == 0b01:
            return "6.4kHz"
        elif sdata == 0b10:
            return "12.8kHz"
        elif sdata == 0b11:
            return "25.6kHz"

#传感器信息
class NFC_INFO(BigEndianStructure):
    _pack_ = 1
    _fields_ = [
        #设备状态标志
        ('uInitFlag', c_ubyte, 1),
        ('uAccSta', c_ubyte, 1),
        ('uZigbeeSta', c_ubyte, 1),
        ('uLowerTempSta', c_ubyte, 1),
        ('uUpperTempSta', c_ubyte, 1),
        ('uRunningFlag', c_ubyte, 1),

        ('zigbeeMac', c_uint64),   #Zigbee MAC地址
        ('hwVersion', c_uint8),     #硬件版本
        ('sfVersion', c_uint8),     #软件版本
        ('pn', c_uint32),          #批号
        ('sn', c_uint32),          #序列号
        ('sTime', c_uint32),       #首次上电时间
        ('wakeupTimes', c_uint32),  #唤醒次数
        ('tzTimes', c_uint32),      #特征值发送次数
        ('wvTimes', c_uint32),      #原始波形发送次数
        ('batVol', c_uint16),       #电池电压
        ('productType', c_uint8),   #产品型号
        ('rss', c_uint8),           #Zigbee信号强度
    ]


class NFC_CONF(BigEndianStructure):
    _pack_ = 1
    _fields_ = [
        ('active_flag', c_uint8),  # 激活标志
        ('wakeup_period', c_uint8),  # 唤醒周期
        ('wave_period', c_uint16),  # 原始波形发送周期
        ('zig_panid', c_uint16),  # zigbee panid
        ('zig_channel', c_uint8),  # zigbee channel
        ('zig_local_addr', c_uint16),  # zigbee本地地址
        ('zig_dst_addr', c_uint16),  # zigbee目标地址
        ('zig_power_level', c_uint8),  # zigbee发射功率
        ("zig_retry_num", c_uint8),  # 重试次数
        ("zig_retry_time", c_uint8),  # 重试间隔

        ("reserve", c_ubyte, 4),
        ("acc_acq_range", c_ubyte, 2),  # 量程
        ("acc_acq_freq", c_ubyte, 2),  # 采样率

        ("acc_acq_time", c_uint8),  # 采样时长

        ("freq_power1_start", c_uint16),  # 频带能量参数1
        ("freq_power1_stop", c_uint16),  # 频带能量参数1
        ("freq_power2_start", c_uint16),  # 频带能量参数2
        ("freq_power2_stop", c_uint16),  # 频带能量参数2
        ("freq_power3_start", c_uint16),  # 频带能量参数3
        ("freq_power3_stop", c_uint16),  # 频带能量参数3
        ("freq_power4_start", c_uint16),  # 频带能量参数4
        ("freq_power4_stop", c_uint16),  # 频带能量参数4
        ("freq_power5_start", c_uint16),  # 频带能量参数5
        ("freq_power5_stop", c_uint16),  # 频带能量参数5
        ("envel_freq_start", c_uint16),  # 包络带通频率
        ("envel_freq_stop", c_uint16),  # 包络带通频率
        ("fail_freq1", c_uint16),  # 故障频率1
        ("fail_freq2", c_uint16),  # 故障频率2
        ("fail_freq3", c_uint16),  # 故障频率3
        ("fail_freq4", c_uint16),  # 故障频率4
        ("conf_date", c_uint32),  # 配置时间
        ("speed_freq_start", c_uint8),  # 速度积分起始频率
        ("node_name", c_uint16*32),  # 节点名称
    ]


class RFIDM_C2_WRITE_HEADER(BigEndianStructure):
    _pack_ = 1
    _fields_ = [
        ('address', c_uint16),  # 模块地址
        ('dlen', c_uint8),  # 长度
        ('cmd', c_uint8),  # 命令
        ('crc', c_uint8)
    ]

class RFIDM_C2_READ_HEADER(BigEndianStructure):
    _pack_ = 1
    _fields_ = [
        ('cmd', c_uint8),  # 模块地址
        ('dlen', c_uint8),  # 长度
        ('flag', c_uint8),  # 命令
        ('crc', c_uint8)
    ]

class RFIDM_C2_MULTI_WRITE_PACK(BigEndianStructure):
    _pack_ = 1
    _fields_ = [
        ('uuid', c_uint64),  # UUID
        ('flag', c_uint8),  # 标志字节，固定值0x22
        ('start_block', c_uint8),  # 起始块号
        ('block_len', c_uint8), #块数
    ]


class RFIDM_C2_SINGLE_WRITE_PACK(BigEndianStructure):
    _pack_ = 1
    _fields_ = [
        ('address', c_uint16),  # 模块地址
        ('dlen', c_uint8),  # 长度0x10
        ('cmd', c_uint8),  # 命令 0x21
        ('uuid', c_uint64),  # UUID
        ('flag', c_uint8),  # 标志字节，固定值0x22
        ('block_index', c_uint8),  # 起始块号
        ('data', c_uint8*4),  # 写入的数据
        ('crc', c_uint8)
    ]

class RFIDM_C2_MULTI_READ_PACK(BigEndianStructure):
    _pack_ = 1
    _fields_ = [
        ('address', c_uint16),  # 模块地址
        ('dlen', c_uint8),  # 长度0x10
        ('cmd', c_uint8),  # 命令 0x21
        ('uuid', c_uint64),  # UUID
        ('block_index', c_uint8),  # 起始块号
        ('block_count', c_uint8),  # 块数
        ('crc', c_uint8)
    ]

class RFIDM_C2_SINGLE_READ_PACK(BigEndianStructure):
    _pack_ = 1
    _fields_ = [
        ('address', c_uint16),  # 模块地址
        ('dlen', c_uint8),  # 长度0x10
        ('cmd', c_uint8),  # 命令 0x21
        ('uuid', c_uint64),  # UUID
        ('block_index', c_uint8),  # 数据块号
        ('crc', c_uint8)
    ]

class RFIDM_C2_TAG_INFO_PACK(BigEndianStructure):
    _pack_ = 1
    _fields_ = [
        ('cmd', c_uint8),  # 命令头 0xFE
        ('dlen', c_uint8),  # 长度 0x0C
        ('sucess_flag', c_uint8),  # 成功:0x11, 失败0xE2
        ('flag', c_uint8),  # flag
        ('dsfid', c_uint8),  # DSFID信息
        ('uuid', c_uint64),  # UUID
        ('crc', c_uint8)
    ]

class RFIDM_C2_RET_PACK(BigEndianStructure):
    _pack_ = 1
    _fields_ = [
        ('cmd', c_uint8),  # 命令头 0xFE
        ('dlen', c_uint8),  # 长度 0x02
        ('sucess_flag', c_uint8),  # 成功:0x11, 失败0xE2
        ('crc', c_uint8)
    ]

class RFIDM_C2_CMD_PACK(BigEndianStructure):
    _pack_ = 1
    _fields_ = [
        ('address', c_uint16),  # 模块地址
        ('dlen', c_uint8),  # 长度
        ('cmd', c_uint8),  # 命令
        ('conf', c_uint8), # 设置
        ('crc', c_uint8)
    ]