package com.eternal.rfid;
|
|
|
import com.eternal.event.DeviceWorkEvent;
|
import com.eternal.monitor.AbstractEquipmentManager;
|
import com.eternal.monitor.constant.ErrorTypeEnums;
|
import com.eternal.monitor.constant.StatusTypeEnums;
|
import com.eternal.monitor.entity.Device;
|
import com.eternal.monitor.entity.DeviceErrorType;
|
import com.eternal.monitor.entity.DeviceStatus;
|
import com.eternal.monitor.entity.DeviceType;
|
import com.eternal.rfid.params.UF3ReaderConfig;
|
import com.eternal.rfid.service.UF3RFIDReader;
|
import lombok.Getter;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.context.ApplicationEventPublisher;
|
import org.springframework.context.event.EventListener;
|
import org.springframework.scheduling.TaskScheduler;
|
import org.springframework.scheduling.annotation.Scheduled;
|
import org.springframework.stereotype.Service;
|
|
import javax.annotation.PostConstruct;
|
import javax.annotation.PreDestroy;
|
import java.util.ArrayList;
|
import java.util.List;
|
import java.util.concurrent.atomic.AtomicInteger;
|
|
/**
|
* description: 略
|
*
|
* @author senzhi
|
* @since 2026/1/19 17:14
|
*/
|
@Slf4j
|
@Service("UF3RFIDReader")
|
public class RfidReaderServer extends AbstractEquipmentManager {
|
@Autowired
|
private ApplicationEventPublisher eventPublisher;
|
|
@Autowired
|
private UF3ReaderConfig readerConfig;
|
|
@Getter
|
private final List<UF3RFIDReader> readers = new ArrayList<>();
|
/**
|
* 是否允许读写器工作
|
*/
|
private boolean enableWork = false;
|
|
public void setEnableWork(boolean enableWork) {
|
log.info("RfidReaderServer work mode changed. from {} --> {}", this.enableWork, enableWork);
|
this.enableWork = enableWork;
|
}
|
|
@EventListener(DeviceWorkEvent.class)
|
public void onDeviceWorkEvent(DeviceWorkEvent event) {
|
setEnableWork(event.isEnableWork());
|
}
|
|
private final static int maxTryTime = 3;
|
|
private final AtomicInteger currentRunIndex = new AtomicInteger(-1);
|
private final AtomicInteger tryTime = new AtomicInteger(0);
|
|
@PostConstruct
|
public void init() {
|
String readerKey = readerConfig.getReaderKey();
|
String[] antennasKey = new String[4];
|
for (int j = 0; j < 4; j++) {
|
antennasKey[j] = "reader" + 1 + "-antenna" + (j + 1);
|
}
|
UF3RFIDReader uf3RFIDReader = new UF3RFIDReader(readerKey, "uf3-rfid-reader", antennasKey, "reader-antenna");
|
readers.add(uf3RFIDReader);
|
}
|
|
@Override
|
public void start() {
|
for (int i = 0; i < readers.size(); i++) {
|
UF3RFIDReader uf3RFIDReader = readers.get(i);
|
uf3RFIDReader.setUpdateDeviceStatusConsumer(this::updateDeviceStatus);
|
uf3RFIDReader.setEventConsumer(event -> eventPublisher.publishEvent(event));
|
uf3RFIDReader.init(i, readerConfig);
|
|
}
|
log.info("RfidReaderServer create finished,reader number:{}", readers.size());
|
}
|
|
@Scheduled(initialDelay = 100, fixedDelay = 3000)
|
public void checkingTimer() {
|
try {
|
if (enableWork) {
|
if (currentRunIndex.get() < 0) {
|
currentRunIndex.set(0);
|
}
|
|
UF3RFIDReader uf3RFIDReader = readers.get(currentRunIndex.get());
|
if (uf3RFIDReader.isOnline()) {
|
log.debug("ZebraReader<ip:{}> is online", uf3RFIDReader.getIp());
|
return;
|
}
|
|
log.info("Try to connect to ZebraReader<ip:{}>，attempts：{}", uf3RFIDReader.getIp(), tryTime.get());
|
uf3RFIDReader.start();
|
if (uf3RFIDReader.isOnline()) {
|
tryTime.set(0);
|
return;
|
}
|
|
// 超过最大尝试次数，切换下一个读写器
|
if (tryTime.incrementAndGet() > maxTryTime) {
|
log.warn("The ZebraReader<{}> exceeds the maximum attempts number<{}>, switch to the next reader", uf3RFIDReader.getIp(), maxTryTime);
|
|
// 重置尝试次数
|
tryTime.set(0);
|
// 切换下一个读写器
|
currentRunIndex.incrementAndGet();
|
if (currentRunIndex.get() >= readers.size()) {
|
currentRunIndex.set(0);
|
}
|
}
|
} else {
|
if (currentRunIndex.get() < 0) {
|
log.debug("The node is not ACTIVE, do not connect to RFIDReader");
|
return;
|
}
|
UF3RFIDReader zebraRFIDReader = readers.get(currentRunIndex.get());
|
zebraRFIDReader.disconnectReader();
|
currentRunIndex.set(-1);
|
|
log.info("The node is not ACTIVE, disconnect from RFIDReader");
|
}
|
} catch (Exception e) {
|
log.error("RfidReaderServer checkingTimer error", e);
|
}
|
}
|
|
/**
|
* 启动读
|
*/
|
public void startRead() {
|
if (enableWork) {
|
if (currentRunIndex.get() < 0) {
|
log.warn("It is not working and cannot be started.");
|
return;
|
}
|
UF3RFIDReader zebraRFIDReader = readers.get(currentRunIndex.get());
|
try {
|
zebraRFIDReader.startRead();
|
} catch (Exception e) {
|
log.error("Failed to start read.", e);
|
}
|
|
}
|
|
}
|
|
/**
|
* 停止读
|
*/
|
public void stopRead() {
|
if (enableWork) {
|
if (currentRunIndex.get() < 0) {
|
log.warn("It is not working and cannot be stopped.");
|
return;
|
}
|
UF3RFIDReader zebraRFIDReader = readers.get(currentRunIndex.get());
|
zebraRFIDReader.stopRead();
|
}
|
}
|
|
|
@PreDestroy
|
public void destroy() {
|
if (enableWork) {
|
if (currentRunIndex.get() < 0) {
|
return;
|
}
|
|
UF3RFIDReader zebraRFIDReader = readers.get(currentRunIndex.get());
|
zebraRFIDReader.disconnectReader();
|
currentRunIndex.set(-1);
|
|
log.info("Close the rfid-reader before closing the application");
|
}
|
}
|
|
@Override
|
public void initDevices() {
|
for (UF3RFIDReader reader : readers) {
|
int index = reader.getIndex();
|
// 添加设备类型
|
DeviceType readerType = new DeviceType();
|
readerType.setDeviceTypeKey("zebra-rfid-reader");
|
readerType.setName("东集读写器");
|
readerType.setTypeDescription("东集读写器");
|
addDeviceType(readerType);
|
DeviceType antennaType = new DeviceType();
|
antennaType.setDeviceTypeKey("reader-antenna");
|
antennaType.setName("读写器天线");
|
antennaType.setTypeDescription("RFID读写器天线");
|
addDeviceType(antennaType);
|
|
// 添加状态
|
for (StatusTypeEnums.Common value : StatusTypeEnums.Common.values()) {
|
// 读写器状态
|
DeviceStatus readerStatus = new DeviceStatus();
|
readerStatus.setDeviceTypeKey(readerType.getDeviceTypeKey());
|
readerStatus.setDeviceStatusKey(value.getKey());
|
readerStatus.setName(value.getName());
|
readerStatus.setStatusDescription(value.getDescription());
|
addDeviceStatusType(readerStatus);
|
// 天线状态
|
DeviceStatus antennaStatus = new DeviceStatus();
|
antennaStatus.setDeviceTypeKey(antennaType.getDeviceTypeKey());
|
antennaStatus.setDeviceStatusKey(value.getKey());
|
antennaStatus.setName(value.getName());
|
antennaStatus.setStatusDescription(value.getDescription());
|
addDeviceStatusType(antennaStatus);
|
}
|
|
// 添加错误码
|
for (ErrorTypeEnums.Common value : ErrorTypeEnums.Common.values()) {
|
DeviceErrorType readerErrorType = new DeviceErrorType(readerType.getDeviceTypeKey(), value.getKey(), value.getName(), value.getDescription());
|
addDeviceErrorType(readerErrorType);
|
DeviceErrorType antennaErrorType = new DeviceErrorType(readerType.getDeviceTypeKey(), value.getKey(), value.getName(), value.getDescription());
|
addDeviceErrorType(antennaErrorType);
|
}
|
|
// 添加设备
|
Device readerDevice = new Device();
|
readerDevice.setDeviceKey(reader.getReaderKey());
|
readerDevice.setName(readerConfig.getEquipType() + (index + 1));
|
readerDevice.setDeviceTypeKey(readerType.getDeviceTypeKey());
|
readerDevice.setDeviceStatusKey(StatusTypeEnums.Common.UNKNOWN.getKey());
|
addDevice(readerDevice);
|
for (int i = 0; i < 4; i++) {
|
Device antennaDevice = new Device();
|
antennaDevice.setParentDeviceKey(readerDevice.getDeviceKey());
|
antennaDevice.setDeviceKey(reader.getAntennasKey()[i]);
|
antennaDevice.setName("reader" + (index + 1) + "-antenna" + (i + 1));
|
antennaDevice.setDeviceTypeKey(antennaType.getDeviceTypeKey());
|
antennaDevice.setDeviceStatusKey(StatusTypeEnums.Common.UNKNOWN.getKey());
|
antennaDevice.setParentDeviceKey(readerDevice.getDeviceKey());
|
addDevice(antennaDevice);
|
}
|
}
|
|
}
|
}
|
