255 lines
No EOL
8.6 KiB
TypeScript
255 lines
No EOL
8.6 KiB
TypeScript
import { NextRequest, NextResponse } from 'next/server';
|
|
import { bedHardwareInstance, PinState, PinChange } from '@/services/BedHardware';
|
|
import { SensorDataStorage, SensorDataPoint } from '@/services/SensorDataStorage';
|
|
import { SensorConfig } from '@/types/sensor';
|
|
|
|
// Complete sensor configuration with positions, pin mappings, and thresholds
|
|
const SENSOR_CONFIG: SensorConfig[] = [
|
|
// Head area
|
|
{ id: "head-1", x: 45, y: 15, zone: "head", label: "Head Left", pin: 2, baseNoise: 200, warningThreshold: 3000, alarmThreshold: 3500, warningDelayMs: 30000 },
|
|
{ id: "head-2", x: 55, y: 15, zone: "head", label: "Head Right", pin: 3, baseNoise: 150, warningThreshold: 3000, alarmThreshold: 3500, warningDelayMs: 30000 },
|
|
|
|
// Shoulder area
|
|
{ id: "shoulder-1", x: 35, y: 25, zone: "shoulders", label: "Left Shoulder", pin: 4, baseNoise: 250, warningThreshold: 2800, alarmThreshold: 3200, warningDelayMs: 45000 },
|
|
{ id: "shoulder-2", x: 65, y: 25, zone: "shoulders", label: "Right Shoulder", pin: 5, baseNoise: 220, warningThreshold: 2800, alarmThreshold: 3200, warningDelayMs: 45000 },
|
|
|
|
// Upper back
|
|
{ id: "back-1", x: 40, y: 35, zone: "back", label: "Upper Back Left", pin: 6, baseNoise: 300, warningThreshold: 2500, alarmThreshold: 3000, warningDelayMs: 60000 },
|
|
{ id: "back-2", x: 50, y: 35, zone: "back", label: "Upper Back Center", pin: 7, baseNoise: 350, warningThreshold: 2500, alarmThreshold: 3000, warningDelayMs: 60000 },
|
|
{ id: "back-3", x: 60, y: 35, zone: "back", label: "Upper Back Right", pin: 8, baseNoise: 280, warningThreshold: 2500, alarmThreshold: 3000, warningDelayMs: 60000 },
|
|
|
|
// Lower back/Hip area
|
|
{ id: "hip-1", x: 35, y: 50, zone: "hips", label: "Left Hip", pin: 9, baseNoise: 400, warningThreshold: 2200, alarmThreshold: 2800, warningDelayMs: 90000 },
|
|
{ id: "hip-2", x: 50, y: 50, zone: "hips", label: "Lower Back", pin: 10, baseNoise: 450, warningThreshold: 2200, alarmThreshold: 2800, warningDelayMs: 90000 },
|
|
{ id: "hip-3", x: 65, y: 50, zone: "hips", label: "Right Hip", pin: 11, baseNoise: 380, warningThreshold: 2200, alarmThreshold: 2800, warningDelayMs: 90000 },
|
|
// Thigh area
|
|
{ id: "thigh-1", x: 40, y: 65, zone: "legs", label: "Left Thigh", pin: 12, baseNoise: 320, warningThreshold: 2000, alarmThreshold: 2500, warningDelayMs: 120000 },
|
|
{ id: "thigh-2", x: 60, y: 65, zone: "legs", label: "Right Thigh", pin: 13, baseNoise: 300, warningThreshold: 2000, alarmThreshold: 2500, warningDelayMs: 120000 },
|
|
];
|
|
|
|
// Create pin mapping from sensor config
|
|
const PIN_SENSOR_MAP: Record<number, typeof SENSOR_CONFIG[0]> = {};
|
|
SENSOR_CONFIG.forEach(sensor => {
|
|
if (sensor.pin) {
|
|
PIN_SENSOR_MAP[sensor.pin] = sensor;
|
|
}
|
|
});
|
|
|
|
const sensorDataStorage = SensorDataStorage.getInstance();
|
|
const sensorData: Record<string, {
|
|
id: string;
|
|
x: number;
|
|
y: number;
|
|
label: string;
|
|
zone: string;
|
|
value: number; // Changed from pressure to value (0-4095)
|
|
pin?: number;
|
|
digitalState?: number;
|
|
timestamp: string;
|
|
source: 'hardware' | 'mock';
|
|
data: Array<{ time: string; timestamp: number; value: number }>;
|
|
status: string;
|
|
warningStartTime?: number; // Track when warning state started
|
|
warningThreshold: number;
|
|
alarmThreshold: number;
|
|
warningDelayMs: number;
|
|
}> = {};
|
|
let isHardwareConnected = false;
|
|
|
|
// Initialize all sensor data
|
|
function initializeSensorData() {
|
|
SENSOR_CONFIG.forEach(sensor => {
|
|
if (!sensorData[sensor.id] && sensor.pin) { // Only initialize sensors with pins (real hardware)
|
|
sensorData[sensor.id] = {
|
|
id: sensor.id,
|
|
x: sensor.x,
|
|
y: sensor.y,
|
|
label: sensor.label,
|
|
zone: sensor.zone,
|
|
value: 0, // Start with zero until real data arrives
|
|
pin: sensor.pin,
|
|
timestamp: new Date().toISOString(),
|
|
source: 'hardware',
|
|
data: [], // Start with empty data array
|
|
status: 'normal',
|
|
warningThreshold: sensor.warningThreshold,
|
|
alarmThreshold: sensor.alarmThreshold,
|
|
warningDelayMs: sensor.warningDelayMs
|
|
};
|
|
}
|
|
});
|
|
}
|
|
|
|
|
|
|
|
// Initialize hardware connection
|
|
async function initializeHardware() {
|
|
if (isHardwareConnected) return;
|
|
|
|
try {
|
|
bedHardwareInstance.on('connected', () => {
|
|
console.log('BedHardware connected');
|
|
isHardwareConnected = true;
|
|
});
|
|
|
|
bedHardwareInstance.on('disconnected', () => {
|
|
console.log('BedHardware disconnected');
|
|
isHardwareConnected = false;
|
|
});
|
|
|
|
bedHardwareInstance.on('pinChanged', (change: PinChange) => {
|
|
updateSensorFromPin(change.pin, change.currentState);
|
|
});
|
|
|
|
bedHardwareInstance.on('pinInitialized', (pinState: PinState) => {
|
|
updateSensorFromPin(pinState.pin, pinState.state);
|
|
});
|
|
|
|
bedHardwareInstance.on('error', (error) => {
|
|
console.error('BedHardware error:', error);
|
|
isHardwareConnected = false;
|
|
});
|
|
|
|
await bedHardwareInstance.connect(); } catch (error) {
|
|
console.warn('Failed to connect to hardware, system will wait for real hardware data:', error);
|
|
isHardwareConnected = false;
|
|
}
|
|
}
|
|
|
|
// Update sensor data from pin change
|
|
async function updateSensorFromPin(pin: number, value: number) {
|
|
const mapping = PIN_SENSOR_MAP[pin];
|
|
if (!mapping) return;
|
|
const timestamp = Date.now();
|
|
const time = new Date(timestamp).toLocaleTimeString("en-US", { hour12: false });
|
|
// Save to persistent storage
|
|
const dataPoint: SensorDataPoint = {
|
|
sensorId: mapping.id,
|
|
value,
|
|
timestamp,
|
|
time,
|
|
source: 'hardware',
|
|
pin,
|
|
digitalState: value
|
|
};
|
|
await sensorDataStorage.addDataPoint(dataPoint);
|
|
|
|
if (sensorData[mapping.id]) {
|
|
// Update existing sensor data
|
|
const currentData = sensorData[mapping.id];
|
|
|
|
// Determine status based on thresholds
|
|
let status = 'normal';
|
|
let warningStartTime = currentData.warningStartTime;
|
|
|
|
if (value >= mapping.alarmThreshold) {
|
|
status = 'alarm';
|
|
warningStartTime = undefined; // Clear warning timer for immediate alarm
|
|
} else if (value >= mapping.warningThreshold) {
|
|
status = 'warning';
|
|
if (!warningStartTime) {
|
|
warningStartTime = timestamp; // Start warning timer
|
|
} else if (timestamp - warningStartTime >= mapping.warningDelayMs) {
|
|
status = 'alarm'; // Escalate to alarm after delay
|
|
}
|
|
} else {
|
|
warningStartTime = undefined; // Clear warning timer
|
|
}
|
|
sensorData[mapping.id] = {
|
|
...currentData,
|
|
value,
|
|
digitalState: value,
|
|
timestamp: new Date().toISOString(),
|
|
source: 'hardware',
|
|
data: [
|
|
...currentData.data.slice(-287), // Keep last ~24 hours (288 points at 5min intervals)
|
|
{
|
|
time,
|
|
timestamp,
|
|
value: value,
|
|
}
|
|
],
|
|
status,
|
|
warningStartTime
|
|
};
|
|
}
|
|
}
|
|
|
|
|
|
|
|
export async function GET() {
|
|
try {
|
|
// Initialize sensor data if not already done
|
|
if (Object.keys(sensorData).length === 0) {
|
|
initializeSensorData();
|
|
} // Initialize hardware if not already done
|
|
if (!isHardwareConnected) {
|
|
await initializeHardware();
|
|
}
|
|
|
|
// If hardware is connected, get current pin states
|
|
if (isHardwareConnected) {
|
|
const pinStates = bedHardwareInstance.getAllPinStates();
|
|
for (const pinState of pinStates) {
|
|
await updateSensorFromPin(pinState.pin, pinState.state);
|
|
}
|
|
}
|
|
|
|
// Return all sensor data
|
|
return NextResponse.json({
|
|
success: true,
|
|
connected: isHardwareConnected,
|
|
sensors: Object.values(sensorData),
|
|
timestamp: new Date().toISOString()
|
|
});
|
|
|
|
} catch (error) {
|
|
console.error('Sensor API error:', error);
|
|
return NextResponse.json({
|
|
success: false,
|
|
error: 'Failed to get sensor data',
|
|
connected: false,
|
|
sensors: [],
|
|
timestamp: new Date().toISOString()
|
|
}, { status: 500 });
|
|
}
|
|
}
|
|
|
|
export async function POST(request: NextRequest) {
|
|
try {
|
|
const body = await request.json();
|
|
|
|
if (body.action === 'connect') {
|
|
await initializeHardware();
|
|
return NextResponse.json({
|
|
success: true,
|
|
connected: isHardwareConnected,
|
|
message: isHardwareConnected ? 'Hardware connected' : 'Hardware connection failed'
|
|
});
|
|
}
|
|
|
|
if (body.action === 'disconnect') {
|
|
if (bedHardwareInstance) {
|
|
await bedHardwareInstance.disconnect();
|
|
isHardwareConnected = false;
|
|
}
|
|
return NextResponse.json({
|
|
success: true,
|
|
connected: false,
|
|
message: 'Hardware disconnected'
|
|
});
|
|
}
|
|
|
|
return NextResponse.json({
|
|
success: false,
|
|
error: 'Invalid action'
|
|
}, { status: 400 });
|
|
|
|
} catch (error) {
|
|
console.error('Sensor API POST error:', error);
|
|
return NextResponse.json({
|
|
success: false,
|
|
error: 'Failed to process request'
|
|
}, { status: 500 });
|
|
}
|
|
} |