|
|
import socket
|
|
|
import struct
|
|
|
import threading
|
|
|
import time
|
|
|
import logging
|
|
|
from collections import deque
|
|
|
|
|
|
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
|
|
|
|
|
|
class TCPCommunicator:
|
|
|
START_FLAG = b'\xF3\x12'
|
|
|
END_FLAG = b'\xF3\x14'
|
|
|
HEADER_SIZE = 10
|
|
|
|
|
|
# 命令类型
|
|
|
CMD_READ_AI = 1
|
|
|
CMD_WRITE_AO = 2
|
|
|
CMD_READ_DELTAT = 3
|
|
|
RESP_READ_AI = 11
|
|
|
RESP_WRITE_AO = 12
|
|
|
RESP_READ_DELTAT = 13
|
|
|
|
|
|
def __init__(self, host, port, reconnectInterval=3):
|
|
|
self.host = host
|
|
|
self.port = port
|
|
|
self.reconnectInterval = reconnectInterval
|
|
|
|
|
|
self.sock = None
|
|
|
self.connected = False
|
|
|
self.packetCounter = 0
|
|
|
self.lock = threading.Lock()
|
|
|
self.stopEvent = threading.Event()
|
|
|
|
|
|
# 回调函数
|
|
|
self.aiCallback = None
|
|
|
self.deltatCallback = None
|
|
|
self.aoCallback = None
|
|
|
|
|
|
# 响应等待机制
|
|
|
self.pending_responses = {}
|
|
|
self.response_lock = threading.Lock()
|
|
|
# 新增就绪状态标志
|
|
|
self.isReady = False # 服务器是否完全就绪
|
|
|
self.connect()
|
|
|
|
|
|
# 启动连接和接收线程
|
|
|
threading.Thread(target=self.connectThread, daemon=True).start()
|
|
|
threading.Thread(target=self.receiveThread, daemon=True).start()
|
|
|
|
|
|
def registerCallbacks(self, aiCallback=None, deltatCallback=None, aoCallback=None):
|
|
|
self.aiCallback = aiCallback
|
|
|
self.deltatCallback = deltatCallback
|
|
|
self.aoCallback = aoCallback
|
|
|
|
|
|
def connectThread(self):
|
|
|
while not self.stopEvent.is_set():
|
|
|
if not self.connected:
|
|
|
self.connect()
|
|
|
# 重连后执行就绪检查
|
|
|
time.sleep(0.5)
|
|
|
|
|
|
def connect(self):
|
|
|
try:
|
|
|
if self.sock:
|
|
|
self.sock.close()
|
|
|
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
|
|
self.sock.connect((self.host, self.port))
|
|
|
self.connected = True
|
|
|
self.packetCounter = 0
|
|
|
self.isReady = False # 重置就绪状态
|
|
|
|
|
|
# 连接后执行就绪检
|
|
|
|
|
|
logging.info(f"Connected to {self.host}:{self.port}")
|
|
|
return True
|
|
|
except Exception as e:
|
|
|
logging.error(f"Connection failed: {e}")
|
|
|
self.connected = False
|
|
|
time.sleep(self.reconnectInterval)
|
|
|
return False
|
|
|
|
|
|
|
|
|
def sendCommand(self, cmdType, data=None, skipReadyCheck=False):
|
|
|
# 增加就绪状态检查
|
|
|
|
|
|
# 增加连接状态检查，确保完全连接后再发送
|
|
|
if not self.connected or not self.sock:
|
|
|
print("Not connected")
|
|
|
if not self.connect():
|
|
|
return None
|
|
|
|
|
|
|
|
|
try:
|
|
|
with self.lock:
|
|
|
body = b''
|
|
|
if cmdType == self.CMD_WRITE_AO and data:
|
|
|
if len(data) != 36:
|
|
|
raise ValueError("AO data requires 36 elements")
|
|
|
body = struct.pack('<' + 'd'*36, *data)
|
|
|
elif cmdType == self.CMD_READ_AI or cmdType == self.CMD_READ_DELTAT:
|
|
|
body = struct.pack('<d', 0) # 占位数据
|
|
|
|
|
|
dataSize = len(body)
|
|
|
current_counter = self.packetCounter
|
|
|
header = struct.pack('>H I I', cmdType, dataSize, current_counter)
|
|
|
packet = self.START_FLAG + header + body + self.END_FLAG
|
|
|
|
|
|
# 创建等待事件
|
|
|
response_event = threading.Event()
|
|
|
with self.response_lock:
|
|
|
self.pending_responses[current_counter] = (cmdType, response_event, deque())
|
|
|
|
|
|
self.sock.sendall(packet)
|
|
|
self.packetCounter += 1
|
|
|
return current_counter
|
|
|
except Exception as e:
|
|
|
logging.error(f"Send error: {e}")
|
|
|
self.connected = False
|
|
|
return None
|
|
|
|
|
|
def waitForResponse(self, packetNum, expectedType, timeout=5):
|
|
|
"""等待指定packetNum的响应"""
|
|
|
try:
|
|
|
with self.response_lock:
|
|
|
if packetNum not in self.pending_responses:
|
|
|
logging.error(f"Invalid packetNum: {packetNum}")
|
|
|
return None
|
|
|
|
|
|
_, event, result_queue = self.pending_responses[packetNum]
|
|
|
|
|
|
# 等待响应或超时
|
|
|
if not event.wait(timeout):
|
|
|
logging.warning(f"Response timeout for packet {packetNum}")
|
|
|
return None
|
|
|
|
|
|
with self.response_lock:
|
|
|
# 检查结果是否有效
|
|
|
if not result_queue:
|
|
|
return None
|
|
|
|
|
|
result = result_queue.popleft()
|
|
|
# 验证响应类型
|
|
|
if result[0] != expectedType + 10: # 响应类型 = 命令类型 + 10
|
|
|
logging.error(f"Response type mismatch. Expected:{expectedType+10}, Got:{result[0]}")
|
|
|
return None
|
|
|
|
|
|
return result[1]
|
|
|
finally:
|
|
|
with self.response_lock:
|
|
|
if packetNum in self.pending_responses:
|
|
|
del self.pending_responses[packetNum]
|
|
|
|
|
|
def receiveThread(self):
|
|
|
buffer = b''
|
|
|
while not self.stopEvent.is_set():
|
|
|
try:
|
|
|
if not self.connected:
|
|
|
time.sleep(0.5)
|
|
|
continue
|
|
|
|
|
|
data = self.sock.recv(4096)
|
|
|
if not data:
|
|
|
self.connected = False
|
|
|
continue
|
|
|
|
|
|
buffer += data
|
|
|
|
|
|
while True:
|
|
|
startPos = buffer.find(self.START_FLAG)
|
|
|
if startPos == -1:
|
|
|
break
|
|
|
|
|
|
# 移除起始标志前的无效数据
|
|
|
if startPos > 0:
|
|
|
buffer = buffer[startPos:]
|
|
|
|
|
|
# 检查是否收到完整头部
|
|
|
if len(buffer) < len(self.START_FLAG) + self.HEADER_SIZE:
|
|
|
break
|
|
|
|
|
|
# 解析头部
|
|
|
header = buffer[len(self.START_FLAG):len(self.START_FLAG) + self.HEADER_SIZE]
|
|
|
dataType, dataSize, packetNum = struct.unpack('>H I I', header)
|
|
|
|
|
|
# 检查是否收到完整数据包
|
|
|
frameLen = len(self.START_FLAG) + self.HEADER_SIZE + dataSize + len(self.END_FLAG)
|
|
|
if len(buffer) < frameLen:
|
|
|
break
|
|
|
|
|
|
# 提取完整数据帧
|
|
|
fullFrame = buffer[:frameLen]
|
|
|
buffer = buffer[frameLen:]
|
|
|
|
|
|
# 验证结束标志
|
|
|
if fullFrame[-len(self.END_FLAG):] != self.END_FLAG:
|
|
|
logging.warning("Invalid end flag. Discarding packet.")
|
|
|
continue
|
|
|
|
|
|
# 处理数据包
|
|
|
body = fullFrame[len(self.START_FLAG) + self.HEADER_SIZE:-len(self.END_FLAG)]
|
|
|
self.processData(dataType, body, packetNum)
|
|
|
|
|
|
except Exception as e:
|
|
|
logging.error(f"Receive error: {e}")
|
|
|
self.connected = False
|
|
|
|
|
|
def processData(self, dataType, body, packetNum):
|
|
|
try:
|
|
|
result = None
|
|
|
# print(body, dataType)
|
|
|
# AI响应处理
|
|
|
if dataType == self.RESP_READ_AI:
|
|
|
# print(body)
|
|
|
if len(body) != 36000:
|
|
|
logging.error(f"Invalid AI response length: {len(body)}")
|
|
|
return
|
|
|
# print(1)
|
|
|
l = []
|
|
|
for i in range(9):
|
|
|
# print(i)
|
|
|
start_idx = i * 4000
|
|
|
#end_idx_ai = start_idx + 64
|
|
|
#end_idx_di = start_idx + 72
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# 解析8个AI值 (64字节)
|
|
|
ai_chunk = body[start_idx:start_idx + 8]
|
|
|
#print(ai_chunk)
|
|
|
if i == 8:
|
|
|
diValues = struct.unpack('<d', ai_chunk)[0]
|
|
|
# print(struct.unpack('<d', ai_chunk)[0])
|
|
|
diBools = [(int(diValues) >> j) & 1 for j in range(16)]
|
|
|
l.append(diBools)
|
|
|
else:
|
|
|
aiValues = struct.unpack('<d', ai_chunk)[0]
|
|
|
l.append(aiValues)
|
|
|
# 解析16个DI状态 (8字节)
|
|
|
#di_chunk = body[end_idx_ai:end_idx_di]
|
|
|
#di_double = struct.unpack('<d', di_chunk)[0]
|
|
|
# print(di_double)
|
|
|
#diBools = [(int(di_double) >> j) & 1 for j in range(16)]
|
|
|
|
|
|
# all_ai_values.append(ai_values)
|
|
|
# all_di_states.append(di_bools)
|
|
|
# print(l)
|
|
|
result = (l[0:8], l[8])
|
|
|
# print(result, 111)
|
|
|
if self.aiCallback:
|
|
|
self.aiCallback(result[0], result[1], packetNum)
|
|
|
|
|
|
# DeltaT响应处理
|
|
|
elif dataType == self.RESP_READ_DELTAT:
|
|
|
if len(body) != 128:
|
|
|
logging.error(f"Invalid DeltaT response length: {len(body)}")
|
|
|
return
|
|
|
#(body)
|
|
|
deltatValues = struct.unpack('<16Q', body)
|
|
|
result = deltatValues
|
|
|
if self.deltatCallback:
|
|
|
self.deltatCallback(deltatValues, packetNum)
|
|
|
|
|
|
# AO响应处理
|
|
|
elif dataType == self.RESP_WRITE_AO:
|
|
|
# print(len(body))
|
|
|
success = struct.unpack('<d', body)[0] == 0.0 if len(body)==8 else False
|
|
|
result = success
|
|
|
if self.aoCallback:
|
|
|
self.aoCallback(success, packetNum)
|
|
|
else:
|
|
|
logging.warning(f"Unknown response type: {dataType}")
|
|
|
return
|
|
|
|
|
|
# 唤醒等待线程
|
|
|
with self.response_lock:
|
|
|
if packetNum in self.pending_responses:
|
|
|
_, event, result_queue = self.pending_responses[packetNum]
|
|
|
result_queue.append((dataType, result))
|
|
|
event.set()
|
|
|
|
|
|
except Exception as e:
|
|
|
logging.error(f"Data processing error: {e}")
|
|
|
|
|
|
def readAIDI(self):
|
|
|
"""同步读取AI数据"""
|
|
|
packetNum = self.sendCommand(self.CMD_READ_AI)
|
|
|
if packetNum is None:
|
|
|
return None
|
|
|
return self.waitForResponse(packetNum, self.CMD_READ_AI) # 返回16通道AI和8通道DI
|
|
|
|
|
|
def readDeltaT(self):
|
|
|
"""同步读取DeltaT数据"""
|
|
|
packetNum = self.sendCommand(self.CMD_READ_DELTAT)
|
|
|
if packetNum is None:
|
|
|
return None
|
|
|
return self.waitForResponse(packetNum, self.CMD_READ_DELTAT)
|
|
|
|
|
|
def writeAo(self, aoData):
|
|
|
"""同步写入AO数据并返回结果"""
|
|
|
packetNum = self.sendCommand(self.CMD_WRITE_AO, aoData)
|
|
|
if packetNum is None:
|
|
|
return False
|
|
|
return self.waitForResponse(packetNum, self.CMD_WRITE_AO) or False
|
|
|
|
|
|
def shutdown(self):
|
|
|
self.stopEvent.set()
|
|
|
if self.sock:
|
|
|
self.sock.close()
|
|
|
|
|
|
# 唤醒所有等待线程
|
|
|
with self.response_lock:
|
|
|
for packetNum, (_, event, _) in list(self.pending_responses.items()):
|
|
|
event.set()
|
|
|
del self.pending_responses[packetNum]
|
|
|
|
|
|
logging.info("Communicator stopped")
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
import time
|
|
|
import logging
|
|
|
import threading
|
|
|
import random
|
|
|
# from procli import Box1Communicator # 导入前面修改的客户端类
|
|
|
|
|
|
# 配置日志
|
|
|
logging.basicConfig(
|
|
|
level=logging.INFO,
|
|
|
format='%(asctime)s - %(levelname)s - %(message)s',
|
|
|
handlers=[
|
|
|
logging.FileHandler("box1_client_test.log"),
|
|
|
logging.StreamHandler()
|
|
|
]
|
|
|
)
|
|
|
|
|
|
# 全局状态
|
|
|
class TestState:
|
|
|
running = True
|
|
|
read_count = 0
|
|
|
read_count_1 = 0
|
|
|
write_count = 0
|
|
|
last_ai = None
|
|
|
last_deltat = None
|
|
|
|
|
|
# 回调函数定义
|
|
|
def ai_callback(ai_values, di_states, packet_num):
|
|
|
TestState.last_ai = (ai_values, di_states)
|
|
|
TestState.read_count += 1
|
|
|
# if TestState.read_count % 10 == 0:
|
|
|
# logging.info(f"AI Callback - Packet {packet_num}: Received {TestState.read_count}th AI update")
|
|
|
logging.info(f" 读取到的AI: {ai_values}...")
|
|
|
logging.info(f" 读取到的DI: {di_states}...")
|
|
|
|
|
|
def deltat_callback(deltat_values, packet_num):
|
|
|
TestState.last_deltat = deltat_values
|
|
|
TestState.read_count_1 += 1
|
|
|
# if TestState.read_count_1 % 10 == 0:
|
|
|
# logging.info(f"DeltaT Callback - Packet {packet_num}: Received {TestState.read_count}th DeltaT update")
|
|
|
logging.info(f"读取到的delat: {deltat_values}...")
|
|
|
|
|
|
def ao_callback(success, packet_num):
|
|
|
TestState.write_count += 1
|
|
|
status = "SUCCESS" if success else "FAILED"
|
|
|
# if TestState.write_count % 10 == 0:
|
|
|
logging.info(f"写入AO成功 {packet_num}: Write {status} ({TestState.write_count}th write)")
|
|
|
|
|
|
def read_worker(communicator, interval):
|
|
|
"""循环读取数据的线程"""
|
|
|
while TestState.running:
|
|
|
try:
|
|
|
# 读取AI数据
|
|
|
communicator.readAIDI()
|
|
|
|
|
|
# 读取DeltaT数据
|
|
|
communicator.readDeltaT()
|
|
|
|
|
|
# 等待指定间隔
|
|
|
time.sleep(interval)
|
|
|
|
|
|
except Exception as e:
|
|
|
logging.error(f"Read worker error: {e}")
|
|
|
time.sleep(1)
|
|
|
|
|
|
def write_worker(communicator, interval):
|
|
|
"""循环写入数据的线程"""
|
|
|
ao_data = [0.0] * 36 # 初始AO数据
|
|
|
|
|
|
while TestState.running:
|
|
|
try:
|
|
|
# 修改：生成16个随机的DO状态（0或1）
|
|
|
do_states = [random.randint(0, 1) for _ in range(16)]
|
|
|
# 将16个DO状态转换为16位整数
|
|
|
do_value = 0
|
|
|
for i, state in enumerate(do_states):
|
|
|
do_value |= (state << i)
|
|
|
|
|
|
# 构建AO数据数组（包含16个DO状态）
|
|
|
ao_data = [
|
|
|
# 0-15: 16通道AO电流数据（A）
|
|
|
0.004, 0.005, 0.006, 0.007, 0.008, 0.009, 0.010, 0.011,
|
|
|
0.012, 0.013, 0.014, 0.015, 0.016, 0.017, 0.018, 0.019,
|
|
|
|
|
|
# 16: 输出模式（0：无输出/1：正常输出/2：触发输出）
|
|
|
1, # 正常输出
|
|
|
|
|
|
# 17: 触发类型（0:无输出 1：fpga触发/2：TC触发/3：RTD触发）
|
|
|
2, # TC触发
|
|
|
|
|
|
100, # 实验时间（ms）
|
|
|
# 18: 实验时间（ms）和 DO状态（U16转双精度）
|
|
|
float(do_value), # 将16位整数转换为双精度浮点数
|
|
|
|
|
|
# 19: DO状态已包含在上面的do_value中
|
|
|
|
|
|
# 20-27: 8通道TC数据（mV）
|
|
|
1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0,
|
|
|
|
|
|
# 28-35: 8通道RTD数据（Ω）
|
|
|
100.0, 200.0, 300.0, 400.0, 500.0, 600.0, 700.0, 800.0
|
|
|
]
|
|
|
|
|
|
# 写入AO数据
|
|
|
print(len(ao_data), ao_data)
|
|
|
communicator.writeAo(ao_data)
|
|
|
|
|
|
# 等待指定间隔
|
|
|
time.sleep(interval)
|
|
|
|
|
|
except Exception as e:
|
|
|
logging.error(f"Write worker error: {e}")
|
|
|
time.sleep(1)
|
|
|
|
|
|
|
|
|
def main():
|
|
|
# 创建通信器实例
|
|
|
# communicator = TCPCommunicator("192.168.1.50", 5055)
|
|
|
communicator = TCPCommunicator("127.0.0.1", 8000)
|
|
|
|
|
|
|
|
|
|
|
|
# 注册回调函数
|
|
|
communicator.registerCallbacks(
|
|
|
aiCallback=ai_callback,
|
|
|
deltatCallback=deltat_callback,
|
|
|
aoCallback=ao_callback
|
|
|
)
|
|
|
#for i in range(1000):
|
|
|
|
|
|
|
|
|
#communicator.readAIDI()
|
|
|
#time.sleep(0.5)
|
|
|
#ao_data = [0.004,0.005,0.006,0.007,0.008,0.009,0.010,0.011,0.012,0.013,0.014,0.015,0.016,0.017,0.018,0.019,2,1,200,255,1,2,3,4,5,6,7,8,100,200,300,400,500,600,700,800]
|
|
|
|
|
|
#communicator.writeAo(ao_data)
|
|
|
#time.sleep(2)
|
|
|
#communicator.readDeltaT()
|
|
|
#time.sleep(1)
|
|
|
#communicator.readDeltaT()
|
|
|
#
|
|
|
|
|
|
# 单步调试
|
|
|
|
|
|
# logging.info("Starting Box1 client test with continuous read/write...")
|
|
|
|
|
|
try:
|
|
|
# # 等待初始连接
|
|
|
time.sleep(1)
|
|
|
|
|
|
# # 启动读取线程 (每200ms读取一次)
|
|
|
read_thread = threading.Thread(target=read_worker, args=(communicator, 0.5), daemon=True)
|
|
|
read_thread.start()
|
|
|
|
|
|
# # 启动写入线程 (每500ms写入一次)
|
|
|
write_thread = threading.Thread(target=write_worker, args=(communicator, 0.5), daemon=True)
|
|
|
write_thread.start()
|
|
|
|
|
|
# # # 启动状态监控线程
|
|
|
# monitor_thread = threading.Thread(target=status_monitor, daemon=True)
|
|
|
# monitor_thread.start()
|
|
|
|
|
|
# # 主线程等待用户输入退出
|
|
|
logging.info("Continuous read/write test running. Press Enter to stop...")
|
|
|
input()
|
|
|
|
|
|
except KeyboardInterrupt:
|
|
|
logging.info("Test interrupted by user")
|
|
|
finally:
|
|
|
# 设置停止标志
|
|
|
TestState.running = False
|
|
|
|
|
|
# # 等待工作线程结束
|
|
|
# time.sleep(1)
|
|
|
|
|
|
# # 清理资源
|
|
|
#communicator.shutdown()
|
|
|
# logging.info("Test completed. Final stats:")
|
|
|
# logging.info(f"Total reads: {TestState.read_count}")
|
|
|
# logging.info(f"Total writes: {TestState.write_count}")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
|
main() |