package com.mes.common.PlcTools;
|
|
import java.io.FileInputStream;
|
import java.io.FileOutputStream;
|
import java.io.IOException;
|
import java.nio.charset.StandardCharsets;
|
import java.util.ArrayList;
|
import java.util.List;
|
import java.util.Properties;
|
import java.util.concurrent.ConcurrentHashMap;
|
import java.util.regex.Matcher;
|
import java.util.regex.Pattern;
|
|
public class MockS7PLCtwo {
|
private static volatile MockS7PLCtwo instance; // 单例实例
|
private ConcurrentHashMap<String, String> memory = new ConcurrentHashMap<>();
|
private String storageFilePath = "mockPLCData.properties";
|
|
// 私有化构造函数
|
private MockS7PLCtwo() {
|
// 在构造函数中尝试加载现有的模拟数据
|
try (FileInputStream fis = new FileInputStream(storageFilePath)) {
|
Properties properties = new Properties();
|
properties.load(fis);
|
properties.forEach((key, value) -> memory.put(String.valueOf(key), String.valueOf(value)));
|
} catch (IOException e) {
|
System.out.println("没有找到现有的模拟数据文件，将创建一个新的。");
|
}
|
}
|
|
// 公共静态方法获取类的唯一实例
|
public static MockS7PLCtwo getInstance() {
|
if (instance == null) {
|
synchronized (MockS7PLCtwo.class) {
|
if (instance == null)
|
instance = new MockS7PLCtwo();
|
}
|
}
|
return instance;
|
}
|
|
// 修改写入方法以持久化数据
|
public void writeByte(String address, byte[] data) {
|
memory.put(address, new String(data, StandardCharsets.ISO_8859_1));
|
saveMemory();
|
}
|
|
// 修改读取方法以从持久化的数据中读取
|
public byte[] readByte(String address,int count) {
|
String value = memory.getOrDefault(address, "");
|
byte[] bytes = value.getBytes(StandardCharsets.ISO_8859_1);
|
if (count >= 0 && count <= bytes.length) {
|
byte[] result = new byte[count];
|
System.arraycopy(bytes, 0, result, 0, count);
|
return result;
|
} else {
|
// 如果请求的字节数超出了实际可用的字节数，则返回全部可用的字节
|
return bytes;
|
}
|
}
|
|
|
|
|
|
|
public void writeInt16(String address, short data) {
|
memory.put(address, Short.toString(data));
|
saveMemory();
|
}
|
|
public Short readInt16(String address) {
|
String value = memory.get(address);
|
return value != null ? Short.parseShort(value) : null;
|
}
|
|
public void writeBoolean(String address, boolean data) {
|
memory.put(address, Boolean.toString(data));
|
saveMemory();
|
}
|
|
public Boolean readBoolean(String address) {
|
String value = memory.get(address);
|
return value != null ? Boolean.parseBoolean(value) : null;
|
}
|
|
public void writeString(String address, String data) {
|
memory.put(address, data);
|
saveMemory();
|
}
|
|
public String readString(String address) {
|
return memory.getOrDefault(address, "");
|
}
|
|
public void writeTime(String address, long data) {
|
memory.put(address, Long.toString(data));
|
saveMemory();
|
}
|
|
public Long readTime(String address) {
|
String value = memory.get(address);
|
return value != null ? Long.parseLong(value) : null;
|
}
|
|
// 添加一个方法来保存数据到文件
|
private void saveMemory() {
|
Properties properties = new Properties();
|
properties.putAll(memory);
|
try (FileOutputStream fos = new FileOutputStream(storageFilePath)) {
|
properties.store(fos, "Mock S7 PLC Data");
|
} catch (IOException e) {
|
System.out.println("保存模拟数据失败：" + e.getMessage());
|
}
|
}
|
|
// 连续写入多个Word
|
public void writeword(String address, List<Short> data) {
|
for (int i = 0; i < data.size(); i++) {
|
String addr = calculateAddress(address, i * 2); // 假设每个word占两个地址单位
|
memory.put(addr, Short.toString(data.get(i)));
|
|
}
|
saveMemory();
|
}
|
|
// 不连续地址word写入多个Word
|
public void WriteWords(List<String> addresses, List<Short> datas) {
|
if (addresses.size() != datas.size()) {
|
throw new IllegalArgumentException("地址列表和数据列表的大小必须相同。");
|
}
|
|
for (int i = 0; i < addresses.size(); i++) {
|
String addr = addresses.get(i);
|
short data = datas.get(i);
|
// 假设这里使用内存映射来模拟PLC写入操作
|
memory.put(addr, Short.toString(data));
|
}
|
saveMemory(); // 在所有数据写入后保存更改
|
}
|
|
// 连续读取多个Word
|
public List<Short> readwords(String address, int count) {
|
List<Short> result = new ArrayList<>();
|
for (int i = 0; i < count; i++) {
|
String addr = calculateAddress(address, i * 2); // 同上，每个word占两个地址单位
|
|
//System.out.println(addr);
|
|
String value = memory.get(addr);
|
if (value != null) {
|
result.add(Short.parseShort(value));
|
} else {
|
result.add(null); // 或者考虑抛出异常或其他错误处理
|
}
|
}
|
return result;
|
}
|
|
|
public List<Short> ReadWords(List<String> addresses) {
|
List<Short> datas = new ArrayList<>();
|
|
for (String addr : addresses) {
|
// 从内存映射中获取数据
|
String dataStr = memory.get(addr);
|
|
// 将字符串转换成short类型，并添加到结果列表中
|
// 这里假设数据已经以适当的方式存储（例如，作为短整型的字符串表示）
|
// 如果读取的数据为空或转换失败，你可能需要处理这些情况
|
try {
|
short data = Short.parseShort(dataStr);
|
datas.add(data);
|
} catch (NumberFormatException e) {
|
System.err.println("读取地址 " + addr + " 的数据时出错: " + e.getMessage());
|
|
}
|
}
|
|
return datas;
|
}
|
|
|
|
|
|
// 连续写入多个Bit
|
public void writebits(String address, List<Boolean> data) {
|
for (int i = 0; i < data.size(); i++) {
|
String addr = calculateAddress(address, i); // 假设每个bit占一个地址单位
|
memory.put(addr, Boolean.toString(data.get(i)));
|
}
|
saveMemory();
|
}
|
|
//bit分散地址读取
|
public List<Boolean> readBits(List<String> addresses) {
|
List<Boolean> results = new ArrayList<>();
|
for (String address : addresses) {
|
// 对于每个地址，直接使用 calculateAddress 来处理可能的位偏移
|
// 这里假设 calculateAddress 已经足够智能以处理单个位的偏移
|
// 由于我们是逐个读取，每次偏移量都是0
|
String addr = calculateAddress(address, 0);
|
String value = memory.get(addr);
|
if (value != null) {
|
results.add(Boolean.parseBoolean(value));
|
} else {
|
// 如果地址对应的值不存在于内存中，可以选择添加 null 或抛出异常
|
// 这里选择添加 null，但在实际应用中应根据具体需求决定
|
results.add(null);
|
}
|
}
|
return results;
|
}
|
|
// 连续读取多个Bit
|
public List<Boolean> readbits(String address, int count) {
|
List<Boolean> result = new ArrayList<>();
|
for (int i = 0; i < count; i++) {
|
String addr = calculateAddress(address, i); // 同上，每个bit占一个地址单位
|
String value = memory.get(addr);
|
if (value != null) {
|
result.add(Boolean.parseBoolean(value));
|
} else {
|
result.add(null); // 或者考虑抛出异常或其他错误处理
|
}
|
}
|
return result;
|
}
|
|
// 计算连续地址
|
// private String calculateAddress(String baseAddress, int offset) {
|
// // 支持带字母的地址格式
|
// Pattern pattern = Pattern.compile("(\\D*)(\\d+)");
|
// Matcher matcher = pattern.matcher(baseAddress);
|
// if (matcher.find()) {
|
// String prefix = matcher.group(1);
|
// int address = Integer.parseInt(matcher.group(2));
|
// return prefix + (address + offset);
|
// } else {
|
// throw new IllegalArgumentException("Invalid address format: " + baseAddress);
|
// }
|
// }
|
|
private String calculateAddress(String baseAddress, int offset) {
|
// 分割地址为数据块、字偏移和位偏移（如果有）
|
Pattern pattern = Pattern.compile("(DB\\d+)\\.(\\d+)(?:\\.(\\d+))?");
|
Matcher matcher = pattern.matcher(baseAddress);
|
if (matcher.find()) {
|
String dbNumber = matcher.group(1); // 数据块编号，如 "DB100"
|
int wordOffset = Integer.parseInt(matcher.group(2)); // 字偏移
|
String bitOffsetStr = matcher.group(3); // 位偏移，可能为空
|
|
if (bitOffsetStr != null) {
|
// 存在位偏移，进行位操作
|
int bitOffset = Integer.parseInt(bitOffsetStr);
|
int totalBitOffset = bitOffset + offset;
|
// 计算新的字偏移和位偏移
|
int newWordOffset = wordOffset + (totalBitOffset / 8);
|
int newBitOffset = totalBitOffset % 8;
|
return String.format("%s.%d.%d", dbNumber, newWordOffset, newBitOffset);
|
} else {
|
// 仅存在字偏移，进行字操作
|
// 注意：假设每个字占用2个字节
|
int newWordOffset = wordOffset + (offset );
|
return String.format("%s.%d", dbNumber, newWordOffset);
|
}
|
} else {
|
throw new IllegalArgumentException("Invalid address format: " + baseAddress);
|
}
|
}
|
|
|
|
|
}
|
