import os

import time
import datetime
import socket
import numpy as np

max_file_size = 500 * 1024 * 1024 # 500MB

class Demo:

def __init__(self, ip, path, chn = 16):

self.ip = ip
self.path = path
self.chn = chn
self.header_hex = 'CDCDFBFB'

def _calc_crc16(self, hex_str):

data = bytearray.fromhex(hex_str)
crc = 0xFFFF
for pos in data:
crc ^= pos
for i in range(8):
if (crc & 1) != 0:
crc >>= 1
crc ^= 0xA001
else:
crc >>= 1
return hex(((crc & 0xFF) << 8) + (crc >> 8)).upper()

def _del_files(self, seconds = 600):

nd = datetime.datetime.now() - datetime.timedelta(seconds=seconds)
for _, _, files in os.walk(self.path):
for file in files:
if file.endswith(".txt") and
datetime.datetime.fromtimestamp(os.path.getctime(self.path+file)) < nd:
os.remove(self.path+file)

def connect(self):
self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# self.client_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# self.client_socket.setblocking(True)
# self.client_socket.settimeout(None)
try:
self.client_socket.connect((self.ip, 10003))
except socket.error as err:
print("this time can't connect daq")

def _start_daq(self, cmd="01"):

'''
0xFBFBCDCD 0x01 0x01 CRC-16-Modbus
'''
content = self.header_hex + cmd + "01"
body = content + self._calc_crc16(content)[2:]
print('start daq:', body)
self.client_socket.send(bytes.fromhex(body))

def _set_chn(self, cmd='00'):

'''
 0xFBFBCDCD 0x00 0xchn CRC-16-Modbus
'''
content = self.header_hex + cmd + '{:02x}'.format(self.chn)
body = content + self._calc_crc16(content)[2:]
print('get_data:', body)
self.client_socket.send(bytes.fromhex(body))

def get_data_write_file(self, aging_seconds = 0):

self._set_chn()
time.sleep(1)
self._start_daq()
time.sleep(1)

file_count = 1
file_size = 0
while True:
# 接收数据
data = self.client_socket.recv(1024*64)
if not data:
break

# 检查是否需要换文件
if file_size >= max_file_size:
file_count += 1
file_size = 0
if aging_seconds > 0:
self._del_files(aging_seconds)

# 写入数据到文件
with open(f"{self.path}ph_data_chn{self.chn}_{file_count}.txt", "ab")
as file:
file.write(data)
file_size += len(data)

def _frombytes(self, bytes_data):

data = np.frombuffer(bytes_data, dtype=np.int16)
data = data.astype(np.float32)
data = data / (0.5 / 4.1 * 65536.0) * 1040 + 25.0
# print(data, max(data), min(data))
return data

def parse_data_demo(self, header_hex = 'CDCDFBFB02', file_name =

'ph_data_chn16_1.txt', chn = 16):
chn_data = [np.array([]) for i in range(chn)]

with open(f"{self.path}{file_name}", "rb") as f:

header_data = ""
while header_hex.upper() not in header_data:
header = f.read(1024)
header_data = header.hex().upper()

split_data = header_data.split(header_hex)

seq = np.frombuffer(bytes.fromhex(split_data[1][:2]), dtype=np.int8)[0]

data_len = np.frombuffer(bytes.fromhex(split_data[1][2:6]),
dtype=np.int16)[0]
print(f'seq: {seq} data_len: {data_len}')
 bytes_data = bytes.fromhex(split_data[1][6:])
bytes_data += f.read(data_len - len(bytes_data))

data = self._frombytes(bytes_data)
chn_data[0] = np.concatenate((chn_data[0], data))

for i in range(1, 16):

data = self._frombytes(f.read(data_len))
chn_data[i] = np.concatenate((chn_data[i], data))

cnt = 0
while cnt < 500:
head = f.read(len(header_hex) // 2).hex().upper()
if head != header_hex:
break

seq = np.frombuffer(f.read(1), dtype=np.int8)[0]

data_len = np.frombuffer(f.read(2), dtype=np.int16)[0]

# print(f'seq: {seq} data_len: {data_len}')

for i in range(16):
data = self._frombytes(f.read(data_len))
chn_data[i] = np.concatenate((chn_data[i], data))

cnt += 1
return chn_data

chn = 16
ip = "192.168.4.100"
path = ".\\"

demo = Demo(ip, path, chn)

# demo.connect()
# demo.get_data_write_file(aging_seconds=600)

import matplotlib.pyplot as plt

data = demo.parse_data_demo(file_name = "ph_data_chn16_3.txt", chn=chn)
print(len(data))
show_data = data[8]
print(f'max: {max(show_data)} min: {min(show_data)}')
plt.plot(np.array(range(len(show_data))), show_data)
plt.show()