Skip to content

V
vue_django_test
Commit f587727f by qianmo
Options

Merge remote-tracking branch 'origin/main'

parents ccd943a1 1ba96316
Showing with 2801 additions and 0 deletions
frontend/src/components/home/DevicePerformanceTabel.vue
...@@ -5,6 +5,13 @@ ...@@ -5,6 +5,13 @@
<p>{{ props.devName }}</p> <p>{{ props.devName }}</p>
</div> </div>
<div class="float-right"> <div class="float-right">
<el-switch
v-if="props.type === '2'"
v-model="openSimulateDevice"
@change="changeSimulateDevice"
class="mr-4"
style="--el-switch-on-color: #13ce66; --el-switch-off-color: #ff4949"
/>
<el-button type="danger" size="small" class="mr-4" @click="del" :icon="Delete" circle /> <el-button type="danger" size="small" class="mr-4" @click="del" :icon="Delete" circle />
</div> </div>
</div> </div>
...@@ -18,6 +25,7 @@ ...@@ -18,6 +25,7 @@
<script setup lang="ts"> <script setup lang="ts">
import { ref, onMounted, onBeforeUnmount } from 'vue' import { ref, onMounted, onBeforeUnmount } from 'vue'
import { Delete } from '@element-plus/icons-vue' import { Delete } from '@element-plus/icons-vue'
import request from '@/plugins/axios/requests';
import axios from 'axios'; import axios from 'axios';
type propsType = { type propsType = {
...@@ -72,4 +80,21 @@ onBeforeUnmount(() => { ...@@ -72,4 +80,21 @@ onBeforeUnmount(() => {
table_websocket?.close() table_websocket?.close()
}) })
const openSimulateDevice = ref<boolean>(false)
const changeSimulateDevice = () => {
let body = {
protocol_name: props.protocolName,
status: openSimulateDevice.value,
device_name: props.devName
}
console.log(body);
request.post('/api/change_simulate_device/', body)
.then((res) => {
console.log(res);
})
.catch((err) => {
console.log(err);
})
}
</script> </script>
simulate_device_manager/admin.py 0 → 100644
from django.contrib import admin
# Register your models here.
simulate_device_manager/apps.py 0 → 100644
from django.apps import AppConfig
class ManageSimulateDeviceConfig(AppConfig):
default_auto_field = 'django.db.models.BigAutoField'
name = 'simulate_device_manager'
simulate_device_manager/device_manager.py 0 → 100644
import os
import subprocess
import signal
from subprocess import CompletedProcess
from django.dispatch import Signal, receiver
# 用于存储模拟设备的进程
# str: device_name -> CompletedProcess
SIMULATE_DEVICE_PROCESS: dict[str, CompletedProcess] = {}
start_signal = Signal(providing_args=['protocol_name', 'device_name', 'port'])
stop_signal = Signal(providing_args=['device_name'])
@receiver(start_signal)
def start_signal_callback(sender, **kwargs):
"""
处理启动模拟设备的信号
"""
protocol_name = kwargs.get('protocol_name')
device_name = kwargs.get('device_name')
device_port = kwargs.get('port')
assert protocol_name is not None, 'protocol_name is None'
assert device_name is not None, 'device_name is None'
assert device_port is not None, 'device_port is None'
process = subprocess.Popen(['python',
f'./simulate_device_manager/simulate_devices/{protocol_name}.py',
f'{device_port}'],
preexec_fn=os.setsid)
SIMULATE_DEVICE_PROCESS[device_name] = process
@receiver(stop_signal)
def stop_signal_callback(sender, **kwargs):
"""
处理关闭模拟设备的信号
"""
device_name = kwargs.get('device_name')
assert device_name is not None, 'device_name is None'
process = SIMULATE_DEVICE_PROCESS.get(device_name)
if process.poll() is None:
os.killpg(process.pid, signal.SIGTERM)
del SIMULATE_DEVICE_PROCESS[device_name]
simulate_device_manager/simulate_devices/FSR-4WeatherStation_hyds.py 0 → 100644
# -*- coding:utf-8 -*-
from pickletools import pyinteger_or_bool
import socket
import sys
import time
import re
import threading
import datetime
import sys
import configparser
import signal
# 定义回调函数
def myHandler(signum, frame):
print("接收信号为：", signum)
exit(0)
# 等待接收 signal.SIGTERM命令
signal.signal(signal.SIGTERM, myHandler)
argv = sys.argv[1:]
tcp_port = int(argv[0])
map_work_status_lock = threading.Lock() # 锁的声明
"""字典 数据存放的map 使用锁进行读写访问"""
map_work_status = {
"CMDS":"#00EF030C","TIME":"221013170133","Radiation1DailyAccumu":"0001","Radiation2DailyAccumu":"0002",\
"GroundTem1":"0003","GroundTem2":"0004","GroundTem3":"0005","GroundTem4":"0006","GroundTem5":"0007","AmbientTem":"0008",\
"Circumhumidity":"0009","DewPoint":"000A", "Pressure":"000B","Altitude":"000C","WindSpeed":"000D","WindSpeed2MinAverage":"000E" ,\
"WindSpeed10MinAverage":"000F","WindDirection":"0010","Radiation1":"0011","Radiation2":"0012","SoilWetness":"0013","BatteryVoltage":"0014",\
"DailyAccumulatedRainfall":"0015","visibility":"0016","visibility10MinAverage":"0017","SunshineHourDailyAccumu":"0018","CO2":"0019",\
"ElectronicCompass":"0020","END":"GG"\
}
"""字段中文名"""
map_name_chg = {
"CMDS":"报文头","TIME":"时间","Radiation1DailyAccumu":"辐射1 日累计","Radiation2DailyAccumu":"辐射2 日累计",\
"GroundTem1":"地温1","GroundTem2":"地温2","GroundTem3":"地温3","GroundTem4": "地温4","GroundTem5":"地温5",\
"AmbientTem":"环温","Circumhumidity": "环湿","DewPoint": "露点" ,"Pressure": "气压","Altitude" : "海拨",\
"WindSpeed":"风速","WindSpeed2MinAverage":"2分钟平均风速" ,"WindSpeed10MinAverage": "10分钟平均风速",\
"WindDirection" : "风向","Radiation1" :" 辐射1","Radiation2":"辐射2","SoilWetness": "土湿",\
"BatteryVoltage" : "电池电压","DailyAccumulatedRainfall": "雨量日累计","visibility" :"能见度",\
"visibility10MinAverage" : "能见度10分钟平均","SunshineHourDailyAccumu" : "日照时日累计","CO2": "CO2浓度","ElectronicCompass" : "电子罗盘","END" : "END"\
}
tem_packet_str = "$"
for key in map_work_status:
tem_packet_str = tem_packet_str + map_work_status[key]
tem_packet_str = tem_packet_str + "\r\n"
print("初始化数据：" + tem_packet_str)
# mesage1="$,111.84,063.28,143.53,56.01,W,200,155,000,008,055,0,1,121,123,1,0,0,0,+1.23,-4.56\r\n"
# print(mesage1)
config = configparser.ConfigParser() # 类实例化
# 定义ini文件路径 这个文件用于存放 天控器当前的报警状态
path = r"acu7m5_hyds.ini"
tcpServer_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 1创建socket对象
tcpServer_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
tcpServer_socket.bind(("0.0.0.0", tcp_port)) # 2，需要自己绑定一个ip地址和端口号
tcpServer_socket.listen(1) # 可以同时监听3个，但是这里只有一个因为没有写多线程
client_socket, addr = tcpServer_socket.accept() # 阻塞 是服务端的socket对象clientServer_socket是接入的客户端socket对象
print(addr)
TCP_LINK_STATUS = 1 # TCP 连接标志位
def precision0001(key):
return str(round(int(key,16)* 0.001, 3))
def precison01(key):
return str(round((int(key, 16) * 0.1), 1))
def precision1(key):
return str(int(key, 16))
def downp(key):
# map_work_status[key]=int("FFFF",16)-int(key,16)+1
# return str(-map_work_status[key])
if(int(key, 16)>0x7fff):
return '-'+str(int("FFFF",16)-int(key,16)+1)
else:
return str((int(key, 16)))
def downp001(key):
if(int(key, 16)>0x7fff):
return '-'+str((int("FFFF", 16) - int(key, 16) + 1)*0.01)
else:
return str((int(key, 16))*0.01)
"""定时读取 map_work_status 发布设备状态报文 间隔200ms"""
def SendStatusHandle():
global client_socket
C_MDS= "#00EF030C"
T_IME = "221013170133"
cont = 0
cont_print = 0
max_cont = 10000
while 1:
# print(time.time())
map_work_status_lock.acquire() # 上锁
map_work_status["CMDS"] =C_MDS
map_work_status["TIME"] = T_IME
tem_packet_str = ""
tem_status_str = ""
#完成十六进制到十进制的转化
#tem_status_str=tem_status_str+map_name_chg[key]+" : "+map_work_status[key]+"\r\n"
tem_packet_str= tem_packet_str+map_work_status["CMDS"]
tem_status_str = tem_status_str + map_name_chg["CMDS"] + " : " + tem_packet_str[0:11] + "\r\n"
tem_packet_str =tem_packet_str + map_work_status["TIME"]
tem_status_str = tem_status_str + map_name_chg["TIME"] + " : " + tem_packet_str[12:25] + "\r\n"
tem_packet_str = tem_packet_str + map_work_status["Radiation1DailyAccumu"]
tem_status_str = tem_status_str + map_name_chg["Radiation1DailyAccumu"] + " : " + precision0001(map_work_status["Radiation1DailyAccumu"]) + "MJ/m²"+ "\r\n"
tem_packet_str = tem_packet_str + map_work_status["Radiation2DailyAccumu"]
tem_status_str = tem_status_str + map_name_chg["Radiation2DailyAccumu"] + " : " +precision0001(map_work_status["Radiation2DailyAccumu"]) + "MJ/m²" + "\r\n"
tem_packet_str = tem_packet_str + map_work_status["GroundTem1"]
tem_status_str = tem_status_str + map_name_chg["GroundTem1"] + " : " + precison01( map_work_status["GroundTem1"] )+ "°C"+ "\r\n"
tem_packet_str = tem_packet_str + map_work_status["GroundTem2"]
tem_status_str = tem_status_str + map_name_chg["GroundTem2"] + " : " + precison01( map_work_status["GroundTem2"] )+ "°C" + "\r\n"
tem_packet_str = tem_packet_str + map_work_status["GroundTem3"]
tem_status_str = tem_status_str + map_name_chg["GroundTem3"] + " : " +precison01( map_work_status["GroundTem3"] )+ "°C" + "\r\n"
tem_packet_str = tem_packet_str + map_work_status["GroundTem4"]
tem_status_str = tem_status_str + map_name_chg["GroundTem4"] + " : " + precison01( map_work_status["GroundTem4"] )+ "°C" + "\r\n"
tem_packet_str = tem_packet_str + map_work_status["GroundTem5"]
tem_status_str = tem_status_str + map_name_chg["GroundTem5"] + " : " + precison01( map_work_status["GroundTem5"] )+ "°C"+ "\r\n"
tem_packet_str = tem_packet_str + map_work_status["AmbientTem"]
tem_status_str = tem_status_str + map_name_chg["AmbientTem"] + " : " +precison01( map_work_status["AmbientTem"] )+ "°C" + "\r\n"
tem_packet_str = tem_packet_str + map_work_status["Circumhumidity"]
tem_status_str = tem_status_str + map_name_chg["Circumhumidity"] + " : " + precison01( map_work_status["Circumhumidity"] )+ "%RH"+ "\r\n"
tem_packet_str = tem_packet_str + map_work_status["DewPoint"]
tem_status_str = tem_status_str + map_name_chg["DewPoint"] + " : " + downp001( map_work_status["DewPoint"] ) + "°C"+ "\r\n"
tem_packet_str = tem_packet_str + map_work_status["Pressure"]
tem_status_str = tem_status_str + map_name_chg["Pressure"] + " : " +precison01( map_work_status["Pressure"] ) + "hPa"+ "\r\n"
tem_packet_str = tem_packet_str + map_work_status["Altitude"]
tem_status_str = tem_status_str + map_name_chg["Altitude"] + " : " + downp(map_work_status["Altitude"] ) + "m"+ "\r\n"
tem_packet_str = tem_packet_str + map_work_status["WindSpeed"]
tem_status_str = tem_status_str + map_name_chg["WindSpeed"] + " : " + precison01(map_work_status["WindSpeed"] ) + "hPa" + "\r\n"
tem_packet_str = tem_packet_str + map_work_status["WindSpeed2MinAverage"]
tem_status_str = tem_status_str + map_name_chg["WindSpeed2MinAverage"] + " : " + precison01(map_work_status["WindSpeed2MinAverage"]) + "m/s" + "\r\n"
tem_packet_str = tem_packet_str + map_work_status["WindSpeed10MinAverage"]
tem_status_str = tem_status_str + map_name_chg["WindSpeed10MinAverage"] + " : " + precison01(map_work_status["WindSpeed10MinAverage"]) + "m/s" + "\r\n"
tem_packet_str = tem_packet_str + map_work_status["WindDirection"]
tem_status_str = tem_status_str + map_name_chg["WindDirection"] + " : " + precision1( map_work_status["WindDirection"]) + "°" + "\r\n"
tem_packet_str = tem_packet_str + map_work_status["Radiation1"]
tem_status_str = tem_status_str + map_name_chg["Radiation1"] + " : " + precision1( map_work_status["Radiation1"]) + "w/m²" + "\r\n"
tem_packet_str = tem_packet_str + map_work_status["Radiation2"]
tem_status_str = tem_status_str + map_name_chg["Radiation2"] + " : " +precision1(map_work_status["Radiation2"]) + "w/m²" + "\r\n"
tem_packet_str = tem_packet_str + map_work_status["SoilWetness"]
tem_status_str = tem_status_str + map_name_chg["SoilWetness"] + " : " + precison01(map_work_status["SoilWetness"]) + "%m³/m³"+ "\r\n"
tem_packet_str = tem_packet_str + map_work_status["BatteryVoltage"]
tem_status_str = tem_status_str + map_name_chg["BatteryVoltage"] + " : " + precison01( map_work_status["BatteryVoltage"]) + "V" + "\r\n"
tem_packet_str = tem_packet_str + map_work_status["DailyAccumulatedRainfall"]
tem_status_str = tem_status_str + map_name_chg["DailyAccumulatedRainfall"] + " : " + precison01(map_work_status["DailyAccumulatedRainfall"]) + "mm"+ "\r\n"
tem_packet_str = tem_packet_str + map_work_status["visibility"]
tem_status_str = tem_status_str + map_name_chg["visibility"] + " : " + precision1(map_work_status["visibility"]) + "m" + "\r\n"
tem_packet_str = tem_packet_str + map_work_status["visibility10MinAverage"]
tem_status_str = tem_status_str + map_name_chg["visibility10MinAverage"] + " : " +precision1( map_work_status["visibility10MinAverage"]) + "m" + "\r\n"
tem_packet_str = tem_packet_str + map_work_status["SunshineHourDailyAccumu"]
tem_status_str = tem_status_str + map_name_chg["SunshineHourDailyAccumu"] + " : " + precision1(map_work_status["SunshineHourDailyAccumu"]) + "分钟"+ "\r\n"
tem_packet_str = tem_packet_str + map_work_status["CO2"]
tem_status_str = tem_status_str + map_name_chg["CO2"] + " : " + precison01(map_work_status["CO2"]) + "ppm" + "\r\n"
tem_packet_str = tem_packet_str + map_work_status["ElectronicCompass"]
tem_status_str = tem_status_str + map_name_chg["ElectronicCompass"] + " : " +precision1(map_work_status["ElectronicCompass"]) + "°" + "\r\n"
tem_packet_str = tem_packet_str + map_work_status["END"]
tem_status_str = tem_status_str + map_name_chg["END"] + " : " +map_work_status["END"] + "\r\n"
if (TCP_LINK_STATUS != 0):
max_cont = max_cont - 1
client_socket.send(tem_packet_str.encode("utf-8"))
# print(tem_packet_str)
map_work_status_lock.release() # 解锁
# print(time.time())
# cont = cont + 1
for key in map_work_status:
# print( map_work_status[key])
# print(str(hex(cont_print)[2:].zfill(4)))
if(key != "CMDS" and key != "TIME" and key != "END"):
map_work_status[key]=str(hex(cont_print)[2:].zfill(4))
# if (cont > 5 and TCP_LINK_STATUS):
cont_print = cont_print + 1
print("=============== 打印当前模拟设备状态 ================= ", cont_print)
print(tem_status_str)
time.sleep(1)
def RecvSetCMDHandle():
print("线程2")
global TCP_LINK_STATUS
global client_socket
while 1:
data = client_socket.recv(1024)
rec_str = data.decode()
if (len(data) > 0):
print("收到未知报文 : " + rec_str)
else:
TCP_LINK_STATUS = 0
print("连接断开，等待接入")
client_socket.close()
client_socket, addr = tcpServer_socket.accept() # 阻塞 s是服务端的socket对象clientServer_socket是接入的客户端socket对象
TCP_LINK_STATUS = 1
print(addr)
cont = 0
time.sleep(1)
""" 一个模拟接收端，收到设置类型的指令后，修改map_work_status。"""
if __name__ == "__main__":
tr1 = threading.Thread(target=SendStatusHandle)
tr2 = threading.Thread(target=RecvSetCMDHandle)
tr1.start()
tr2.start()
simulate_device_manager/simulate_devices/HWF0357FC_hyds.py 0 → 100644
from pickletools import pyinteger_or_bool
import socket
import sys
import time
import re
import threading
import datetime
import sys
import configparser
import signal
#模拟下变频器设备 S/720 L/720
# 定义回调函数
def myHandler(signum, frame):
print("接收信号为：", signum)
exit(0)
# 等待接收 signal.SIGTERM命令
signal.signal(signal.SIGTERM, myHandler)
argv = sys.argv[1:]
tcp_port = int(argv[0])
map_work_status_lock = threading.Lock() # 锁的声明
"""字典 数据存放的map 使用锁进行读写访问"""
map_work_status = {"InputFrequency": "02200.000",\
"Attenuation": "40.00",\
"RFSignalSwitch": "ON",\
"LOState": "LOCK",\
"Current": "0.22",\
"TEM": "+25",\
"EXT": "NO",\
"ControlState": "ON",\
"ChannelStatus": "OK"\
}
"""字段中文名"""
map_name_chg = {"InputFrequency": "输入频率",\
"Attenuation": "衰减",\
"RFSignalSwitch": "射频信号开关",\
"LOState": "本振状态",\
"Current": "电源电流",\
"TEM": "温度",\
"EXT": "外参考输入",\
"ControlState": "控制状态",\
"ChannelStatus": "通道状态"\
}
tem_packet_str = map_name_chg["InputFrequency"]+": "+map_work_status["InputFrequency"]+" "+\
map_name_chg["Attenuation"]+": "+map_work_status["Attenuation"]+\
map_name_chg["RFSignalSwitch"]+": "+map_work_status["RFSignalSwitch"]+\
map_name_chg["LOState"]+": "+map_work_status["LOState"]+\
map_name_chg["TEM"]+": "+map_work_status["TEM"]+\
map_name_chg["EXT"]+": "+map_work_status["EXT"]+\
map_name_chg["ControlState"]+": "+map_work_status["ControlState"]+\
map_name_chg["ChannelStatus"]+": "+map_work_status["ChannelStatus"]
print("初始化数据：" + tem_packet_str)
# config = configparser.ConfigParser() # 类实例化
# 定义ini文件路径 这个文件用于存放 跟踪接收机当前的报警状态
# path = r'trackingReceiver.ini'
tcpServer_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 1创建socket对象
tcpServer_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
tcpServer_socket.bind(('0.0.0.0', tcp_port)) # 2，需要自己绑定一个ip地址和端口号
tcpServer_socket.listen(1) # 可以同时监听3个，但是这里只有一个因为没有写多线程
client_socket, addr = tcpServer_socket.accept() # 阻塞 是服务端的socket对象clientServer_socket是接入的客户端socket对象
TCP_LINK_STATUS = 1 # TCP 连接标志位
""" 设置控制状态 回调函数"""
def HY_HWF03550357FC_SetControlState_CallBack(recv_cmd):
# print("HY_HWF03550357FC_SetControlState_CallBack == recv_cmd",recv_cmd)
if(len(recv_cmd) == 12):
value = recv_cmd[9:11]
else:
value = recv_cmd[9:12]
print("HY_HWF03550357FC_SetControlState_CallBack == ",value)
map_work_status_lock.acquire() # 上锁
map_work_status["ControlState"] = value
map_work_status_lock.release() # 解锁
""" 设置射频信号开关 回调函数"""
def HY_HWF03550357FC_SetRFSignalSwitch_CallBack(recv_cmd):
# print("HY_HWF03550357FC_SetRFSignalSwitch_CallBack == recv_cmd",recv_cmd)
if(len(recv_cmd) == 12):
value = recv_cmd[9:11]
else:
value = recv_cmd[9:12]
print("HY_HWF03550357FC_SetRFSignalSwitch_CallBack == ",value)
map_work_status_lock.acquire() # 上锁
map_work_status["RFSignalSwitch"] = value
map_work_status_lock.release() # 解锁
""" 设置频率 回调函数"""
def HY_HWF03550357FC_SetInputFrequency_CallBack(recv_cmd):
# print("HY_HWF03550357FC_SetInputFrequency_CallBack == recv_cmd",recv_cmd)
value = recv_cmd[9:18]
print("HY_HWF03550357FC_SetInputFrequency_CallBack == ",value)
map_work_status_lock.acquire() # 上锁
map_work_status["InputFrequency"] = value
map_work_status_lock.release() # 解锁
""" 设置衰减指令 """
def HY_HWF03550357FC_SetAttenuation_CallBack(recv_cmd):
# print("HY_HWF03550357FC_SetAttenuation_CallBack == recv_cmd",recv_cmd)
value = recv_cmd[9:15]
print("HY_HWF03550357FC_SetAttenuation_CallBack == ",value)
map_work_status_lock.acquire() # 上锁
map_work_status["Attenuation"] = value
map_work_status_lock.release() # 解锁
""" 查询参数状态指令 回调函数"""
def HY_HWF03550357FC_QueryAllStatus_CallBack(recv_cmd):
print("HY_HWF03550357FC_QueryAllStatus_CallBack == recv_cmd",recv_cmd)
map_work_status_lock.acquire() # 上锁
tem_packet_str = ">006/RCS_\r"+"FRE_"+ map_work_status["InputFrequency"] + "\r"+\
"ATT_"+ map_work_status["Attenuation"] + "\r"+\
"RX_" + map_work_status["RFSignalSwitch"] + "\r"+\
"LO_" + map_work_status["LOState"] + "\r"+\
"POW_"+ map_work_status["Current"]+ "\r" +\
"TEM_"+ map_work_status["TEM"] + "\r"+\
"EXT_"+ map_work_status["EXT"] +\
"\r\n]"
if (TCP_LINK_STATUS != 0):
client_socket.send(tem_packet_str.encode("utf-8"))
map_work_status_lock.release() # 解锁
print(" tem_packet_str == ",tem_packet_str)
""" 查询参数状态指令 回调函数"""
def HY_HWF03550357FC_QueryChannelStatusRespond_CallBack(recv_cmd):
print("HY_HWF03550357FC_QueryChannelStatusRespond_CallBack == recv_cmd",recv_cmd)
map_work_status_lock.acquire() # 上锁
tem_packet_str = ">006/SAS_" + map_work_status["ChannelStatus"] + "\r\n]"
if (TCP_LINK_STATUS != 0):
client_socket.send(tem_packet_str.encode("utf-8"))
map_work_status_lock.release() # 解锁
""" 查询参数状态指令 回调函数"""
def HY_HWF03550357FC_QueryControlState_CallBack(recv_cmd):
print("HY_HWF03550357FC_QueryControlState_CallBack == recv_cmd",recv_cmd)
map_work_status_lock.acquire() # 上锁
tem_packet_str = ">006/REM_" + map_work_status["ControlState"] + "\r\n]"
if (TCP_LINK_STATUS != 0):
client_socket.send(tem_packet_str.encode("utf-8"))
map_work_status_lock.release() # 解锁
map_calBackFun = {"<006/REM_": HY_HWF03550357FC_SetControlState_CallBack,
"<006/MUT_": HY_HWF03550357FC_SetRFSignalSwitch_CallBack,
"<006/FRE_": HY_HWF03550357FC_SetInputFrequency_CallBack,
"<006/ATT_": HY_HWF03550357FC_SetAttenuation_CallBack,
"<006/RCS_": HY_HWF03550357FC_QueryAllStatus_CallBack,
"<006/SAS_": HY_HWF03550357FC_QueryChannelStatusRespond_CallBack,
"<006/REM_\r": HY_HWF03550357FC_QueryControlState_CallBack
}
"""定时读取 map_work_status 发布设备状态报文 间隔200ms"""
def SendStatusHandle():
print("线程1")
global client_socket
cont = 0
cont_print = 0
max_cont = 10000
while max_cont:
map_work_status_lock.acquire()
# tem_packet_str = "<CF_" + map_work_status["InputFrequency"] + ",BD_" + map_banwith_status[map_work_status["Bandwidth"]]+ "\r\n"
tem_status_str = map_name_chg["InputFrequency"]+":"+map_work_status["InputFrequency"]+ "\r\n"+\
map_name_chg["Attenuation"]+":"+map_work_status["Attenuation"]+ "\r\n"+\
map_name_chg["RFSignalSwitch"]+":"+map_work_status["RFSignalSwitch"]+ "\r\n"+\
map_name_chg["LOState"]+":"+map_work_status["LOState"]+ "\r\n"+\
map_name_chg["TEM"]+":"+map_work_status["TEM"]+ "\r\n"+\
map_name_chg["EXT"]+":"+map_work_status["EXT"]+ "\r\n"+\
map_name_chg["ControlState"]+":"+map_work_status["ControlState"]+ "\r\n"+\
map_name_chg["ChannelStatus"]+":"+map_work_status["ChannelStatus"]
# if (TCP_LINK_STATUS != 0):
# max_cont = max_cont - 1
# client_socket.send(tem_packet_str.encode("utf-8"))
map_work_status_lock.release()
cont = cont + 1
if (cont > 2 and TCP_LINK_STATUS):
cont_print = cont_print + 1
print("=============== 打印当前模拟设备状态 ================= ", cont_print)
print(tem_status_str)
cont = 0
time.sleep(1)
""" 一个模拟接收端，收到设置类型的指令后，修改map_work_status。"""
def RecvSetCMDHandle():
print("线程2")
global TCP_LINK_STATUS
global client_socket
while 1:
data = client_socket.recv(1024)
rec_str = data.decode()
if (len(data) > 0):
cmd = rec_str[0:9]
# print("1111111",cmd)
# print("2222222",rec_str)
# print("3333333",len(data))
if(cmd =="<006/REM_" and len(data) == 10):
cmd = rec_str[0:10]
if (cmd in map_calBackFun):
map_calBackFun[cmd](rec_str)
# SendMessage(rec_str)
else:
print("收到未知报文 : " + rec_str)
else:
TCP_LINK_STATUS = 0
print("连接断开，等待接入")
client_socket.close()
client_socket, addr = tcpServer_socket.accept() # s是服务端的socket对象clientServer_socket是接入的客户端socket对象
TCP_LINK_STATUS = 1
print(addr)
cont = 0
time.sleep(1)
# def SendMessage(recv_cmd):
# global client_socket
# send_str = ""
# map_work_status_lock.acquire()
# if recv_cmd[0] == "C":
# send_str = "<" + recv_cmd
# elif recv_cmd[0] == "B":
# send_str = "<" + recv_cmd
# elif recv_cmd[0] == "?":
# send_str = "<CF_" + map_work_status["InputFrequency"] + ",BD_" + map_banwith_status[map_work_status["Bandwidth"]] + "\r\n"
# client_socket.send(send_str.encode("utf-8"))
# map_work_status_lock.release()
if __name__ == '__main__':
tr1 = threading.Thread(target=SendStatusHandle)
tr2 = threading.Thread(target=RecvSetCMDHandle)
tr1.start()
tr2.start()
"""数据格式：
CF_xxxx.xxx\r\n
解释：
xxxx.xxx:输入频率,范围:2200.000~3000.000,单位:MHz;
BD_x\r\n
解释：
x:带宽,范围:1,2,3 1:50KHz 2:1MHz 3:2MHz 默认 1
"""
simulate_device_manager/simulate_devices/HY_7M3ACU.py 0 → 100644
from pickletools import pyinteger_or_bool
import socket
import sys
import time
import re
import threading
import datetime
import sys
import configparser
import signal
# 定义回调函数
def myHandler(signum, frame):
print("接收信号为：", signum)
exit(0)
# 等待接收 signal.SIGTERM命令
signal.signal(signal.SIGTERM, myHandler)
argv = sys.argv[1:]
tcp_port = int(argv[0])
map_work_status_lock = threading.Lock() # 锁的声明
"""字典 数据存放的map 使用锁进行读写访问"""
map_work_status = {
"T1": "20170102",
"T2": "210612",
"AzimuthAngle": "19657",
"ElevationAngle": "03946",
"PolarizationAngle": "-0608",
"WorkMode": "N",
"AzimuthStatus": "00",
"ElevationStatus": "00",
"PolarizationStatus": "00",
"Longitude": "11645",
"Latitude": "03916",
"Altitude": "0500",
"SignalStrengthDiff": "+123",
"XBJ_FR": "169800",
"XBJ_PCenter": "00",
"XBJ_PSize": "00",
"XBJ_PBHSize": "0000",
"NowTrackingMethod": "N",
"LastTrackingMethod": "N",
"Flag": "1"
}
"""字段中文名"""
map_name_chg = {
"T1": "年月日",
"T2": "时分秒",
"AzimuthAngle": "方位位置 单位度",
"ElevationAngle": "俯仰位置 单位度",
"PolarizationAngle": "极化轴 单位度",
"WorkMode": "工作状态信息",
"AzimuthStatus": "方位状态数据",
"ElevationStatus": "俯仰状态数据",
"PolarizationStatus": "极化状态数据",
"Longitude": "经度值",
"Latitude": "纬度值",
"Altitude": "海拔高度",
"SignalStrengthDiff": "信号强度差",
"XBJ_FR": "备用字段:信标机的信号频率",
"XBJ_PCenter": "备用字段:信标功率中心点",
"XBJ_PSize": "备用字段:信标功率中心点",
"XBJ_PBHSize": "备用字段:信标机频率捕获范围",
"NowTrackingMethod": "备用字段:此次采用的跟踪方式",
"LastTrackingMethod": "备用字段:上一次采用的跟踪方式",
"Flag": "运动到位标志"
}
packet_head ="#"
packet_end ="END\n\r"
tem_packet_str=""
def packet_string():
map_work_status_lock.acquire()
packet_info=packet_head+"\t"+\
map_work_status["T1"]+"\t"+\
map_work_status["T2"]+"\t"+\
map_work_status["AzimuthAngle"]+"\t"+\
map_work_status["ElevationAngle"]+"\t"+\
map_work_status["PolarizationAngle"]+"\t"+\
map_work_status["WorkMode"]+"\t"+\
map_work_status["AzimuthStatus"]+"\t"+\
map_work_status["ElevationStatus"]+"\t"+\
map_work_status["PolarizationStatus"]+"\t"+\
map_work_status["Longitude"]+"\t"+\
map_work_status["Latitude"]+"\t"+\
map_work_status["Altitude"]+"\t"+\
map_work_status["SignalStrengthDiff"]+"\t"+\
map_work_status["XBJ_FR"]+"\t"+\
map_work_status["XBJ_PCenter"]+"\t"+\
map_work_status["XBJ_PSize"]+"\t"+\
map_work_status["XBJ_PBHSize"]+"\t"+\
map_work_status["NowTrackingMethod"]+"\t"+\
map_work_status["LastTrackingMethod"]+"\t"+\
map_work_status["Flag"]+"\t\t\t\t\t"+packet_end
map_work_status_lock.release()
# print("11111111111122222222222222222: ",packet_info)
return packet_info
# packet_string()
def packet_status_string():
map_work_status_lock.acquire()
packet_info=\
map_name_chg["T1"]+" : "+map_work_status["T1"]+"\r\n"+\
map_name_chg["T2"]+" : "+map_work_status["T2"]+"\r\n"+\
map_name_chg["AzimuthAngle"]+" : "+map_work_status["AzimuthAngle"]+"\r\n"+\
map_name_chg["ElevationAngle"]+" : "+map_work_status["ElevationAngle"]+"\r\n"+\
map_name_chg["PolarizationAngle"]+" : "+map_work_status["PolarizationAngle"]+"\r\n"+\
map_name_chg["WorkMode"]+" : "+map_work_status["WorkMode"]+"\r\n"+\
map_name_chg["AzimuthStatus"]+" : "+map_work_status["AzimuthStatus"]+"\r\n"+\
map_name_chg["ElevationStatus"]+" : "+map_work_status["ElevationStatus"]+"\r\n"+\
map_name_chg["PolarizationStatus"]+" : "+map_work_status["PolarizationStatus"]+"\r\n"+\
map_name_chg["Longitude"]+" : "+map_work_status["Longitude"]+"\r\n"+\
map_name_chg["Latitude"]+" : "+map_work_status["Latitude"]+"\r\n"+\
map_name_chg["Altitude"]+" : "+map_work_status["Altitude"]+"\r\n"+\
map_name_chg["SignalStrengthDiff"]+" : "+map_work_status["SignalStrengthDiff"]+"\r\n"+\
map_name_chg["XBJ_FR"]+" : "+map_work_status["XBJ_FR"]+"\r\n"+\
map_name_chg["XBJ_PCenter"]+" : "+map_work_status["XBJ_PCenter"]+"\r\n"+\
map_name_chg["XBJ_PSize"]+" : "+map_work_status["XBJ_PSize"]+"\r\n"+\
map_name_chg["XBJ_PBHSize"]+" : "+map_work_status["XBJ_PBHSize"]+"\r\n"+\
map_name_chg["NowTrackingMethod"]+" : "+map_work_status["NowTrackingMethod"]+"\r\n"+\
map_name_chg["LastTrackingMethod"]+" : "+map_work_status["LastTrackingMethod"]+"\r\n"+\
map_name_chg["Flag"]+" : "+map_work_status["Flag"]
map_work_status_lock.release()
# print("11111111111122222222222222222: ",packet_info)
return packet_info
initstr=packet_status_string()
tem_packet_str = packet_string()
print("初始化数据：\r\n" + initstr)
tcpServer_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 1创建socket对象
tcpServer_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
tcpServer_socket.bind(('0.0.0.0', tcp_port)) # 2，需要自己绑定一个ip地址和端口号
tcpServer_socket.listen(1) # 可以同时监听3个，但是这里只有一个因为没有写多线程
client_socket, addr = tcpServer_socket.accept() # 阻塞 是服务端的socket对象clientServer_socket是接入的客户端socket对象
TCP_LINK_STATUS = 1 # TCP 连接标志位
""" 状态查询指令 回调函数 """
def HY_HSM_QueryStatus_CallBack(recv_cmd):
# print(recv_cmd.hex()) binascii.unhexlify(hex_str.encode())
tem_packet_str = packet_string()
if (TCP_LINK_STATUS != 0):
client_socket.send((tem_packet_str))
""" 参数设置指令 回调函数"""
def HY_HSM_ParamSetting_CallBack(recv_cmd):
buf = recv_cmd[6:].decode()
# print("11111111111 == " ,buf)
map_work_status_lock.acquire()
map_work_status["ControlMode"]=buf[0]
map_work_status["Demodulation"]=buf[1]
map_work_status["CepstrumSate"]=buf[2]
map_work_status["SignalRate"]=buf[3:13]
map_work_status["DifferentialDecoding"]=buf[13]
map_work_status["FEC"]=buf[14]
map_work_status["DecodingChannels"]=buf[15]
map_work_status["ConvolutionalDecodingState"]=buf[16]
map_work_status["RSDecoding"]=buf[17]
map_work_status["RSChannels"]=buf[18]
map_work_status["RSDepth"]=buf[19]
map_work_status["Descrambling"]=buf[20]
map_work_status["IPPacketSize"]=buf[21]
map_work_status["FrameDetect"]=buf[22]
map_work_status["SYNCLength"]=buf[23]
map_work_status["FrameLength"]=buf[24:29]
map_work_status["SYNC_I"]=buf[29:45]
map_work_status["SYNC_Q"]=buf[45:61]
map_work_status["CRC_Switch"]=buf[61]
# map_work_status["Demodulation"]=
map_work_status_lock.release()
tem_packet_str = bytearray([0xeb,0x90,0x3E, 0X00])+recv_cmd[4:]
# tem_packet_str = packet_string()
if (TCP_LINK_STATUS != 0):
client_socket.send((tem_packet_str))
""" 开始接收数据控制指令 回调函数 """
def HY_HSM_StartReceiveDataControl_CallBack(recv_cmd):
# print(recv_cmd.hex()) binascii.unhexlify(hex_str.encode())
tem_packet_str = bytearray([0xeb,0x90,0x3E, 0X09])+recv_cmd[4:]
# tem_packet_str = packet_string()
buf = recv_cmd[6:].decode()
print(buf)
map_work_status_lock.acquire()
map_work_status["StartTime"]=buf[0:14]
map_work_status["EndTime"]=buf[14:28]
map_work_status["targetID"]=buf[28:33]
map_work_status["frequency"]=buf[33:39 ]
map_work_status_lock.release()
if (TCP_LINK_STATUS != 0):
client_socket.send((tem_packet_str))
""" 方位俯仰置位指令 回调函数 """
def HY_ACU7M3_DirectionSet(recv_cmd):
map_work_status_lock.acquire()
map_work_status["AzimuthAngle"]=recv_cmd[3:8]
map_work_status["ElevationAngle"]=recv_cmd[8:13]
map_work_status["PolarizationAngle"]=recv_cmd[13:18]
map_work_status_lock.release()
map_calBackFun = {"$PP": HY_ACU7M3_DirectionSet
}
"""定时读取 map_work_status 发布设备状态报文 间隔200ms"""
def SendStatusHandle():
print("线程1")
global client_socket
cont = 0
cont_print = 0
max_cont = 10000
while max_cont:
tem_packet_str =""
tem_packet_str = packet_string()
if (TCP_LINK_STATUS != 0):
max_cont = max_cont - 1
client_socket.send(tem_packet_str.encode("utf-8"))
cont = cont + 1
if (cont > 2 and TCP_LINK_STATUS):
cont_print = cont_print + 1
tem_status_str = packet_status_string()
print("=============== 打印当前模拟设备状态 ================= ", cont_print)
print(tem_status_str)
cont = 0
time.sleep(1)
""" 一个模拟接收端，收到设置类型的指令后，修改 map_work_status。"""
def RecvSetCMDHandle():
print("线程2")
global TCP_LINK_STATUS
global client_socket
while 1:
data = client_socket.recv(1024)
str1= ""
str1=data.decode()
if (len(data) > 0):
cmd = str1[0:3]
print(cmd)
print(data)
if (cmd in map_calBackFun):
map_calBackFun[cmd](str1)
# SendMessage(rec_str)
else:
print("收到未知报文 : " + str1)
else:
TCP_LINK_STATUS = 0
print("连接断开，等待接入")
client_socket.close()
client_socket, addr = tcpServer_socket.accept() # s是服务端的socket对象clientServer_socket是接入的客户端socket对象
TCP_LINK_STATUS = 1
print(addr)
cont = 0
time.sleep(1)
def SendMessage(recv_cmd):
global client_socket
send_str = ""
map_work_status_lock.acquire()
if recv_cmd[0] == "C":
send_str = "<" + recv_cmd
elif recv_cmd[0] == "B":
send_str = "<" + recv_cmd
elif recv_cmd[0] == "?":
send_str = "<CF_" + map_work_status["InputFrequency"] + ",BD_" + map_banwith_status[map_work_status["Bandwidth"]] + "\r\n"
client_socket.send(send_str.encode("utf-8"))
map_work_status_lock.release()
if __name__ == '__main__':
tr1 = threading.Thread(target=SendStatusHandle)
tr2 = threading.Thread(target=RecvSetCMDHandle)
tr1.start()
tr2.start()
simulate_device_manager/simulate_devices/HY_ACU7M5_Antenna_PROTOCOL.py 0 → 100644
from pickletools import pyinteger_or_bool
import socket
import sys
import time
import re
import threading
import datetime
import sys
import configparser
config = configparser.ConfigParser() # 类实例化
# 定义ini文件路径 这个文件用于存放 天控器当前的报警状态
path = r'./simulate_device_manager/simulate_devices/acu7m5_hyds.ini'
argv = sys.argv[1:]
tcp_port =int(argv[0])
map_work_status_lock = threading.Lock()#锁的声明
"""数据存放的map 使用锁进行读写访问"""
map_work_status={"Xaxis":"090.00","Yaxis":"090.00","Azimuth":"000.00","ElevationAngle":"090.00","ACUstatus":"P", \
"XTrackerSigIntensity":"255","YTrackerSigIntensity":"255","X_STATUS":"255","Y_STATUS":"255","XInitPhase":"012",\
"XPolarizationType":"1","SPolarizationType":"0","XTrackerVoltageLimit":"255",\
"STrackerVoltageLimit":"255","SUpPolarizationType":"1","XUpPolarizationType":"1",\
"TrackingStatus":"0","TrackingBand":"1","X-Bias":"+0.00","Y-Bias":"+0.00" }
"""字段中文名"""
map_name_chg={"Xaxis":"X轴角度","Yaxis":"Y轴角度","Azimuth":"方位轴角度","ElevationAngle":"俯仰轴角度","ACUstatus":"ACU程序状态", \
"XTrackerSigIntensity":"X频段信号强度","YTrackerSigIntensity":"y频段信号强度","X_STATUS":"X轴状态","Y_STATUS":"Y轴状态","XInitPhase":"X频段初相位",\
"XPolarizationType":"X频段跟踪极化","SPolarizationType":"S频段跟踪极化","XTrackerVoltageLimit":"X频段跟踪门限",\
"STrackerVoltageLimit":"S频段跟踪门限","SUpPolarizationType":"S频段上行极化","XUpPolarizationType":"X频段上行极化",\
"TrackingStatus":"跟踪方式","TrackingBand":"跟踪频段","X-Bias":"X轴偏置度","Y-Bias":"Y轴偏置度" }
tem_packet_str="$"
for key in map_work_status:
tem_packet_str=tem_packet_str+","+map_work_status[key]
tem_packet_str=tem_packet_str+"\r\n"
print("初始化数据："+tem_packet_str)
# mesage1="$,111.84,063.28,143.53,56.01,W,200,155,000,008,055,0,1,121,123,1,0,0,0,+1.23,-4.56\r\n"
# print(mesage1)
tcpServer_socket=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #1创建socket对象
tcpServer_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
rc=tcpServer_socket.bind(('0.0.0.0',tcp_port ))#2，需要自己绑定一个ip地址和端口号
print("开启TCPserver 0.0.0.0 ",tcp_port)
tcpServer_socket.listen(1) #可以同时监听3个，但是这里只有一个因为没有写多线程
client_socket,addr=tcpServer_socket.accept() #阻塞 是服务端的socket对象clientServer_socket是接入的客户端socket对象
TCP_LINK_STATUS = 1 #TCP 连接标志位
""" 处理XY置位指令 回调函数"""
def HY_ACU7M5_PostionSet_CallBack(recv_cmd):
# print("收到报文"+cmd_str)
Xaxis = recv_cmd[4:10]
Yaxis =recv_cmd[11:17]
# print(Xaxis+" "+Yaxis)
map_work_status_lock.acquire()#上锁
map_work_status["Xaxis"]=Xaxis
map_work_status["Yaxis"]=Yaxis
map_work_status_lock.release()#解锁
""" 运动停止指令 回调函数"""
def HY_ACU7M5_MoveStop_CallBack(recv_cmd):
map_work_status_lock.acquire()#上锁
map_work_status["ACUstatus"]="W"
map_work_status_lock.release()#解锁
""" 方位俯仰置位指令 回调函数"""
def HY_ACU7M5_DirectionSet_CallBack(recv_cmd):
# print("收到报文"+cmd_str)
Azimuth = recv_cmd[4:10]
ElevationAngle =recv_cmd[11:17]
print(Azimuth+" "+ElevationAngle)
map_work_status_lock.acquire()#上锁
map_work_status["Azimuth"]=Azimuth
map_work_status["ElevationAngle"]=ElevationAngle
map_work_status_lock.release()#解锁
""" 自跟指令 回调函数"""
def HY_ACU7M5_AutoTrace_CallBack(recv_cmd):
# print("收到报文"+cmd_str)
TrackingStatus = recv_cmd[4:5]
map_work_status_lock.acquire()#上锁
map_work_status["TrackingStatus"]=TrackingStatus
map_work_status_lock.release()#解锁
""" 跟踪极化及跟踪门限设置指令 回调函数"""
def HY_ACU7M5_GZJHMXSetting_CallBack(recv_cmd):
# print("收到报文"+cmd_str)
XPolarizationType = recv_cmd[4:5]
SPolarizationType = recv_cmd[6:7]
XTrackerVoltageLimit = recv_cmd[8:11]
STrackerVoltageLimit = recv_cmd[12:15]
map_work_status_lock.acquire()#上锁
map_work_status["XPolarizationType"]=XPolarizationType
map_work_status["SPolarizationType"]=SPolarizationType
map_work_status["XTrackerVoltageLimit"]=XTrackerVoltageLimit
map_work_status["STrackerVoltageLimit"]=STrackerVoltageLimit
map_work_status_lock.release()#解锁
""" 加载轨道数据指令 回调函数"""
def HY_ACU7M5_LoadingTrackData_CallBack(recv_cmd):
map_work_status_lock.acquire()#上锁
map_work_status["ACUstatus"]="P"
map_work_status_lock.release()#解锁
""" 程引偏置指令 回调函数"""
def HY_ACU7M5_BiasCommand_CallBack(recv_cmd):
# print("收到报文"+recv_cmd)
X_Bias = recv_cmd[4:9]
Y_Bias = recv_cmd[10:15]
map_work_status_lock.acquire()#上锁
map_work_status["X-Bias"]=X_Bias
map_work_status["Y-Bias"]=Y_Bias
map_work_status_lock.release()#解锁
""" 初相位设置指令 回调函数"""
def HY_ACU7M5_InitPhaseSet_CallBack(recv_cmd):
# print("收到报文"+recv_cmd)
XInitPhase = recv_cmd[3:6]
map_work_status_lock.acquire()#上锁
map_work_status["XInitPhase"]=XInitPhase
map_work_status_lock.release()#解锁
""" X频段上行极化设置指令 回调函数"""
def HY_ACU7M5_XUpPolarizationTypeSet_CallBack(recv_cmd):
# print("收到报文"+recv_cmd)
XUpPolarizationType = recv_cmd[3:4]
map_work_status_lock.acquire()#上锁
map_work_status["XUpPolarizationType"]=XUpPolarizationType
map_work_status_lock.release()#解锁
""" S频段上行极化设置指令 回调函数"""
def HY_ACU7M5_SUpPolarizationTypeSet_CallBack(recv_cmd):
# print("收到报文"+recv_cmd)
SUpPolarizationType = recv_cmd[3:4]
map_work_status_lock.acquire()#上锁
map_work_status["SUpPolarizationType"]=SUpPolarizationType
map_work_status_lock.release()#解锁
""" 跟踪频段指令 回调函数"""
def HY_ACU7M5_TrackingBandSet_CallBack(recv_cmd):
# print("收到报文"+recv_cmd)
TrackingBand = recv_cmd[3:4]
map_work_status_lock.acquire()#上锁
map_work_status["TrackingBand"]=TrackingBand
map_work_status_lock.release()#解锁
map_callBackFun={"$XY":HY_ACU7M5_PostionSet_CallBack,\
"$WT":HY_ACU7M5_MoveStop_CallBack,\
"$AE":HY_ACU7M5_DirectionSet_CallBack,\
"$AT":HY_ACU7M5_AutoTrace_CallBack,\
"$PL":HY_ACU7M5_GZJHMXSetting_CallBack,\
"$SP":HY_ACU7M5_LoadingTrackData_CallBack,\
"$RS":HY_ACU7M5_BiasCommand_CallBack,\
"$PH":HY_ACU7M5_InitPhaseSet_CallBack,\
"$XU":HY_ACU7M5_XUpPolarizationTypeSet_CallBack,\
"$SU":HY_ACU7M5_SUpPolarizationTypeSet_CallBack,\
"$BD":HY_ACU7M5_TrackingBandSet_CallBack
}
"""定时读取 map_work_status 发布设备状态报文 间隔200ms"""
def SendStatusHandle():
global client_socket
X_STATUS ="000"
Y_STATUS ="000"
cont =0
while 1:
# print(time.time())
map_work_status_lock.acquire()#上锁
map_work_status["X_STATUS"]=X_STATUS
map_work_status["Y_STATUS"]=Y_STATUS
x_axis = float(map_work_status["Xaxis"])
y_axis = float(map_work_status["Yaxis"])
# x_axis = (x_axis + 1) % 181
# y_axis = (y_axis + 1) % 181
map_work_status["Xaxis"] = "{:03d}.{:02d}".format(int(x_axis), int((x_axis % 1) * 100))
map_work_status["Yaxis"] = "{:03d}.{:02d}".format(int(y_axis), int((y_axis % 1) * 100))
tem_packet_str="$"
tem_status_str = ""
for key in map_work_status:
tem_packet_str=tem_packet_str+","+map_work_status[key]
tem_status_str=tem_status_str+map_name_chg[key]+" : "+map_work_status[key]+"\r\n"
tem_packet_str=tem_packet_str+"\r\n"
if (TCP_LINK_STATUS != 0):
client_socket.send(tem_packet_str.encode("utf-8"))
# print(tem_packet_str)
map_work_status_lock.release()#解锁
# print(time.time())
cont= cont+1
if(cont>5 and TCP_LINK_STATUS):
print("=============== 打印当前模拟设备状态 =================")
print(tem_status_str)
config.read(path)
XaxisAlarm = config['alarm_status']['XaxisAlarm']
XaxisServoStatus = config['alarm_status']['XaxisServoStatus']
EasternLimit = config['alarm_status']['EasternLimit']
WestLimit = config['alarm_status']['WestLimit']
YaxisAlarm = config['alarm_status']['YaxisAlarm']
YaxisServoStatus = config['alarm_status']['YaxisServoStatus']
SouthrLimit = config['alarm_status']['SouthrLimit']
NorthLimit = config['alarm_status']['NorthLimit']
X_STATUS =str(240+ int(XaxisAlarm)*8+ int(XaxisServoStatus)*4+ int(EasternLimit)*2+ int(WestLimit)*1)
Y_STATUS =str(240+ int(YaxisAlarm)*8+ int(YaxisServoStatus)*4+ int(SouthrLimit)*2+ int(NorthLimit)*1)
cont =0
# print("X_STATUS ======= ",X_STATUS)
# print("Y_STATUS ======= ",Y_STATUS)
# print("==================== 结束打印 =======================\r\n")
time.sleep(1)
""" 一个模拟接收端，收到设置类型的指令后，修改map_work_status。"""
def RecvSetCMDHandle():
global TCP_LINK_STATUS
global client_socket
while 1:
data = client_socket.recv(1024) # 一次接收1024字节
rec_str =data.decode()
if(len(data)>0):
cmd =rec_str[0:3]
# print("cmd = "+cmd)
if(cmd in map_callBackFun):
map_callBackFun[cmd](rec_str)
else:
print("收到未知报文 : "+rec_str)
else:
TCP_LINK_STATUS =0
print("连接断开，等待接入")
client_socket.close()
client_socket,addr=tcpServer_socket.accept() #s是服务端的socket对象clientServer_socket是接入的客户端socket对象
TCP_LINK_STATUS =1
print(addr)
cont = 0
time.sleep(0.1)
# time.sleep(1)
"""
初始化TCP SERVER
起两个线程
一个模拟设备定时读取 map_work_status 发布设备状态报文 间隔200ms
一个模拟接收端，收到设置类型的指令后，修改map_work_status。
"""
if __name__ == '__main__':
tr1 =threading.Thread(target=SendStatusHandle)
tr2 =threading.Thread(target=RecvSetCMDHandle)
tr1.start()
tr2.start()
"""数据格式:
$,xxx.xx,yyy.yy,aaa.aa,ee.ee,p,lsx,lsy,lx,ly,ph,psx,pss,gx,gs,us,ux,at,bd,fffff,ggggg\r\n
解释:
xxx.xx:X轴角度数据,范围:000.00~180.00,单位:度;
yyy.yy:俯仰角度数据,范围:000.00~180.00,单位:度;
aaa.aa:方位轴角度数据,范围:000.00~360.00,单位:度;
ee.ee:俯仰轴角度数据,范围:00.00~90.00,单位:度;
p:程序状态,W待机,M手动,P程引,A自跟,ZW置位;
lsx: X频段信号强度,范围0-512;
lsy; S频段信号强度,范围0-512;
lx: X轴状态数据,详见举例说明 ;
ly: Y轴状态数据,详见举例说明;
ph: X频段初相位,范围0-255;
psx: X频段跟踪极化,范围0-1,0左旋,1右旋;
pss: S频段跟踪极化,范围0-1,0左旋,1右旋;
gx: X频段跟踪门限,范围0-512;
gs: S频段跟踪门限,范围0-512;
us: S频段上行极化,范围0-1,0左旋,1右旋;
ux: X频段上行极化,范围0-1,0左旋,1右旋;
at:跟踪方式,1 表示启动了自动进入跟踪。0 表示未启动。
Bd:跟踪频段,1为X频段,0为S频段。
fffff:X轴偏置角;
ggggg:y轴偏置角;
举例:
$,111.84,063.28,143.53,56.01,W,200,155,000,008,055,0,1,121,123,1,0,0,0,+1.23,-4.56\r\n
"XaxisAlarm":"0", "XaxisServoStatus":"1","EasternLimit":"0","WestLimit":"0","YaxisAlarm":"0","YaxisServoStatus":"0","SouthrLimit":"0","NorthLimit":"0",
"XaxisAlarm":"X轴报警","XaxisServoStatus":"X轴伺服状态","EasternLimit":"东限位","WestLimit":"西限位","YaxisAlarm":"Y轴报警","YaxisServoStatus":"Y轴伺服","SouthrLimit":"南限位","NorthLimit":"北限位",
"""
\ No newline at end of file
simulate_device_manager/simulate_devices/HY_DualChannelLBandOpticalTransceiver_hyds.py 0 → 100644
from pickletools import pyinteger_or_bool
import socket
import sys
import time
import re
import threading
import datetime
import sys
import configparser
import signal
# 定义回调函数
def myHandler(signum, frame):
print("接收信号为：", signum)
exit(0)
# 等待接收 signal.SIGTERM命令
signal.signal(signal.SIGTERM, myHandler)
argv = sys.argv[1:]
tcp_port = int(argv[0])
map_work_status_lock = threading.Lock() # 锁的声明
"""字典 数据存放的map 使用锁进行读写访问"""
map_work_status = {
"DevEnvTemp": "2230",
"ControlMode": "1",
"TxModuleRFPow": "1234",
"RxModuleRFPow": "1234",
"TxModuleOpPow": "1234",
"RxModuleOpPow": "1234",
"TxModuleWorkMode": "1",
"RxModuleWorkMode": "2",
"TxModuleATT": "11.1",
"RxModuleATT": "222",
"TxModuleAGC": "333",
"RxModuleAGC": "444",
"TxModuleTemp": "1750",
"RxModuleTemp": "1760",
"TxModuleRFPowAlarmThreshold": "180",
"RxModuleRFPowAlarmThreshold": "180",
"TxModuleOpPowAlarmThreshold": "-2900",
"RxModuleOpPowAlarmThreshold": "-3000",
"TxModuleopticalPowerLow": "0",
"TxModuleopticalPowerHight": "0",
"TxModuleRFPowerLow": "0",
"TxModuleRFPowerHight": "0",
"TxModuleWorkStatus": "0",
"RxModuleopticalPowerLow": "0",
"RxModuleopticalPowerHight": "0",
"RxModuleRFPowerLow": "0",
"RxModuleRFPowerHight": "0",
"RxModuleWorkStatus": "0",
"DeviceWorkStatus": "1"
}
"""字段中文名"""
map_name_chg = {
"DevEnvTemp": "设备环境温度 精度0.01",
"ControlMode": "设备控制模式",
"TxModuleRFPow": "发射模块射频功率",
"RxModuleRFPow": "接收模块射频功率",
"TxModuleOpPow": "发送模块光功率",
"RxModuleOpPow": "接收模块光功率",
"TxModuleWorkMode": "发射模块工作模式",
"RxModuleWorkMode": "接收模块工作模式",
"TxModuleATT":"发射模MGC块衰减值",
"RxModuleATT": "接收模MGC块衰减值",
"TxModuleAGC": "发射模块AGC衰减值",
"RxModuleAGC": "接收模块AGC衰减值",
"TxModuleTemp": "发射模块温度",
"RxModuleTemp": "接收模块温度",
"TxModuleRFPowAlarmThreshold": "发射模块射频功率告警门限",
"RxModuleRFPowAlarmThreshold": "接收模块射频功率告警门限",
"TxModuleOpPowAlarmThreshold": "发射模块光功率告警门限",
"RxModuleOpPowAlarmThreshold": "接收模块光功率告警门限",
"TxModuleopticalPowerLow": "发射模块光功率过小",
"TxModuleopticalPowerHight": "发射模块光功率过大",
"TxModuleRFPowerLow": "发射模块射频功率过小",
"TxModuleRFPowerHight": "发射模块射频功率过大",
"TxModuleWorkStatus": "发射模块工作状态",
"RxModuleopticalPowerLow": "接收模块光功率过小",
"RxModuleopticalPowerHight": "接收模块光功率过大",
"RxModuleRFPowerLow": "接收模块射频功率过小",
"RxModuleRFPowerHight": "接收射模块射频功率过大",
"RxModuleWorkStatus": "接收模块工作状态",
"DeviceWorkStatus": "设备工作状态"
}
packet_head =bytearray([0xAA,0x55,0x00,0x9C,0x00,0x30,0x00,0x00,0x00,0xA8,0x02,0x01,0x00,0x00,0x00,0x00,0x02,0x00,0x01,0xC2,0x00,0x03,0xC0,0xA8,0x01,0xB3,0x04,0x00,0x00,0x1F,0x90,0x05,0xFF,0xFF,0xFF,0x00,0x06,0xC0,0xA8,0x01,0x01,0x07,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x0E,0x00,0x00,0x00,0x00,0x0F,0x00,0x00,0x00,0x00])
# print("1111111111111111 ",packet_head)
tem_packet_str=""
def genCRC(tem_packet_str):
sum=0
size =len(tem_packet_str)
# print("size == ", size)
for num in range(2,size):
sum=sum+(tem_packet_str[num])
# print("sum == ",sum)
# print("sum == ",sum)
# print("%#x"%sum)
crc=sum&0xff
# print("%#x"%crc)
return crc
def packet_string():
tx_module_code =bytes([0x00,0xff])
rx_module_code =bytes([0x01,0xff])
packet_info=bytes()
map_work_status_lock.acquire()
cmd_value =bytes([0x10]) #设备环境温度
value = int(map_work_status["DevEnvTemp"])
# print(value," ",type(value))
value_byte =value.to_bytes(4,"big")
# print(value_byte," ",type(value_byte))
packet_info=packet_info+cmd_value+value_byte
cmd_value =bytes([0x20]) #设备控制模式
value = int(map_work_status["ControlMode"])
value_byte =value.to_bytes(4,"big")
packet_info=packet_info+cmd_value+value_byte
cmd_value =bytes([0x21]) #射频功率
packet_info=packet_info+cmd_value
value = int(map_work_status["TxModuleRFPow"]) #发射模块
value_byte =value.to_bytes(2,"big")
packet_info=packet_info+tx_module_code+value_byte
value = int(map_work_status["RxModuleRFPow"]) #接收模块
value_byte =value.to_bytes(2,"big")
packet_info=packet_info+rx_module_code+value_byte
cmd_value =bytes([0x22]) #光功率
packet_info=packet_info+cmd_value
value = int(map_work_status["TxModuleOpPow"]) #发射模块
value_byte =value.to_bytes(2,"big")
packet_info=packet_info+tx_module_code+value_byte
value = int(map_work_status["TxModuleOpPow"]) #接收模块
value_byte =value.to_bytes(2,"big")
packet_info=packet_info+rx_module_code+value_byte
cmd_value =bytes([0x23]) #工作模式
packet_info=packet_info+cmd_value
value = int(map_work_status["TxModuleWorkMode"]) #发射模块
value_byte =value.to_bytes(2,"big")
packet_info=packet_info+tx_module_code+value_byte
value = int(map_work_status["RxModuleWorkMode"]) #接收模块
value_byte =value.to_bytes(2,"big")
packet_info=packet_info+rx_module_code+value_byte
cmd_value =bytes([0x24]) #MGC衰减值
packet_info=packet_info+cmd_value
value = int(float(map_work_status["TxModuleATT"])*10) #发射模块
value_byte =value.to_bytes(2,"big")
packet_info=packet_info+tx_module_code+value_byte
value = int(float(map_work_status["RxModuleATT"])*10) #接收模块
value_byte =value.to_bytes(2,"big")
packet_info=packet_info+rx_module_code+value_byte
cmd_value =bytes([0x25]) #MGC衰减值
packet_info=packet_info+cmd_value
value = int(float(map_work_status["TxModuleAGC"])*10) #发射模块
value_byte =value.to_bytes(2,"big")
packet_info=packet_info+tx_module_code+value_byte
value =int(float(map_work_status["RxModuleAGC"])*10) #接收模块
value_byte =value.to_bytes(2,"big")
packet_info=packet_info+rx_module_code+value_byte
packet_info=packet_info+bytes([0x26,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00]) #激光参考电压
cmd_value =bytes([0x2C]) #模块温度
packet_info=packet_info+cmd_value
value = int(map_work_status["TxModuleTemp"]) #发射模块
value_byte =value.to_bytes(2,"big")
packet_info=packet_info+tx_module_code+value_byte
value = int(map_work_status["RxModuleTemp"]) #接收模块
value_byte =value.to_bytes(2,"big")
packet_info=packet_info+rx_module_code+value_byte
cmd_value =bytes([0x2D]) #射频功率告警门限
packet_info=packet_info+cmd_value
value = int(map_work_status["TxModuleRFPowAlarmThreshold"]) #接收模块
if(value<0):
value = 65536+int(map_work_status["TxModuleRFPowAlarmThreshold"]) #发射模块
# print(value," ",type(value))
value_byte =value.to_bytes(2,"big")
# print(value_byte," ",type(value_byte))
# value_byte =value.to_bytes(2,"big")
packet_info=packet_info+tx_module_code+value_byte
value = int(map_work_status["RxModuleRFPowAlarmThreshold"]) #接收模块
if(value<0):
value = 65536+int(map_work_status["RxModuleRFPowAlarmThreshold"]) #接收模块
value_byte =value.to_bytes(2,"big")
packet_info=packet_info+rx_module_code+value_byte
cmd_value =bytes([0x2E]) #光功率告警门限
packet_info=packet_info+cmd_value
value = int(map_work_status["TxModuleOpPowAlarmThreshold"]) #接收模块
if(value<0):
value = 65536+int(map_work_status["TxModuleOpPowAlarmThreshold"]) #发射模块
value_byte =value.to_bytes(2,"big")
packet_info=packet_info+tx_module_code+value_byte
value = int(map_work_status["RxModuleOpPowAlarmThreshold"]) #接收模块
if(value<0):
value = 65536+int(map_work_status["RxModuleOpPowAlarmThreshold"]) #接收模块
value_byte =value.to_bytes(2,"big")
packet_info=packet_info+rx_module_code+value_byte
# 发射模块的工作状态;取最后一个字节状态值转换成二进制，bit0:工作状态（0异常，1正常）；
# bit1:射频功率大（0正常，1大）；bit2:射频功率小（0正常，1小）；bit3:光功率大（0正常，1大）；bit4:光功率小（0正常，1小）
# TxModuleopticalPowerLow 发射模块光功率过小
# TxModuleopticalPowerHight 发射模块光功率过大
# TxModuleRFPowerLow 发射模块射频功率过小
# TxModuleRFPowerHight 发射模块射频功率过大
# TxModuleWorkStatus 发射模块工作状态
cmd_value =bytes([0x2F]) #光功率告警门限
packet_info=packet_info+cmd_value
value = \
int(map_work_status["TxModuleopticalPowerLow"],2)<<4|\
int(map_work_status["TxModuleopticalPowerHight"],2)<<3|\
int(map_work_status["TxModuleRFPowerLow"],2)<<2|\
int(map_work_status["TxModuleRFPowerHight"],2)<<1|\
int(map_work_status["TxModuleWorkStatus"],2)
# print(bin(value)," 111111111111111 ",type(value))
value_byte =value.to_bytes(4,"big") #接收模
packet_info=packet_info+value_byte
# 发射模块的工作状态;取最后一个字节状态值转换成二进制，bit0:工作状态（0异常，1正常）；
# bit1:射频功率大（0正常，1大）；bit2:射频功率小（0正常，1小）；bit3:光功率大（0正常，1大）；bit4:光功率小（0正常，1小）
# RxModuleopticalPowerLow 接收模块光功率过小
# RxModuleopticalPowerHight 接收模块光功率过大
# RxModuleRFPowerLow 接收模块射频功率过小
# RxModuleRFPowerHight 接收射模块射频功率过大
# RxModuleWorkStatus 接收模块工作状态
#发射模块
value = \
int(map_work_status["RxModuleopticalPowerLow"],2)<<4|\
int(map_work_status["RxModuleopticalPowerHight"],2)<<3|\
int(map_work_status["RxModuleRFPowerLow"],2)<<2|\
int(map_work_status["RxModuleRFPowerHight"],2)<<1|\
int(map_work_status["RxModuleWorkStatus"],2)
# print(bin(value)," 111111111111111 ",type(value))
value_byte =value.to_bytes(4,"big") #接收模
packet_info=packet_info+value_byte
# DeviceWorkStatus 设备工作状态
value = int(map_work_status["RxModuleWorkStatus"])
# print(bin(value)," 111111111111111 ",type(value))
value_byte =value.to_bytes(4,"big") #接收模
packet_info=packet_info+value_byte
packet_info=packet_head+packet_info
# print(packet_info," ",type(packet_info))
map_work_status_lock.release()
crc =genCRC(packet_info)
packet_info=packet_info+bytes([crc]) #crc
return packet_info
# return packet_head+packet_info.encode("utf-8")
def packet_status_string():
map_work_status_lock.acquire()
packet_info=\
map_name_chg["DevEnvTemp"]+" : "+map_work_status["DevEnvTemp"]+"\r\n"+\
map_name_chg["ControlMode"]+" : "+map_work_status["ControlMode"]+"\r\n"+\
map_name_chg["TxModuleRFPow"]+" : "+map_work_status["TxModuleRFPow"]+"\r\n"+\
map_name_chg["RxModuleRFPow"]+" : "+map_work_status["RxModuleRFPow"]+"\r\n"+\
map_name_chg["TxModuleOpPow"]+" : "+map_work_status["TxModuleOpPow"]+"\r\n"+\
map_name_chg["RxModuleOpPow"]+" : "+map_work_status["RxModuleOpPow"]+"\r\n"+\
map_name_chg["TxModuleWorkMode"]+" : "+map_work_status["TxModuleWorkMode"]+"\r\n"+\
map_name_chg["RxModuleWorkMode"]+" : "+map_work_status["RxModuleWorkMode"]+"\r\n"+\
map_name_chg["TxModuleATT"]+" : "+map_work_status["TxModuleATT"]+"\r\n"+\
map_name_chg["RxModuleATT"]+" : "+map_work_status["RxModuleATT"]+"\r\n"+\
map_name_chg["TxModuleAGC"]+" : "+map_work_status["TxModuleAGC"]+"\r\n"+\
map_name_chg["RxModuleAGC"]+" : "+map_work_status["RxModuleAGC"]+"\r\n"+\
map_name_chg["TxModuleTemp"]+" : "+map_work_status["TxModuleTemp"]+"\r\n"+\
map_name_chg["RxModuleTemp"]+" : "+map_work_status["RxModuleTemp"]+"\r\n"+\
map_name_chg["TxModuleRFPowAlarmThreshold"]+" : "+map_work_status["TxModuleRFPowAlarmThreshold"]+"\r\n"+\
map_name_chg["RxModuleRFPowAlarmThreshold"]+" : "+map_work_status["RxModuleRFPowAlarmThreshold"]+"\r\n"+\
map_name_chg["TxModuleRFPowAlarmThreshold"]+" : "+map_work_status["TxModuleRFPowAlarmThreshold"]+"\r\n"+\
map_name_chg["RxModuleRFPowAlarmThreshold"]+" : "+map_work_status["RxModuleRFPowAlarmThreshold"]+"\r\n"+\
map_name_chg["TxModuleopticalPowerLow"]+" : "+map_work_status["TxModuleopticalPowerLow"]+"\r\n"+\
map_name_chg["TxModuleopticalPowerHight"]+" : "+map_work_status["TxModuleopticalPowerHight"]+"\r\n"+\
map_name_chg["TxModuleRFPowerLow"]+" : "+map_work_status["TxModuleRFPowerLow"]+"\r\n"+\
map_name_chg["TxModuleRFPowerHight"]+" : "+map_work_status["TxModuleRFPowerHight"]+"\r\n"+\
map_name_chg["TxModuleWorkStatus"]+" : "+map_work_status["TxModuleWorkStatus"]+"\r\n"+\
map_name_chg["RxModuleopticalPowerLow"]+" : "+map_work_status["RxModuleopticalPowerLow"]+"\r\n"+\
map_name_chg["RxModuleopticalPowerHight"]+" : "+map_work_status["RxModuleopticalPowerHight"]+"\r\n"+\
map_name_chg["RxModuleRFPowerLow"]+" : "+map_work_status["RxModuleRFPowerLow"]+"\r\n"+\
map_name_chg["RxModuleRFPowerHight"]+" : "+map_work_status["RxModuleRFPowerHight"]+"\r\n"+\
map_name_chg["RxModuleWorkStatus"]+" : "+map_work_status["RxModuleWorkStatus"]+"\r\n"+\
map_name_chg["DeviceWorkStatus"]+" : "+map_work_status["DeviceWorkStatus"]
map_work_status_lock.release()
# print("11111111111122222222222222222: ",packet_info)
return packet_info
initstr=packet_status_string()
print("初始化数据：\r\n" + initstr)
tem_packet_str = packet_string()
print("tem_packet_str len ==: ",len(tem_packet_str))
sum=0
tcpServer_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 1创建socket对象
tcpServer_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
tcpServer_socket.bind(('0.0.0.0', tcp_port)) # 2，需要自己绑定一个ip地址和端口号
tcpServer_socket.listen(1) # 可以同时监听3个，但是这里只有一个因为没有写多线程
client_socket, addr = tcpServer_socket.accept() # 阻塞 是服务端的socket对象clientServer_socket是接入的客户端socket对象
TCP_LINK_STATUS = 1 # TCP 连接标志位
""" 状态查询指令 回调函数 """
def HY_DChLBandOT_Query_CallBack(recv_cmd):
# print(recv_cmd.hex()) binascii.unhexlify(hex_str.encode())
tem_packet_str = packet_string()
if (TCP_LINK_STATUS != 0):
client_socket.send((tem_packet_str))
""" 参数设置指令 回调函数"""
def HY_HSM_ParamSetting_CallBack(recv_cmd):
buf = recv_cmd[6:].decode()
# print("11111111111 == " ,buf)
map_work_status_lock.acquire()
map_work_status["ControlMode"]=buf[0]
map_work_status["Demodulation"]=buf[1]
map_work_status["CepstrumSate"]=buf[2]
map_work_status["SignalRate"]=buf[3:13]
map_work_status["DifferentialDecoding"]=buf[13]
map_work_status["FEC"]=buf[14]
map_work_status["DecodingChannels"]=buf[15]
map_work_status["ConvolutionalDecodingState"]=buf[16]
map_work_status["RSDecoding"]=buf[17]
map_work_status["RSChannels"]=buf[18]
map_work_status["RSDepth"]=buf[19]
map_work_status["Descrambling"]=buf[20]
map_work_status["IPPacketSize"]=buf[21]
map_work_status["FrameDetect"]=buf[22]
map_work_status["SYNCLength"]=buf[23]
map_work_status["FrameLength"]=buf[24:29]
map_work_status["SYNC_I"]=buf[29:45]
map_work_status["SYNC_Q"]=buf[45:61]
map_work_status["CRC_Switch"]=buf[61]
# map_work_status["Demodulation"]=
map_work_status_lock.release()
tem_packet_str = bytearray([0xeb,0x90,0x3E, 0X00])+recv_cmd[4:]
# tem_packet_str = packet_string()
if (TCP_LINK_STATUS != 0):
client_socket.send((tem_packet_str))
""" 设置设备控制模式 回调函数 """
def HY_DChLBandOT_ControlMode_CallBack(recv_cmd):
value=0
value = recv_cmd[9]
print(value)
map_work_status_lock.acquire()
map_work_status["ControlMode"]=str(value)
map_work_status_lock.release()
""" 设置衰减指令 回调函数 """
def HY_DChLBandOT_SetATTd_CallBack(recv_cmd):
module=0
module = recv_cmd[6]
value =int((recv_cmd[8]))
# print("1111111111value == ",value)
value1 =int((recv_cmd[9]))
# print("1111111111value == ",value1)
value2 =value<<8|value1
# print("1111111111value == ",value2)
ATT_value=0.0
ATT_value = float(value2)/10
# print("22222222222ATT_value == ",ATT_value)
map_work_status_lock.acquire()
# print("2333333333333333recv_cmd = ",recv_cmd)
if(module == 0): #发射模块
if(ATT_value!=6553.5):
map_work_status["TxModuleATT"]=str(ATT_value)
map_work_status["TxModuleWorkMode"]="0"
print("ATT_value == ",(ATT_value))
else:
map_work_status["TxModuleAGC"]=str(222)
map_work_status["TxModuleWorkMode"]="1"
else:
if(ATT_value!=6553.5):
map_work_status["RxModuleATT"]=str(ATT_value)
map_work_status["RxModuleWorkMode"]="0"
else:
map_work_status["RxModuleAGC"]=str(111)
map_work_status["RxModuleWorkMode"]="1"
map_work_status_lock.release()
map_calBackFun = {"0030": HY_DChLBandOT_Query_CallBack,
"0120":HY_DChLBandOT_ControlMode_CallBack,
"0121":HY_DChLBandOT_SetATTd_CallBack
}
"""定时读取 map_work_status 发布设备状态报文 间隔200ms"""
def SendStatusHandle():
print("线程1")
global client_socket
cont = 0
cont_print = 0
max_cont = 10000
while max_cont:
# tem_packet_str =""
# tem_packet_str = packet_string()
# if (TCP_LINK_STATUS != 0):
# max_cont = max_cont - 1
# client_socket.send(tem_packet_str)
cont = cont + 1
if (cont > 2 and TCP_LINK_STATUS):
cont_print = cont_print + 1
tem_status_str = packet_status_string()
print("=============== 打印当前模拟设备状态 ================= ", cont_print)
print(tem_status_str)
cont = 0
time.sleep(1)
""" 一个模拟接收端，收到设置类型的指令后，修改 map_work_status。"""
def RecvSetCMDHandle():
print("线程2")
global TCP_LINK_STATUS
global client_socket
while 1:
data = client_socket.recv(1024)
# print("data: ",data)
if (len(data) > 0):
rec_str = data[4:6]
print(rec_str.hex())
cmd=rec_str.hex()
# if(len(data)==7):
# cmd = rec_str[0:5]
# print("1111111",cmd)#查询指令
# elif(len(data)==10 or len(data)==11):
# cmd = rec_str[0:4]
# print("1111111",cmd)#设置指令
if (cmd in map_calBackFun):
map_calBackFun[cmd](data)
else:
print("收到未知报文 : " + rec_str.hex())
else:
TCP_LINK_STATUS = 0
print("连接断开，等待接入")
client_socket.close()
client_socket, addr = tcpServer_socket.accept() # s是服务端的socket对象clientServer_socket是接入的客户端socket对象
TCP_LINK_STATUS = 1
print(addr)
cont = 0
time.sleep(1)
if __name__ == '__main__':
tr1 = threading.Thread(target=SendStatusHandle)
tr2 = threading.Thread(target=RecvSetCMDHandle)
tr1.start()
tr2.start()
simulate_device_manager/simulate_devices/HY_NP16EHPDU_hyds.py 0 → 100644
from pickletools import pyinteger_or_bool
import socket
import sys
import time
import re
import threading
import datetime
import sys
import configparser
import signal
# 定义回调函数
def myHandler(signum, frame):
print("接收信号为：", signum)
exit(0)
# 等待接收 signal.SIGTERM命令
signal.signal(signal.SIGTERM, myHandler)
argv = sys.argv[1:]
tcp_port = int(argv[0])
map_work_status_lock = threading.Lock() # 锁的声明
"""字典 数据存放的map 使用锁进行读写访问"""
map_work_status = {"Pow1": "ON",
"Pow2": "ON",
"Pow3": "ON",
"Pow4": "ON",
"Pow5": "ON",
"Pow6": "ON",
"Pow7": "ON",
"Pow8": "ON",
"Pow9": "ON",
"Pow10": "ON",
"Pow11": "ON",
"Pow12": "ON",
"Pow13": "ON",
"Pow14": "ON",
"Pow15": "ON",
"Pow16": "ON"
}
"""字段中文名"""
map_name_chg = {"Pow1": "电源输出端口1",
"Pow2": "电源输出端口2",
"Pow3": "电源输出端口3",
"Pow4": "电源输出端口4",
"Pow5": "电源输出端口5",
"Pow6": "电源输出端口6",
"Pow7": "电源输出端口7",
"Pow8": "电源输出端口8",
"Pow9": "电源输出端口9",
"Pow10": "电源输出端口10",
"Pow11": "电源输出端口11",
"Pow12": "电源输出端口12",
"Pow13": "电源输出端口13",
"Pow14": "电源输出端口14",
"Pow15": "电源输出端口15",
"Pow16": "电源输出端口16"
}
packet_head = \
"************************************************************\r\n\
* *\r\n\
* *\r\n\
* Power Outlet Port Parameters and Status *\r\n\
* *\r\n\
* *\r\n\
************************************************************\r\n\
>\r\n\
>\r\n\
\r\n\
Port | Name | status | Reserved By | Timer | AutoPing \r\n\
-----+------------+--------+-------------+-----------|---------\r\n\
"
tem_packet_str=""
def packet_string(tem_packet_str):
packet_info=""
status_str=""
for num in range(1,17):
key = "Pow"+str(num)
if(num<10):
str1=" "+ str(num).zfill(2)+" | Outlet "+str(num)+" |"
else:
str1=" "+ str(num).zfill(2)+" | Outlet "+str(num).zfill(2)+" |"
if(map_work_status[key] == "ON"):
status_str=" "+map_work_status[key] +" "
else:
status_str=" "+map_work_status[key] +" "
str3="| Open | OFF | OFF\r\n"
packet_info=packet_info+str1+status_str+str3
tem_packet_str=packet_head +packet_info+"\r\n> "
# print("11111111111122222222222222222: ",tem_packet_str)
return tem_packet_str
tem_packet_str = packet_string(tem_packet_str)
print("初始化数据：\r\n" + tem_packet_str)
tcpServer_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 1创建socket对象
tcpServer_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
tcpServer_socket.bind(('0.0.0.0', tcp_port)) # 2，需要自己绑定一个ip地址和端口号
tcpServer_socket.listen(1) # 可以同时监听3个，但是这里只有一个因为没有写多线程
client_socket, addr = tcpServer_socket.accept() # 阻塞 是服务端的socket对象clientServer_socket是接入的客户端socket对象
TCP_LINK_STATUS = 1 # TCP 连接标志位
""" 状态查询指令 回调函数 """
def HY_NP16EHPDU_PShow_CallBack(recv_cmd):
print("NP16EHPDU_PShow_CallBack")
map_work_status_lock.acquire() # 上锁
tem_packet_str=""
tem_packet_str = packet_string(tem_packet_str)
if (TCP_LINK_STATUS != 0):
# client_socket.send("".encode("utf-8"))
print("send")
client_socket.send(tem_packet_str.encode("utf-8"))
map_work_status_lock.release() # 解锁
""" 控制开关指令 回调函数"""
def HY_NP16EHPDU_SetOutPort_CallBack(recv_cmd):
print(recv_cmd)
if(len(recv_cmd)==10):
key = "Pow"+recv_cmd[5]
value = recv_cmd[7]
else:
key = "Pow"+recv_cmd[5:7]
value = recv_cmd[8]
print("key = ",key," value = ",value)
map_work_status_lock.acquire() # 上锁
if (int(value) == 1):
map_work_status[key] = "ON"
elif (int(value) == 0):
map_work_status[key] = "OFF"
map_work_status_lock.release() # 解锁
map_calBackFun = {"pset": HY_NP16EHPDU_SetOutPort_CallBack,
"pshow":HY_NP16EHPDU_PShow_CallBack
}
"""定时读取 map_work_status 发布设备状态报文 间隔200ms"""
def SendStatusHandle():
print("线程1")
global client_socket
cont = 0
cont_print = 0
max_cont = 10000
while max_cont:
map_work_status_lock.acquire()
# tem_packet_str =""
# tem_packet_str = packet_string(tem_packet_str)
# if (TCP_LINK_STATUS != 0):
# max_cont = max_cont - 1
# client_socket.send(tem_packet_str.encode("utf-8"))
tem_status_str=""
for num in range(1,17):
key = "Pow"+str(num)
tem_status_str =tem_status_str+map_name_chg[key]+" : "+map_work_status[key]+"\r\n"
map_work_status_lock.release()
cont = cont + 1
if (cont > 2 and TCP_LINK_STATUS):
cont_print = cont_print + 1
print("=============== 打印当前模拟设备状态 ================= ", cont_print)
print(tem_status_str)
cont = 0
time.sleep(1)
""" 一个模拟接收端，收到设置类型的指令后，修改 map_work_status。"""
def RecvSetCMDHandle():
print("线程2")
global TCP_LINK_STATUS
global client_socket
while 1:
data = client_socket.recv(1024)
rec_str = data.decode()
cmd=""
if (len(data) > 0):
if(len(data)==7):
cmd = rec_str[0:5]
print("1111111",cmd)#查询指令
elif(len(data)==10 or len(data)==11):
cmd = rec_str[0:4]
print("1111111",cmd)#设置指令
if (cmd in map_calBackFun):
map_calBackFun[cmd](rec_str)
# SendMessage(rec_str)
else:
print("收到未知报文 : " + rec_str)
else:
TCP_LINK_STATUS = 0
print("连接断开，等待接入")
client_socket.close()
client_socket, addr = tcpServer_socket.accept() # s是服务端的socket对象clientServer_socket是接入的客户端socket对象
TCP_LINK_STATUS = 1
print(addr)
cont = 0
time.sleep(1)
def SendMessage(recv_cmd):
global client_socket
send_str = ""
map_work_status_lock.acquire()
if recv_cmd[0] == "C":
send_str = "<" + recv_cmd
elif recv_cmd[0] == "B":
send_str = "<" + recv_cmd
elif recv_cmd[0] == "?":
send_str = "<CF_" + map_work_status["InputFrequency"] + ",BD_" + map_banwith_status[map_work_status["Bandwidth"]] + "\r\n"
client_socket.send(send_str.encode("utf-8"))
map_work_status_lock.release()
if __name__ == '__main__':
tr1 = threading.Thread(target=SendStatusHandle)
tr2 = threading.Thread(target=RecvSetCMDHandle)
tr1.start()
tr2.start()
"""数据格式：
CF_xxxx.xxx\r\n
解释：
xxxx.xxx:输入频率,范围:2200.000~3000.000,单位:MHz;
BD_x\r\n
解释：
x:带宽,范围:1,2,3 1:50KHz 2:1MHz 3:2MHz 默认 1
"""
simulate_device_manager/simulate_devices/HY_TOWEPDU_hyds.py 0 → 100644
import socket
import sys
import time
import threading
import sys
import signal
# 定义回调函数
def myHandler(signum, frame):
print("接收信号为：", signum)
exit(0)
# 等待接收 signal.SIGTERM命令
signal.signal(signal.SIGTERM, myHandler)
argv = sys.argv[1:]
tcp_port = int(argv[0])
# PDU 状态锁
map_work_status_lock = threading.Lock()
map_work_status = {
"total_voltage": 10,
"total_current": 22.2,
"total_electricity": 2222.2,
"contribute_power": 22.1,
"powerless_power": 11.1,
"inspecting_power": 22.2,
"power_factor": 20,
"temperature": 23.2,
"humidity": 10.3,
"St0": 1,
"St1": 1,
"St2": 1,
"St3": 1,
"St4": 1,
"St5": 1,
"St6": 1,
"St7": 1,
"Cur0": 10,
"Cur1": 10,
"Cur2": 10,
"Cur3": 10,
"Cur4": 10,
"Cur5": 10,
"Cur6": 10,
"Cur7": 10,
"Pow0": 5,
"Pow1": 5,
"Pow2": 5,
"Pow3": 5,
"Pow4": 5,
"Pow5": 5,
"Pow6": 5,
"Pow7": 5,
}
"""字段中文名"""
map_name_chg = {
"total_voltage": "总电压",
"total_current": "总电流",
"total_electricity": "总电能",
"contribute_power": "有功功率",
"powerless_power": "无功功率",
"inspecting_power": "视在功率",
"power_factor": "功率因数",
"temperature": "温度值",
"humidity": "湿度值",
"St0": "电源输出端口1",
"St1": "电源输出端口2",
"St2": "电源输出端口3",
"St3": "电源输出端口4",
"St4": "电源输出端口5",
"St5": "电源输出端口6",
"St6": "电源输出端口7",
"St7": "电源输出端口8",
"Cur0": "端口1电流",
"Cur1": "端口2电流",
"Cur2": "端口3电流",
"Cur3": "端口4电流",
"Cur4": "端口5电流",
"Cur5": "端口6电流",
"Cur6": "端口7电流",
"Cur7": "端口8电流",
"Pow0": "端口1功率",
"Pow1": "端口2功率",
"Pow2": "端口3功率",
"Pow3": "端口4功率",
"Pow4": "端口5功率",
"Pow5": "端口6功率",
"Pow6": "端口7功率",
"Pow7": "端口8功率",
}
packet_head = \
"************************************************************\r\n\
* *\r\n\
* *\r\n\
* Power Outlet Port Parameters and Status *\r\n\
* *\r\n\
* *\r\n\
************************************************************\r\n\
>\r\n\
>\r\n\
>\r\n\
************************************************************\r\n\
* Power Outlet Port Status *\r\n\
************************************************************\r\n\
Port | Name | status | current | power | \r\n\
-----+------------+--------+---------+--------\r\n\
"
PDU_total_info_head = \
" \
>\r\n\
>\r\n\
**********************************************************************************************\r\n\
* Total Info *\r\n\
**********************************************************************************************\r\n\
Voltage | Current | Electricity | Contribute | Powerless | Inspecting | temperature | humidity\r\n\
--------+---------+-------------+------------+-----------+------------+-------------+----------\r\n\
"
def packet_string(tem_packet_str: str = "") -> str:
packet_info = ""
for num in range(0, 8):
status_key = "St" + str(num)
current_key = "Cur" + str(num)
power_key = "Pow" + str(num)
packet_info += f" {str(num)} | Outlet {str(num)} | {map_work_status[status_key]} | {map_work_status[current_key]} | {map_work_status[power_key]} \r\n"
tem_packet_str = packet_head + packet_info
str1 = f' {map_work_status["total_voltage"]} | {map_work_status["total_current"]} | {map_work_status["total_electricity"]} | {map_work_status["contribute_power"]} |\
{map_work_status["powerless_power"]} | {map_work_status["inspecting_power"]} | {map_work_status["temperature"]} | {map_work_status["humidity"]} '
tem_packet_str += PDU_total_info_head + str1
return tem_packet_str
print("初始化数据：\r\n" + packet_string(""))
# 创建tcp通信服务
tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
tcp_server_socket.bind(('0.0.0.0', tcp_port))
tcp_server_socket.listen(1)
client_socket, addr = tcp_server_socket.accept()
# tcp 连接标志
TCP_LINK_STATUS = 1
def change_info_to_hex() -> bytes:
packet_head = bytes([0xAA, 0x43, 0x01, 0xFF, 0x00])
packet_tail = bytes([0x00, 0x00, 0x2E, 0xEC])
packet_info = bytearray()
# total voltage
value = int(float(map_work_status["total_voltage"]) * 10)
value_bytes = value.to_bytes(2, "big")
packet_info = packet_head + value_bytes
# total current
value = int(float(map_work_status["total_current"]) * 10)
value_bytes = value.to_bytes(2, "big")
packet_info += value_bytes
# total electricity
value = int(float(map_work_status["total_electricity"]) * 10)
value_bytes = value.to_bytes(4, "big")
packet_info += value_bytes
# contribute power
value = int(float(map_work_status["contribute_power"]) * 10)
value_bytes = value.to_bytes(2, "big")
packet_info += value_bytes
# powerless power
value = int(float(map_work_status["powerless_power"]) * 10)
value_bytes = value.to_bytes(2, "big")
packet_info += value_bytes
# inspecting power
value = int(float(map_work_status["inspecting_power"]) * 10)
value_bytes = value.to_bytes(2, "big")
packet_info += value_bytes
# power factor
value = int(float(map_work_status["power_factor"]) * 10)
value_bytes = value.to_bytes(2, "big")
packet_info += value_bytes
# temperature
value = int(float(map_work_status["temperature"]) * 10)
value_bytes = value.to_bytes(2, "big")
packet_info += value_bytes
# humidity
value = int(float(map_work_status["humidity"]) * 10)
value_bytes = value.to_bytes(2, "big")
packet_info += value_bytes
# power number
packet_info += bytes([0x08])
for num in range(0, 8):
status_key = "St" + str(num)
current_key = "Cur" + str(num)
power_key = "Pow" + str(num)
current_value = int(float(map_work_status[current_key]) * 10)
current_value_bytes = current_value.to_bytes(1, "big")
packet_info += current_value_bytes + bytes([0x00])
power_value = int(float(map_work_status[power_key]) * 10)
power_value_bytes = power_value.to_bytes(1, "big")
packet_info += power_value_bytes + bytes([0x00])
status_value = int(map_work_status[status_key])
status_value_bytes = status_value.to_bytes(1, "big")
packet_info += status_value_bytes
packet_info += packet_tail
return packet_info
def HY_TOWEPDU_Pshow_callback (recv_cmd: bytes) -> None:
if (len(recv_cmd) != 7):
print(f"This cmd len cant show info of the power, the len is {len(recv_cmd)}")
return
map_work_status_lock.acquire()
# tem_packet_str = packet_string(tem_packet_str)
print(packet_string(""))
tem_packet_str = change_info_to_hex()
if (TCP_LINK_STATUS != 0):
client_socket.send(tem_packet_str)
map_work_status_lock.release()
def HY_TOWEPDU_SetOutPort_callback (recv_cmd: bytes) -> None:
if (len(recv_cmd) != 9):
print(f"This cmd len cant show info of the power, the len is {len(recv_cmd)}")
return
# 00 - 07
key = f'St{int(recv_cmd[5])}'
value = int(recv_cmd[6])
map_work_status_lock.acquire()
map_work_status[key] = value
map_work_status_lock.release()
client_socket.send(bytes([0xAA, 0x07, 0x02, 0x01, 0x00, 0x07, 0x00, 0x00, 0xED, 0xEF]))
map_call_back_fun = {
"5504": HY_TOWEPDU_Pshow_callback,
"5506": HY_TOWEPDU_SetOutPort_callback
}
def send_status_handle() -> None:
print("线程1")
cont = 0
cont_print = 0
max_cont = 10000
while max_cont:
map_work_status_lock.acquire()
tem_status_str = ""
for num in range(0, 8):
key = "St" + str(num)
tem_status_str += f" {str(num)} | Outlet {str(num)} | {map_work_status[key]} |\r\n"
map_work_status_lock.release()
cont += 1
if (cont > 2 and TCP_LINK_STATUS):
cont_print += 1
print("=============== 打印当前模拟设备状态 ================= ", cont_print)
print(tem_status_str)
cont = 0
time.sleep(1)
def recv_set_CMD_handle() -> None:
print("线程2")
global TCP_LINK_STATUS
global client_socket
while True:
data = client_socket.recv(1024)
if (len(data) > 0):
rec_str = data[0: 2]
cmd = rec_str.hex()
print(f"cmd =======> {cmd}")
if (cmd in map_call_back_fun):
map_call_back_fun[cmd](data)
else:
print(f'收到位置报文 ====> {data.hex()}')
else:
TCP_LINK_STATUS = 0
print("连接断开，等待接入")
client_socket.close()
client_socket, addr = tcp_server_socket.accept()
TCP_LINK_STATUS = 1
print(addr)
time.sleep(1)
if __name__ == '__main__':
tr1 = threading.Thread(target=send_status_handle)
tr2 = threading.Thread(target=recv_set_CMD_handle)
tr1.start()
tr2.start()
simulate_device_manager/simulate_devices/HY_X-Demodulator_hyds.py 0 → 100644
from pickletools import pyinteger_or_bool
import socket
import sys
import time
import re
import threading
import datetime
import sys
import configparser
import signal
# 定义回调函数
def myHandler(signum, frame):
print("接收信号为：", signum)
exit(0)
# 等待接收 signal.SIGTERM命令
signal.signal(signal.SIGTERM, myHandler)
argv = sys.argv[1:]
tcp_port = int(argv[0])
map_work_status_lock = threading.Lock() # 锁的声明
"""字典 数据存放的map 使用锁进行读写访问"""
# DevEnvTemp 设备环境温度 精度0.01
# ControlMode 设备控制模式
# TxModuleRFPow 发射模块射频功率
# RxModuleRFPow 接收模块射频功率
# TxModuleOpPow 发送模块光功率
# RxModuleOpPow 接收模块光功率
# TxModuleWorkMode 发射模块工作模式
# RxModuleWorkMode 接收模块工作模式
# TxModuleATT 发射模MGC块衰减值
# RxModuleATT 接收模MGC块衰减值
# TxModuleAGC 发射模块AGC衰减值
# RxModuleAGC 接收模块AGC衰减值
# TxModuleTemp 发射模块温度
# RxModuleTemp 接收模块温度
# TxModuleRFPowAlarmThreshold 发射模块射频功率告警门限
# RxModuleRFPowAlarmThreshold 接收模块射频功率告警门限
# TxModuleRFPowAlarmThreshold 发射模块光功率告警门限
# RxModuleRFPowAlarmThreshold 接收模块光功率告警门限
# TxModuleopticalPowerLow 发射模块光功率过小
# TxModuleopticalPowerHight 发射模块光功率过大
# TxModuleRFPowerLow 发射模块射频功率过小
# TxModuleRFPowerHight 发射模块射频功率过大
# TxModuleWorkStatus 发射模块工作状态
# RxModuleopticalPowerLow 接收模块光功率过小
# RxModuleopticalPowerHight 接收模块光功率过大
# RxModuleRFPowerLow 接收模块射频功率过小
# RxModuleRFPowerHight 接收射模块射频功率过大
# RxModuleWorkStatus 接收模块工作状态
# DeviceWorkStatus 设备工作状态
map_work_status = {
"ControlMode": "0",
"Demodulation": "0",
"CepstrumSate": "0",
"SignalRate": "123456.789",
"DifferentialDecoding": "0",
"FEC": "0",
"DecodingChannels": "1",
"ConvolutionalDecodingState": "0",
"RSDecoding": "0",
"RSChannels": "1",
"RSDepth": "1",
"Descrambling": "0",
"IPPacketSize": "0",
"FrameDetect": "0",
"SYNCLength": "1",
"FrameLength": "01024",
"SYNC_I": "000000001ACFFC1D",
"SYNC_Q": "000000001ACFFC1D",
"CRC_Switch": "0",
"IFInputStatus": "0",
"DSStatus": "0",
"DecodingIndication": "0",
"Eb_No": "12.5",
"DemodulationBitErrorRate": "1.2-34",
"IF_Level": "-12.5",
# "RemDataLinkStatus": "远程数据传输终端连接状态", 这个模拟的也不会有
# "ERRORINFO": "参数设置状态", 这个暂时不用
"StartTime": "11111111111111",
"EndTime": "2222222222222",
"targetID": "33333",
"frequency": "1234.5"
}
# ControlMode 控制模式
# Demodulation 接收信号解调方式
# CepstrumSate 接收信号倒谱状态
# SignalRate 接收信号信息速率
# DifferentialDecoding 差分译码
# FEC 前向纠错
# DecodingChannels 前向纠错译码路数
# ConvolutionalDecodingState 卷积译码状态
# RSDecoding RS译码状态
# RSChannels RS译码路数
# RSDepth RS译码交织深度
# Descrambling 去扰状态
# IPPacketSize IP包长设置
# FrameDetect 帧检测
# SYNCLength 同步码长度
# FrameLength 帧长度
# SYNC_I I路同步码型
# SYNC_Q Q路同步码型
# CRC_Switch CRC校验开关状态
# IFInputStatus 中频输入信号状态
# DSStatus 解调同步状态
# DecodingIndication 译码或帧同步状态
# Eb_No 信号Eb/No
# DemodulationBitErrorRate 解调误码率
# IF_Level 中频电平幅度
"""字段中文名"""
map_name_chg = {
"ControlMode": "控制模式",
"Demodulation": "接收信号解调方式",
"CepstrumSate": "接收信号倒谱状态",
"SignalRate": "接收信号信息速率",
"DifferentialDecoding": "差分译码",
"FEC": "前向纠错",
"DecodingChannels": "前向纠错译码路数",
"ConvolutionalDecodingState": "卷积译码状态",
"RSDecoding": "RS译码状态",
"RSChannels": "RS译码路数",
"RSDepth": "RS译码交织深度",
"Descrambling": "去扰状态",
"IPPacketSize": "IP包长设置",
"FrameDetect": "帧检测",
"SYNCLength": "同步码长度",
"FrameLength": "帧长度",
"SYNC_I": "I路同步码型",
"SYNC_Q": "Q路同步码型",
"CRC_Switch": "CRC校验开关状态",
"IFInputStatus": "Q路同步码型",
"DSStatus": "解调同步状态",
"DecodingIndication": "译码或帧同步状态",
"Eb_No": "信号Eb/No",
"DemodulationBitErrorRate": "解调误码率",
"IF_Level": "中频电平幅度",
# "RemDataLinkStatus": "远程数据传输终端连接状态", 这个模拟的也不会有
# "ERRORINFO": "参数设置状态", 这个暂时不用
"StartTime": "任务开始时间",
"EndTime": "任务结束时间",
"targetID": "卫星编号参数",
"frequency": "频率"
}
packet_head =bytearray([0xeb,0x90,0x3e, 0x4f, 0x7b, 0x7a])
packet_end ="000000000000000000000000000000000000000000000000000000000000"
# print("1111111111111111 ",packet_head)
tem_packet_str=""
Eb_No_value = 12.5
def packet_string():
global Eb_No_value
if(Eb_No_value>90):
Eb_No_value=10
Eb_No_value=Eb_No_value+1.5
str_Eb_No=format(Eb_No_value,'.1f')
map_work_status_lock.acquire()
map_work_status["Eb_No"]=str_Eb_No
packet_info=\
map_work_status["ControlMode"]+\
map_work_status["Demodulation"]+\
map_work_status["CepstrumSate"]+\
map_work_status["SignalRate"]+\
map_work_status["DifferentialDecoding"]+\
map_work_status["FEC"]+\
map_work_status["DecodingChannels"]+\
map_work_status["ConvolutionalDecodingState"]+\
map_work_status["RSDecoding"]+\
map_work_status["RSChannels"]+\
map_work_status["RSDepth"]+\
map_work_status["Descrambling"]+\
map_work_status["IPPacketSize"]+\
map_work_status["FrameDetect"]+\
map_work_status["SYNCLength"]+\
map_work_status["FrameLength"]+\
map_work_status["SYNC_I"]+\
map_work_status["SYNC_Q"]+\
map_work_status["CRC_Switch"]+\
map_work_status["IFInputStatus"]+\
map_work_status["DSStatus"]+\
map_work_status["DecodingIndication"]+\
map_work_status["Eb_No"]+\
map_work_status["DemodulationBitErrorRate"]+\
map_work_status["IF_Level"]+packet_end
map_work_status_lock.release()
# print("11111111111122222222222222222: ",tem_packet_str)
return packet_head+packet_info.encode("utf-8")
def packet_status_string():
map_work_status_lock.acquire()
packet_info=\
map_name_chg["ControlMode"]+" : "+map_work_status["ControlMode"]+"\r\n"+\
map_name_chg["Demodulation"]+" : "+map_work_status["Demodulation"]+"\r\n"+\
map_name_chg["CepstrumSate"]+" : "+ map_work_status["CepstrumSate"]+"\r\n"+\
map_name_chg["SignalRate"]+" : "+ map_work_status["SignalRate"]+"\r\n"+\
map_name_chg["DifferentialDecoding"]+" : "+map_work_status["DifferentialDecoding"]+"\r\n"+\
map_name_chg["FEC"]+" : "+ map_work_status["FEC"]+"\r\n"+\
map_name_chg["DecodingChannels"]+" : "+map_work_status["DecodingChannels"]+"\r\n"+\
map_name_chg["ConvolutionalDecodingState"]+" : "+ map_work_status["ConvolutionalDecodingState"]+"\r\n"+\
map_name_chg["RSDecoding"]+" : "+ map_work_status["RSDecoding"]+"\r\n"+\
map_name_chg["RSChannels"]+" : "+ map_work_status["RSChannels"]+"\r\n"+\
map_name_chg["RSDepth"]+" : "+ map_work_status["RSDepth"]+"\r\n"+\
map_name_chg["Descrambling"]+" : "+ map_work_status["Descrambling"]+"\r\n"+\
map_name_chg["IPPacketSize"]+" : "+ map_work_status["IPPacketSize"]+"\r\n"+\
map_name_chg["FrameDetect"]+" : "+ map_work_status["FrameDetect"]+"\r\n"+\
map_name_chg["SYNCLength"]+" : "+ map_work_status["SYNCLength"]+"\r\n"+\
map_name_chg["FrameLength"]+" : "+map_work_status["FrameLength"]+"\r\n"+\
map_name_chg["SYNC_I"]+" : "+map_work_status["SYNC_I"]+"\r\n"+\
map_name_chg["SYNC_Q"]+" : "+ map_work_status["SYNC_Q"]+"\r\n"+\
map_name_chg["CRC_Switch"]+" : "+ map_work_status["CRC_Switch"]+"\r\n"+\
map_name_chg["IFInputStatus"]+" : "+map_work_status["IFInputStatus"]+"\r\n"+\
map_name_chg["DSStatus"]+" : "+map_work_status["DSStatus"]+"\r\n"+\
map_name_chg["DecodingIndication"]+" : "+map_work_status["DecodingIndication"]+"\r\n"+\
map_name_chg["Eb_No"]+" : "+map_work_status["Eb_No"]+"\r\n"+\
map_name_chg["DemodulationBitErrorRate"]+" : "+map_work_status["DemodulationBitErrorRate"]+"\r\n"+\
map_name_chg["IF_Level"]+" : "+map_work_status["IF_Level"]+"\r\n"+\
map_name_chg["StartTime"]+" : "+map_work_status["StartTime"]+"\r\n"+\
map_name_chg["EndTime"]+" : "+map_work_status["EndTime"]+"\r\n"+\
map_name_chg["targetID"]+" : "+map_work_status["targetID"]+"\r\n"+\
map_name_chg["frequency"]+" : "+map_work_status["frequency"]
map_work_status_lock.release()
# print("11111111111122222222222222222: ",packet_info)
return packet_info
initstr=packet_status_string()
tem_packet_str = packet_string()
print("初始化数据：\r\n" + initstr)
tcpServer_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 1创建socket对象
tcpServer_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
tcpServer_socket.bind(('0.0.0.0', tcp_port)) # 2，需要自己绑定一个ip地址和端口号
tcpServer_socket.listen(1) # 可以同时监听3个，但是这里只有一个因为没有写多线程
client_socket, addr = tcpServer_socket.accept() # 阻塞 是服务端的socket对象clientServer_socket是接入的客户端socket对象
TCP_LINK_STATUS = 1 # TCP 连接标志位
""" 状态查询指令 回调函数 """
def HY_HSM_QueryStatus_CallBack(recv_cmd):
# print(recv_cmd.hex()) binascii.unhexlify(hex_str.encode())
tem_packet_str = packet_string()
if (TCP_LINK_STATUS != 0):
client_socket.send((tem_packet_str))
""" 参数设置指令 回调函数"""
def HY_HSM_ParamSetting_CallBack(recv_cmd):
buf = recv_cmd[6:].decode()
# print("11111111111 == " ,buf)
map_work_status_lock.acquire()
map_work_status["ControlMode"]=buf[0]
map_work_status["Demodulation"]=buf[1]
map_work_status["CepstrumSate"]=buf[2]
map_work_status["SignalRate"]=buf[3:13]
map_work_status["DifferentialDecoding"]=buf[13]
map_work_status["FEC"]=buf[14]
map_work_status["DecodingChannels"]=buf[15]
map_work_status["ConvolutionalDecodingState"]=buf[16]
map_work_status["RSDecoding"]=buf[17]
map_work_status["RSChannels"]=buf[18]
map_work_status["RSDepth"]=buf[19]
map_work_status["Descrambling"]=buf[20]
map_work_status["IPPacketSize"]=buf[21]
map_work_status["FrameDetect"]=buf[22]
map_work_status["SYNCLength"]=buf[23]
map_work_status["FrameLength"]=buf[24:29]
map_work_status["SYNC_I"]=buf[29:45]
map_work_status["SYNC_Q"]=buf[45:61]
map_work_status["CRC_Switch"]=buf[61]
# map_work_status["Demodulation"]=
map_work_status_lock.release()
tem_packet_str = bytearray([0xeb,0x90,0x3E, 0X00])+recv_cmd[4:]
# tem_packet_str = packet_string()
if (TCP_LINK_STATUS != 0):
client_socket.send((tem_packet_str))
""" 开始接收数据控制指令 回调函数 """
def HY_HSM_StartReceiveDataControl_CallBack(recv_cmd):
# print(recv_cmd.hex()) binascii.unhexlify(hex_str.encode())
tem_packet_str = bytearray([0xeb,0x90,0x3E, 0X09])+recv_cmd[4:]
# tem_packet_str = packet_string()
buf = recv_cmd[6:].decode()
print(buf)
map_work_status_lock.acquire()
map_work_status["StartTime"]=buf[0:14]
map_work_status["EndTime"]=buf[14:28]
map_work_status["targetID"]=buf[28:33]
map_work_status["frequency"]=buf[33:39 ]
map_work_status_lock.release()
if (TCP_LINK_STATUS != 0):
client_socket.send((tem_packet_str))
""" 停止记录控制指令 回调函数 """
def HY_HSM_StopRecord_CallBack(recv_cmd):
# print(recv_cmd.hex()) binascii.unhexlify(hex_str.encode())
tem_packet_str = bytearray([0xeb,0x90,0x3E, 0X0a])+recv_cmd[4:]
# tem_packet_str = packet_string()
if (TCP_LINK_STATUS != 0):
client_socket.send((tem_packet_str))
map_calBackFun = {"eb903c4f": HY_HSM_QueryStatus_CallBack,
"eb903c00":HY_HSM_ParamSetting_CallBack,
"eb903c09":HY_HSM_StartReceiveDataControl_CallBack,
"eb903c0a":HY_HSM_StopRecord_CallBack
}
"""定时读取 map_work_status 发布设备状态报文 间隔200ms"""
def SendStatusHandle():
print("线程1")
global client_socket
cont = 0
cont_print = 0
max_cont = 10000
while max_cont:
# tem_packet_str =""
# tem_packet_str = packet_string()
# if (TCP_LINK_STATUS != 0):
# max_cont = max_cont - 1
# client_socket.send(tem_packet_str.encode("utf-8"))
cont = cont + 1
if (cont > 2 and TCP_LINK_STATUS):
cont_print = cont_print + 1
tem_status_str = packet_status_string()
print("=============== 打印当前模拟设备状态 ================= ", cont_print)
print(tem_status_str)
cont = 0
time.sleep(1)
""" 一个模拟接收端，收到设置类型的指令后，修改 map_work_status。"""
def RecvSetCMDHandle():
print("线程2")
global TCP_LINK_STATUS
global client_socket
while 1:
data = client_socket.recv(1024)
if (len(data) > 0):
rec_str = data[0:4]
print(rec_str.hex())
cmd=rec_str.hex()
# if(len(data)==7):
# cmd = rec_str[0:5]
# print("1111111",cmd)#查询指令
# elif(len(data)==10 or len(data)==11):
# cmd = rec_str[0:4]
# print("1111111",cmd)#设置指令
if (cmd in map_calBackFun):
map_calBackFun[cmd](data)
# SendMessage(rec_str)
else:
print("收到未知报文 : " + rec_str.hex())
else:
TCP_LINK_STATUS = 0
print("连接断开，等待接入")
client_socket.close()
client_socket, addr = tcpServer_socket.accept() # s是服务端的socket对象clientServer_socket是接入的客户端socket对象
TCP_LINK_STATUS = 1
print(addr)
cont = 0
time.sleep(1)
if __name__ == '__main__':
tr1 = threading.Thread(target=SendStatusHandle)
tr2 = threading.Thread(target=RecvSetCMDHandle)
tr1.start()
tr2.start()
simulate_device_manager/simulate_devices/HY_trackingReceiver_hyds.py 0 → 100644
from pickletools import pyinteger_or_bool
import socket
import sys
import time
import re
import threading
import datetime
import sys
import configparser
import signal
# 定义回调函数
def myHandler(signum, frame):
print("接收信号为：", signum)
exit(0)
# 等待接收 signal.SIGTERM命令
signal.signal(signal.SIGTERM, myHandler)
argv = sys.argv[1:]
tcp_port = int(argv[0])
map_work_status_lock = threading.Lock() # 锁的声明
"""字典 数据存放的map 使用锁进行读写访问"""
map_work_status = {"InputFrequency": "2200.000", "Bandwidth": "50KHz"}
"""字段中文名"""
map_name_chg = {"InputFrequency": "输入频率", "Bandwidth": "带宽"}
map_banwith_status = {"50KHz":"1","1MHz":"2","2MHz":"3"}
tem_packet_str = map_name_chg["InputFrequency"]+":"+map_work_status["InputFrequency"]+" "+map_name_chg["Bandwidth"]+":"+map_work_status["Bandwidth"]
print("初始化数据：" + tem_packet_str)
# config = configparser.ConfigParser() # 类实例化
# 定义ini文件路径 这个文件用于存放 跟踪接收机当前的报警状态
# path = r'trackingReceiver.ini'
tcpServer_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 1创建socket对象
tcpServer_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
tcpServer_socket.bind(('0.0.0.0', tcp_port)) # 2，需要自己绑定一个ip地址和端口号
tcpServer_socket.listen(1) # 可以同时监听3个，但是这里只有一个因为没有写多线程
client_socket, addr = tcpServer_socket.accept() # 阻塞 是服务端的socket对象clientServer_socket是接入的客户端socket对象
TCP_LINK_STATUS = 1 # TCP 连接标志位
""" 处理输入频率指令 回调函数"""
def HY_TrackingReceiver_SetInputFrequency_CallBack(recv_cmd):
InputFrequency = recv_cmd[3:11]
print("HY_TrackingReceiver_SetInputFrequency_CallBack InputFrequency = ",InputFrequency)
map_work_status_lock.acquire() # 上锁
map_work_status["InputFrequency"] = InputFrequency
map_work_status_lock.release() # 解锁
""" 处理带宽指令 回调函数"""
def HY_TrackingReceiver_Bandwidth_CallBack(recv_cmd):
Bandwith = recv_cmd[3]
print("HY_TrackingReceiver_Bandwidth_CallBack Bandwith = ",Bandwith)
map_work_status_lock.acquire() # 上锁
if int(Bandwith) == 1:
map_work_status["Bandwidth"] = "50KHz"
elif int(Bandwith) == 2:
map_work_status["Bandwidth"] = "1MHz"
elif int(Bandwith) == 3:
map_work_status["Bandwidth"] = "2MHz"
else:
map_work_status["Bandwidth"] = "50KHz"
map_work_status_lock.release() # 解锁
""" 处理查询状态指令 回调函数"""
def HY_TrackingReceiver_QueryState_CallBack(recv_cmd):
map_work_status_lock.acquire() # 上锁
# print("2222222222222",recv_cmd)
#map_work_status = map_work_status
tem_packet_str = "CF_" + map_work_status["InputFrequency"] + ", BD_" + map_banwith_status[map_work_status["Bandwidth"]]+ " \r\n"
# tem_status_str = map_name_chg["InputFrequency"]+":"+map_work_status["InputFrequency"]+"\r\n"+map_name_chg["Bandwidth"]+":"+map_work_status["Bandwidth"]+"\r\n"
if (TCP_LINK_STATUS != 0):
client_socket.send(tem_packet_str.encode("utf-8"))
map_work_status_lock.release() # 解锁
map_calBackFun = {"C": HY_TrackingReceiver_SetInputFrequency_CallBack,
"B": HY_TrackingReceiver_Bandwidth_CallBack,
"?": HY_TrackingReceiver_QueryState_CallBack}
"""定时读取 map_work_status 发布设备状态报文 间隔200ms"""
def SendStatusHandle():
print("线程1")
global client_socket
cont = 0
cont_print = 0
max_cont = 10000
while max_cont:
map_work_status_lock.acquire()
# tem_packet_str = "<CF_" + map_work_status["InputFrequency"] + ",BD_" + map_banwith_status[map_work_status["Bandwidth"]]+ "\r\n"
tem_status_str = map_name_chg["InputFrequency"]+":"+map_work_status["InputFrequency"]+"\r\n"+map_name_chg["Bandwidth"]+":"+map_work_status["Bandwidth"]+"\r\n"
# if (TCP_LINK_STATUS != 0):
# max_cont = max_cont - 1
# client_socket.send(tem_packet_str.encode("utf-8"))
map_work_status_lock.release()
cont = cont + 1
if (cont > 2 and TCP_LINK_STATUS):
cont_print = cont_print + 1
print("=============== 打印当前模拟设备状态 ================= ", cont_print)
print(tem_status_str)
cont = 0
time.sleep(1)
""" 一个模拟接收端，收到设置类型的指令后，修改map_work_status。"""
def RecvSetCMDHandle():
print("线程2")
global TCP_LINK_STATUS
global client_socket
while 1:
data = client_socket.recv(1024)
rec_str = data.decode()
if (len(data) > 0):
cmd = rec_str[0]
# print("1111111",cmd)
# print("2222222",rec_str)
if (cmd in map_calBackFun):
map_calBackFun[cmd](rec_str)
# SendMessage(rec_str)
else:
print("收到未知报文 : " + rec_str)
else:
TCP_LINK_STATUS = 0
print("连接断开，等待接入")
client_socket.close()
client_socket, addr = tcpServer_socket.accept() # s是服务端的socket对象clientServer_socket是接入的客户端socket对象
TCP_LINK_STATUS = 1
print(addr)
cont = 0
time.sleep(1)
def SendMessage(recv_cmd):
global client_socket
send_str = ""
map_work_status_lock.acquire()
if recv_cmd[0] == "C":
send_str = "<" + recv_cmd
elif recv_cmd[0] == "B":
send_str = "<" + recv_cmd
elif recv_cmd[0] == "?":
send_str = "<CF_" + map_work_status["InputFrequency"] + ",BD_" + map_banwith_status[map_work_status["Bandwidth"]] + "\r\n"
client_socket.send(send_str.encode("utf-8"))
map_work_status_lock.release()
if __name__ == '__main__':
tr1 = threading.Thread(target=SendStatusHandle)
tr2 = threading.Thread(target=RecvSetCMDHandle)
tr1.start()
tr2.start()
"""数据格式：
CF_xxxx.xxx\r\n
解释：
xxxx.xxx:输入频率,范围:2200.000~3000.000,单位:MHz;
BD_x\r\n
解释：
x:带宽,范围:1,2,3 1:50KHz 2:1MHz 3:2MHz 默认 1
"""
simulate_device_manager/simulate_devices/acu7m5_hyds.ini 0 → 100644
; XaxisAlarm X轴报警 Boolean 1 X轴报警；0 正常；
; XaxisServoStatus X轴伺服状态 Boolean 1 X轴伺服打开；0 X轴伺服关闭；
; EasternLimit 东限位 Boolean 1 东限位；0 正常；
; WestLimit 西限位 Boolean 1 西限位；0 正常；
; YaxisAlarm Y轴报警 Boolean 1 Y轴报警；0 正常；
; YaxisServoStatus Y轴伺服 Boolean 1 Y轴伺服打开；0 Y轴伺服关闭；
; SouthrLimit 南限位 Boolean 1 限位；0 正常；
; NorthLimit 北限位 Boolean 1 限位；0 正常；
[alarm_status]
XaxisAlarm = 0
XaxisServoStatus = 1
EasternLimit = 0
WestLimit = 0
YaxisAlarm = 0
YaxisServoStatus= 1
SouthrLimit = 0
NorthLimit = 1
simulate_device_manager/urls.py 0 → 100644
from django.urls import re_path
from .views import change_simulate_device_status
urlpatterns = [
re_path(r'^change_simulate_device/$', change_simulate_device_status)
]
simulate_device_manager/views.py 0 → 100644
from rest_framework.decorators import api_view
from rest_framework.response import Response
from rest_framework import status
from device_data_op.models import TableXproAllDevinfo
from drf_yasg.utils import swagger_auto_schema
from drf_yasg import openapi
from .device_manager import SIMULATE_DEVICE_PROCESS, start_signal, stop_signal
@swagger_auto_schema(method='post', request_body=openapi.Schema(
type=openapi.TYPE_OBJECT,
properties={
'status': openapi.Schema(type=openapi.TYPE_BOOLEAN),
'protocol_name': openapi.Schema(type=openapi.TYPE_STRING),
'device_name': openapi.Schema(type=openapi.TYPE_STRING)
}
), responses={200: 'OK', 400: 'Bad Request', 500: 'Internal Server Error'})
@api_view(['POST'])
def change_simulate_device_status(request):
"""
通过 subprocess 模块来启动或者关闭模拟设备
"""
device_status = request.data.get('status')
protocol_name = request.data.get('protocol_name')
device_name = request.data.get('device_name')
if device_status is None or protocol_name is None or device_name is None:
return Response(status=status.HTTP_400_BAD_REQUEST)
# 获取改设备的端口
device_communication = TableXproAllDevinfo.objects.filter(dev_name=device_name).first()
if "TCP" in device_communication.comunitate_mode.upper():
device_port = device_communication.tcp_port
else:
return Response(status=status.HTTP_500_INTERNAL_SERVER_ERROR)
# 发送相关信号
if device_status == 'true':
if device_name in SIMULATE_DEVICE_PROCESS.keys():
return Response(status=status.HTTP_400_BAD_REQUEST)
start_signal.send(sender=None, protocol_name=protocol_name, device_name=device_name, port=device_port)
else:
if device_name not in SIMULATE_DEVICE_PROCESS.keys():
return Response(status=status.HTTP_400_BAD_REQUEST)
stop_signal.send(sender=None, device_name=device_name)
return Response(status=status.HTTP_200_OK)
vue_django/urls.py
...@@ -42,6 +42,7 @@ urlpatterns = [ ...@@ -42,6 +42,7 @@ urlpatterns = [
path("api/", include("download_db.urls")), path("api/", include("download_db.urls")),
path("api/", include("protocol_version_manage.urls")), path("api/", include("protocol_version_manage.urls")),
path("api/", include("device_communication.urls")), path("api/", include("device_communication.urls")),
path("api/", include("simulate_device_manager.urls")),
re_path(r'^assets/(?P<path>.*)/$', serve, {'document_root': settings.STATIC_ROOT}), re_path(r'^assets/(?P<path>.*)/$', serve, {'document_root': settings.STATIC_ROOT}),
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment