package com.ard.work.sdk.hp.service;
|
|
import com.ard.work.api.domian.ArdCamera;
|
import com.ard.work.api.domian.PtzDto;
|
import com.ard.work.sdk.hik.lib.HCNetSDK;
|
import com.ard.work.sdk.hp.cache.CameraPTZCache;
|
import com.sun.jna.Pointer;
|
import lombok.extern.slf4j.Slf4j;
|
|
import java.util.Arrays;
|
import java.util.concurrent.BlockingQueue;
|
import java.util.concurrent.LinkedBlockingQueue;
|
import java.util.concurrent.atomic.AtomicBoolean;
|
|
/**
|
* 实时解析Pelco-D完整帧版
|
*/
|
@Slf4j
|
public class HpSerialDataCallBack implements HCNetSDK.FSerialDataCallBack_V40, AutoCloseable {
|
// 协议常量
|
private static final byte PELCO_D_HEAD = (byte) 0xFF;
|
private static final int PELCO_D_FRAME_LEN = 7;
|
private static final int CACHE_MAX_SIZE = 1024;
|
|
private final ArdCamera camera;
|
private final AtomicBoolean isRunning = new AtomicBoolean(true);
|
private final byte[] frameCache = new byte[CACHE_MAX_SIZE];
|
private int cacheLen = 0;
|
|
// 数据队列
|
private final BlockingQueue<byte[]> queue = new LinkedBlockingQueue<>();
|
|
// 镜头参数
|
private static final float MIN_FOCAL = 3.3f;
|
private static final float MAX_FOCAL = 37f;
|
private static final float COEFFICIENT = 1.63f;
|
private static final int FRONT_MIN = 1;
|
private static final int FRONT_MAX = 60;
|
|
public HpSerialDataCallBack(ArdCamera camera) {
|
this.camera = camera;
|
startConsumer();
|
}
|
|
/**
|
* SDK回调：接收碎片化数据 → 放入队列
|
*/
|
@Override
|
public void invoke(int lSerialHandle, int lChannel, Pointer pRecvDataBuffer, int dwBufSize, Pointer pUser) {
|
if (!isRunning.get() || dwBufSize <= 0 || pRecvDataBuffer == null) return;
|
|
byte[] recvData = new byte[dwBufSize];
|
pRecvDataBuffer.read(0, recvData, 0, dwBufSize);
|
queue.offer(recvData);
|
}
|
|
/**
|
* 单线程消费队列
|
*/
|
private void startConsumer() {
|
Thread t = new Thread(() -> {
|
while (isRunning.get()) {
|
try {
|
byte[] data = queue.take();
|
synchronized (frameCache) {
|
if (cacheLen + data.length > CACHE_MAX_SIZE) cacheLen = 0;
|
System.arraycopy(data, 0, frameCache, cacheLen, data.length);
|
cacheLen += data.length;
|
parseCompleteFrames();
|
}
|
} catch (InterruptedException ignored) {
|
}
|
}
|
}, "Serial-Consumer-" + camera.getIp());
|
t.setDaemon(true);
|
t.start();
|
}
|
|
/**
|
* 解析缓存中的完整帧
|
*/
|
private void parseCompleteFrames() {
|
while (cacheLen >= PELCO_D_FRAME_LEN) {
|
int headIndex = findHeadIndex(frameCache, cacheLen);
|
if (headIndex == -1) {
|
cacheLen = 0;
|
break;
|
}
|
if (cacheLen - headIndex < PELCO_D_FRAME_LEN) {
|
byte[] remain = Arrays.copyOfRange(frameCache, headIndex, cacheLen);
|
System.arraycopy(remain, 0, frameCache, 0, remain.length);
|
cacheLen = remain.length;
|
break;
|
}
|
byte[] completeFrame = Arrays.copyOfRange(frameCache, headIndex, headIndex + PELCO_D_FRAME_LEN);
|
int remainLen = cacheLen - (headIndex + PELCO_D_FRAME_LEN);
|
if (remainLen > 0) {
|
System.arraycopy(frameCache, headIndex + PELCO_D_FRAME_LEN, frameCache, 0, remainLen);
|
}
|
cacheLen = remainLen;
|
|
parsePelcoDFrame(completeFrame);
|
}
|
}
|
|
private int findHeadIndex(byte[] cache, int len) {
|
for (int i = 0; i < len; i++) {
|
if (cache[i] == PELCO_D_HEAD) return i;
|
}
|
return -1;
|
}
|
|
private void parsePelcoDFrame(byte[] frame) {
|
try {
|
if (frame.length != PELCO_D_FRAME_LEN || frame[0] != PELCO_D_HEAD) return;
|
|
int address = frame[1] & 0xFF;
|
if (address != 1) return;
|
|
int command2 = frame[3] & 0xFF;
|
int data1 = frame[4] & 0xFF;
|
int data2 = frame[5] & 0xFF;
|
int completeData = (data1 << 8) | data2;
|
|
PtzDto ptzDto = CameraPTZCache.get(camera.getId());
|
if (ptzDto == null) ptzDto = new PtzDto();
|
|
switch (command2) {
|
case 0x59:
|
ptzDto.setP(completeData / 100f);
|
break;
|
case 0x5B:
|
float pitch = 360 - completeData / 100f;
|
if (Math.abs(pitch - 360f) < 1e-6) pitch = 0f;
|
ptzDto.setT(Math.round(pitch * 100f) / 100f);
|
break;
|
case 0x5D:
|
float zoomValue = completeData / 100f * COEFFICIENT;
|
ptzDto.setZ((float) convertZoomToFrontValue(zoomValue));
|
break;
|
default:
|
break;
|
}
|
CameraPTZCache.put(camera.getId(), ptzDto);
|
//printStatusLog();
|
} catch (Exception e) {
|
log.error("[{}] 解析Pelco-D帧异常 | 帧：{}", camera.getIp(), bytesToHex(frame), e);
|
}
|
}
|
|
private void printStatusLog() {
|
PtzDto ptzDto = CameraPTZCache.get(camera.getId());
|
if (ptzDto != null) {
|
log.info("【{}】实时状态- Azimuth = {}° Pitch = {}° Zoom={}",
|
camera.getIp(), ptzDto.getP(), ptzDto.getT(), ptzDto.getZ());
|
}
|
}
|
|
private int convertZoomToFrontValue(float zoomValue) {
|
float minZoom = MIN_FOCAL * COEFFICIENT;
|
float maxZoom = MAX_FOCAL * COEFFICIENT;
|
zoomValue = Math.max(minZoom, Math.min(maxZoom, zoomValue));
|
float frontFloat = FRONT_MIN + (FRONT_MAX - FRONT_MIN) * (zoomValue - minZoom) / (maxZoom - minZoom);
|
return Math.max(FRONT_MIN, Math.min(FRONT_MAX, Math.round(frontFloat)));
|
}
|
|
private String bytesToHex(byte[] bytes) {
|
if (bytes == null || bytes.length == 0) return "";
|
StringBuilder sb = new StringBuilder();
|
for (byte b : bytes) sb.append(String.format("%02X ", b & 0xFF));
|
return sb.toString().trim();
|
}
|
|
public void stop() {
|
isRunning.set(false);
|
queue.clear();
|
log.info("[{}] 串口回调已关闭", camera.getIp());
|
}
|
|
@Override
|
public void close() {
|
stop();
|
}
|
}
|
