2023-11-09 14:48:10 +00:00
|
|
|
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);
|
|
|
|
|
2023-11-18 16:12:05 +00:00
|
|
|
import { settingsStore as settings } from "../store/settingsStore.js";
|
2023-11-09 14:48:10 +00:00
|
|
|
|
2023-11-13 06:21:13 +00:00
|
|
|
export function connectionFailed(endpoint, event) {
|
|
|
|
stateStore.modem_connection = "disconnected";
|
2023-11-13 06:20:06 +00:00
|
|
|
}
|
2023-11-11 19:46:49 +00:00
|
|
|
export function stateDispatcher(data) {
|
2023-11-13 16:28:00 +00:00
|
|
|
data = JSON.parse(data);
|
2023-12-24 08:58:20 +00:00
|
|
|
console.log(data);
|
2023-11-12 18:56:15 +00:00
|
|
|
|
2023-11-13 06:21:13 +00:00
|
|
|
stateStore.modem_connection = "connected";
|
2023-11-13 06:20:06 +00:00
|
|
|
|
2023-11-17 21:36:37 +00:00
|
|
|
if (
|
2024-01-04 14:46:58 +00:00
|
|
|
data["type"] == "state-change" ||
|
|
|
|
data["type"] == "state"
|
2023-11-17 21:36:37 +00:00
|
|
|
) {
|
2023-11-12 18:56:15 +00:00
|
|
|
stateStore.channel_busy = data["channel_busy"];
|
|
|
|
stateStore.is_codec2_traffic = data["is_codec2_traffic"];
|
|
|
|
stateStore.is_modem_running = data["is_modem_running"];
|
2023-11-28 22:46:55 +00:00
|
|
|
stateStore.dbfs_level = Math.round(data["audio_dbfs"]);
|
|
|
|
stateStore.dbfs_level_percent = Math.round(
|
|
|
|
Math.pow(10, data["audio_dbfs"] / 20) * 100,
|
|
|
|
);
|
2023-11-13 21:35:54 +00:00
|
|
|
stateStore.channel_busy_slot = data["channel_busy_slot"];
|
|
|
|
stateStore.beacon_state = data["is_beacon_running"];
|
2023-11-18 22:50:40 +00:00
|
|
|
stateStore.radio_status = data["radio_status"];
|
|
|
|
stateStore.frequency = data["radio_frequency"];
|
2023-11-26 18:54:28 +00:00
|
|
|
stateStore.mode = data["radio_mode"];
|
2023-12-05 03:24:30 +00:00
|
|
|
//Reverse entries so most recent is first
|
2023-12-03 16:49:56 +00:00
|
|
|
stateStore.activities = Object.entries(data["activities"]).reverse();
|
2023-12-05 03:24:30 +00:00
|
|
|
build_HSL();
|
2023-11-13 21:36:18 +00:00
|
|
|
/*
|
2023-11-13 21:35:54 +00:00
|
|
|
self.is_arq_state = False
|
|
|
|
self.is_arq_session = False
|
|
|
|
self.arq_session_state = 'disconnected'
|
|
|
|
*/
|
|
|
|
|
2023-11-12 18:56:15 +00:00
|
|
|
/*
|
2023-11-09 14:48:51 +00:00
|
|
|
|
|
|
|
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"]);
|
|
|
|
}
|
2023-11-12 18:56:15 +00:00
|
|
|
*/
|
2023-11-11 19:47:05 +00:00
|
|
|
}
|
2023-11-11 19:46:49 +00:00
|
|
|
}
|
2024-01-04 14:46:58 +00:00
|
|
|
|
2023-12-05 03:27:35 +00:00
|
|
|
|
2023-11-11 19:46:49 +00:00
|
|
|
export function eventDispatcher(data) {
|
|
|
|
data = JSON.parse(data);
|
|
|
|
|
2023-11-12 21:35:32 +00:00
|
|
|
// 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;
|
|
|
|
}
|
2023-12-01 03:09:25 +00:00
|
|
|
|
2023-11-30 21:49:43 +00:00
|
|
|
console.info(data);
|
2023-12-01 02:12:04 +00:00
|
|
|
if (data["scatter"] !== undefined) {
|
|
|
|
stateStore.scatter = JSON.parse(data["scatter"]);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2024-01-04 14:46:58 +00:00
|
|
|
|
2023-11-30 21:49:43 +00:00
|
|
|
switch (data["ptt"]) {
|
|
|
|
case true:
|
2023-12-01 02:12:04 +00:00
|
|
|
case false:
|
2023-11-30 21:49:43 +00:00
|
|
|
// get ptt state as a first test
|
2023-12-01 02:12:04 +00:00
|
|
|
//console.warn("PTT state true")
|
2023-11-30 21:49:43 +00:00
|
|
|
stateStore.ptt_state = data.ptt;
|
|
|
|
return;
|
|
|
|
}
|
2023-12-01 03:08:42 +00:00
|
|
|
|
2024-01-04 14:46:58 +00:00
|
|
|
switch (data["type"]) {
|
|
|
|
case "hello-client":
|
|
|
|
console.log("hello client received")
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2023-11-30 21:49:43 +00:00
|
|
|
switch (data["freedata"]) {
|
2023-12-01 03:09:25 +00:00
|
|
|
case "modem-message":
|
|
|
|
switch (data["received"]) {
|
|
|
|
case "BEACON":
|
2023-12-01 03:08:42 +00:00
|
|
|
//Beacon received
|
2023-12-01 03:09:25 +00:00
|
|
|
displayToast(
|
|
|
|
"info",
|
|
|
|
"bi-broadcast",
|
|
|
|
"Beacon from " + data["dxcallsign"],
|
|
|
|
5000,
|
|
|
|
);
|
2023-12-01 03:08:42 +00:00
|
|
|
return;
|
2023-12-09 16:37:39 +00:00
|
|
|
case "QRV":
|
|
|
|
//Qrv received
|
|
|
|
displayToast(
|
|
|
|
"success",
|
|
|
|
"bi-person-raised-hand",
|
|
|
|
"QRV from " + data["dxcallsign"],
|
|
|
|
5000,
|
|
|
|
);
|
|
|
|
return;
|
2023-12-09 16:34:25 +00:00
|
|
|
case "PING":
|
2023-12-01 03:08:42 +00:00
|
|
|
//Qrv received
|
2023-12-01 03:09:25 +00:00
|
|
|
displayToast(
|
|
|
|
"success",
|
2023-12-09 16:34:25 +00:00
|
|
|
"bi-arrow-right-short",
|
|
|
|
"Ping request from " + data["dxcallsign"],
|
2023-12-01 03:09:25 +00:00
|
|
|
5000,
|
|
|
|
);
|
2023-12-01 03:08:42 +00:00
|
|
|
return;
|
2023-12-05 03:27:35 +00:00
|
|
|
case "PING_ACK":
|
|
|
|
//Qrv received
|
|
|
|
displayToast(
|
|
|
|
"success",
|
|
|
|
"bi-arrow-left-right",
|
|
|
|
"Received ping-ack from " +
|
|
|
|
"callsignisbroken" +
|
|
|
|
" | " +
|
|
|
|
data["dxgrid"],
|
|
|
|
5000,
|
|
|
|
);
|
|
|
|
return;
|
2023-12-01 03:08:42 +00:00
|
|
|
}
|
|
|
|
|
2023-12-01 03:09:25 +00:00
|
|
|
case "modem-event":
|
2023-11-30 21:49:43 +00:00
|
|
|
switch (data["event"]) {
|
|
|
|
case "start":
|
|
|
|
displayToast("success", "bi-arrow-left-right", "Modem started", 5000);
|
|
|
|
return;
|
2023-12-01 03:09:25 +00:00
|
|
|
|
2023-11-30 21:49:43 +00:00
|
|
|
case "stop":
|
|
|
|
displayToast("success", "bi-arrow-left-right", "Modem stopped", 5000);
|
|
|
|
return;
|
2023-12-01 03:09:25 +00:00
|
|
|
|
2023-11-30 21:49:43 +00:00
|
|
|
case "restart":
|
|
|
|
displayToast(
|
|
|
|
"secondary",
|
|
|
|
"bi-bootstrap-reboot",
|
|
|
|
"Modem restarted",
|
|
|
|
5000,
|
|
|
|
);
|
|
|
|
return;
|
2023-12-01 03:09:25 +00:00
|
|
|
|
2023-11-30 21:49:43 +00:00
|
|
|
case "failed":
|
|
|
|
displayToast(
|
|
|
|
"danger",
|
|
|
|
"bi-bootstrap-reboot",
|
|
|
|
"Modem startup failed | bad config?",
|
|
|
|
5000,
|
|
|
|
);
|
|
|
|
return;
|
2023-12-01 03:09:25 +00:00
|
|
|
default:
|
|
|
|
console.warn("Unknown event message received:");
|
|
|
|
console.warn(data);
|
|
|
|
break;
|
|
|
|
}
|
2023-11-12 21:35:32 +00:00
|
|
|
}
|
2023-11-12 21:35:10 +00:00
|
|
|
|
2024-01-04 14:46:58 +00:00
|
|
|
if (data['arq-transfer-outbound']) {
|
|
|
|
switch (data["arq-transfer-outbound"].state) {
|
|
|
|
|
|
|
|
case "OPEN_SENT":
|
|
|
|
console.log("state OPEN_ACK_SENT needs to be implemented")
|
|
|
|
return
|
|
|
|
|
|
|
|
case "INFO_SENT":
|
|
|
|
console.log("state INFO_ACK_SENT needs to be implemented")
|
|
|
|
return
|
|
|
|
|
|
|
|
case "BURST_SENT":
|
|
|
|
console.log("state BURST_REPLY_SENT needs to be implemented")
|
|
|
|
return
|
|
|
|
|
|
|
|
case "ABORTING":
|
|
|
|
console.log("state ABORTING needs to be implemented")
|
|
|
|
return
|
|
|
|
|
|
|
|
case "ABORTED":
|
|
|
|
console.log("state ABORTED needs to be implemented")
|
|
|
|
return
|
|
|
|
|
|
|
|
case "FAILED":
|
|
|
|
let message = "Transmission failed";
|
|
|
|
displayToast("danger", "bi-x-octagon", message, 5000);
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (data['arq-transfer-inbound']) {
|
|
|
|
switch (data["arq-transfer-inbound"].state) {
|
|
|
|
|
|
|
|
case "NEW":
|
|
|
|
console.log("state NEW needs to be implemented")
|
|
|
|
return
|
|
|
|
|
|
|
|
case "OPEN_ACK_SENT":
|
|
|
|
console.log("state OPEN_ACK_SENT needs to be implemented")
|
|
|
|
return
|
|
|
|
|
|
|
|
case "INFO_ACK_SENT":
|
|
|
|
console.log("state INFO_ACK_SENT needs to be implemented")
|
|
|
|
return
|
|
|
|
|
|
|
|
case "BURST_REPLY_SENT":
|
|
|
|
console.log("state BURST_REPLY_SENT needs to be implemented")
|
|
|
|
return
|
|
|
|
|
|
|
|
case "ENDED":
|
|
|
|
console.log("state ENDED needs to be implemented")
|
|
|
|
return
|
|
|
|
|
|
|
|
case "ABORTED":
|
|
|
|
console.log("state ABORTED needs to be implemented")
|
|
|
|
return
|
|
|
|
|
|
|
|
case "FAILED":
|
|
|
|
let message = "Transmission failed";
|
|
|
|
displayToast("danger", "bi-x-octagon", message, 5000);
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-11-12 21:35:32 +00:00
|
|
|
/*
|
2023-11-12 21:35:10 +00:00
|
|
|
|
|
|
|
var message = "";
|
|
|
|
if (data["freedata"] == "modem-message") {
|
|
|
|
|
2023-11-09 14:48:51 +00:00
|
|
|
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);
|
2023-11-09 14:48:10 +00:00
|
|
|
}
|
2023-11-09 14:48:51 +00:00
|
|
|
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);
|
2023-11-09 14:48:10 +00:00
|
|
|
break;
|
2023-11-09 14:48:51 +00:00
|
|
|
} else {
|
|
|
|
message = "ARQ sesson request from: " + data["dxcallsign"];
|
|
|
|
displayToast("success", "bi-arrow-left-right", message, 5000);
|
2023-11-09 14:48:10 +00:00
|
|
|
break;
|
2023-11-09 14:48:51 +00:00
|
|
|
}
|
2023-11-09 14:48:10 +00:00
|
|
|
|
2023-11-09 14:48:51 +00:00
|
|
|
case "waiting":
|
|
|
|
// ARQ waiting
|
|
|
|
message = "Channel busy | ARQ protocol is waiting";
|
|
|
|
displayToast("warning", "bi-hourglass-split", message, 5000);
|
|
|
|
break;
|
2023-11-09 14:48:10 +00:00
|
|
|
|
2023-11-09 14:48:51 +00:00
|
|
|
case "receiving":
|
|
|
|
// ARQ RX
|
|
|
|
break;
|
2023-11-09 14:48:10 +00:00
|
|
|
|
2023-11-09 14:48:51 +00:00
|
|
|
case "failed":
|
|
|
|
// ARQ TX Failed
|
|
|
|
if (data["reason"] == "protocol version missmatch") {
|
|
|
|
message = "Protocol version mismatch!";
|
|
|
|
displayToast("danger", "bi-chevron-bar-expand", message, 5000);
|
|
|
|
setStateFailed();
|
2023-11-09 14:48:10 +00:00
|
|
|
|
|
|
|
break;
|
2023-11-09 14:48:51 +00:00
|
|
|
} else {
|
|
|
|
message = "Transmission failed";
|
|
|
|
displayToast("danger", "bi-x-octagon", message, 5000);
|
|
|
|
updateTransmissionStatus(data);
|
|
|
|
setStateFailed();
|
2023-11-09 14:48:10 +00:00
|
|
|
break;
|
|
|
|
}
|
2023-11-09 14:48:51 +00:00
|
|
|
switch (data["irs"]) {
|
|
|
|
case "True":
|
|
|
|
updateTransmissionStatus(data);
|
2023-11-09 14:48:10 +00:00
|
|
|
|
|
|
|
break;
|
2023-11-09 14:48:51 +00:00
|
|
|
default:
|
|
|
|
updateTransmissionStatus(data);
|
2023-11-09 14:48:10 +00:00
|
|
|
break;
|
2023-11-09 14:48:51 +00:00
|
|
|
}
|
|
|
|
break;
|
2023-11-09 14:48:10 +00:00
|
|
|
|
2023-11-09 14:48:51 +00:00
|
|
|
case "received":
|
|
|
|
// ARQ data received
|
2023-11-09 14:48:10 +00:00
|
|
|
|
2023-11-09 14:48:51 +00:00
|
|
|
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);
|
2023-11-09 14:48:10 +00:00
|
|
|
|
2023-11-09 14:48:51 +00:00
|
|
|
// new message received
|
|
|
|
if (splitted_data[0] == "m") {
|
|
|
|
console.log(splitted_data);
|
|
|
|
newMessageReceived(splitted_data, data);
|
|
|
|
}
|
2023-11-09 14:48:10 +00:00
|
|
|
|
2023-11-09 14:48:51 +00:00
|
|
|
break;
|
2023-11-09 14:48:10 +00:00
|
|
|
|
2023-11-09 14:48:51 +00:00
|
|
|
case "transmitting":
|
|
|
|
// ARQ transmitting
|
|
|
|
updateTransmissionStatus(data);
|
|
|
|
break;
|
2023-11-09 14:48:10 +00:00
|
|
|
|
2023-11-09 14:48:51 +00:00
|
|
|
case "transmitted":
|
|
|
|
// ARQ transmitted
|
|
|
|
message = "Data transmitted";
|
|
|
|
displayToast("success", "bi-check-sqaure", message, 5000);
|
|
|
|
updateTransmissionStatus(data);
|
|
|
|
setStateSuccess();
|
2023-11-09 14:48:10 +00:00
|
|
|
|
2023-11-09 14:48:51 +00:00
|
|
|
break;
|
2023-11-09 14:48:10 +00:00
|
|
|
}
|
2023-11-09 14:48:51 +00:00
|
|
|
}
|
|
|
|
}
|
2023-11-12 21:35:10 +00:00
|
|
|
*/
|
2023-11-09 14:48:10 +00:00
|
|
|
}
|
2024-01-04 14:46:58 +00:00
|
|
|
|
|
|
|
|
|
|
|
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
|
|
|
|
}
|