const fs = require('fs');
|
const path = require('path');
|
|
const HEADER_1 = 0x55;
|
const HEADER_2 = 0xAA;
|
const MIN_FRAME_LENGTH = 7;
|
const CMDTYPE_DATA_SYNC = 0x01;
|
const CMDID_REALTIME = 0x00;
|
const CMDID_BLOOD_PRESSURE = 0x01;
|
const REALTIME_PAYLOAD_LENGTH = 46;
|
const BLOOD_PRESSURE_PAYLOAD_LENGTH = 5;
|
|
const REALTIME_FIELDS = [
|
{ identifier: 'AF', offset: 0, read: readInt16LE, scale: 10 },
|
{ identifier: 'F', offset: 2, read: readInt16LE, scale: 10 },
|
{ identifier: 'A', offset: 4, read: readUInt16LE },
|
{ identifier: 'C', offset: 6, read: readUInt16LE },
|
{ identifier: 'B', offset: 8, read: readUInt16LE },
|
{ identifier: 'K', offset: 10, read: readUInt16LE },
|
{ identifier: 'L', offset: 12, read: readUInt16LE },
|
{ identifier: 'D', offset: 14, read: readUInt16LE },
|
{ identifier: 'H', offset: 16, read: readInt16LE },
|
{ identifier: 'o', offset: 18, read: readInt16LE },
|
{ identifier: 'J', offset: 20, read: readInt16LE },
|
{ identifier: 'U', offset: 22, read: readUInt32LE },
|
{ identifier: 'G', offset: 26, read: readUInt16LE },
|
{ identifier: 'Na', offset: 28, read: readUInt16LE },
|
{ identifier: 'HCO3', offset: 30, read: readUInt16LE },
|
{ identifier: 'O2Sat', offset: 36, read: readUInt16LE, scale: 10 },
|
{ identifier: 'Hct', offset: 38, read: readUInt16LE, scale: 10 },
|
{ identifier: 'Hb', offset: 40, read: readUInt16LE, scale: 10 },
|
{ identifier: 'Tblood', offset: 42, read: readUInt16LE, scale: 10 },
|
{ identifier: 'ktv', offset: 44, read: readUInt16LE, scale: 10 },
|
];
|
|
function toHex(value) {
|
return `0x${value.toString(16).toUpperCase().padStart(2, '0')}`;
|
}
|
|
function bytesToHex(buffer) {
|
return Array.from(buffer, toHex).join(' ');
|
}
|
|
function crc8(bytes) {
|
let crc = 0;
|
|
for (const value of bytes) {
|
crc ^= value;
|
|
for (let index = 0; index < 8; index += 1) {
|
if ((crc & 0x01) !== 0) {
|
crc = ((crc >> 1) ^ 0x8C) & 0xFF;
|
} else {
|
crc = (crc >> 1) & 0xFF;
|
}
|
}
|
}
|
|
return crc & 0xFF;
|
}
|
|
function readUInt16LE(buffer, offset) {
|
return buffer.readUInt16LE(offset);
|
}
|
|
function readInt16LE(buffer, offset) {
|
return buffer.readInt16LE(offset);
|
}
|
|
function readUInt32LE(buffer, offset) {
|
return buffer.readUInt32LE(offset);
|
}
|
|
function scaled(value, scale) {
|
if (!scale) {
|
return value;
|
}
|
|
return Number((value / scale).toFixed(1));
|
}
|
|
function resolveFilePath(filePath) {
|
if (path.isAbsolute(filePath)) {
|
return filePath;
|
}
|
|
return path.join(process.cwd(), filePath);
|
}
|
|
function loadAlModelMap(filePath) {
|
const resolvedPath = resolveFilePath(filePath);
|
const content = fs.readFileSync(resolvedPath, 'utf8');
|
const model = JSON.parse(content);
|
const map = new Map();
|
|
for (const item of model.properties || []) {
|
if (item && item.identifier) {
|
map.set(item.identifier, item.name || item.identifier);
|
}
|
}
|
|
return map;
|
}
|
|
class Jh2028Decoder {
|
constructor(options = {}) {
|
this.buffer = Buffer.alloc(0);
|
this.maxBufferBytes = options.maxBufferBytes || 8192;
|
this.alModelMap = loadAlModelMap(options.alModelPath || './alModel.json');
|
}
|
|
push(chunk) {
|
if (!Buffer.isBuffer(chunk) || chunk.length === 0) {
|
return [];
|
}
|
|
this.buffer = Buffer.concat([this.buffer, chunk]);
|
|
if (this.buffer.length > this.maxBufferBytes) {
|
this.buffer = Buffer.alloc(0);
|
return [{ ok: false, publish: false, reason: 'buffer-overflow' }];
|
}
|
|
const results = [];
|
|
while (this.buffer.length >= 2) {
|
const headerIndex = this.findHeader();
|
|
if (headerIndex < 0) {
|
this.buffer = this.buffer.slice(Math.max(0, this.buffer.length - 1));
|
break;
|
}
|
|
if (headerIndex > 0) {
|
this.buffer = this.buffer.slice(headerIndex);
|
}
|
|
if (this.buffer.length < 3) {
|
break;
|
}
|
|
const frameLength = this.buffer[2];
|
|
if (frameLength < MIN_FRAME_LENGTH) {
|
this.buffer = this.buffer.slice(1);
|
continue;
|
}
|
|
if (this.buffer.length < frameLength) {
|
break;
|
}
|
|
const frame = this.buffer.slice(0, frameLength);
|
this.buffer = this.buffer.slice(frameLength);
|
results.push(this.parseFrame(frame));
|
}
|
|
return results;
|
}
|
|
findHeader() {
|
for (let index = 0; index <= this.buffer.length - 2; index += 1) {
|
if (this.buffer[index] === HEADER_1 && this.buffer[index + 1] === HEADER_2) {
|
return index;
|
}
|
}
|
|
return -1;
|
}
|
|
parseFrame(frame) {
|
const frameLength = frame[2];
|
const timestamp = frame[3];
|
const commandType = frame[4];
|
const commandId = frame[5];
|
const payload = frame.slice(6, frame.length - 1);
|
const receivedCrc = frame[frame.length - 1];
|
const expectedCrc = crc8(frame.slice(0, -1));
|
const rawHex = bytesToHex(frame);
|
|
if (frameLength !== frame.length) {
|
return this.buildErrorResult('length-invalid', frame, {
|
timestamp,
|
commandType,
|
commandId,
|
rawHex,
|
});
|
}
|
|
if (receivedCrc !== expectedCrc) {
|
return this.buildErrorResult('crc-invalid', frame, {
|
timestamp,
|
commandType,
|
commandId,
|
rawHex,
|
receivedCrc,
|
expectedCrc,
|
});
|
}
|
|
if (commandType !== CMDTYPE_DATA_SYNC) {
|
return this.buildSkipResult('unsupported-command-type', {
|
timestamp,
|
commandType,
|
commandId,
|
rawHex,
|
});
|
}
|
|
if (commandId === CMDID_REALTIME) {
|
return this.parseRealtimeFrame(payload, {
|
timestamp,
|
commandType,
|
commandId,
|
rawHex,
|
});
|
}
|
|
if (commandId === CMDID_BLOOD_PRESSURE) {
|
return this.parseBloodPressureFrame(payload, {
|
timestamp,
|
commandType,
|
commandId,
|
rawHex,
|
});
|
}
|
|
return this.buildSkipResult('unsupported-command-id', {
|
timestamp,
|
commandType,
|
commandId,
|
rawHex,
|
});
|
}
|
|
parseRealtimeFrame(payload, meta) {
|
if (payload.length < REALTIME_PAYLOAD_LENGTH) {
|
return this.buildErrorResult('payload-too-short', payload, meta);
|
}
|
|
const metric = {};
|
|
for (const field of REALTIME_FIELDS) {
|
const rawValue = field.read(payload, field.offset);
|
metric[field.identifier] = scaled(rawValue, field.scale);
|
}
|
|
return this.buildMetricResult(metric, {
|
...meta,
|
protocol: 'jh2028-20260511',
|
messageType: 'realtime',
|
});
|
}
|
|
parseBloodPressureFrame(payload, meta) {
|
if (payload.length < BLOOD_PRESSURE_PAYLOAD_LENGTH) {
|
return this.buildErrorResult('payload-too-short', payload, meta);
|
}
|
|
const systolicOrErrorCode = payload[0];
|
const diastolic = payload[1];
|
const pulse = payload[2];
|
const irregularPulse = payload[3];
|
const meanPressure = payload[4];
|
const hasError = systolicOrErrorCode > 0
|
&& diastolic === 0
|
&& pulse === 0
|
&& irregularPulse === 0;
|
|
if (hasError) {
|
return this.buildSkipResult('blood-pressure-error-code', {
|
...meta,
|
protocol: 'jh2028-20260511',
|
messageType: 'blood-pressure',
|
errorCode: systolicOrErrorCode,
|
});
|
}
|
|
return this.buildMetricResult({
|
N: systolicOrErrorCode,
|
O: diastolic,
|
P: pulse,
|
}, {
|
...meta,
|
protocol: 'jh2028-20260511',
|
messageType: 'blood-pressure',
|
ignored: {
|
irregularPulse,
|
meanPressure,
|
},
|
});
|
}
|
|
buildMetricResult(metric, meta) {
|
const entries = Object.entries(metric)
|
.filter(([, value]) => value !== undefined && value !== null)
|
.filter(([identifier]) => this.alModelMap.has(identifier));
|
|
if (entries.length === 0) {
|
return this.buildSkipResult('identifier-not-in-almodel', meta);
|
}
|
|
return {
|
ok: true,
|
publish: true,
|
reason: 'ok',
|
metric: Object.fromEntries(entries),
|
identifiers: entries.map(([identifier]) => identifier),
|
...meta,
|
};
|
}
|
|
buildErrorResult(reason, _frame, meta = {}) {
|
return {
|
ok: false,
|
publish: false,
|
reason,
|
...meta,
|
};
|
}
|
|
buildSkipResult(reason, meta = {}) {
|
return {
|
ok: true,
|
publish: false,
|
reason,
|
...meta,
|
};
|
}
|
}
|
|
module.exports = {
|
BLOOD_PRESSURE_PAYLOAD_LENGTH,
|
CMDID_BLOOD_PRESSURE,
|
CMDID_REALTIME,
|
CMDTYPE_DATA_SYNC,
|
HEADER_1,
|
HEADER_2,
|
Jh2028Decoder,
|
MIN_FRAME_LENGTH,
|
REALTIME_FIELDS,
|
REALTIME_PAYLOAD_LENGTH,
|
bytesToHex,
|
crc8,
|
loadAlModelMap,
|
toHex,
|
};
|
