kuba/fm-dx-webserver
1
0
Fork 0
mirror of https://github.com/KubaPro010/fm-dx-webserver.git synced 2026-02-26 22:13:53 +01:00
Code Issues Activity

fmlist integration, new admin panel, bugfixes

Browse Source
This commit is contained in:
NoobishSVK
2024-09-15 00:00:42 +02:00
parent acc0c4fb16
commit ab000412fa
22 changed files with 834 additions and 540 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
server/datahandler.js
View File

@@ -235,7 +235,7 @@ var dataToSend = {
dist: '',
azi: '',
id: '',
reg: '',
reg: false,
pi: '',
},
country_name: '',
@@ -394,21 +394,26 @@ function handleData(wss, receivedData, rdsWss) {
}
// Get the received TX info
const currentTx = fetchTx(parseFloat(dataToSend.freq).toFixed(1), dataToSend.pi, dataToSend.ps);
if(currentTx && currentTx.station !== undefined) {
dataToSend.txInfo = {
tx: currentTx.station,
pol: currentTx.pol,
erp: currentTx.erp,
city: currentTx.city,
itu: currentTx.itu,
dist: currentTx.distance,
azi: currentTx.azimuth,
id: currentTx.id,
pi: currentTx.pi,
reg: currentTx.reg
}
}
fetchTx(parseFloat(dataToSend.freq).toFixed(1), dataToSend.pi, dataToSend.ps)
.then((currentTx) => {
if (currentTx && currentTx.station !== undefined) {
dataToSend.txInfo = {
tx: currentTx.station,
pol: currentTx.pol,
erp: currentTx.erp,
city: currentTx.city,
itu: currentTx.itu,
dist: currentTx.distance,
azi: currentTx.azimuth,
id: currentTx.id,
pi: currentTx.pi,
reg: currentTx.reg
};
}
})
.catch((error) => {
logError("Error fetching Tx info:", error);
});
// Send the updated data to the client
const dataToSendJSON = JSON.stringify(dataToSend);

22
server/endpoints.js
View File

