Add files via upload

datahandler.js

@@ -0,0 +1,209 @@
+const koffi = require('koffi');
+const path = require('path');
+const lib = koffi.load(path.join(__dirname, "librds.so"));
+
+koffi.proto('void callback_pi(uint16_t pi, void *user_data)');
+koffi.proto('void callback_pty(uint8_t pty, void *user_data)');
+koffi.proto('void callback_tp(bool tp, void *user_data)');
+koffi.proto('void callback_ta(bool ta, void *user_data)');
+koffi.proto('void callback_ms(bool ms, void *user_data)');
+koffi.proto('void callback_af(uint8_t af, void *user_data)');
+koffi.proto('void callback_ecc(uint8_t ecc, void *user_data)');
+koffi.proto('void callback_ps(const char *ps, const uint8_t *errors, void *user_data)');
+koffi.proto('void callback_rt(const char *rt, const uint8_t *errors, int flag, void *user_data)');
+
+const librds = {
+  new: lib.func('void* librds_new()'),
+  clear: lib.func('void librds_clear(void *context)'),
+  free: lib.func('void librds_free(void *context)'),
+  parse: lib.func('bool librds_parse(void *context, const char *input)'),
+  get_ps: lib.func('char* librds_get_ps(void *context)'),
+  get_rt: lib.func('char* librds_get_rt(void *context, int flag)'),
+  register_pi: lib.func('void librds_register_pi(void *context, callback_pi *cb)'),
+  register_pty: lib.func('void librds_register_pty(void *context, callback_pty *cb)'),
+  register_tp: lib.func('void librds_register_tp(void *context, callback_tp *cb)'),
+  register_ta: lib.func('void librds_register_ta(void *context, callback_ta *cb)'),
+  register_ms: lib.func('void librds_register_ms(void *context, callback_ms *cb)'),
+  register_af: lib.func('void librds_register_af(void *context, callback_af *cb)'),
+  register_ecc: lib.func('void librds_register_ecc(void *context, callback_ecc *cb)'),
+  register_ps: lib.func('void librds_register_ps(void *context, callback_ps *cb1)'),
+  register_rt: lib.func('void librds_register_rt(void *context, callback_rt *cb)')
+}
+
+const callbacks = {
+  pi: koffi.register((value) => {
+    console.log('PI: ' + value.toString(16).toUpperCase());
+  }, 'callback_pi *'),
+
+  pty: koffi.register((value) => {
+    dataToSend.pty = value;
+  }, 'callback_pty *'),
+
+  tp: koffi.register((value) => {
+    dataToSend.tp = value;
+  }, 'callback_tp *'),
+
+  ta: koffi.register((value) => {
+    console.log('TA: ' + value);
+  }, 'callback_ta *'),
+
+  ms: koffi.register((value) => {
+    console.log('MS: ' + value);
+  }, 'callback_ms *'),
+
+  af: koffi.register((value) => {
+    dataToSend.af.push(87500 + value * 100);
+  }, 'callback_af *'),
+
+  ecc: koffi.register((value) => {
+    console.log('ECC: ' + value.toString(16).toUpperCase());
+  }, 'callback_ecc *'),
+
+  ps: koffi.register((value) => {
+    dataToSend.ps = value;
+  }, 'callback_ps *'),
+
+  rt: koffi.register((value, errors, flag) => {
+    if (flag === 0) {
+      dataToSend.rt0 = value;
+    }
+    if (flag === 1) {
+      dataToSend.rt1 = value;
+    }
+  }, 'callback_rt *'),
+};
+
+
+let rds = librds.new()
+librds.register_pi(rds, callbacks.pi)
+librds.register_pty(rds, callbacks.pty)
+librds.register_tp(rds, callbacks.tp)
+librds.register_ta(rds, callbacks.ta)
+librds.register_ms(rds, callbacks.ms)
+librds.register_af(rds, callbacks.af)
+librds.register_ecc(rds, callbacks.ecc)
+librds.register_ps(rds, callbacks.ps)
+librds.register_rt(rds, callbacks.rt)
+
+const updateInterval = 75;
+const clientUpdateIntervals = new Map(); // Store update intervals for each client
+
+// Initialize the data object
+var dataToSend = {
+  pi: '?',
+  freq: 0,
+  signal: '',
+  st: false,
+  rds: '',
+  ps: '',
+  tp: false,
+  pty: 0,
+  af: [],
+  rt0: '',
+  rt1: '',
+};
+
+const initialData = {
+  pi: '?',
+  freq: 0,
+  signal: '',
+  st: false,
+  rds: '',
+  ps: '',
+  tp: false,
+  pty: 0,
+  af: [],
+  rt0: '',
+  rt1: '',
+};
+
+const resetToDefault = dataToSend => Object.assign(dataToSend, initialData);
+
+var rdsBuffer = [];
+function handleBuffer() {
+
+  for (let group of rdsBuffer)
+    {
+      librds.parse(rds, group);
+    }
+}
+
+function handleData(ws, receivedData) {
+  // Retrieve the last update time for this client
+  let lastUpdateTime = clientUpdateIntervals.get(ws) || 0;
+  const currentTime = Date.now();
+  let modifiedData, parsedValue;
+
+    switch (true) {
+      case receivedData.startsWith('P'):
+        modifiedData = receivedData.substring(1, 5);
+        dataToSend.pi = modifiedData;
+        break;
+
+      case receivedData.startsWith('T'):
+        rdsBuffer = [];
+        resetToDefault(dataToSend);
+        dataToSend.af.length = 0;
+        librds.clear(rds);
+        modifiedData = receivedData.substring(1);
+        parsedValue = parseFloat(modifiedData);
+
+        if (!isNaN(parsedValue)) {
+          dataToSend.freq = (parsedValue / 1000).toFixed(3);
+          dataToSend.pi = '?';
+        }
+        break;
+
+      case receivedData.startsWith('Sm'):
+        modifiedData = receivedData.substring(2);
+        parsedValue = parseFloat(modifiedData);
+        dataToSend.st = false;
+
+        if (!isNaN(parsedValue)) {
+          dataToSend.signal = parsedValue.toFixed(1);
+        }
+        break;
+      case receivedData.startsWith('Ss'):
+        modifiedData = receivedData.substring(2);
+        parsedValue = parseFloat(modifiedData);
+        dataToSend.st = true;
+
+        if (!isNaN(parsedValue)) {
+          dataToSend.signal = parsedValue.toFixed(1);
+        }
+        break;
+
+      case receivedData.startsWith('R'):
+        modifiedData = dataToSend.pi.toUpperCase() + receivedData.slice(1, -1).toUpperCase();
+
+        // Ensure modifiedData is exactly 18 characters long
+        if (modifiedData.length < 18) {
+          modifiedData = modifiedData.padEnd(18, '0'); // Add zeroes at the end
+        } else if (modifiedData.length > 18) {
+          modifiedData = modifiedData.slice(0, 18); // Truncate to 18 characters
+        }
+
+        dataToSend.rds = modifiedData;
+        if (rdsBuffer.length > 1000) {
+          rdsBuffer.shift();
+        }
+        rdsBuffer.push(modifiedData);
+        if (rdsBuffer.length > 1) {
+          handleBuffer();
+        }
+        break;
+
+    }
+
+    // Send the updated data to the client
+    const dataToSendJSON = JSON.stringify(dataToSend);
+      if (currentTime - lastUpdateTime >= updateInterval) {
+    clientUpdateIntervals.set(ws, currentTime); // Update the last update time for this client
+    ws.send(dataToSendJSON);
+  }
+}
+
+
+module.exports = {
+  handleData
+};

