FreeDATA/gui/sock.js

440 lines
14 KiB
JavaScript
Raw Normal View History

2021-07-17 07:03:40 +00:00
var net = require('net');
2021-09-04 18:23:58 +00:00
const path = require('path')
2021-07-24 07:06:22 +00:00
const {
ipcRenderer
2021-09-04 18:23:58 +00:00
} = require('electron')
const log = require('electron-log');
const socketLog = log.scope('tnc');
const utf8 = require('utf8');
2021-09-04 18:23:58 +00:00
// https://stackoverflow.com/a/26227660
2021-09-04 19:37:56 +00:00
var appDataFolder = process.env.APPDATA || (process.platform == 'darwin' ? process.env.HOME + '/Library/Application Support' : process.env.HOME + "/.config")
2021-09-13 16:27:50 +00:00
var configFolder = path.join(appDataFolder, "FreeDATA");
2021-09-04 18:23:58 +00:00
var configPath = path.join(configFolder, 'config.json')
const config = require(configPath);
2021-07-17 07:03:40 +00:00
var client = new net.Socket();
var socketchunk = ''; // Current message, per connection.
2021-07-17 07:03:40 +00:00
// split character
const split_char = '\0;'
// globals for getting new data only if available so we are saving bandwith
2021-08-23 14:24:49 +00:00
var rxBufferLengthTnc = 0
var rxBufferLengthGui = 0
var rxMsgBufferLengthTnc = 0
var rxMsgBufferLengthGui = 0
2021-08-23 14:24:49 +00:00
// network connection Timeout
setTimeout(connectTNC, 2000)
2021-07-17 07:03:40 +00:00
2021-07-24 07:06:22 +00:00
function connectTNC() {
//exports.connectTNC = function(){
//socketLog.info('connecting to TNC...')
2021-07-24 07:06:22 +00:00
2021-07-17 07:03:40 +00:00
//clear message buffer after reconnecting or inital connection
socketchunk = '';
2021-09-04 18:23:58 +00:00
if (config.tnclocation == 'localhost') {
client.connect(3000, '127.0.0.1')
2021-09-04 14:33:17 +00:00
} else {
client.connect(config.tnc_port, config.tnc_host)
}
2021-07-17 07:03:40 +00:00
}
client.on('connect', function(data) {
socketLog.info('TNC connection established')
2022-02-12 15:34:47 +00:00
let Data = {
busy_state: "-",
arq_state: "-",
//channel_state: "-",
frequency: "-",
mode: "-",
bandwith: "-",
rms_level: 0
};
ipcRenderer.send('request-update-tnc-state', Data);
// also update tnc connection state
ipcRenderer.send('request-update-tnc-connection', {tnc_connection : client.readyState});
2021-07-17 07:03:40 +00:00
})
client.on('error', function(data) {
socketLog.error('TNC connection error');
socketLog.error(data);
2021-07-24 07:06:22 +00:00
let Data = {
2022-02-12 15:34:47 +00:00
tnc_connection: client.readyState,
2021-07-24 07:06:22 +00:00
busy_state: "-",
arq_state: "-",
2021-12-26 08:24:22 +00:00
//channel_state: "-",
2021-07-24 07:06:22 +00:00
frequency: "-",
mode: "-",
bandwith: "-",
rms_level: 0
2021-07-17 07:03:40 +00:00
2021-07-24 07:06:22 +00:00
};
ipcRenderer.send('request-update-tnc-state', Data);
2022-02-12 15:34:47 +00:00
ipcRenderer.send('request-update-tnc-connection', {tnc_connection : client.readyState});
client.destroy();
setTimeout(connectTNC, 500)
2021-07-24 07:06:22 +00:00
// setTimeout( function() { exports.connectTNC(tnc_host, tnc_port); }, 2000 );
2021-07-17 07:03:40 +00:00
});
/*
client.on('close', function(data) {
socketLog.info(' TNC connection closed');
2021-09-13 16:27:50 +00:00
setTimeout(connectTNC, 2000)
2021-07-17 07:03:40 +00:00
});
*/
client.on('end', function(data) {
socketLog.info('TNC connection ended');
2022-02-12 15:34:47 +00:00
ipcRenderer.send('request-update-tnc-connection', {tnc_connection : client.readyState});
client.destroy();
2022-02-12 15:34:47 +00:00
setTimeout(connectTNC, 500)
2021-07-17 07:03:40 +00:00
});
2021-07-24 07:06:22 +00:00
writeTncCommand = function(command) {
2022-02-12 15:34:47 +00:00
//socketLog.info(command)
2021-07-17 07:03:40 +00:00
// we use the writingCommand function to update our TCPIP state because we are calling this function a lot
2021-07-24 07:06:22 +00:00
// if socket openend, we are able to run commands
2021-07-24 07:06:22 +00:00
if (client.readyState == 'open') {
client.write(command + '\n');
2022-02-12 15:34:47 +00:00
2021-07-17 07:03:40 +00:00
}
2021-07-24 07:06:22 +00:00
if (client.readyState == 'closed') {
socketLog.info("CLOSED!")
2022-02-12 15:34:47 +00:00
2021-07-24 07:06:22 +00:00
}
2021-07-24 07:06:22 +00:00
if (client.readyState == 'opening') {
socketLog.info('connecting to TNC...')
2022-02-12 15:34:47 +00:00
2021-07-24 07:06:22 +00:00
}
2021-07-17 07:03:40 +00:00
}
client.on('data', function(socketdata) {
2021-07-17 07:03:40 +00:00
2022-02-12 15:34:47 +00:00
ipcRenderer.send('request-update-tnc-connection', {tnc_connection : client.readyState});
2021-09-13 16:27:50 +00:00
/*
inspired by:
2021-07-24 07:06:22 +00:00
stackoverflow.com questions 9070700 nodejs-net-createserver-large-amount-of-data-coming-in
*/
socketdata = socketdata.toString('utf8'); // convert data to string
socketchunk += socketdata// append data to buffer so we can stick long data together
// check if we received begin and end of json data
if (socketchunk.startsWith('{"') && socketchunk.endsWith('"}\n')) {
var data = ''
// split data into chunks if we received multiple commands
socketchunk = socketchunk.split("\n");
data = JSON.parse(socketchunk[0])
// search for empty entries in socketchunk and remove them
for (i = 0; i < socketchunk.length; i++) {
if (socketchunk[i] === ''){
socketchunk.splice(i, 1);
}
}
//iterate through socketchunks array to execute multiple commands in row
for (i = 0; i < socketchunk.length; i++) {
2021-09-04 18:23:58 +00:00
//check if data is not empty
if(socketchunk[i].length > 0){
//try to parse JSON
try {
data = JSON.parse(socketchunk[i])
} catch (e) {
socketLog.info(e); // "SyntaxError
socketLog.info(socketchunk[i])
socketchunk = ''
}
}
2021-08-16 17:39:20 +00:00
if (data['command'] == 'tnc_state') {
//socketLog.info(data)
// set length of RX Buffer to global variable
rxBufferLengthTnc = data['rx_buffer_length']
rxMsgBufferLengthTnc = data['rx_msg_buffer_length']
let Data = {
ptt_state: data['ptt_state'],
busy_state: data['tnc_state'],
arq_state: data['arq_state'],
arq_session: data['arq_session'],
//channel_state: data['CHANNEL_STATE'],
frequency: data['frequency'],
speed_level: data['speed_level'],
mode: data['mode'],
bandwith: data['bandwith'],
rms_level: (data['audio_rms'] / 1000) * 100,
fft: data['fft'],
2022-02-15 17:10:14 +00:00
channel_busy: data['channel_busy'],
scatter: data['scatter'],
info: data['info'],
rx_buffer_length: data['rx_buffer_length'],
rx_msg_buffer_length: data['rx_msg_buffer_length'],
tx_n_max_retries: data['tx_n_max_retries'],
arq_tx_n_frames_per_burst: data['arq_tx_n_frames_per_burst'],
arq_tx_n_bursts: data['arq_tx_n_bursts'],
arq_tx_n_current_arq_frame: data['arq_tx_n_current_arq_frame'],
arq_tx_n_total_arq_frames: data['arq_tx_n_total_arq_frames'],
arq_rx_frame_n_bursts: data['arq_rx_frame_n_bursts'],
arq_rx_n_current_arq_frame: data['arq_rx_n_current_arq_frame'],
arq_n_arq_frames_per_data_frame: data['arq_n_arq_frames_per_data_frame'],
arq_bytes_per_minute: data['arq_bytes_per_minute'],
arq_compression_factor: data['arq_compression_factor'],
total_bytes: data['total_bytes'],
arq_transmission_percent: data['arq_transmission_percent'],
stations: data['stations'],
beacon_state: data['beacon_state'],
};
ipcRenderer.send('request-update-tnc-state', Data);
}
// update transmission status
if (data['arq'] == 'transmission'){
socketLog.info(data)
let state = {
status: data['status'],
uuid: data['uuid'],
};
ipcRenderer.send('request-update-transmission-status', state);
}
/* A TEST WITH STREAMING DATA .... */
// if we received data through network stream, we get a single data item
if (data['arq'] == 'received') {
dataArray = []
messageArray = []
socketLog.info(data)
// we need to encode here to do a deep check for checking if file or message
var encoded_data = atob(data['data'])
var splitted_data = encoded_data.split(split_char)
if(splitted_data[0] == 'f'){
dataArray.push(data)
}
if(splitted_data[0] == 'm'){
messageArray.push(data)
}
rxBufferLengthGui = dataArray.length
let Files = {
data: dataArray,
};
ipcRenderer.send('request-update-rx-buffer', Files);
rxMsgBufferLengthGui = messageArray.length
let Messages = {
data: messageArray,
};
//ipcRenderer.send('request-update-rx-msg-buffer', Messages);
ipcRenderer.send('request-new-msg-received', Messages);
}
// if we manually checking for the rx buffer we are getting an array of multiple data
if (data['command'] == 'rx_buffer') {
socketLog.info(data)
// iterate through buffer list and sort it to file or message array
dataArray = []
messageArray = []
for (i = 0; i < data['data-array'].length; i++) {
try{
// we need to encode here to do a deep check for checking if file or message
var encoded_data = atob(data['data-array'][i]['data'])
var splitted_data = encoded_data.split(split_char)
if(splitted_data[0] == 'f'){
dataArray.push(data['data-array'][i])
}
if(splitted_data[0] == 'm'){
messageArray.push(data['data-array'][i])
}
} catch (e) {
socketLog.info(e)
}
}
rxBufferLengthGui = dataArray.length
let Files = {
data: dataArray,
};
ipcRenderer.send('request-update-rx-buffer', Files);
rxMsgBufferLengthGui = messageArray.length
let Messages = {
data: messageArray,
};
//ipcRenderer.send('request-update-rx-msg-buffer', Messages);
ipcRenderer.send('request-new-msg-received', Messages);
}
}
//finally delete message buffer
socketchunk = '';
2021-07-17 07:03:40 +00:00
}
});
function hexToBytes(hex) {
for (var bytes = [], c = 0; c < hex.length; c += 2)
2021-07-24 07:06:22 +00:00
bytes.push(parseInt(hex.substr(c, 2), 16));
2021-07-17 07:03:40 +00:00
return bytes;
}
//Get TNC State
2021-07-24 07:06:22 +00:00
exports.getTncState = function() {
command = '{"type" : "get", "command" : "tnc_state"}';
2021-07-24 07:06:22 +00:00
writeTncCommand(command)
2021-07-17 07:03:40 +00:00
}
2021-07-23 15:40:44 +00:00
//Get DATA State
2021-07-24 07:06:22 +00:00
exports.getDataState = function() {
command = '{"type" : "get", "command" : "data_state"}';
2021-07-25 16:19:51 +00:00
//writeTncCommand(command)
2021-07-23 15:40:44 +00:00
}
// Send Ping
2021-07-24 07:06:22 +00:00
exports.sendPing = function(dxcallsign) {
command = '{"type" : "ping", "command" : "ping", "dxcallsign" : "' + dxcallsign + '"}'
2021-07-24 07:06:22 +00:00
writeTncCommand(command)
}
// Send CQ
2021-07-24 07:06:22 +00:00
exports.sendCQ = function() {
command = '{"type" : "broadcast", "command" : "cqcqcq"}'
2021-07-24 07:06:22 +00:00
writeTncCommand(command)
2021-07-26 16:09:04 +00:00
}
// Send File
exports.sendFile = function(dxcallsign, mode, frames, filename, filetype, data, checksum) {
socketLog.info(data)
socketLog.info(filetype)
socketLog.info(filename)
var datatype = "f"
data = datatype + split_char + filename + split_char + filetype + split_char + checksum + split_char + data
socketLog.info(data)
socketLog.info(btoa(data))
data = btoa(data)
2022-03-03 19:40:52 +00:00
command = '{"type" : "arq", "command" : "send_raw", "parameter" : [{"dxcallsign" : "' + dxcallsign + '", "mode" : "' + mode + '", "n_frames" : "' + frames + '", "data" : "' + data + '"}]}'
2021-07-26 16:09:04 +00:00
writeTncCommand(command)
}
// Send Message
exports.sendMessage = function(dxcallsign, mode, frames, data, checksum, uuid, command) {
2022-03-03 19:40:52 +00:00
socketLog.info(data)
// convert message to plain utf8 because of unicode emojis
data = utf8.encode(data)
socketLog.info(data)
2022-03-03 19:40:52 +00:00
var datatype = "m"
data = datatype + split_char + command + split_char + checksum + split_char + uuid + split_char + data
2022-03-03 19:40:52 +00:00
socketLog.info(data)
2022-03-03 19:40:52 +00:00
socketLog.info(btoa(data))
data = btoa(data)
//command = '{"type" : "arq", "command" : "send_message", "parameter" : [{ "dxcallsign" : "' + dxcallsign + '", "mode" : "' + mode + '", "n_frames" : "' + frames + '", "data" : "' + data + '" , "checksum" : "' + checksum + '"}]}'
command = '{"type" : "arq", "command" : "send_raw", "uuid" : "'+ uuid +'", "parameter" : [{"dxcallsign" : "' + dxcallsign + '", "mode" : "' + mode + '", "n_frames" : "' + frames + '", "data" : "' + data + '"}]}'
socketLog.info(command)
socketLog.info("-------------------------------------")
2021-07-26 16:09:04 +00:00
writeTncCommand(command)
2021-08-15 15:30:50 +00:00
}
//STOP TRANSMISSION
exports.stopTransmission = function() {
command = '{"type" : "arq", "command": "stop_transmission"}'
writeTncCommand(command)
}
2021-08-15 15:30:50 +00:00
// Get RX BUffer
exports.getRxBuffer = function() {
command = '{"type" : "get", "command" : "rx_buffer"}'
2021-08-23 14:24:49 +00:00
// call command only if new data arrived
2021-09-04 18:23:58 +00:00
if (rxBufferLengthGui != rxBufferLengthTnc) {
2021-08-23 14:24:49 +00:00
writeTncCommand(command)
}
2021-09-05 09:26:09 +00:00
}
// START BEACON
exports.startBeacon = function(interval) {
command = '{"type" : "broadcast", "command" : "start_beacon", "parameter": "' + interval + '"}'
writeTncCommand(command)
}
// STOP BEACON
exports.stopBeacon = function() {
command = '{"type" : "broadcast", "command" : "stop_beacon"}'
writeTncCommand(command)
}
// OPEN ARQ SESSION
exports.connectARQ = function(dxcallsign) {
command = '{"type" : "arq", "command" : "connect", "dxcallsign": "'+ dxcallsign + '"}'
writeTncCommand(command)
}
// CLOSE ARQ SESSION
exports.disconnectARQ = function() {
command = '{"type" : "arq", "command" : "disconnect"}'
writeTncCommand(command)
}