@@ -62,6 +62,7 @@ router.get('/', (req, res) => {
device: serverConfig.device,
noPlugins,
plugins: serverConfig.plugins,
fmlist_integration: serverConfig.fmlist_integration ? serverConfig.fmlist_integration : true,
bwSwitch: serverConfig.bwSwitch ? serverConfig.bwSwitch : false
});
}
@@ -74,6 +75,11 @@ router.get('/403', (req, res) => {
router.get('/wizard', (req, res) => {
let serialPorts;
if(!req.session.isAdminAuthenticated) {
res.render('login');
return;
}
SerialPort.list()
.then((deviceList) => {
serialPorts = deviceList.map(port => ({
@@ -94,6 +100,11 @@ router.get('/wizard', (req, res) => {
router.get('/setup', (req, res) => {
let serialPorts;
if(!req.session.isAdminAuthenticated) {
res.render('login');
return;
}
SerialPort.list()
.then((deviceList) => {
@@ -260,6 +271,14 @@ router.get('/ping', (req, res) => {
});
router.get('/log_fmlist', (req, res) => {
if(dataHandler.dataToSend.txInfo.tx.length === 0) {
res.status(500).send('No suitable transmitter to log.');
return;
}
if(serverConfig.extras?.fmlist_integration == false) {
res.status(500).send('FMLIST Integration is not enabled on this server.');
}
const clientIp = req.headers['x-forwarded-for'] || req.connection.remoteAddress;
const postData = JSON.stringify({
station: {
@@ -278,11 +297,12 @@ router.get('/log_fmlist', (req, res) => {
longitude: serverConfig.identification.lon,
address: serverConfig.identification.proxyIp.length > 1 ? serverConfig.identification.proxyIp : ('Matches request IP with port ' + serverConfig.webserver.port),
webserver_name: serverConfig.identification.tunerName,
omid: serverConfig.extras?.fmlist_omid || '',
},
client: {
request_ip: clientIp
},
log_msg: `PS: ${dataHandler.dataToSend.ps}, PI: ${dataHandler.dataToSend.pi}, Signal: ${dataHandler.dataToSend.sig.toFixed(0)} dBf`
log_msg: `Logged PS: ${dataHandler.dataToSend.ps.replace(/\s+/g, '_')}, PI: ${dataHandler.dataToSend.pi}, Signal: ${dataHandler.dataToSend.sig.toFixed(0)} dBf`
});
const options = {

2
server/index.js
View File

@@ -52,7 +52,7 @@ function startPluginsWithDelay(plugins, delay) {
setTimeout(() => {
const pluginName = path.basename(pluginPath, '.js'); // Extract plugin name from path
logInfo(`-----------------------------------------------------------------`);
logInfo(`Plugin ${pluginName} is loaded`);
logInfo(`Plugin ${pluginName} loaded successfully!`);
require(pluginPath);
}, delay * index);
});

4
server/server_config.js
View File

@@ -45,6 +45,10 @@ let serverConfig = {
tunePass: "",
adminPass: ""
},
extras: {
fmlist_integration: true,
fmlist_omid: "",
},
plugins: [],
device: 'tef',
defaultFreq: 87.5,

97
server/tx_search.js
View File

@@ -3,29 +3,69 @@ const { serverConfig } = require('./server_config');
const consoleCmd = require('./console');
let cachedData = {};
let lastFetchTime = 0;
const fetchInterval = 3000;
const fetchInterval = 1000;
const esSwitchCache = {"lastCheck":0, "esSwitch":false};
const esFetchInterval = 300000;
const usStatesGeoJsonUrl = "https://raw.githubusercontent.com/PublicaMundi/MappingAPI/master/data/geojson/us-states.json";
let usStatesGeoJson = null; // To cache the GeoJSON data for US states
// Load the US states GeoJSON data
async function loadUsStatesGeoJson() {
if (!usStatesGeoJson) {
const response = await fetch(usStatesGeoJsonUrl);
usStatesGeoJson = await response.json();
}
}
// Function to get bounding box of a state
function getStateBoundingBox(coordinates) {
let minLat = Infinity, maxLat = -Infinity, minLon = Infinity, maxLon = -Infinity;
for (const polygon of coordinates) {
for (const coord of polygon[0]) { // First level in case of MultiPolygon
const [lon, lat] = coord;
if (lat < minLat) minLat = lat;
if (lat > maxLat) maxLat = lat;
if (lon < minLon) minLon = lon;
if (lon > maxLon) maxLon = lon;
}
}
return { minLat, maxLat, minLon, maxLon };
}
// Function to check if a city (lat, lon) falls within the bounding box of a state
function isCityInState(lat, lon, boundingBox) {
return lat >= boundingBox.minLat && lat <= boundingBox.maxLat &&
lon >= boundingBox.minLon && lon <= boundingBox.maxLon;
}
// Function to check if a city (lat, lon) is inside any US state and return the state name
function getStateForCoordinates(lat, lon) {
if (!usStatesGeoJson) return null;
for (const feature of usStatesGeoJson.features) {
const boundingBox = getStateBoundingBox(feature.geometry.coordinates);
if (isCityInState(lat, lon, boundingBox)) {
return feature.properties.name; // Return the state's name if city is inside bounding box
}
}
return null;
}
// Fetch data from maps
function fetchTx(freq, piCode, rdsPs) {
async function fetchTx(freq, piCode, rdsPs) {
const now = Date.now();
freq = parseFloat(freq);
if(isNaN(freq)) {
if (isNaN(freq)) {
return;
}
// Check if it's been at least 3 seconds since the last fetch and if the QTH is correct
if (now - lastFetchTime < fetchInterval || serverConfig.identification.lat.length < 2 || freq < 87) {
return Promise.resolve();
}
lastFetchTime = now;
// Check if data for the given frequency is already cached
if (cachedData[freq]) {
return processData(cachedData[freq], piCode, rdsPs);
}
@@ -34,32 +74,32 @@ function fetchTx(freq, piCode, rdsPs) {
return fetch(url)
.then(response => response.json())
.then(data => {
// Cache the fetched data for the specific frequency
.then(async (data) => {
cachedData[freq] = data;
await loadUsStatesGeoJson();
return processData(data, piCode, rdsPs);
})
.catch(error => {
console.error("Error fetching data:", error);
});
}
function processData(data, piCode, rdsPs) {
async function processData(data, piCode, rdsPs) {
let matchingStation = null;
let matchingCity = null;
let maxScore = -Infinity; // Initialize maxScore with a very low value
let maxScore = -Infinity;
let txAzimuth;
let maxDistance;
let esMode = checkEs();
let detectedByPireg = false; // To track if the station was found by pireg
let detectedByPireg = false;
// Helper function to calculate score and update matching station/city
function evaluateStation(station, city, distance) {
let weightDistance = distance.distanceKm;
if (esMode && distance.distanceKm > 500) {
weightDistance = Math.abs(distance.distanceKm - 1500);
}
let erp = station.erp && station.erp > 0 ? station.erp : 1;
const score = (10 * Math.log10(erp * 1000)) / weightDistance; // Calculate score
const score = (10 * Math.log10(erp * 1000)) / weightDistance;
if (score > maxScore) {
maxScore = score;
txAzimuth = distance.azimuth;
@@ -77,13 +117,13 @@ function processData(data, piCode, rdsPs) {
if (station.pi === piCode.toUpperCase() && !station.extra && station.ps && station.ps.toLowerCase().includes(rdsPs.replace(/ /g, '_').replace(/^_*(.*?)_*$/, '$1').toLowerCase())) {
const distance = haversine(serverConfig.identification.lat, serverConfig.identification.lon, city.lat, city.lon);
evaluateStation(station, city, distance);
detectedByPireg = false; // Detected by pi, not pireg
detectedByPireg = false;
}
}
}
}
// If no matching station is found, fallback to pireg
// Fallback to pireg if no match is found
if (!matchingStation) {
for (const cityId in data.locations) {
const city = data.locations[cityId];
@@ -92,27 +132,34 @@ function processData(data, piCode, rdsPs) {
if (station.pireg && station.pireg.toUpperCase() === piCode.toUpperCase() && !station.extra && station.ps && station.ps.toLowerCase().includes(rdsPs.replace(/ /g, '_').replace(/^_*(.*?)_*$/, '$1').toLowerCase())) {
const distance = haversine(serverConfig.identification.lat, serverConfig.identification.lon, city.lat, city.lon);
evaluateStation(station, city, distance);
detectedByPireg = true; // Detected by pireg
detectedByPireg = true;
}
}
}
}
}
// Return the results if a station was found, otherwise return undefined
// Determine the state if the city is in the USA
if (matchingStation && matchingCity.itu === 'USA') {
const state = getStateForCoordinates(matchingCity.lat, matchingCity.lon);
if (state) {
matchingCity.state = state; // Add state to matchingCity
}
}
if (matchingStation) {
return {
station: matchingStation.station.replace("R.", "Radio "),
pol: matchingStation.pol.toUpperCase(),
erp: matchingStation.erp && matchingStation.erp > 0 ? matchingStation.erp : '?',
city: matchingCity.name,
itu: matchingCity.itu,
itu: matchingCity.state ? matchingCity.state + ', ' + matchingCity.itu : matchingCity.itu,
distance: maxDistance.toFixed(0),
azimuth: txAzimuth.toFixed(0),
id: matchingStation.id,
pi: matchingStation.pi,
foundStation: true,
reg: detectedByPireg // Indicates if it was detected by pireg
reg: detectedByPireg
};
} else {
return;
@@ -151,26 +198,19 @@ function checkEs() {
}
function haversine(lat1, lon1, lat2, lon2) {
const R = 6371; // Earth radius in kilometers
const R = 6371;
const dLat = deg2rad(lat2 - lat1);
const dLon = deg2rad(lon2 - lon1);
const a =
Math.sin(dLat / 2) * Math.sin(dLat / 2) +
Math.cos(deg2rad(lat1)) * Math.cos(deg2rad(lat2)) * Math.sin(dLon / 2) * Math.sin(dLon / 2);
const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
// Distance in kilometers
const distance = R * c;
// Azimuth calculation
const y = Math.sin(dLon) * Math.cos(deg2rad(lat2));
const x = Math.cos(deg2rad(lat1)) * Math.sin(deg2rad(lat2)) -
Math.sin(deg2rad(lat1)) * Math.cos(deg2rad(lat2)) * Math.cos(dLon);
const azimuth = Math.atan2(y, x);
// Convert azimuth from radians to degrees
const azimuthDegrees = (azimuth * 180 / Math.PI + 360) % 360;
return {
@@ -179,7 +219,6 @@ function haversine(lat1, lon1, lat2, lon2) {
};
}
function deg2rad(deg) {
return deg * (Math.PI / 180);
}