package com.hxzkoa.udp;
|
|
import java.math.BigInteger;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
|
import com.hxzkoa.json.tb_achor;
|
import com.hxzkoa.json.tb_person;
|
import com.hxzkoa.util.Config;
|
import com.hxzkoa.util.HttpUtil;
|
import com.hxzkoa.util.ModifyConfig;
|
|
import net.sf.json.JSONObject;
|
|
public class ReadPeizhiMessage {
|
|
public static boolean readpeizhi_succ=false;
|
|
/**读取配置信息*/
|
public static String get_readpeizhi(String ip,String message) {
|
String peizhi=message;
|
if(message.startsWith("55AA0355") ) {
|
//System.out.println("msg"+message);
|
|
String[] hex=new String[70];
|
for(int i=0;i<70;i++) {
|
hex[i]=message.substring(14+i*2, 16+i*2);
|
}
|
|
//将配置保存到property文件中
|
String filePath = Config.getAnchorConfig();
|
|
//固件版本
|
String r_version="V"+Integer.parseInt(hex[1],16)+"."+Integer.parseInt(hex[0],16);
|
ModifyConfig.writeData(filePath,"gujianbanben",r_version);
|
|
//模块ID
|
String r_ida=hex[3];
|
String r_idb=hex[2];
|
if(r_ida.length()<2) {
|
r_ida="0"+r_ida;
|
}
|
if(r_idb.length()<2) {
|
r_idb="0"+r_idb;
|
}
|
String r_id=r_ida+r_idb;
|
ModifyConfig.writeData(filePath,"jizhanid",r_id);
|
|
//修改基站的版本
|
tb_achor anchor = new tb_achor();
|
anchor.setAnchorip(ip);
|
anchor.setVersion(r_version);
|
String postUrl = Config.getPostUrl() + "modify_anchor_version.do";
|
JSONObject jsonObject = JSONObject.fromObject(anchor);
|
HttpUtil.doPost(postUrl, jsonObject.toString(), "UTF-8");
|
|
|
//标签通讯间隔(通讯频率)
|
String r_hz1=hex[5]+hex[4];
|
String r_hz=String.valueOf(decodeHEX(r_hz1));
|
ModifyConfig.writeData(filePath,"tongxunpinlv",r_hz);
|
|
//单次通讯基站数量上限（通讯上限）
|
String r_tongxunshangxian1=hex[7]+hex[6];
|
String r_tongxunshangxian=String.valueOf(decodeHEX(r_tongxunshangxian1));
|
ModifyConfig.writeData(filePath,"tongxunshangxian",r_tongxunshangxian);
|
|
//小组id（通讯小组）
|
String r_tongxunxiaxian1=hex[9]+hex[8];
|
String r_tongxunxiaxian=String.valueOf(decodeHEX(r_tongxunxiaxian1));
|
ModifyConfig.writeData(filePath,"tongxunxiaozu",r_tongxunxiaxian);
|
|
//距离校准值（误差校准）
|
String r_jiaozhunzhi1=hex[11]+hex[10];
|
//带符号十六进制转换十进制
|
String r_jiaozhunzhi=String.valueOf((Integer.valueOf(r_jiaozhunzhi1, 16).shortValue()));
|
ModifyConfig.writeData(filePath,"wuchajiaozhun",r_jiaozhunzhi);
|
|
//模块类型（设备模式）
|
String r_leixing1=hex[13]+hex[12];
|
String r_leixing=String.valueOf(decodeHEX(r_leixing1));
|
if(r_leixing.equals("0")) {
|
ModifyConfig.writeData(filePath,"shebeimoshi","jizhan");
|
}else {
|
ModifyConfig.writeData(filePath,"shebeimoshi","biaoqian");
|
}
|
|
//基站主动测距（是否开启主动测距）
|
String r_zhudongceju1=hex[15]+hex[14];
|
String r_zhudongceju=String.valueOf(decodeHEX(r_zhudongceju1));
|
if(r_zhudongceju.equals("1")) {
|
ModifyConfig.writeData(filePath,"zhudongceju","true");
|
}else {
|
ModifyConfig.writeData(filePath,"zhudongceju","false");
|
}
|
|
//报警设备hex[17]+hex[16]
|
|
//报警距离1hex[19]+hex[18]切换距离
|
//距离校准值（切换距离）
|
String r_qiehuan=hex[19]+hex[18];
|
//带符号十六进制转换十进制
|
String r_qie=String.valueOf((Integer.valueOf(r_qiehuan, 16).shortValue()));
|
ModifyConfig.writeData(filePath,"qiehuanjuli",r_qie);
|
|
//报警距离2hex[21]+hex[20]
|
|
//报警距离3hex[23]+hex[22]
|
|
//配对ID hex[25]+hex[24]
|
|
|
//心跳包（开启心跳）
|
String heart1=hex[27]+hex[26];
|
String r_heart=String.valueOf(decodeHEX(heart1));
|
if(r_heart.equals("1")) {
|
ModifyConfig.writeData(filePath,"kaiqixintiao","true");
|
}else {
|
ModifyConfig.writeData(filePath,"kaiqixintiao","false");
|
}
|
|
//MODBUS模式hex[29]+hex[28];
|
|
//临近基站数量
|
String r_nernum1=hex[31]+hex[30];
|
String r_nernum=String.valueOf(decodeHEX(r_nernum1));
|
ModifyConfig.writeData(filePath,"linjinjizhanshuliang",r_nernum);
|
|
//临近基站1
|
String r_near11=hex[33]+hex[32];
|
if(r_near11.equals("0001") || r_near11.equals("0000") ) {
|
ModifyConfig.writeData(filePath,"linjinjizhan1","");
|
} else {
|
ModifyConfig.writeData(filePath,"linjinjizhan1",r_near11);
|
}
|
|
//临近基站2
|
String r_near22=hex[35]+hex[34];
|
if(r_near22.equals("0001") || r_near22.equals("0000") ) {
|
ModifyConfig.writeData(filePath,"linjinjizhan2","");
|
} else {
|
ModifyConfig.writeData(filePath,"linjinjizhan2",r_near22);
|
}
|
|
//临近基站3
|
String r_near33=hex[37]+hex[36];
|
if(r_near33.equals("0001") || r_near33.equals("0000") ) {
|
ModifyConfig.writeData(filePath,"linjinjizhan3","");
|
} else {
|
ModifyConfig.writeData(filePath,"linjinjizhan3",r_near33);
|
}
|
|
//临近基站4
|
String r_near44=hex[39]+hex[38];
|
if(r_near44.equals("0001") || r_near44.equals("0000") ) {
|
ModifyConfig.writeData(filePath,"linjinjizhan4","");
|
} else {
|
ModifyConfig.writeData(filePath,"linjinjizhan4",r_near44);
|
}
|
|
//临近基站5
|
String r_near55=hex[41]+hex[40];
|
if(r_near55.equals("0001") || r_near55.equals("0000") ) {
|
ModifyConfig.writeData(filePath,"linjinjizhan5","");
|
} else {
|
ModifyConfig.writeData(filePath,"linjinjizhan5",r_near55);
|
}
|
|
//临近基站6
|
String r_near66=hex[43]+hex[42];
|
if(r_near66.equals("0001") || r_near66.equals("0000") ) {
|
ModifyConfig.writeData(filePath,"linjinjizhan6","");
|
} else {
|
ModifyConfig.writeData(filePath,"linjinjizhan6",r_near66);
|
}
|
|
//临近基站7
|
String r_near77=hex[45]+hex[44];
|
if(r_near77.equals("0001") || r_near77.equals("0000") ) {
|
ModifyConfig.writeData(filePath,"linjinjizhan7","");
|
} else {
|
ModifyConfig.writeData(filePath,"linjinjizhan7",r_near77);
|
}
|
|
//临近基站8
|
String r_near88=hex[47]+hex[46];
|
if(r_near88.equals("0001") || r_near88.equals("0000") ) {
|
ModifyConfig.writeData(filePath,"linjinjizhan8","");
|
} else {
|
ModifyConfig.writeData(filePath,"linjinjizhan8",r_near88);
|
}
|
|
//临近基站9
|
String r_near99=hex[49]+hex[48];
|
|
//临近基站10
|
String r_near10=hex[51]+hex[50];
|
|
|
//发射功率0x36
|
String r_gonglv1=hex[53]+hex[52];
|
String r_gonglv=String.valueOf(decodeHEX(r_gonglv1));
|
ModifyConfig.writeData(filePath,"fashegonglv",r_gonglv);
|
|
//加速度计阈值（no）
|
String r_imu_thres1=hex[55]+hex[54];
|
String r_imu_thres=String.valueOf(decodeHEX(r_imu_thres1));
|
|
//无静止休眠时间(no)
|
String r_sleep1=hex[57]+hex[56];
|
String r_sleep=String.valueOf(decodeHEX(r_sleep1));
|
|
//振动使能0x3c(no)
|
String r_zhendong1=hex[59]+hex[58];
|
String r_zhendong=String.valueOf(decodeHEX(r_zhendong1));
|
|
//加速计使能(no)
|
String r_jiasuji1=hex[61]+hex[60];
|
String r_jiasuji=String.valueOf(decodeHEX(r_jiasuji1));
|
|
//标签下发配置状态
|
String r_peizhi1=hex[63]+hex[62];
|
String r_peizhi=String.valueOf(decodeHEX(r_peizhi1));
|
|
//标签下发配置id 0x42
|
String r_peizhiid1=hex[65]+hex[64];
|
String r_peizhiid=String.valueOf(decodeHEX(r_peizhiid1));
|
|
//0x44同步主机站ID(同步基站)
|
|
String r_id1=hex[67];
|
String r_id2=hex[66];
|
if(r_id1.length()<2) {
|
r_id1="0"+r_id1;
|
}
|
if(r_id2.length()<2) {
|
r_id2="0"+r_id2;
|
}
|
String r_rootanchor=r_id1+r_id2;
|
ModifyConfig.writeData(filePath,"tongbujizhan",r_rootanchor);
|
|
//0x45同步基站类型(0-无，1-主，2-从)
|
String r_xuhao1=hex[69]+hex[68];
|
String r_xuhao=String.valueOf(decodeHEX(r_xuhao1));
|
if(r_xuhao.equals("0")) {
|
ModifyConfig.writeData(filePath,"tongjileixing","wu");
|
}else if(r_xuhao.equals("1")) {
|
ModifyConfig.writeData(filePath,"tongjileixing","zhu");
|
}else if(r_xuhao.equals("2")) {
|
ModifyConfig.writeData(filePath,"tongjileixing","cong");
|
}
|
|
if(message.length()>137) {
|
String hex69=message.substring(138, 140);
|
String hex70=message.substring(140, 142);
|
String r_lubocanshu1=hex70+hex69;
|
String r_lubocanshu=String.valueOf(decodeHEX(r_lubocanshu1));//滤波参数
|
ModifyConfig.writeData(filePath,"lvbocanshu",r_lubocanshu);
|
//AnchorSet.jf_lvbo.setText(r_lubocanshu);
|
}
|
ModifyConfig.writeData(filePath,"readpeizhi","done");
|
|
}
|
return peizhi;
|
}
|
|
/**保存配置信息
|
* @param anchorid基站id
|
* @param gonglv基站功率
|
* @param wucha基站误差
|
* @param lvbo滤波参数
|
* @param zu组
|
* @param hz频率
|
* @param shangxian通讯数量上限
|
* @param rootanchor同步基站
|
* @param xuhao同步基站类型0普通基站，1主机站，2是从基站*/
|
public static byte[] save(
|
String anchorid,
|
String gonglv,
|
String wucha,
|
String lvbo,
|
String zu,
|
String hz,
|
String shangxian,
|
String type,
|
String nearnum,
|
String near1,
|
String near2,
|
String near3,
|
String near4,
|
String near5,
|
String near6,
|
String near7,
|
String near8,
|
String near9,
|
String qiehuan,
|
String initiative,
|
String heart,
|
String rootanchor,
|
String xuhao
|
) {
|
byte[] data=null;
|
int[] value=new int[34];
|
|
//设备id 0x4
|
value[0]=covert(anchorid);
|
|
//标签通讯间隔 0x6
|
value[1]=Integer.parseInt(hz);
|
|
//单次通讯基站数量上限
|
value[2]=Integer.parseInt(shangxian);
|
|
//0xA 通讯组ID（2Byte）
|
value[3]=Integer.parseInt(zu);
|
|
//0xC 距离校准值（2Byte）
|
value[4]=Integer.parseInt(wucha);
|
|
//0xE 模块类型（2Byte）
|
value[5]=1;
|
if(type.equals("jizhan")) {
|
value[5]=0;
|
}
|
|
//0x10 基站主动测距（2Byte）
|
value[6]=0;
|
if(initiative.equals("true")) {
|
value[6]=1;
|
}
|
|
|
//0x12 报警设备（2Byte）
|
value[7]=0;
|
|
//0x14 报警距离1（2Byte）
|
value[8]=Integer.parseInt(qiehuan);;
|
|
//0x16 报警距离2（2Byte）
|
value[9]=0;
|
|
//0x18 报警距离3（2Byte）
|
value[10]=0;
|
|
//0x1A 配对ID无作用（2Byte）
|
value[11]=0;
|
|
//0x1C 心跳包（2Byte）
|
value[12]=0;
|
if(heart.equals("true")) {
|
value[12]=1;
|
}
|
|
//0x1E Modbus模式（2Byte）
|
value[13]=0;
|
|
value[14]=Integer.parseInt(nearnum);
|
value[15]=covert(near1);
|
value[16]=covert(near2);
|
value[17]=covert(near3);
|
value[18]=covert(near4);
|
value[19]=covert(near5);
|
value[20]=covert(near6);
|
value[21]=covert(near7);
|
value[22]=covert(near8);
|
value[23]=covert("");
|
value[24]=covert("");
|
|
//发射功率
|
value[25]=Integer.parseInt(gonglv);
|
|
//加速度灵敏度
|
value[26]=2;
|
|
//休眠时间
|
value[27]=120;
|
|
//振动使能
|
value[28]=0;
|
|
|
//加速度使能
|
value[29]=0;
|
|
|
//标签下发配置状态
|
value[30]=Integer.parseInt(lvbo);
|
|
//标签下发配置ID 0x42
|
value[31]=0;
|
|
//同步基站地址 0x44
|
value[32]=covert(rootanchor);
|
|
//同步类型0/1/2(0普通基站，1主机站，2是从基站)
|
value[33]=Integer.parseInt(xuhao);
|
|
//保存配置信息
|
data=WriteDatapeiz((byte)0x4,(byte)0x44, value);
|
return data;
|
}
|
|
|
/**修改所有基站*/
|
public static byte[] alert_all_anchor(
|
String gonglv,
|
String wucha,
|
String lvbo,
|
String zu,
|
String hz,
|
String shangxian,
|
String rootanc,
|
String xuhao
|
) {
|
|
int[] value=new int[30];
|
//标签通讯间隔 0x6
|
value[0]=Integer.parseInt(hz);
|
|
//单次通讯基站数量上限
|
value[1]=Integer.parseInt(shangxian);
|
|
//0xA 通讯组ID（2Byte）
|
value[2]=Integer.parseInt(zu);
|
|
//0xC 距离校准值（2Byte）
|
value[3]=Integer.parseInt(wucha);
|
|
//0xE 模块类型（2Byte）
|
value[4]=0;
|
|
//0x10 基站主动测距（2Byte）
|
value[5]=0;
|
|
//0x12 报警设备（2Byte）
|
value[6]=0;
|
|
//0x14 报警距离1（2Byte）
|
value[7]=0;
|
|
//0x16 报警距离2（2Byte）
|
value[8]=0;
|
|
//0x18 报警距离3（2Byte）
|
value[9]=0;
|
|
//0x1A 配对ID无作用（2Byte）
|
value[10]=0;
|
|
//0x1C 心跳包（2Byte）
|
value[11]=1;
|
|
//0x1E Modbus模式（2Byte）
|
value[12]=0;
|
|
value[13]=0;
|
value[14]=0;
|
value[15]=0;
|
value[16]=0;
|
value[17]=0;
|
value[18]=0;
|
value[19]=0;
|
value[20]=0;
|
value[21]=0;
|
value[22]=0;
|
value[23]=0;
|
|
//发射功率
|
value[24]=Integer.parseInt(gonglv);
|
|
//加速度灵敏度
|
value[25]=2;
|
|
//休眠时间
|
value[26]=120;
|
|
//振动使能
|
value[27]=0;
|
|
|
//加速度使能
|
value[28]=0;
|
|
//滤波参数
|
value[29]=Integer.parseInt(lvbo);
|
|
// //标签下发配置ID
|
// value[30]=0;
|
//
|
// //同步基站ID
|
// value[31]=covert(rootanc);
|
//
|
// //同步基站角色
|
// value[32]=Integer.parseInt(xuhao);
|
|
byte[] data=WriteDatapeiz((byte)0x6,(byte)0x3F, value);
|
return data;
|
}
|
|
/**写保存配置
|
* @param ref 起始地址
|
* @param lenth 数据长度
|
* @param value 写入值*/
|
public static byte[] WriteDatapeiz(byte ref ,byte lenth,int[] value) {
|
byte[] buf =new byte[9+lenth];
|
byte[] buf1 =new byte[5+lenth];
|
//包头
|
buf[0]=(byte) 0x55;
|
//包头
|
buf[1]=(byte) 0xAA;
|
//指令类型
|
buf1[0]=(byte) 0x03;
|
//数据长度
|
buf1[1]=(byte) ((byte) 5+lenth);
|
//读模式
|
buf1[2]=(byte) 0x02;
|
//起始地址
|
buf1[3]=(byte) ref;
|
|
//读写长度
|
buf1[4]=(byte) lenth;
|
|
for(int i=0;i<value.length;i++) {
|
buf1[5+2*i]=intToRegisters(value[i])[3];
|
buf1[6+2*i]=intToRegisters(value[i])[2];
|
}
|
|
for(int i=0;i<buf1.length;i++) {
|
buf[i+2]=buf1[i];
|
}
|
//校验码
|
buf[buf.length-2]=Jiaoyan.check(buf1)[1];
|
buf[buf.length-1]=Jiaoyan.check(buf1)[0];
|
return buf;
|
}
|
|
/**保存临近基站配置*/
|
public static byte[] save_nerby(List<String> near) {
|
int size=near.size();
|
int lenth=near.size()*2;
|
byte[] buf =new byte[19+lenth];
|
byte[] buf1 =new byte[15+lenth];
|
//包头
|
buf[0]=(byte) 0x55;
|
//包头
|
buf[1]=(byte) 0xAA;
|
//指令类型
|
buf1[0]=(byte) 0x03;
|
//数据长度
|
buf1[1]=(byte) (15+lenth);
|
//读模式
|
buf1[2]=(byte) 0x02;
|
//起始地址
|
buf1[3]=(byte) 0x14;
|
|
//读写长度
|
buf1[4]=(byte) (lenth+10);
|
|
//报警距离1
|
|
buf1[5]=intToRegisters(Integer.parseInt(near.get(size-1)))[3];
|
buf1[6]=intToRegisters(Integer.parseInt(near.get(size-1)))[2];
|
|
|
//报警距离2
|
buf1[7]=(byte) 0x0;
|
buf1[8]=(byte) 0x0;
|
|
//报警距离3
|
buf1[9]=(byte) 0x0;
|
buf1[10]=(byte) 0x0;
|
|
//配对ID
|
buf1[11]= (byte)0x0;
|
buf1[12]= (byte)0x0;
|
|
//心跳包,开启心跳包
|
buf1[13]= (byte)0x01;
|
buf1[14]= (byte)0x0;
|
|
//MODBUS模式
|
buf1[15]= (byte)0x0;
|
buf1[16]= (byte)0x0;
|
|
//临近基站数量
|
buf1[17]=(byte)(near.size()-2);
|
buf1[18]= (byte)0x0;
|
|
|
for(int i=0;i<near.size()-2;i++) {
|
buf1[19+i*2]=Read_Write_Anchor_Message.toByteArray(near.get(i+1))[1];
|
buf1[20+i*2]=Read_Write_Anchor_Message.toByteArray(near.get(i+1))[0];
|
}
|
|
for(int i=0;i<buf1.length;i++) {
|
buf[i+2]=buf1[i];
|
}
|
//校验码
|
buf[buf.length-2]=Jiaoyan.check(buf1)[1];
|
buf[buf.length-1]=Jiaoyan.check(buf1)[0];
|
|
|
return buf;
|
|
}
|
|
|
public static byte[] intToRegisters(int v) {
|
byte[] registers = new byte[4];
|
registers[0] = (byte) (0xff & (v >> 24));
|
registers[1] = (byte) (0xff & (v >> 16));
|
registers[2] = (byte) (0xff & (v >> 8));
|
registers[3] = (byte) (0xff & v);
|
return registers;
|
}
|
|
|
/**
|
* @param: [content]
|
* @return: int
|
* @description: 十六进制转十进制
|
*/
|
public static int covert(String content){
|
int number=0;
|
String [] HighLetter = {"A","B","C","D","E","F"};
|
Map<String,Integer> map = new HashMap<>();
|
for(int i = 0;i <= 9;i++){
|
map.put(i+"",i);
|
}
|
for(int j= 10;j<HighLetter.length+10;j++){
|
map.put(HighLetter[j-10],j);
|
}
|
String[]str = new String[content.length()];
|
for(int i = 0; i < str.length; i++){
|
str[i] = content.substring(i,i+1);
|
}
|
for(int i = 0; i < str.length; i++){
|
number += map.get(str[i])*Math.pow(16,str.length-1-i);
|
}
|
return number;
|
}
|
|
|
/**截取指定长度的BYTE数组
|
* @param src原字节数组
|
* @param 开始位置
|
* @param 截取长度*/
|
public static byte[] subBytes(byte[] src, int begin, int count) {
|
byte[] bs = new byte[count];
|
System.arraycopy(src, begin, bs, 0, count);
|
return bs;
|
}
|
|
/**
|
* 将byte[]转为各种进制的字符串
|
* @param bytes byte[]
|
* @param radix 基数可以转换进制的范围，从Character.MIN_RADIX到Character.MAX_RADIX，超出范围后变为10进制
|
* @return 转换后的字符串
|
*/
|
public static String binary(byte[] bytes, int radix){
|
return new BigInteger(1, bytes).toString(radix);// 这里的1代表正数
|
}
|
|
|
private static final char[] HEXES = {
|
'0', '1', '2', '3',
|
'4', '5', '6', '7',
|
'8', '9', 'a', 'b',
|
'c', 'd', 'e', 'f'
|
};
|
|
/**
|
* byte数组 转换成 16进制小写字符串
|
*/
|
public static String bytes2Hex(byte[] bytes) {
|
if (bytes == null || bytes.length == 0) {
|
return null;
|
}
|
|
StringBuilder hex = new StringBuilder();
|
|
for (byte b : bytes) {
|
hex.append(HEXES[(b >> 4) & 0x0F]);
|
hex.append(HEXES[b & 0x0F]);
|
}
|
|
return hex.toString();
|
}
|
|
/**16进制转为10进制*/
|
public static int decodeHEX(String hexs){
|
BigInteger bigint=new BigInteger(hexs, 16);
|
int numb=bigint.intValue();
|
return numb;
|
|
}
|
|
|
}
|