index.js

@@ -0,0 +1,97 @@
+// Libraries
+const express = require('express');
+const http = require('http');
+const WebSocket = require('ws');
+const path = require('path');
+const net = require('net');
+const cors = require('cors');
+const axios = require('axios');
+
+// Other JS files
+const dataHandler = require('./datahandler');
+
+/* Server settings */
+const webServerHost = '192.168.1.39'; // IP of the web server
+const webServerPort = 8080; // web server port
+
+const xdrdServerHost = '192.168.1.15'; // xdrd server iP
+const xdrdServerPort = 7373; // xdrd server port
+
+const wss = new WebSocket.Server({ noServer: true });
+
+const app = express();
+const httpServer = http.createServer(app);
+
+
+/* webSocket handlers */
+wss.on('connection', (ws) => {
+  console.log('WebSocket client connected');
+
+  ws.on('message', (message) => {
+    console.log('Received message from client:', message);
+  });
+});
+
+
+// Serve static files from the "web" folder
+app.use(express.static(path.join(__dirname, 'web')));
+
+/* connection to xdrd */
+const client = new net.Socket();
+
+client.connect(xdrdServerPort, xdrdServerHost, () => {
+  console.log('Connected to xdrd');
+});
+
+client.on('data', (data) => {
+  const receivedData = data.toString();
+  wss.clients.forEach((client) => {
+    if (client.readyState === WebSocket.OPEN) {
+      dataHandler.handleData(client, receivedData);
+    }
+  });
+});
+
+client.on('close', () => {
+  console.log('Disconnected from xdrd');
+});
+
+client.write('x');
+
+/* HTTP Server */
+
+httpServer.on('upgrade', (request, socket, head) => {
+  wss.handleUpgrade(request, socket, head, (ws) => {
+    wss.emit('connection', ws, request);
+  });
+});
+
+httpServer.listen(webServerPort, webServerHost, () => {
+  console.log(`Web server is running at http://${webServerHost}:${webServerPort}`);
+});
+
+/* Audio */
+
+app.get('/audio-proxy', (req, res) => {
+  const audioStreamUrl = 'http://fmdx.pl:8000/noobish.opus';
+
+  axios.get(audioStreamUrl, {
+    headers: {
+      'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36',
+    },
+    responseType: 'stream', // Specify the response type as a stream
+  })
+  .then((response) => {
+    const contentType = response.headers['content-type'] || 'audio/ogg';
+    res.setHeader('Content-Type', contentType);
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    console.log(contentType);
+    response.data.pipe(res);
+  })
+  .catch((error) => {
+    console.error('Error in audio proxy request:', error);
+    res.status(500).send('Error in audio proxy request');
+  });
+});
+
+app.use('/audio-proxy', cors());

package.json

@@ -0,0 +1,29 @@
+{
+  "name": "xdrd-client",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "axios": "^1.6.0",
+    "cors": "^2.8.5",
+    "express": "^4.18.2",
+    "ffi-napi": "^4.0.3",
+    "http": "^0.0.1-security",
+    "https": "^1.0.0",
+    "koffi": "^2.6.6",
+    "mic": "^2.1.2",
+    "module-alias": "^2.2.3",
+    "net": "^1.0.2",
+    "node-record-lpcm16": "^1.0.1",
+    "opus-decoder": "^0.7.3",
+    "pcm-convert": "^1.6.5",
+    "request": "^2.88.2",
+    "websocket": "^1.0.34",
+    "ws": "^8.14.2"
+  }
+}