Integrar dashboard y control EZO por I2C
Mejora el monitoreo, alarmas, historiales y exportaciones del dashboard. Agrega consola y calibración Atlas Scientific con transporte I2C real y modo demo, corrige módulos de sensores, incorpora documentación oficial y pruebas automáticas.main
EMOTIONS-HUNTER
1 month ago
parent
0ba3e59fb6
commit
426b9c247b
@ -0,0 +1,77 @@
|
|||||||
|
# Estado del Proyecto
|
||||||
|
|
||||||
|
## Estado actual
|
||||||
|
|
||||||
|
El dashboard integra monitoreo en vivo, alarmas configurables, tendencias
|
||||||
|
historicas, exportacion de datos y una consola Atlas Scientific EZO capaz de
|
||||||
|
usar I2C real en Raspberry Pi o modo demo en desarrollo.
|
||||||
|
|
||||||
|
## Funciones operativas
|
||||||
|
|
||||||
|
- Lectura de `data/EZORTD.json`, `data/EZOPH.json`, `data/EZODO.json` y
|
||||||
|
`data/EZOEC.json` cada segundo.
|
||||||
|
- Evaluacion de alarmas mediante `config/alarms.json`.
|
||||||
|
- Graficas Chart.js alimentadas por los CSV de `logs/`.
|
||||||
|
- Intervalo configurable para actualizar graficas.
|
||||||
|
- Exportacion CSV y Excel usando datos historicos simulados de la API.
|
||||||
|
- Borrado real de los cuatro CSV mediante `POST /api/history/clear`, conservando
|
||||||
|
sus encabezados.
|
||||||
|
- API Express con validacion basica para sensores, comandos y frecuencia de
|
||||||
|
registro simulada.
|
||||||
|
- Pruebas automaticas de los endpoints principales con `node --test`.
|
||||||
|
|
||||||
|
## Arquitectura de datos
|
||||||
|
|
||||||
|
| Funcion | Fuente actual |
|
||||||
|
|---|---|
|
||||||
|
| Lecturas en vivo | Archivos JSON en `data/` |
|
||||||
|
| Alarmas | `config/alarms.json` |
|
||||||
|
| Graficas | Archivos CSV en `logs/` |
|
||||||
|
| Exportaciones | API Express con datos simulados |
|
||||||
|
| Comandos y calibracion | API Express + `EZO_COMMAND` en hardware; demo fuera de Raspberry Pi |
|
||||||
|
|
||||||
|
Nginx sirve los archivos estaticos y redirige `/api/*` al proceso Express en el
|
||||||
|
puerto 3000.
|
||||||
|
|
||||||
|
Para desarrollo local, Express tambien sirve exclusivamente `frontend/`,
|
||||||
|
`data/`, `logs/` y `config/`. El dashboard puede abrirse directamente en
|
||||||
|
`http://localhost:3000/frontend/index.html` sin configurar Nginx.
|
||||||
|
|
||||||
|
## Hardware
|
||||||
|
|
||||||
|
- `EZO-RTD`, `EZO-pH`, `EZO-DO` y `EZO-EC` tienen ejecutables C de lectura unica.
|
||||||
|
- Los Makefiles usan los objetos correspondientes a cada modulo.
|
||||||
|
- El daemon continuo existente corresponde solamente a EZO-RTD.
|
||||||
|
- La conexion de comandos web con el bus I2C real usa
|
||||||
|
`sensors/EZOCommand/EZO_COMMAND`.
|
||||||
|
- La frecuencia seleccionada en la interfaz afecta solamente al backend
|
||||||
|
simulado; no reconfigura los procesos C.
|
||||||
|
|
||||||
|
## Dependencias externas
|
||||||
|
|
||||||
|
- Express y CORS mediante npm.
|
||||||
|
- Chart.js mediante CDN.
|
||||||
|
- SheetJS mediante CDN.
|
||||||
|
|
||||||
|
Para operar sin internet en la Raspberry Pi se recomienda almacenar Chart.js y
|
||||||
|
SheetJS localmente dentro de `frontend/vendor/`.
|
||||||
|
|
||||||
|
## Verificacion
|
||||||
|
|
||||||
|
Ejecutar:
|
||||||
|
|
||||||
|
```bash
|
||||||
|
npm test
|
||||||
|
npm start
|
||||||
|
```
|
||||||
|
|
||||||
|
La compilacion de los controladores C debe verificarse en Raspberry Pi OS,
|
||||||
|
porque depende de `/dev/i2c-1` y de los encabezados Linux I2C.
|
||||||
|
|
||||||
|
## Trabajo pendiente
|
||||||
|
|
||||||
|
1. Crear daemons continuos para EZO-pH, EZO-DO y EZO-EC.
|
||||||
|
2. Verificar la capa I2C y cada rutina de calibracion con las sondas fisicas.
|
||||||
|
3. Hacer que la frecuencia de registro configure los daemons.
|
||||||
|
4. Servir Chart.js y SheetJS localmente para despliegues sin internet.
|
||||||
|
5. Agregar pruebas de navegador para el dashboard completo.
|
||||||
@ -0,0 +1,311 @@
|
|||||||
|
const fs = require('fs');
|
||||||
|
const path = require('path');
|
||||||
|
const { execFile } = require('child_process');
|
||||||
|
const { promisify } = require('util');
|
||||||
|
|
||||||
|
const execFileAsync = promisify(execFile);
|
||||||
|
|
||||||
|
const SENSOR_CONFIG = {
|
||||||
|
rtd: { address: '0x66', name: 'RTD' },
|
||||||
|
ph: { address: '0x63', name: 'pH' },
|
||||||
|
do: { address: '0x61', name: 'DO' },
|
||||||
|
ec: { address: '0x64', name: 'EC' }
|
||||||
|
};
|
||||||
|
|
||||||
|
const DANGEROUS_COMMANDS = new Set(['factory', 'i2c', 'baud', 'sleep']);
|
||||||
|
const COMMON_COMMANDS = new Set([
|
||||||
|
'r', 'i', 'status', 'find', 'l', 'plock', 'name', 'cal',
|
||||||
|
'export', 'import', 't', 'rt', '*ok'
|
||||||
|
]);
|
||||||
|
const SENSOR_COMMANDS = {
|
||||||
|
rtd: new Set(['s', 'd', 'm']),
|
||||||
|
ph: new Set(['slope', 'phext']),
|
||||||
|
do: new Set(['s', 'p', 'o']),
|
||||||
|
ec: new Set(['k', 'tc', 'tds', 'o'])
|
||||||
|
};
|
||||||
|
|
||||||
|
const MOCK_STATE = {
|
||||||
|
rtd: { calibrationPoints: 0 },
|
||||||
|
ph: { calibrationPoints: 0 },
|
||||||
|
do: { calibrationPoints: 0 },
|
||||||
|
ec: { calibrationPoints: 0, k: 1.0 }
|
||||||
|
};
|
||||||
|
|
||||||
|
function normalizeCommand(rawCommand) {
|
||||||
|
return String(rawCommand || '').trim().replace(/\s+/g, '');
|
||||||
|
}
|
||||||
|
|
||||||
|
function getBaseCommand(command) {
|
||||||
|
return command.split(',')[0].toLowerCase();
|
||||||
|
}
|
||||||
|
|
||||||
|
function validateCommand(sensor, command, dangerousConfirmed) {
|
||||||
|
if (!SENSOR_CONFIG[sensor]) {
|
||||||
|
throw createHttpError(400, 'Sensor no válido.');
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!command || command.length > 64 || !/^[a-zA-Z0-9*?.+\-,]+$/.test(command)) {
|
||||||
|
throw createHttpError(400, 'Comando EZO no válido.');
|
||||||
|
}
|
||||||
|
|
||||||
|
const baseCommand = getBaseCommand(command);
|
||||||
|
const isAllowed = COMMON_COMMANDS.has(baseCommand) ||
|
||||||
|
SENSOR_COMMANDS[sensor].has(baseCommand) ||
|
||||||
|
DANGEROUS_COMMANDS.has(baseCommand);
|
||||||
|
|
||||||
|
if (!isAllowed) {
|
||||||
|
throw createHttpError(400, `El comando ${baseCommand} no aplica a ${sensor.toUpperCase()}.`);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (DANGEROUS_COMMANDS.has(baseCommand) && !dangerousConfirmed) {
|
||||||
|
throw createHttpError(409, 'El comando requiere confirmación explícita.');
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!matchesOfficialSyntax(sensor, command)) {
|
||||||
|
throw createHttpError(
|
||||||
|
400,
|
||||||
|
`La sintaxis "${command}" no coincide con los comandos documentados para ${sensor.toUpperCase()}.`
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function matchesOfficialSyntax(sensor, command) {
|
||||||
|
const normalized = command.toLowerCase();
|
||||||
|
const commonPatterns = [
|
||||||
|
/^(r|i|status|find|sleep|factory)$/,
|
||||||
|
/^l,(0|1|\?)$/,
|
||||||
|
/^plock,(0|1|\?)$/,
|
||||||
|
/^name,(|\?|[a-z0-9_.-]{1,16})$/,
|
||||||
|
/^\*ok,(0|1|\?)$/,
|
||||||
|
/^export(\,?)?$/,
|
||||||
|
/^export,\?$/,
|
||||||
|
/^import,[0-9a-f ]+$/,
|
||||||
|
/^i2c,([1-9]|[1-9]\d|1[01]\d|12[0-7])$/,
|
||||||
|
/^baud,(300|1200|2400|9600|19200|38400|57600|115200)$/
|
||||||
|
];
|
||||||
|
|
||||||
|
if (commonPatterns.some((pattern) => pattern.test(normalized))) return true;
|
||||||
|
|
||||||
|
const sensorPatterns = {
|
||||||
|
rtd: [
|
||||||
|
/^cal,(\?|clear|[-+]?\d+(\.\d+)?)$/,
|
||||||
|
/^s,(c|k|f|\?)$/,
|
||||||
|
/^d,(0|1|\?)$/,
|
||||||
|
/^m,(clear|\?)$/
|
||||||
|
],
|
||||||
|
ph: [
|
||||||
|
/^cal,(\?|clear)$/,
|
||||||
|
/^cal,(mid|low|high),[-+]?\d+(\.\d+)?$/,
|
||||||
|
/^slope,\?$/,
|
||||||
|
/^phext,(0|1|\?)$/,
|
||||||
|
/^t,(\?|[-+]?\d+(\.\d+)?)$/,
|
||||||
|
/^rt,[-+]?\d+(\.\d+)?$/
|
||||||
|
],
|
||||||
|
do: [
|
||||||
|
/^cal$/,
|
||||||
|
/^cal,(0|\?|clear)$/,
|
||||||
|
/^t,(\?|[-+]?\d+(\.\d+)?)$/,
|
||||||
|
/^rt,[-+]?\d+(\.\d+)?$/,
|
||||||
|
/^s,(\?|[-+]?\d+(\.\d+)?(,ppt)?)$/,
|
||||||
|
/^p,(\?|[-+]?\d+(\.\d+)?)$/,
|
||||||
|
/^o,\?$/,
|
||||||
|
/^o,(mg|%),(0|1)$/
|
||||||
|
],
|
||||||
|
ec: [
|
||||||
|
/^cal,(\?|clear|dry|[-+]?\d+(\.\d+)?)$/,
|
||||||
|
/^cal,(low|high),[-+]?\d+(\.\d+)?$/,
|
||||||
|
/^k,(\?|[-+]?\d+(\.\d+)?)$/,
|
||||||
|
/^t,(\?|[-+]?\d+(\.\d+)?)$/,
|
||||||
|
/^rt,[-+]?\d+(\.\d+)?$/,
|
||||||
|
/^tc,(\?|[-+]?\d+(\.\d+)?)$/,
|
||||||
|
/^tds,(\?|[-+]?\d+(\.\d+)?)$/,
|
||||||
|
/^o,\?$/,
|
||||||
|
/^o,(ec|tds|s|sg),(0|1)$/
|
||||||
|
]
|
||||||
|
};
|
||||||
|
|
||||||
|
return sensorPatterns[sensor].some((pattern) => pattern.test(normalized));
|
||||||
|
}
|
||||||
|
|
||||||
|
function getProcessingDelay(command) {
|
||||||
|
const normalized = command.toLowerCase();
|
||||||
|
|
||||||
|
if (normalized === 'r') return 1000;
|
||||||
|
if (normalized.startsWith('rt,')) return 1000;
|
||||||
|
if (normalized === 'cal' || normalized === 'cal,0') return 1300;
|
||||||
|
if (normalized.startsWith('cal,') && !['cal,?', 'cal,clear'].includes(normalized)) {
|
||||||
|
return normalized.includes('mid') || normalized.includes('low') ||
|
||||||
|
normalized.includes('high') ? 900 : 600;
|
||||||
|
}
|
||||||
|
return 300;
|
||||||
|
}
|
||||||
|
|
||||||
|
function commandExpectsNoResponse(command) {
|
||||||
|
return ['sleep', 'factory'].includes(getBaseCommand(command)) ||
|
||||||
|
getBaseCommand(command) === 'i2c' ||
|
||||||
|
getBaseCommand(command) === 'baud';
|
||||||
|
}
|
||||||
|
|
||||||
|
function detectMode() {
|
||||||
|
const requestedMode = String(process.env.EZO_MODE || 'auto').toLowerCase();
|
||||||
|
const helperPath = process.env.EZO_HELPER ||
|
||||||
|
path.join(__dirname, '..', 'sensors', 'EZOCommand', 'EZO_COMMAND');
|
||||||
|
const hardwareReady = process.platform === 'linux' &&
|
||||||
|
fs.existsSync('/dev/i2c-1') &&
|
||||||
|
fs.existsSync(helperPath);
|
||||||
|
|
||||||
|
if (requestedMode === 'hardware' && !hardwareReady) {
|
||||||
|
return {
|
||||||
|
mode: 'unavailable',
|
||||||
|
helperPath,
|
||||||
|
message: 'Se solicitó hardware, pero /dev/i2c-1 o EZO_COMMAND no está disponible.'
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
if (requestedMode === 'hardware' || (requestedMode === 'auto' && hardwareReady)) {
|
||||||
|
return { mode: 'hardware', helperPath, message: 'Bus I2C real activo.' };
|
||||||
|
}
|
||||||
|
|
||||||
|
return {
|
||||||
|
mode: 'demo',
|
||||||
|
helperPath,
|
||||||
|
message: 'Modo demo activo; no se enviarán comandos al bus I2C.'
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
async function executeHardwareCommand(sensor, command, modeInfo) {
|
||||||
|
const config = SENSOR_CONFIG[sensor];
|
||||||
|
const args = [
|
||||||
|
'/dev/i2c-1',
|
||||||
|
config.address,
|
||||||
|
String(getProcessingDelay(command)),
|
||||||
|
command
|
||||||
|
];
|
||||||
|
|
||||||
|
if (commandExpectsNoResponse(command)) {
|
||||||
|
args.push('--no-response');
|
||||||
|
}
|
||||||
|
|
||||||
|
const { stdout } = await execFileAsync(modeInfo.helperPath, args, {
|
||||||
|
timeout: getProcessingDelay(command) + 2500,
|
||||||
|
windowsHide: true
|
||||||
|
});
|
||||||
|
const result = JSON.parse(stdout.trim());
|
||||||
|
|
||||||
|
if (!result.success) {
|
||||||
|
throw createHttpError(502, result.error || 'El circuito EZO rechazó el comando.');
|
||||||
|
}
|
||||||
|
|
||||||
|
return result.response || '*OK';
|
||||||
|
}
|
||||||
|
|
||||||
|
async function executeDemoCommand(sensor, command) {
|
||||||
|
const normalized = command.toLowerCase();
|
||||||
|
const state = MOCK_STATE[sensor];
|
||||||
|
await new Promise((resolve) => setTimeout(resolve, Math.min(getProcessingDelay(command), 80)));
|
||||||
|
|
||||||
|
if (normalized === 'r') {
|
||||||
|
const values = {
|
||||||
|
rtd: (25 + Math.random() * 0.1).toFixed(3),
|
||||||
|
ph: (7.2 + Math.random() * 0.05).toFixed(3),
|
||||||
|
do: (8.5 + Math.random() * 0.1).toFixed(2),
|
||||||
|
ec: (1050 + Math.random() * 5).toFixed(0)
|
||||||
|
};
|
||||||
|
return values[sensor];
|
||||||
|
}
|
||||||
|
|
||||||
|
if (normalized === 'i') return `?i,${SENSOR_CONFIG[sensor].name},demo`;
|
||||||
|
if (normalized === 'status') return '?Status,P,5.000';
|
||||||
|
if (normalized === 'cal,?') return `?Cal,${state.calibrationPoints}`;
|
||||||
|
if (normalized === 'cal,clear') {
|
||||||
|
state.calibrationPoints = 0;
|
||||||
|
return '*OK';
|
||||||
|
}
|
||||||
|
|
||||||
|
if (normalized.startsWith('cal')) {
|
||||||
|
updateDemoCalibration(sensor, normalized);
|
||||||
|
return '*OK';
|
||||||
|
}
|
||||||
|
|
||||||
|
if (normalized === 'slope,?') return '?Slope,98.2,97.8,-1.20';
|
||||||
|
if (normalized === 'k,?') return `?K,${state.k.toFixed(1)}`;
|
||||||
|
if (normalized.startsWith('k,')) {
|
||||||
|
state.k = Number(normalized.split(',')[1]);
|
||||||
|
return '*OK';
|
||||||
|
}
|
||||||
|
if (normalized === 't,?') return '?T,25.0';
|
||||||
|
if (normalized === 's,?' && sensor === 'do') return '?S,0,µS';
|
||||||
|
if (normalized === 'p,?') return '?P,101.3';
|
||||||
|
if (normalized === 'o,?') {
|
||||||
|
return sensor === 'do' ? '?O,mg,%' : '?O,EC,TDS,S,SG';
|
||||||
|
}
|
||||||
|
if (normalized === 'l,?') return '?L,1';
|
||||||
|
if (normalized === 'plock,?') return '?Plock,1';
|
||||||
|
if (normalized === 'phext,?') return '?pHext,0';
|
||||||
|
if (normalized === 's,?' && sensor === 'rtd') return '?S,C';
|
||||||
|
|
||||||
|
return '*OK';
|
||||||
|
}
|
||||||
|
|
||||||
|
function updateDemoCalibration(sensor, command) {
|
||||||
|
if (sensor === 'ph') {
|
||||||
|
if (command.startsWith('cal,mid,')) MOCK_STATE.ph.calibrationPoints = 1;
|
||||||
|
if (command.startsWith('cal,low,')) MOCK_STATE.ph.calibrationPoints = 2;
|
||||||
|
if (command.startsWith('cal,high,')) MOCK_STATE.ph.calibrationPoints = 3;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (sensor === 'do') {
|
||||||
|
if (command === 'cal,0') MOCK_STATE.do.calibrationPoints = 1;
|
||||||
|
if (command === 'cal') MOCK_STATE.do.calibrationPoints = 2;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (sensor === 'ec') {
|
||||||
|
if (command === 'cal,dry') MOCK_STATE.ec.calibrationPoints = 0;
|
||||||
|
if (command.startsWith('cal,low,')) MOCK_STATE.ec.calibrationPoints = 1;
|
||||||
|
if (command.startsWith('cal,high,')) MOCK_STATE.ec.calibrationPoints = 2;
|
||||||
|
if (/^cal,[\d.]+$/.test(command)) MOCK_STATE.ec.calibrationPoints = 1;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
MOCK_STATE.rtd.calibrationPoints = 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
async function executeEzoCommand(sensor, rawCommand, options = {}) {
|
||||||
|
const command = normalizeCommand(rawCommand);
|
||||||
|
validateCommand(sensor, command, options.dangerousConfirmed);
|
||||||
|
const modeInfo = detectMode();
|
||||||
|
|
||||||
|
if (modeInfo.mode === 'unavailable') {
|
||||||
|
throw createHttpError(503, modeInfo.message);
|
||||||
|
}
|
||||||
|
|
||||||
|
const response = modeInfo.mode === 'hardware'
|
||||||
|
? await executeHardwareCommand(sensor, command, modeInfo)
|
||||||
|
: await executeDemoCommand(sensor, command);
|
||||||
|
|
||||||
|
return {
|
||||||
|
success: true,
|
||||||
|
mode: modeInfo.mode,
|
||||||
|
sensor: SENSOR_CONFIG[sensor].name,
|
||||||
|
command,
|
||||||
|
response
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
function createHttpError(status, message) {
|
||||||
|
const error = new Error(message);
|
||||||
|
error.status = status;
|
||||||
|
return error;
|
||||||
|
}
|
||||||
|
|
||||||
|
module.exports = {
|
||||||
|
SENSOR_CONFIG,
|
||||||
|
detectMode,
|
||||||
|
executeEzoCommand,
|
||||||
|
getProcessingDelay,
|
||||||
|
matchesOfficialSyntax,
|
||||||
|
normalizeCommand,
|
||||||
|
validateCommand
|
||||||
|
};
|
||||||
@ -0,0 +1,130 @@
|
|||||||
|
# Comandos y calibracion Atlas Scientific EZO
|
||||||
|
|
||||||
|
Esta implementacion sigue los datasheets oficiales vigentes consultados para:
|
||||||
|
|
||||||
|
- EZO-pH, datasheet V6.1, revision 02/2024.
|
||||||
|
- EZO-DO, datasheet V5.8, revision 03/2025.
|
||||||
|
- EZO-EC, datasheet V5.5.
|
||||||
|
- EZO-RTD, datasheet V3.7, revision 10/2024.
|
||||||
|
|
||||||
|
## Transporte I2C
|
||||||
|
|
||||||
|
Los comandos son cadenas ASCII sin retorno de carro. Despues de escribir el
|
||||||
|
comando se espera el tiempo de procesamiento y se solicita la respuesta.
|
||||||
|
|
||||||
|
El primer byte de una respuesta I2C es:
|
||||||
|
|
||||||
|
| Codigo | Significado |
|
||||||
|
|---|---|
|
||||||
|
| `1` | Solicitud procesada correctamente |
|
||||||
|
| `2` | Error de sintaxis |
|
||||||
|
| `254` | Procesando; aun no esta lista |
|
||||||
|
| `255` | No hay datos |
|
||||||
|
|
||||||
|
El ejecutable `sensors/EZOCommand/EZO_COMMAND` implementa este intercambio y
|
||||||
|
reintenta las respuestas pendientes.
|
||||||
|
|
||||||
|
## Calibracion EZO-RTD
|
||||||
|
|
||||||
|
Calibracion de un punto:
|
||||||
|
|
||||||
|
```text
|
||||||
|
Cal,<temperatura>
|
||||||
|
Cal,?
|
||||||
|
Cal,clear
|
||||||
|
```
|
||||||
|
|
||||||
|
Ejemplo: `Cal,25.00`.
|
||||||
|
|
||||||
|
## Calibracion EZO-pH
|
||||||
|
|
||||||
|
Orden recomendado:
|
||||||
|
|
||||||
|
```text
|
||||||
|
Cal,mid,7.00
|
||||||
|
Cal,low,4.00
|
||||||
|
Cal,high,10.00
|
||||||
|
```
|
||||||
|
|
||||||
|
El punto medio siempre debe realizarse primero. Ejecutar `Cal,mid` sobre una
|
||||||
|
calibracion existente elimina los otros puntos. El estado se consulta con
|
||||||
|
`Cal,?` y la salud de la sonda con `Slope,?`.
|
||||||
|
|
||||||
|
## Calibracion EZO-DO
|
||||||
|
|
||||||
|
Un punto:
|
||||||
|
|
||||||
|
```text
|
||||||
|
Cal
|
||||||
|
```
|
||||||
|
|
||||||
|
Dos puntos, en este orden:
|
||||||
|
|
||||||
|
```text
|
||||||
|
Cal,0
|
||||||
|
Cal
|
||||||
|
```
|
||||||
|
|
||||||
|
`Cal,0` usa solucion de cero oxigeno. `Cal` usa la sonda estabilizada en aire
|
||||||
|
atmosferico. Compensaciones disponibles:
|
||||||
|
|
||||||
|
```text
|
||||||
|
T,<grados Celsius>
|
||||||
|
S,<conductividad en uS/cm>
|
||||||
|
S,<salinidad>,ppt
|
||||||
|
P,<presion en kPa>
|
||||||
|
```
|
||||||
|
|
||||||
|
## Calibracion EZO-EC
|
||||||
|
|
||||||
|
Primero se configura la constante de la sonda con `K,<valor>` y se realiza la
|
||||||
|
calibracion en seco:
|
||||||
|
|
||||||
|
```text
|
||||||
|
K,1.0
|
||||||
|
Cal,dry
|
||||||
|
```
|
||||||
|
|
||||||
|
Calibracion de dos puntos:
|
||||||
|
|
||||||
|
```text
|
||||||
|
Cal,dry
|
||||||
|
Cal,<valor>
|
||||||
|
```
|
||||||
|
|
||||||
|
Calibracion de tres puntos:
|
||||||
|
|
||||||
|
```text
|
||||||
|
Cal,dry
|
||||||
|
Cal,low,<valor>
|
||||||
|
Cal,high,<valor>
|
||||||
|
```
|
||||||
|
|
||||||
|
No se debe usar `Cal,0` en EC. El valor cero corresponde unicamente al paso
|
||||||
|
`Cal,dry`.
|
||||||
|
|
||||||
|
## Modos del backend
|
||||||
|
|
||||||
|
- `EZO_MODE=auto`: usa hardware si encuentra `/dev/i2c-1` y `EZO_COMMAND`;
|
||||||
|
de lo contrario usa demo.
|
||||||
|
- `EZO_MODE=hardware`: exige bus y ejecutable reales; si faltan, la API devuelve
|
||||||
|
error en vez de simular.
|
||||||
|
- `EZO_MODE=demo`: genera respuestas de desarrollo sin acceder al bus.
|
||||||
|
|
||||||
|
Para preparar Raspberry Pi:
|
||||||
|
|
||||||
|
```bash
|
||||||
|
make -C sensors/EZOCommand
|
||||||
|
sudo usermod -aG i2c $USER
|
||||||
|
EZO_MODE=hardware npm start
|
||||||
|
```
|
||||||
|
|
||||||
|
Es necesario cerrar sesion y volver a entrar despues de agregar el usuario al
|
||||||
|
grupo `i2c`.
|
||||||
|
|
||||||
|
## Fuentes oficiales
|
||||||
|
|
||||||
|
- https://files.atlas-scientific.com/pH_EZO_Datasheet.pdf
|
||||||
|
- https://files.atlas-scientific.com/DO_EZO_Datasheet.pdf
|
||||||
|
- https://files.atlas-scientific.com/EC_EZO_Datasheet.pdf
|
||||||
|
- https://files.atlas-scientific.com/EZO_RTD_Datasheet.pdf
|
||||||
@ -0,0 +1,339 @@
|
|||||||
|
const calibrationProfiles = {
|
||||||
|
rtd: {
|
||||||
|
description: "Calibración de un punto contra una temperatura de referencia.",
|
||||||
|
note: "Espere a que la lectura se estabilice antes de enviar Cal,<temperatura>.",
|
||||||
|
groups: [
|
||||||
|
{
|
||||||
|
title: "Punto de referencia",
|
||||||
|
help: "Use una referencia térmica trazable en grados Celsius.",
|
||||||
|
value: "25.00",
|
||||||
|
step: "0.01",
|
||||||
|
button: "Calibrar temperatura",
|
||||||
|
command(value) { return `Cal,${value}`; }
|
||||||
|
}
|
||||||
|
]
|
||||||
|
},
|
||||||
|
ph: {
|
||||||
|
description: "Calibración de uno, dos o tres puntos. El punto medio siempre va primero.",
|
||||||
|
note: "Orden Atlas: medio (pH 7), bajo (pH 4), alto (pH 10). Cal,mid borra los otros puntos.",
|
||||||
|
groups: [
|
||||||
|
{
|
||||||
|
title: "Punto medio",
|
||||||
|
help: "Enjuague la sonda, colóquela en buffer pH 7 y espere estabilidad.",
|
||||||
|
value: "7.00",
|
||||||
|
step: "0.01",
|
||||||
|
button: "Calibrar medio",
|
||||||
|
command(value) { return `Cal,mid,${value}`; }
|
||||||
|
},
|
||||||
|
{
|
||||||
|
title: "Punto bajo",
|
||||||
|
help: "Después del punto medio, use buffer ácido, normalmente pH 4.",
|
||||||
|
value: "4.00",
|
||||||
|
step: "0.01",
|
||||||
|
button: "Calibrar bajo",
|
||||||
|
command(value) { return `Cal,low,${value}`; }
|
||||||
|
},
|
||||||
|
{
|
||||||
|
title: "Punto alto",
|
||||||
|
help: "Después del punto bajo, use buffer básico, normalmente pH 10.",
|
||||||
|
value: "10.00",
|
||||||
|
step: "0.01",
|
||||||
|
button: "Calibrar alto",
|
||||||
|
command(value) { return `Cal,high,${value}`; }
|
||||||
|
},
|
||||||
|
{
|
||||||
|
title: "Diagnóstico de pendiente",
|
||||||
|
help: "Muestra pendiente ácida, básica y desplazamiento del punto neutro.",
|
||||||
|
button: "Consultar pendiente",
|
||||||
|
command() { return "Slope,?"; }
|
||||||
|
},
|
||||||
|
{
|
||||||
|
title: "Compensación de temperatura",
|
||||||
|
help: "La compensación es temporal y siempre se expresa en grados Celsius.",
|
||||||
|
value: "25.0",
|
||||||
|
step: "0.1",
|
||||||
|
button: "Aplicar temperatura",
|
||||||
|
command(value) { return `T,${value}`; },
|
||||||
|
secondaryButton: "Consultar temperatura",
|
||||||
|
secondaryCommand: "T,?"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
},
|
||||||
|
do: {
|
||||||
|
description: "Calibración atmosférica de un punto o calibración de dos puntos con cero.",
|
||||||
|
note: "Para dos puntos, Atlas indica calibrar primero cero (Cal,0) y después aire (Cal).",
|
||||||
|
groups: [
|
||||||
|
{
|
||||||
|
title: "Cero oxígeno",
|
||||||
|
help: "Use solución de cero O₂, elimine burbujas y espere una lectura estable.",
|
||||||
|
button: "Calibrar cero",
|
||||||
|
command() { return "Cal,0"; }
|
||||||
|
},
|
||||||
|
{
|
||||||
|
title: "Oxígeno atmosférico",
|
||||||
|
help: "Deje la sonda expuesta al aire hasta que la lectura se estabilice.",
|
||||||
|
button: "Calibrar aire",
|
||||||
|
command() { return "Cal"; }
|
||||||
|
},
|
||||||
|
{
|
||||||
|
title: "Compensaciones",
|
||||||
|
help: "Temperatura en °C, salinidad en µS/cm y presión atmosférica en kPa.",
|
||||||
|
fields: [
|
||||||
|
{ label: "Temperatura", value: "20.0", step: "0.1", command: "T" },
|
||||||
|
{ label: "Salinidad", value: "0", step: "1", command: "S" },
|
||||||
|
{ label: "Presión", value: "101.3", step: "0.1", command: "P" }
|
||||||
|
]
|
||||||
|
}
|
||||||
|
]
|
||||||
|
},
|
||||||
|
ec: {
|
||||||
|
description: "Calibración de dos o tres puntos; la calibración en seco siempre va primero.",
|
||||||
|
note: "Configure primero la constante K de la sonda. Nunca calibre EC a cero con Cal,0.",
|
||||||
|
groups: [
|
||||||
|
{
|
||||||
|
title: "Constante de la sonda",
|
||||||
|
help: "Valores habituales: K 0.1, K 1.0 o K 10.",
|
||||||
|
value: "1.0",
|
||||||
|
step: "0.1",
|
||||||
|
button: "Configurar K",
|
||||||
|
command(value) { return `K,${value}`; },
|
||||||
|
secondaryButton: "Consultar K",
|
||||||
|
secondaryCommand: "K,?"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
title: "Calibración en seco",
|
||||||
|
help: "Conecte la sonda completamente seca. Este paso siempre debe ser primero.",
|
||||||
|
button: "Calibrar seco",
|
||||||
|
command() { return "Cal,dry"; }
|
||||||
|
},
|
||||||
|
{
|
||||||
|
title: "Segundo punto",
|
||||||
|
help: "Para calibración de dos puntos use Cal,<valor>, por ejemplo 1413.",
|
||||||
|
value: "1413",
|
||||||
|
step: "1",
|
||||||
|
button: "Calibrar punto único",
|
||||||
|
command(value) { return `Cal,${value}`; }
|
||||||
|
},
|
||||||
|
{
|
||||||
|
title: "Puntos bajo y alto",
|
||||||
|
help: "Para tres puntos use primero bajo y finalmente alto.",
|
||||||
|
fields: [
|
||||||
|
{ label: "Bajo", value: "12880", step: "1", command: "Cal,low" },
|
||||||
|
{ label: "Alto", value: "80000", step: "1", command: "Cal,high" }
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
title: "Compensación de temperatura",
|
||||||
|
help: "La compensación se expresa en °C y no se conserva al apagar.",
|
||||||
|
value: "25.0",
|
||||||
|
step: "0.1",
|
||||||
|
button: "Aplicar temperatura",
|
||||||
|
command(value) { return `T,${value}`; },
|
||||||
|
secondaryButton: "Consultar temperatura",
|
||||||
|
secondaryCommand: "T,?"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
async function fetchHistoricalData(sensorType) {
|
||||||
|
try {
|
||||||
|
const response = await fetch(`/api/sensors/${sensorType}`);
|
||||||
|
|
||||||
|
if (!response.ok) {
|
||||||
|
throw new Error(`HTTP ${response.status}`);
|
||||||
|
}
|
||||||
|
|
||||||
|
return await response.json();
|
||||||
|
} catch (error) {
|
||||||
|
console.error("[ERROR] Fallo al conectar con el backend:", error);
|
||||||
|
return [];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
async function loadEzoTransportStatus() {
|
||||||
|
const statusElement = document.getElementById("ezo-transport-status");
|
||||||
|
|
||||||
|
try {
|
||||||
|
const response = await fetch("/api/system/ezo", { cache: "no-store" });
|
||||||
|
const data = await response.json();
|
||||||
|
statusElement.textContent = data.mode === "hardware"
|
||||||
|
? "HARDWARE I2C"
|
||||||
|
: data.mode === "demo" ? "DEMO" : "NO DISPONIBLE";
|
||||||
|
statusElement.className = `transport-${data.mode}`;
|
||||||
|
appendTerminalLine(
|
||||||
|
document.getElementById("terminal-output"),
|
||||||
|
`[SISTEMA] ${data.message}`,
|
||||||
|
data.mode === "hardware" ? "#63e6be" : "#ffd166"
|
||||||
|
);
|
||||||
|
} catch (error) {
|
||||||
|
statusElement.textContent = "NO DISPONIBLE";
|
||||||
|
statusElement.className = "transport-unavailable";
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
async function sendCommand(command, options = {}) {
|
||||||
|
const sensorType = options.sensor ||
|
||||||
|
document.getElementById("terminal-sensor-select").value;
|
||||||
|
const terminalOutput = document.getElementById("terminal-output");
|
||||||
|
const dangerous = ["factory", "i2c", "baud", "sleep"]
|
||||||
|
.includes(String(command).split(",")[0].toLowerCase());
|
||||||
|
let dangerousConfirmed = false;
|
||||||
|
|
||||||
|
if (dangerous) {
|
||||||
|
dangerousConfirmed = confirm(
|
||||||
|
`El comando ${command} puede reiniciar, dormir o cambiar la comunicación del circuito. ¿Desea enviarlo?`
|
||||||
|
);
|
||||||
|
if (!dangerousConfirmed) return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
const timeString = new Date().toLocaleTimeString();
|
||||||
|
appendTerminalLine(terminalOutput, `[${timeString}] TX (${sensorType}): ${command}`, "#ffffff");
|
||||||
|
|
||||||
|
try {
|
||||||
|
const response = await fetch(`/api/sensors/${sensorType}/command`, {
|
||||||
|
method: "POST",
|
||||||
|
headers: { "Content-Type": "application/json" },
|
||||||
|
body: JSON.stringify({ command, dangerousConfirmed })
|
||||||
|
});
|
||||||
|
const data = await response.json();
|
||||||
|
|
||||||
|
if (!response.ok) {
|
||||||
|
throw new Error(data.error || `HTTP ${response.status}`);
|
||||||
|
}
|
||||||
|
|
||||||
|
const mode = data.mode === "hardware" ? "I2C" : "DEMO";
|
||||||
|
appendTerminalLine(
|
||||||
|
terminalOutput,
|
||||||
|
`[${timeString}] RX (${mode}/${sensorType}): ${data.response}`,
|
||||||
|
data.response === "*ER" ? "#ff6b6b" : "#63e6be"
|
||||||
|
);
|
||||||
|
terminalOutput.scrollTop = terminalOutput.scrollHeight;
|
||||||
|
return data;
|
||||||
|
} catch (error) {
|
||||||
|
appendTerminalLine(
|
||||||
|
terminalOutput,
|
||||||
|
`[${timeString}] ERROR: ${error.message}`,
|
||||||
|
"#ff6b6b"
|
||||||
|
);
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
async function sendCalibrationCommand(command) {
|
||||||
|
const sensor = document.getElementById("cal-sensor-select").value;
|
||||||
|
document.getElementById("terminal-sensor-select").value = sensor;
|
||||||
|
return sendCommand(command, { sensor });
|
||||||
|
}
|
||||||
|
|
||||||
|
async function clearCalibration() {
|
||||||
|
const sensor = document.getElementById("cal-sensor-select").value;
|
||||||
|
const confirmed = confirm(
|
||||||
|
`Se borrarán todos los puntos de calibración del sensor ${sensor.toUpperCase()}. ¿Continuar?`
|
||||||
|
);
|
||||||
|
if (confirmed) {
|
||||||
|
await sendCalibrationCommand("Cal,clear");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function renderCalibrationPanel() {
|
||||||
|
const sensor = document.getElementById("cal-sensor-select").value;
|
||||||
|
const profile = calibrationProfiles[sensor];
|
||||||
|
const controls = document.getElementById("calibration-controls");
|
||||||
|
|
||||||
|
document.getElementById("calibration-description").textContent = profile.description;
|
||||||
|
document.getElementById("calibration-note").textContent = profile.note;
|
||||||
|
controls.replaceChildren();
|
||||||
|
|
||||||
|
profile.groups.forEach((group, groupIndex) => {
|
||||||
|
const container = document.createElement("div");
|
||||||
|
container.className = "calibration-group";
|
||||||
|
const title = document.createElement("h4");
|
||||||
|
title.textContent = group.title;
|
||||||
|
const help = document.createElement("p");
|
||||||
|
help.textContent = group.help;
|
||||||
|
container.append(title, help);
|
||||||
|
|
||||||
|
if (group.fields) {
|
||||||
|
group.fields.forEach((field, fieldIndex) => {
|
||||||
|
container.appendChild(createCalibrationAction(
|
||||||
|
`${sensor}-${groupIndex}-${fieldIndex}`,
|
||||||
|
field.label,
|
||||||
|
field.value,
|
||||||
|
field.step,
|
||||||
|
(value) => `${field.command},${value}`
|
||||||
|
));
|
||||||
|
});
|
||||||
|
} else {
|
||||||
|
container.appendChild(createCalibrationAction(
|
||||||
|
`${sensor}-${groupIndex}`,
|
||||||
|
null,
|
||||||
|
group.value,
|
||||||
|
group.step,
|
||||||
|
group.command,
|
||||||
|
group.button
|
||||||
|
));
|
||||||
|
}
|
||||||
|
|
||||||
|
if (group.secondaryCommand) {
|
||||||
|
const secondary = document.createElement("button");
|
||||||
|
secondary.className = "btn-command";
|
||||||
|
secondary.textContent = group.secondaryButton;
|
||||||
|
secondary.addEventListener("click", () =>
|
||||||
|
sendCalibrationCommand(group.secondaryCommand)
|
||||||
|
);
|
||||||
|
container.appendChild(secondary);
|
||||||
|
}
|
||||||
|
|
||||||
|
controls.appendChild(container);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
function createCalibrationAction(id, label, value, step, commandBuilder, buttonText) {
|
||||||
|
const row = document.createElement("div");
|
||||||
|
row.className = "calibration-action";
|
||||||
|
let input = null;
|
||||||
|
|
||||||
|
if (value !== undefined) {
|
||||||
|
input = document.createElement("input");
|
||||||
|
input.type = "number";
|
||||||
|
input.id = `cal-${id}`;
|
||||||
|
input.value = value;
|
||||||
|
input.step = step || "0.01";
|
||||||
|
input.setAttribute("aria-label", label || buttonText || "Valor de calibración");
|
||||||
|
row.appendChild(input);
|
||||||
|
}
|
||||||
|
|
||||||
|
const button = document.createElement("button");
|
||||||
|
button.className = "btn-command";
|
||||||
|
button.textContent = buttonText || label;
|
||||||
|
button.addEventListener("click", async () => {
|
||||||
|
const command = commandBuilder(input ? input.value : undefined);
|
||||||
|
if (!command || (input && input.value === "")) return;
|
||||||
|
await sendCalibrationCommand(command);
|
||||||
|
});
|
||||||
|
row.appendChild(button);
|
||||||
|
return row;
|
||||||
|
}
|
||||||
|
|
||||||
|
function sendCustomCommand() {
|
||||||
|
const input = document.getElementById("custom-command");
|
||||||
|
const command = input.value.trim();
|
||||||
|
|
||||||
|
if (command) {
|
||||||
|
sendCommand(command);
|
||||||
|
input.value = "";
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function appendTerminalLine(container, message, color) {
|
||||||
|
const line = document.createElement("div");
|
||||||
|
line.textContent = message;
|
||||||
|
line.style.color = color;
|
||||||
|
container.appendChild(line);
|
||||||
|
}
|
||||||
|
|
||||||
|
document.addEventListener("DOMContentLoaded", () => {
|
||||||
|
loadEzoTransportStatus();
|
||||||
|
renderCalibrationPanel();
|
||||||
|
});
|
||||||
@ -1,109 +0,0 @@
|
|||||||
// Actualización de mock-service.js (que ahora actúa como un api-service real)
|
|
||||||
|
|
||||||
async function fetchHistoricalData(sensorType) {
|
|
||||||
console.log(`[FETCH] Solicitando datos al backend vía Nginx para: ${sensorType}...`);
|
|
||||||
|
|
||||||
try {
|
|
||||||
// Hacemos la petición a la ruta que Nginx está interceptando (/api/...)
|
|
||||||
const response = await fetch(`/api/sensors/${sensorType}`);
|
|
||||||
|
|
||||||
if (!response.ok) {
|
|
||||||
throw new Error(`HTTP error! status: ${response.status}`);
|
|
||||||
}
|
|
||||||
|
|
||||||
const data = await response.json();
|
|
||||||
return data;
|
|
||||||
|
|
||||||
} catch (error) {
|
|
||||||
console.error("[ERROR] Fallo al conectar con el backend:", error);
|
|
||||||
// Retornar array vacío para evitar que la UI colapse
|
|
||||||
return [];
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
async function sendCommand(command) {
|
|
||||||
const sensorType = document.getElementById('terminal-sensor-select').value;
|
|
||||||
const terminalOutput = document.getElementById('terminal-output');
|
|
||||||
|
|
||||||
// 1. Imprimir el comando enviado en la consola UI
|
|
||||||
const timeString = new Date().toLocaleTimeString();
|
|
||||||
terminalOutput.innerHTML += `<div><span style="color: #fff;">[${timeString}] TX (${sensorType}):</span> ${command}</div>`;
|
|
||||||
|
|
||||||
// Hacer scroll automático hacia abajo
|
|
||||||
terminalOutput.scrollTop = terminalOutput.scrollHeight;
|
|
||||||
|
|
||||||
try {
|
|
||||||
// 2. Hacer la petición POST al backend mediante Nginx
|
|
||||||
const response = await fetch(`/api/sensors/${sensorType}/command`, {
|
|
||||||
method: 'POST',
|
|
||||||
headers: {
|
|
||||||
'Content-Type': 'application/json'
|
|
||||||
},
|
|
||||||
// El cuerpo viaja en formato JSON
|
|
||||||
body: JSON.stringify({ command: command })
|
|
||||||
});
|
|
||||||
|
|
||||||
if (!response.ok) {
|
|
||||||
throw new Error(`Error HTTP: ${response.status}`);
|
|
||||||
}
|
|
||||||
|
|
||||||
const data = await response.json();
|
|
||||||
|
|
||||||
// 3. Imprimir la respuesta simulada del circuito EZO en la UI
|
|
||||||
let color = data.response === '*ER' ? '#ff3333' : '#00ffcc';
|
|
||||||
terminalOutput.innerHTML += `<div><span style="color: #fff;">[${timeString}] RX (${sensorType}):</span> <span style="color: ${color};">${data.response}</span></div>`;
|
|
||||||
|
|
||||||
} catch (error) {
|
|
||||||
console.error("Error enviando comando:", error);
|
|
||||||
terminalOutput.innerHTML += `<div><span style="color: #ff3333;">[${timeString}] SYS ERROR: Fallo de bus I2C simulado o servidor desconectado.</span></div>`;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Mantener el scroll al final
|
|
||||||
terminalOutput.scrollTop = terminalOutput.scrollHeight;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Envía un comando de calibración predefinido y sincroniza el select de la consola.
|
|
||||||
*/
|
|
||||||
function sendCalibrationCmd(cmd) {
|
|
||||||
const sensorSelect = document.getElementById('cal-sensor-select').value;
|
|
||||||
|
|
||||||
// Sincronizar el select de la terminal para que los logs sean coherentes
|
|
||||||
document.getElementById('terminal-sensor-select').value = sensorSelect;
|
|
||||||
|
|
||||||
// Reutilizar la función de la consola para enviar la petición POST
|
|
||||||
sendCommand(cmd);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Toma el valor introducido por el usuario y construye el comando (ej. "cal,7.00").
|
|
||||||
*/
|
|
||||||
function calibratePoint() {
|
|
||||||
const sensorSelect = document.getElementById('cal-sensor-select').value;
|
|
||||||
const calValue = document.getElementById('cal-value').value;
|
|
||||||
|
|
||||||
if (!calValue) {
|
|
||||||
alert("Por favor, ingresa un valor de referencia para calibrar.");
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Sincronizar selectores
|
|
||||||
document.getElementById('terminal-sensor-select').value = sensorSelect;
|
|
||||||
|
|
||||||
// Construir el comando Atlas Scientific y enviarlo a la consola
|
|
||||||
const fullCommand = `cal,${calValue}`;
|
|
||||||
sendCommand(fullCommand);
|
|
||||||
|
|
||||||
// Limpiar el input después de enviar
|
|
||||||
document.getElementById('cal-value').value = '';
|
|
||||||
}
|
|
||||||
|
|
||||||
function sendCustomCommand() {
|
|
||||||
const input = document.getElementById('custom-command');
|
|
||||||
const command = input.value.trim();
|
|
||||||
|
|
||||||
if (command !== "") {
|
|
||||||
sendCommand(command);
|
|
||||||
input.value = ""; // Limpiar el input después de enviar
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -0,0 +1,9 @@
|
|||||||
|
CC=gcc
|
||||||
|
CFLAGS=-Wall -Wextra -O2
|
||||||
|
TARGET=EZO_COMMAND
|
||||||
|
|
||||||
|
$(TARGET): main.c
|
||||||
|
$(CC) $(CFLAGS) -o $(TARGET) main.c
|
||||||
|
|
||||||
|
clean:
|
||||||
|
rm -f $(TARGET)
|
||||||
@ -0,0 +1,124 @@
|
|||||||
|
#include <errno.h>
|
||||||
|
#include <fcntl.h>
|
||||||
|
#include <linux/i2c-dev.h>
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <string.h>
|
||||||
|
#include <sys/file.h>
|
||||||
|
#include <sys/ioctl.h>
|
||||||
|
#include <unistd.h>
|
||||||
|
|
||||||
|
static void print_json_error(const char *message)
|
||||||
|
{
|
||||||
|
printf("{\"success\":false,\"error\":\"%s\"}\n", message);
|
||||||
|
}
|
||||||
|
|
||||||
|
int main(int argc, char *argv[])
|
||||||
|
{
|
||||||
|
if (argc < 5)
|
||||||
|
{
|
||||||
|
print_json_error("Uso: EZO_COMMAND bus address delay_ms command [--no-response]");
|
||||||
|
return 2;
|
||||||
|
}
|
||||||
|
|
||||||
|
const char *bus = argv[1];
|
||||||
|
int address = (int)strtol(argv[2], NULL, 0);
|
||||||
|
int delay_ms = atoi(argv[3]);
|
||||||
|
const char *command = argv[4];
|
||||||
|
int no_response = argc > 5 && strcmp(argv[5], "--no-response") == 0;
|
||||||
|
int lock_fd = open("/tmp/photobioreactor-i2c.lock", O_CREAT | O_RDWR, 0660);
|
||||||
|
|
||||||
|
if (lock_fd < 0 || flock(lock_fd, LOCK_EX) < 0)
|
||||||
|
{
|
||||||
|
print_json_error("No se pudo bloquear el bus I2C");
|
||||||
|
return 3;
|
||||||
|
}
|
||||||
|
|
||||||
|
int fd = open(bus, O_RDWR);
|
||||||
|
|
||||||
|
if (fd < 0)
|
||||||
|
{
|
||||||
|
print_json_error("No se pudo abrir el bus I2C");
|
||||||
|
flock(lock_fd, LOCK_UN);
|
||||||
|
close(lock_fd);
|
||||||
|
return 4;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (ioctl(fd, I2C_SLAVE, address) < 0)
|
||||||
|
{
|
||||||
|
print_json_error("No se pudo seleccionar el circuito EZO");
|
||||||
|
close(fd);
|
||||||
|
flock(lock_fd, LOCK_UN);
|
||||||
|
close(lock_fd);
|
||||||
|
return 5;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (write(fd, command, strlen(command)) < 0)
|
||||||
|
{
|
||||||
|
print_json_error("Fallo al escribir el comando EZO");
|
||||||
|
close(fd);
|
||||||
|
flock(lock_fd, LOCK_UN);
|
||||||
|
close(lock_fd);
|
||||||
|
return 6;
|
||||||
|
}
|
||||||
|
|
||||||
|
usleep((useconds_t)delay_ms * 1000);
|
||||||
|
|
||||||
|
if (no_response)
|
||||||
|
{
|
||||||
|
printf("{\"success\":true,\"response\":\"SENT\"}\n");
|
||||||
|
close(fd);
|
||||||
|
flock(lock_fd, LOCK_UN);
|
||||||
|
close(lock_fd);
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
unsigned char response[64] = {0};
|
||||||
|
int bytes_read = read(fd, response, sizeof(response) - 1);
|
||||||
|
|
||||||
|
for (int retry = 0; bytes_read > 0 && response[0] == 254 && retry < 10; retry++)
|
||||||
|
{
|
||||||
|
usleep(100000);
|
||||||
|
memset(response, 0, sizeof(response));
|
||||||
|
bytes_read = read(fd, response, sizeof(response) - 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (bytes_read < 1)
|
||||||
|
{
|
||||||
|
print_json_error("El circuito EZO no respondió");
|
||||||
|
close(fd);
|
||||||
|
flock(lock_fd, LOCK_UN);
|
||||||
|
close(lock_fd);
|
||||||
|
return 7;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (response[0] != 1)
|
||||||
|
{
|
||||||
|
char message[64];
|
||||||
|
snprintf(message, sizeof(message), "Código de respuesta EZO: %u", response[0]);
|
||||||
|
print_json_error(message);
|
||||||
|
close(fd);
|
||||||
|
flock(lock_fd, LOCK_UN);
|
||||||
|
close(lock_fd);
|
||||||
|
return 8;
|
||||||
|
}
|
||||||
|
|
||||||
|
char *payload = (char *)&response[1];
|
||||||
|
payload[bytes_read > 1 ? bytes_read - 1 : 0] = '\0';
|
||||||
|
|
||||||
|
for (int i = 0; payload[i] != '\0'; i++)
|
||||||
|
{
|
||||||
|
if (payload[i] == '"' || payload[i] == '\\')
|
||||||
|
{
|
||||||
|
payload[i] = ' ';
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
printf("{\"success\":true,\"response\":\"%s\"}\n",
|
||||||
|
payload[0] == '\0' ? "*OK" : payload);
|
||||||
|
|
||||||
|
close(fd);
|
||||||
|
flock(lock_fd, LOCK_UN);
|
||||||
|
close(lock_fd);
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
@ -0,0 +1,31 @@
|
|||||||
|
#include <errno.h>
|
||||||
|
#include <fcntl.h>
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <string.h>
|
||||||
|
#include <unistd.h>
|
||||||
|
|
||||||
|
#include "ezodo.h"
|
||||||
|
|
||||||
|
int main()
|
||||||
|
{
|
||||||
|
int fd = open("/dev/i2c-1", O_RDWR);
|
||||||
|
|
||||||
|
if (fd < 0)
|
||||||
|
{
|
||||||
|
fprintf(stderr, "%s\n", strerror(errno));
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
double oxygen;
|
||||||
|
|
||||||
|
if (getDO(fd, &oxygen) < 0)
|
||||||
|
{
|
||||||
|
close(fd);
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
printf("{ \"do\": %.3f }\n", oxygen);
|
||||||
|
close(fd);
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
@ -0,0 +1,119 @@
|
|||||||
|
const assert = require('node:assert/strict');
|
||||||
|
const fs = require('node:fs');
|
||||||
|
const os = require('node:os');
|
||||||
|
const path = require('node:path');
|
||||||
|
const test = require('node:test');
|
||||||
|
|
||||||
|
const temporaryLogs = fs.mkdtempSync(path.join(os.tmpdir(), 'photobioreactor-'));
|
||||||
|
process.env.LOGS_DIRECTORY = temporaryLogs;
|
||||||
|
|
||||||
|
const { app, HISTORY_FILES } = require('../api/server');
|
||||||
|
|
||||||
|
let server;
|
||||||
|
let baseUrl;
|
||||||
|
|
||||||
|
test.before(async () => {
|
||||||
|
await new Promise((resolve) => {
|
||||||
|
server = app.listen(0, '127.0.0.1', resolve);
|
||||||
|
});
|
||||||
|
|
||||||
|
const address = server.address();
|
||||||
|
baseUrl = `http://127.0.0.1:${address.port}`;
|
||||||
|
});
|
||||||
|
|
||||||
|
test.after(async () => {
|
||||||
|
await new Promise((resolve, reject) => {
|
||||||
|
server.close((error) => error ? reject(error) : resolve());
|
||||||
|
});
|
||||||
|
fs.rmSync(temporaryLogs, { recursive: true, force: true });
|
||||||
|
});
|
||||||
|
|
||||||
|
test('returns simulated history for all sensors', async () => {
|
||||||
|
const response = await fetch(`${baseUrl}/api/sensors/all`);
|
||||||
|
const data = await response.json();
|
||||||
|
|
||||||
|
assert.equal(response.status, 200);
|
||||||
|
assert.equal(data.length, 61);
|
||||||
|
assert.ok(data[0].Timestamp);
|
||||||
|
assert.ok(data[0].Temperatura_C);
|
||||||
|
});
|
||||||
|
|
||||||
|
test('serves the dashboard in local development mode', async () => {
|
||||||
|
const response = await fetch(`${baseUrl}/`);
|
||||||
|
const html = await response.text();
|
||||||
|
|
||||||
|
assert.equal(response.status, 200);
|
||||||
|
assert.match(html, /Panel del Fotobiorreactor/);
|
||||||
|
});
|
||||||
|
|
||||||
|
test('validates sensor commands', async () => {
|
||||||
|
const invalidResponse = await fetch(`${baseUrl}/api/sensors/invalid/command`, {
|
||||||
|
method: 'POST',
|
||||||
|
headers: { 'Content-Type': 'application/json' },
|
||||||
|
body: JSON.stringify({ command: 'r' })
|
||||||
|
});
|
||||||
|
assert.equal(invalidResponse.status, 400);
|
||||||
|
|
||||||
|
const validResponse = await fetch(`${baseUrl}/api/sensors/ph/command`, {
|
||||||
|
method: 'POST',
|
||||||
|
headers: { 'Content-Type': 'application/json' },
|
||||||
|
body: JSON.stringify({ command: 'r' })
|
||||||
|
});
|
||||||
|
const validData = await validResponse.json();
|
||||||
|
|
||||||
|
assert.equal(validResponse.status, 200);
|
||||||
|
assert.equal(validData.success, true);
|
||||||
|
assert.equal(validData.mode, 'demo');
|
||||||
|
});
|
||||||
|
|
||||||
|
test('rejects undocumented calibration syntax', async () => {
|
||||||
|
const response = await fetch(`${baseUrl}/api/sensors/do/command`, {
|
||||||
|
method: 'POST',
|
||||||
|
headers: { 'Content-Type': 'application/json' },
|
||||||
|
body: JSON.stringify({ command: 'Cal,atm' })
|
||||||
|
});
|
||||||
|
const data = await response.json();
|
||||||
|
|
||||||
|
assert.equal(response.status, 400);
|
||||||
|
assert.match(data.error, /documentados/);
|
||||||
|
});
|
||||||
|
|
||||||
|
test('validates simulated logging rates', async () => {
|
||||||
|
const invalidResponse = await fetch(`${baseUrl}/api/config/logging`, {
|
||||||
|
method: 'POST',
|
||||||
|
headers: { 'Content-Type': 'application/json' },
|
||||||
|
body: JSON.stringify({ rate: 3 })
|
||||||
|
});
|
||||||
|
assert.equal(invalidResponse.status, 400);
|
||||||
|
|
||||||
|
const validResponse = await fetch(`${baseUrl}/api/config/logging`, {
|
||||||
|
method: 'POST',
|
||||||
|
headers: { 'Content-Type': 'application/json' },
|
||||||
|
body: JSON.stringify({ rate: 5 })
|
||||||
|
});
|
||||||
|
const validData = await validResponse.json();
|
||||||
|
|
||||||
|
assert.equal(validResponse.status, 200);
|
||||||
|
assert.equal(validData.rate, 5);
|
||||||
|
assert.equal(validData.simulated, true);
|
||||||
|
});
|
||||||
|
|
||||||
|
test('clears historical CSV files and preserves headers', async () => {
|
||||||
|
for (const name of Object.keys(HISTORY_FILES)) {
|
||||||
|
fs.writeFileSync(path.join(temporaryLogs, `${name}.csv`), 'old,data\n1,2\n');
|
||||||
|
}
|
||||||
|
|
||||||
|
const response = await fetch(`${baseUrl}/api/history/clear`, {
|
||||||
|
method: 'POST'
|
||||||
|
});
|
||||||
|
|
||||||
|
assert.equal(response.status, 200);
|
||||||
|
|
||||||
|
for (const [name, header] of Object.entries(HISTORY_FILES)) {
|
||||||
|
const content = fs.readFileSync(
|
||||||
|
path.join(temporaryLogs, `${name}.csv`),
|
||||||
|
'utf8'
|
||||||
|
);
|
||||||
|
assert.equal(content, header);
|
||||||
|
}
|
||||||
|
});
|
||||||
@ -0,0 +1,36 @@
|
|||||||
|
const assert = require('node:assert/strict');
|
||||||
|
const test = require('node:test');
|
||||||
|
|
||||||
|
const {
|
||||||
|
getProcessingDelay,
|
||||||
|
matchesOfficialSyntax
|
||||||
|
} = require('../api/ezo-command-service');
|
||||||
|
|
||||||
|
test('accepts official calibration commands by sensor', () => {
|
||||||
|
assert.equal(matchesOfficialSyntax('rtd', 'Cal,25.00'), true);
|
||||||
|
assert.equal(matchesOfficialSyntax('ph', 'Cal,mid,7.00'), true);
|
||||||
|
assert.equal(matchesOfficialSyntax('ph', 'Cal,low,4.00'), true);
|
||||||
|
assert.equal(matchesOfficialSyntax('ph', 'Cal,high,10.00'), true);
|
||||||
|
assert.equal(matchesOfficialSyntax('do', 'Cal'), true);
|
||||||
|
assert.equal(matchesOfficialSyntax('do', 'Cal,0'), true);
|
||||||
|
assert.equal(matchesOfficialSyntax('ec', 'Cal,dry'), true);
|
||||||
|
assert.equal(matchesOfficialSyntax('ec', 'Cal,1413'), true);
|
||||||
|
assert.equal(matchesOfficialSyntax('ec', 'Cal,low,12880'), true);
|
||||||
|
assert.equal(matchesOfficialSyntax('ec', 'Cal,high,80000'), true);
|
||||||
|
});
|
||||||
|
|
||||||
|
test('rejects commands assigned to the wrong sensor', () => {
|
||||||
|
assert.equal(matchesOfficialSyntax('do', 'Cal,atm'), false);
|
||||||
|
assert.equal(matchesOfficialSyntax('rtd', 'Cal,mid,7'), false);
|
||||||
|
assert.equal(matchesOfficialSyntax('ph', 'Cal,dry'), false);
|
||||||
|
assert.equal(matchesOfficialSyntax('rtd', 'T,25'), false);
|
||||||
|
});
|
||||||
|
|
||||||
|
test('uses Atlas processing delays for critical commands', () => {
|
||||||
|
assert.equal(getProcessingDelay('R'), 1000);
|
||||||
|
assert.equal(getProcessingDelay('Cal'), 1300);
|
||||||
|
assert.equal(getProcessingDelay('Cal,0'), 1300);
|
||||||
|
assert.equal(getProcessingDelay('Cal,mid,7'), 900);
|
||||||
|
assert.equal(getProcessingDelay('Cal,dry'), 600);
|
||||||
|
assert.equal(getProcessingDelay('Status'), 300);
|
||||||
|
});
|
||||||
@ -0,0 +1,47 @@
|
|||||||
|
const assert = require('node:assert/strict');
|
||||||
|
const fs = require('node:fs');
|
||||||
|
const path = require('node:path');
|
||||||
|
const test = require('node:test');
|
||||||
|
|
||||||
|
const root = path.join(__dirname, '..');
|
||||||
|
|
||||||
|
function read(relativePath) {
|
||||||
|
return fs.readFileSync(path.join(root, relativePath), 'utf8');
|
||||||
|
}
|
||||||
|
|
||||||
|
test('dashboard starts live polling and exposes required controls', () => {
|
||||||
|
const html = read('frontend/index.html');
|
||||||
|
const dashboard = read('frontend/dashboard.js');
|
||||||
|
|
||||||
|
assert.match(html, /id="history-interval"/);
|
||||||
|
assert.match(dashboard, /updateDashboard\(\);/);
|
||||||
|
assert.match(
|
||||||
|
dashboard,
|
||||||
|
/setInterval\(updateDashboard,\s*POLLING_INTERVAL_MS\)/
|
||||||
|
);
|
||||||
|
});
|
||||||
|
|
||||||
|
test('dashboard HTML has balanced structural containers', () => {
|
||||||
|
const html = read('frontend/index.html');
|
||||||
|
const openDivs = (html.match(/<div\b/g) || []).length;
|
||||||
|
const closeDivs = (html.match(/<\/div>/g) || []).length;
|
||||||
|
const openSections = (html.match(/<section\b/g) || []).length;
|
||||||
|
const closeSections = (html.match(/<\/section>/g) || []).length;
|
||||||
|
|
||||||
|
assert.equal(openDivs, closeDivs);
|
||||||
|
assert.equal(openSections, closeSections);
|
||||||
|
});
|
||||||
|
|
||||||
|
test('terminal output does not append untrusted HTML', () => {
|
||||||
|
const service = read('frontend/ezo-service.js');
|
||||||
|
|
||||||
|
assert.doesNotMatch(service, /terminalOutput\.innerHTML/);
|
||||||
|
assert.match(service, /line\.textContent = message/);
|
||||||
|
});
|
||||||
|
|
||||||
|
test('sensor Makefiles reference their real implementation objects', () => {
|
||||||
|
assert.match(read('sensors/EZOPH/Makefile'), /OBJ=main\.o ezoph\.o/);
|
||||||
|
assert.match(read('sensors/EZODO/Makefile'), /OBJ=main\.o ezodo\.o/);
|
||||||
|
assert.match(read('sensors/EZOEC/Makefile'), /OBJ=main\.o ezoec\.o/);
|
||||||
|
assert.ok(read('sensors/EZODO/main.c').trim().length > 0);
|
||||||
|
});
|
||||||
Loading…
Reference in New Issue