mirror of
https://github.com/DJ2LS/FreeDATA
synced 2024-05-14 08:04:33 +00:00
486 lines
14 KiB
JavaScript
486 lines
14 KiB
JavaScript
import { addDataToWaterfall } from "../js/waterfallHandler.js";
|
|
|
|
import {
|
|
newMessageReceived,
|
|
newBeaconReceived,
|
|
updateTransmissionStatus,
|
|
setStateSuccess,
|
|
setStateFailed,
|
|
} from "./chatHandler";
|
|
import { displayToast } from "./popupHandler";
|
|
|
|
// ----------------- init pinia stores -------------
|
|
import { setActivePinia } from "pinia";
|
|
import pinia from "../store/index";
|
|
setActivePinia(pinia);
|
|
import { useStateStore } from "../store/stateStore.js";
|
|
const stateStore = useStateStore(pinia);
|
|
|
|
import { settingsStore as settings } from "../store/settingsStore.js";
|
|
|
|
export function connectionFailed(endpoint, event) {
|
|
stateStore.modem_connection = "disconnected";
|
|
}
|
|
export function stateDispatcher(data) {
|
|
data = JSON.parse(data);
|
|
console.log(data);
|
|
|
|
stateStore.modem_connection = "connected";
|
|
|
|
if (
|
|
data["freedata-message"] == "state-change" ||
|
|
data["freedata-message"] == "state"
|
|
) {
|
|
stateStore.channel_busy = data["channel_busy"];
|
|
stateStore.is_codec2_traffic = data["is_codec2_traffic"];
|
|
stateStore.is_modem_running = data["is_modem_running"];
|
|
stateStore.dbfs_level = Math.round(data["audio_dbfs"]);
|
|
stateStore.dbfs_level_percent = Math.round(
|
|
Math.pow(10, data["audio_dbfs"] / 20) * 100,
|
|
);
|
|
stateStore.channel_busy_slot = data["channel_busy_slot"];
|
|
stateStore.beacon_state = data["is_beacon_running"];
|
|
stateStore.radio_status = data["radio_status"];
|
|
stateStore.frequency = data["radio_frequency"];
|
|
stateStore.mode = data["radio_mode"];
|
|
//Reverse entries so most recent is first
|
|
stateStore.activities = Object.entries(data["activities"]).reverse();
|
|
build_HSL();
|
|
/*
|
|
self.is_arq_state = False
|
|
self.is_arq_session = False
|
|
self.arq_session_state = 'disconnected'
|
|
*/
|
|
|
|
/*
|
|
|
|
stateStore.rx_buffer_length = data["rx_buffer_length"];
|
|
stateStore.frequency = data["frequency"];
|
|
stateStore.busy_state = data["modem_state"];
|
|
stateStore.arq_state = data["arq_state"];
|
|
stateStore.mode = data["mode"];
|
|
stateStore.bandwidth = data["bandwidth"];
|
|
stateStore.tx_audio_level = data["tx_audio_level"];
|
|
stateStore.rx_audio_level = data["rx_audio_level"];
|
|
// if audio level is different from config one, send new audio level to modem
|
|
//console.log(parseInt(stateStore.tx_audio_level))
|
|
//console.log(parseInt(settings.tx_audio_level))
|
|
if (
|
|
parseInt(stateStore.tx_audio_level) !==
|
|
parseInt(settings.tx_audio_level) &&
|
|
setTxAudioLevelOnce === true
|
|
) {
|
|
setTxAudioLevelOnce = false;
|
|
console.log(setTxAudioLevelOnce);
|
|
setTxAudioLevel(settings.tx_audio_level);
|
|
}
|
|
|
|
if (
|
|
parseInt(stateStore.rx_audio_level) !==
|
|
parseInt(settings.rx_audio_level) &&
|
|
setRxAudioLevelOnce === true
|
|
) {
|
|
setRxAudioLevelOnce = false;
|
|
console.log(setRxAudioLevelOnce);
|
|
setRxAudioLevel(settings.rx_audio_level);
|
|
}
|
|
|
|
stateStore.ptt_state = data["ptt_state"];
|
|
stateStore.speed_level = data["speed_level"];
|
|
stateStore.fft = JSON.parse(data["fft"]);
|
|
|
|
addDataToWaterfall(JSON.parse(data["fft"]));
|
|
|
|
if (data["scatter"].length > 0) {
|
|
stateStore.scatter = data["scatter"];
|
|
}
|
|
// s meter strength
|
|
stateStore.s_meter_strength_raw = data["strength"];
|
|
if (stateStore.s_meter_strength_raw == "") {
|
|
stateStore.s_meter_strength_raw = "Unsupported";
|
|
stateStore.s_meter_strength_percent = 0;
|
|
} else {
|
|
// https://www.moellerstudios.org/converting-amplitude-representations/
|
|
stateStore.s_meter_strength_percent = Math.round(
|
|
Math.pow(10, stateStore.s_meter_strength_raw / 20) * 100,
|
|
);
|
|
}
|
|
|
|
stateStore.dbfs_level_percent = Math.round(
|
|
Math.pow(10, stateStore.dbfs_level / 20) * 100,
|
|
);
|
|
stateStore.dbfs_level = Math.round(stateStore.dbfs_level);
|
|
|
|
stateStore.arq_total_bytes = data["total_bytes"];
|
|
stateStore.heard_stations = data["stations"].sort(
|
|
sortByPropertyDesc("timestamp"),
|
|
);
|
|
stateStore.dxcallsign = data["dxcallsign"];
|
|
|
|
stateStore.audio_recording = data["audio_recording"];
|
|
|
|
stateStore.hamlib_status = data["hamlib_status"];
|
|
stateStore.alc = data["alc"];
|
|
stateStore.rf_level = data["rf_level"];
|
|
|
|
|
|
stateStore.arq_session_state = data["arq_session"];
|
|
stateStore.arq_state = data["arq_state"];
|
|
stateStore.arq_transmission_percent = data["arq_transmission_percent"];
|
|
stateStore.arq_seconds_until_finish = data["arq_seconds_until_finish"];
|
|
stateStore.arq_seconds_until_timeout = data["arq_seconds_until_timeout"];
|
|
stateStore.arq_seconds_until_timeout_percent =
|
|
(stateStore.arq_seconds_until_timeout / 180) * 100;
|
|
|
|
if (data["speed_list"].length > 0) {
|
|
prepareStatsDataForStore(data["speed_list"]);
|
|
}
|
|
*/
|
|
}
|
|
}
|
|
function build_HSL() {
|
|
//Use data from activities to build HSL list
|
|
for (let i = 0; i < stateStore.activities.length; i++) {
|
|
if (
|
|
stateStore.activities[i][1].direction != "received" ||
|
|
stateStore.activities[i][1].origin == undefined
|
|
) {
|
|
//Ignore stations without origin and not received type
|
|
//console.warn("HSL: Ignoring " + stateStore.activities[i][0]);
|
|
continue;
|
|
}
|
|
let found = false;
|
|
for (let ii = 0; ii < stateStore.heard_stations.length; ii++) {
|
|
if (
|
|
stateStore.heard_stations[ii].origin ==
|
|
stateStore.activities[i][1].origin
|
|
) {
|
|
//Station already in HSL, check if newer than one in HSL
|
|
found = true;
|
|
if (
|
|
stateStore.heard_stations[ii].timestamp <
|
|
stateStore.activities[i][1].timestamp
|
|
) {
|
|
//Update existing entry in HSL
|
|
stateStore.heard_stations[ii] = stateStore.activities[i][1];
|
|
}
|
|
}
|
|
}
|
|
if (found == false) {
|
|
//Station not in HSL, let us add it
|
|
stateStore.heard_stations.push(stateStore.activities[i][1]);
|
|
}
|
|
}
|
|
stateStore.heard_stations.sort((a, b) => b.timestamp - a.timestamp); // b - a for reverse sort
|
|
}
|
|
|
|
export function eventDispatcher(data) {
|
|
data = JSON.parse(data);
|
|
|
|
// break early if we received a dummy callsign
|
|
// thats a kind of hotfix, as long as the modem isnt handling this better
|
|
if (data["dxcallsign"] == "AA0AA-0" || data["dxcallsign"] == "ZZ9YY-0") {
|
|
return;
|
|
}
|
|
|
|
console.info(data);
|
|
if (data["scatter"] !== undefined) {
|
|
//console.warn("Got scatter data!!!!");
|
|
stateStore.scatter = JSON.parse(data["scatter"]);
|
|
return;
|
|
}
|
|
|
|
switch (data["ptt"]) {
|
|
case true:
|
|
case false:
|
|
// get ptt state as a first test
|
|
//console.warn("PTT state true")
|
|
stateStore.ptt_state = data.ptt;
|
|
return;
|
|
}
|
|
|
|
switch (data["freedata"]) {
|
|
case "modem-message":
|
|
switch (data["received"]) {
|
|
case "BEACON":
|
|
//Beacon received
|
|
displayToast(
|
|
"info",
|
|
"bi-broadcast",
|
|
"Beacon from " + data["dxcallsign"],
|
|
5000,
|
|
);
|
|
return;
|
|
case "QRV":
|
|
//Qrv received
|
|
displayToast(
|
|
"success",
|
|
"bi-person-raised-hand",
|
|
"QRV from " + data["dxcallsign"],
|
|
5000,
|
|
);
|
|
return;
|
|
case "PING_ACK":
|
|
//Qrv received
|
|
displayToast(
|
|
"success",
|
|
"bi-arrow-left-right",
|
|
"Received ping-ack from " +
|
|
"callsignisbroken" +
|
|
" | " +
|
|
data["dxgrid"],
|
|
5000,
|
|
);
|
|
return;
|
|
}
|
|
|
|
case "modem-event":
|
|
switch (data["event"]) {
|
|
case "start":
|
|
displayToast("success", "bi-arrow-left-right", "Modem started", 5000);
|
|
return;
|
|
|
|
case "stop":
|
|
displayToast("success", "bi-arrow-left-right", "Modem stopped", 5000);
|
|
return;
|
|
|
|
case "restart":
|
|
displayToast(
|
|
"secondary",
|
|
"bi-bootstrap-reboot",
|
|
"Modem restarted",
|
|
5000,
|
|
);
|
|
return;
|
|
|
|
case "failed":
|
|
displayToast(
|
|
"danger",
|
|
"bi-bootstrap-reboot",
|
|
"Modem startup failed | bad config?",
|
|
5000,
|
|
);
|
|
return;
|
|
default:
|
|
console.warn("Unknown event message received:");
|
|
console.warn(data);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
|
|
var message = "";
|
|
if (data["freedata"] == "modem-message") {
|
|
|
|
console.log(data);
|
|
|
|
switch (data["fec"]) {
|
|
case "is_writing":
|
|
// RX'd FECiswriting
|
|
break;
|
|
|
|
case "broadcast":
|
|
// RX'd FEC BROADCAST
|
|
var encoded_data = atob_FD(data["data"]);
|
|
var splitted_data = encoded_data.split(split_char);
|
|
var messageArray = [];
|
|
if (splitted_data[0] == "m") {
|
|
messageArray.push(data);
|
|
console.log(data);
|
|
}
|
|
break;
|
|
}
|
|
|
|
switch (data["cq"]) {
|
|
case "transmitting":
|
|
// CQ TRANSMITTING
|
|
displayToast("success", "bi-arrow-left-right", "Transmitting CQ", 5000);
|
|
break;
|
|
|
|
case "received":
|
|
// CQ RECEIVED
|
|
message = "CQ from " + data["dxcallsign"];
|
|
displayToast("success", "bi-person-arms-up", message, 5000);
|
|
break;
|
|
}
|
|
|
|
switch (data["qrv"]) {
|
|
case "transmitting":
|
|
// QRV TRANSMITTING
|
|
displayToast(
|
|
"info",
|
|
"bi-person-raised-hand",
|
|
"Transmitting QRV ",
|
|
5000,
|
|
);
|
|
break;
|
|
|
|
case "received":
|
|
// QRV RECEIVED
|
|
message = "QRV from " + data["dxcallsign"] + " | " + data["dxgrid"];
|
|
displayToast("success", "bi-person-raised-hand", message, 5000);
|
|
break;
|
|
}
|
|
|
|
switch (data["beacon"]) {
|
|
case "transmitting":
|
|
// BEACON TRANSMITTING
|
|
displayToast(
|
|
"success",
|
|
"bi-broadcast-pin",
|
|
"Transmitting beacon",
|
|
5000,
|
|
);
|
|
break;
|
|
|
|
case "received":
|
|
// BEACON RECEIVED
|
|
newBeaconReceived(data);
|
|
|
|
message = "Beacon from " + data["dxcallsign"] + " | " + data["dxgrid"];
|
|
displayToast("info", "bi-broadcast", message, 5000);
|
|
break;
|
|
}
|
|
|
|
switch (data["ping"]) {
|
|
case "transmitting":
|
|
// PING TRANSMITTING
|
|
message = "Sending ping to " + data["dxcallsign"];
|
|
displayToast("success", "bi-arrow-right", message, 5000);
|
|
break;
|
|
|
|
case "received":
|
|
// PING RECEIVED
|
|
message =
|
|
"Ping request from " + data["dxcallsign"] + " | " + data["dxgrid"];
|
|
displayToast("success", "bi-arrow-right-short", message, 5000);
|
|
break;
|
|
|
|
case "acknowledge":
|
|
// PING ACKNOWLEDGE
|
|
message =
|
|
"Received ping-ack from " +
|
|
data["dxcallsign"] +
|
|
" | " +
|
|
data["dxgrid"];
|
|
displayToast("success", "bi-arrow-left-right", message, 5000);
|
|
break;
|
|
}
|
|
|
|
// ARQ SESSION && freedata == modem-message
|
|
if (data["arq"] == "session") {
|
|
switch (data["status"]) {
|
|
case "connecting":
|
|
// ARQ Open
|
|
break;
|
|
|
|
case "connected":
|
|
// ARQ Opening
|
|
break;
|
|
|
|
case "waiting":
|
|
// ARQ Opening
|
|
break;
|
|
|
|
case "close":
|
|
// ARQ Closing
|
|
break;
|
|
|
|
case "failed":
|
|
// ARQ Failed
|
|
break;
|
|
}
|
|
}
|
|
// ARQ TRANSMISSION && freedata == modem-message
|
|
if (data["arq"] == "transmission") {
|
|
switch (data["status"]) {
|
|
case "opened":
|
|
// ARQ Open
|
|
message = "ARQ session opened: " + data["dxcallsign"];
|
|
displayToast("success", "bi-arrow-left-right", message, 5000);
|
|
break;
|
|
|
|
case "opening":
|
|
// ARQ Opening IRS/ISS
|
|
if (data["irs"] == "False") {
|
|
message = "ARQ session opening: " + data["dxcallsign"];
|
|
displayToast("info", "bi-arrow-left-right", message, 5000);
|
|
break;
|
|
} else {
|
|
message = "ARQ sesson request from: " + data["dxcallsign"];
|
|
displayToast("success", "bi-arrow-left-right", message, 5000);
|
|
break;
|
|
}
|
|
|
|
case "waiting":
|
|
// ARQ waiting
|
|
message = "Channel busy | ARQ protocol is waiting";
|
|
displayToast("warning", "bi-hourglass-split", message, 5000);
|
|
break;
|
|
|
|
case "receiving":
|
|
// ARQ RX
|
|
break;
|
|
|
|
case "failed":
|
|
// ARQ TX Failed
|
|
if (data["reason"] == "protocol version missmatch") {
|
|
message = "Protocol version mismatch!";
|
|
displayToast("danger", "bi-chevron-bar-expand", message, 5000);
|
|
setStateFailed();
|
|
|
|
break;
|
|
} else {
|
|
message = "Transmission failed";
|
|
displayToast("danger", "bi-x-octagon", message, 5000);
|
|
updateTransmissionStatus(data);
|
|
setStateFailed();
|
|
break;
|
|
}
|
|
switch (data["irs"]) {
|
|
case "True":
|
|
updateTransmissionStatus(data);
|
|
|
|
break;
|
|
default:
|
|
updateTransmissionStatus(data);
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case "received":
|
|
// ARQ data received
|
|
|
|
console.log(data);
|
|
// we need to encode here to do a deep check for checking if file or message
|
|
//var encoded_data = atob(data['data'])
|
|
var encoded_data = atob_FD(data["data"]);
|
|
var splitted_data = encoded_data.split(split_char);
|
|
|
|
// new message received
|
|
if (splitted_data[0] == "m") {
|
|
console.log(splitted_data);
|
|
newMessageReceived(splitted_data, data);
|
|
}
|
|
|
|
break;
|
|
|
|
case "transmitting":
|
|
// ARQ transmitting
|
|
updateTransmissionStatus(data);
|
|
break;
|
|
|
|
case "transmitted":
|
|
// ARQ transmitted
|
|
message = "Data transmitted";
|
|
displayToast("success", "bi-check-sqaure", message, 5000);
|
|
updateTransmissionStatus(data);
|
|
setStateSuccess();
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
*/
|
|
}
|