//
// File .......... script.js
// Author ........ Steve Haywood
// Website ....... http://www.spacewire.co.uk
// Project ....... Zedboard Linux (SpaceWire UK Tutorial)
// Date .......... 25 Mar 2026
// Version ....... 10.0
// History .......
// 7.0 zedboard_linux/os/petalinux/project-spec/meta-user/recipes-apps/website/files/uptime.js
// Description ...
// Javascript for System Information & Operating System / Firmware Load.
//
/////////////
// General //
/////////////
// Page load events
window.addEventListener("load", (event) => {
os_read_ids();
fw_read_ids();
st_kickoff();
});
// Get ID web elements
function getIDs(name, count) {
const elements = [];
for (let i = 0; i < count; i++) {
elements.push({
txt: document.getElementById(`${name}_id_${i}`),
img: document.getElementById(`${name}_id_status_${i}`),
});
}
return elements;
}
///////////////////////////////////////////////
// Product Identification - Operating System //
///////////////////////////////////////////////
// Web elements
const os_ids = getIDs("os", 6);
const os_read = document.getElementById("os_read");
// Web events
os_read.addEventListener("click", function() { os_read_ids(); });
// Download OS information file & display result
async function os_read_ids() {
const response = await fetch("/project.txt?" + Date.now());
if (response.status == 200) {
const ids = await response.text();
const fields = ids.split(/\r?\n/);
for (let i = 0; i < 6; i++) {
if (i < fields.length && fields[i] != "") {
os_ids[i].img.src = "../share/green.gif?" + Date.now();
os_ids[i].img.title = "Last file fetch successful";
os_ids[i].txt.innerHTML = fields[i];
} else {
os_ids[i].img.src = "../share/red.gif?" + Date.now();
os_ids[i].img.title = "Missing field information";
os_ids[i].txt.innerHTML = "Unknown";
}
}
} else {
for (let i = 0; i < 6; i++) {
os_ids[i].img.src = "../share/red.gif?" + Date.now();
os_ids[i].img.title = "Last file fetch failed";
os_ids[i].txt.innerHTML = "Unknown";
}
}
}
///////////////////////////////////////
// Product Identification - Firmware //
///////////////////////////////////////
// Web elements
const fw_ids = getIDs("fw", 6);
const fw_read = document.getElementById("fw_read");
// Web events
fw_read.addEventListener("click", function() { fw_read_ids(); });
// Peek all strings
function fw_read_ids() {
fw_read_id(c_id_description, 0);
fw_read_id(c_id_company, 1);
fw_read_id(c_id_author, 2);
fw_read_id(c_id_version, 3);
fw_read_id(c_id_timestamp, 4);
fw_read_id(c_id_hash, 5);
}
// Peek string & display result
function fw_read_id(offset, index) {
const url = "/cgi-bin/peekstring?" + c_axi_identification + "&" + 4096 + "&" + offset + "&" + 128;
const ajaxReq = new XMLHttpRequest();
ajaxReq.open("GET", url, true);
ajaxReq.onload = () => {
if (ajaxReq.readyState === XMLHttpRequest.DONE && ajaxReq.status === 200) {
const respText = ajaxReq.responseText;
if (respText.substr(0,6) == "Error:") {
fw_ids[index].img.src = "../share/red.gif?" + Date.now();;
fw_ids[index].img.title = "Last peekstring failed : " + respText.substr(7);
} else {
fw_ids[index].img.src = "../share/green.gif?" + Date.now();;
fw_ids[index].img.title = "Last peekstring successful";
fw_ids[index].txt.innerHTML = respText;
}
}
}
ajaxReq.send(null);
}
//////////////////////////////////////////////
// Component Reload - Operating System (PS) //
//////////////////////////////////////////////
// Web elements
const os_select = document.getElementById("os_select");
const os_action = document.getElementById("os_action");
const os_progress = document.getElementById("os_progress");
const os_count = document.getElementById("os_count");
const os_status = document.getElementById("os_status");
// Web events
os_select.addEventListener("change", function() { os_reload(); });
// Globals
var os_timer; // OS Timer
var os_ping; // Ping flag
var os_terminal; // Terminal count
var os_counter; // Progress counter
// A very crude ping
function ping() {
const xhr = new XMLHttpRequest();
xhr.timeout = 500;
xhr.open("GET", "", true);
xhr.onreadystatechange = function() {
if (xhr.readyState === XMLHttpRequest.DONE && xhr.status == 200) {
os_ping = 1;
}
}
xhr.send();
}
// Handle sequence of events for OS reload
function os_ticker() {
os_progress.value++;
os_counter++;
os_count.innerHTML = os_counter + "/" + os_progress.max + " s";
if (os_counter == 30) {
os_action.innerHTML = "Ping";
} else if (os_counter == os_progress.max) {
clearInterval(os_timer);
os_action.innerHTML = "Done";
os_status.src = "../share/red.gif?" + Date.now();
os_status.title = "Reload OS timed out, check connection!";
os_select.disabled = false;
fw_select.disabled = false;
} else if (os_counter == os_terminal - 1) {
os_action.innerHTML = "Reload";
} else if (os_counter == os_terminal) {
clearInterval(os_timer);
window.location.reload(true);
} else if (os_terminal == -1 && os_counter > 30) {
if (os_ping == 1) {
os_action.innerHTML = "Done";
os_progress.value = os_progress.max;
os_status.src = "../share/green.gif?" + Date.now();;
os_status.title = "Reload OS successful";
os_terminal = os_counter + 2;
} else {
ping();
}
}
}
// Kick off OS reload
function os_reload(obj) {
if (os_select.value != "none") {
os_select.disabled = true;
fw_select.disabled = true;
st_ref_once.disabled = true;
st_ref_number.disabled = true;
st_ref_range.disabled = true;
st_ref_limit.disabled = true;
st_align(0);
st_kickoff();
os_action.innerHTML = "Install";
os_progress.value = 0;
os_count.innerHTML = "0/" + os_progress.max + " s";
os_status.src = "../share/amber.gif?" + Date.now();
os_status.title = "Unknown!";
os_ping = 0;
os_terminal = -1;
os_counter = 0;
os_timer = setInterval("os_ticker()", 1000);
const url = "/cgi-bin/reload_os.cgi?" + os_select.value;
const ajaxReq = new XMLHttpRequest();
ajaxReq.open("GET", url, true);
ajaxReq.onload = () => {
if (ajaxReq.readyState === XMLHttpRequest.DONE && ajaxReq.status === 200) {
const respText = ajaxReq.responseText;
if (respText == "OK") {
os_action.innerHTML = "Reboot";
} else {
clearInterval(os_timer);
os_action.innerHTML = "Done";
os_status.src = "../share/red.gif?" + Date.now();
os_status.title = respText;
os_select.disabled = false;
fw_select.disabled = false;
st_ref_once.disabled = false;
st_ref_number.disabled = false;
st_ref_range.disabled = false;
st_ref_limit.disabled = false;
}
}
}
ajaxReq.send(null);
}
}
//////////////////////////////////////
// Component Reload - Firmware (PL) //
//////////////////////////////////////
// Web elements
const fw_select = document.getElementById("fw_select");
const fw_action = document.getElementById("fw_action");
const fw_progress = document.getElementById("fw_progress");
const fw_status = document.getElementById("fw_status");
// Web events
fw_select.addEventListener("change", function() { fw_reload(); });
// Load PL Firmware
function fw_reload() {
if (fw_select.value != "none") {
fw_select.disabled = true;
fw_action.innerHTML = "Write";
fw_progress.value = 0;
fw_status.src = "../share/amber.gif?" + Date.now();
fw_status.title = "Unknown!";
const url = "/cgi-bin/loadfirmware?" + fw_select.value;
const ajaxReq = new XMLHttpRequest();
ajaxReq.open("GET", url, true);
ajaxReq.onload = () => {
if (ajaxReq.readyState === XMLHttpRequest.DONE && ajaxReq.status === 200) {
var respText = ajaxReq.responseText;
if (respText.substr(0,6) == "Error:") {
fw_status.src = "../share/red.gif?" + Date.now();
fw_status.title = "Last loadfirmware failed : " + respText.substr(7);
} else {
fw_status.src = "../share/green.gif?" + Date.now();
fw_status.title = "Last loadfirmware successful";
}
fw_action.innerHTML = "Done";
fw_progress.value = fw_progress.max;
fw_select.disabled = false;
fw_read_ids();
}
}
ajaxReq.send(null);
}
}
//////////////////////////////////
// Operating System Information //
//////////////////////////////////
// Return item index from get_stats.cgi
const cgi_sys_hostname = 0;
const cgi_sys_time = 1;
const cgi_sys_uptime = 2;
const cgi_sys_seq = 3;
const cgi_cpu_model = 4;
const cgi_cpu_cores = 5;
const cgi_cpu_load = 6;
const cgi_cpu_idle = 7;
const cgi_cpu_total = 8;
const cgi_mem_total = 9;
const cgi_mem_used = 10;
const cgi_mem_free = 11;
const cgi_mem_buffer = 12;
const cgi_net_mac = 13;
const cgi_net_int_ip = 14;
const cgi_net_ext_ip = 15;
const cgi_net_time = 16;
const cgi_net_rx_bytes = 17;
const cgi_net_tx_bytes = 18;
const cgi_rootfs_total = 19;
const cgi_rootfs_used = 20;
const cgi_rootfs_free = 21;
const cgi_sdcard_total = 22;
const cgi_sdcard_used = 23;
const cgi_sdcard_free = 24;
// Web elements (statistics)
const st_sys_hostname = document.getElementById("st_sys_hostname");
const st_sys_time = document.getElementById("st_sys_time");
const st_sys_uptime = document.getElementById("st_sys_uptime");
const st_sys_seq_sent = document.getElementById("st_sys_seq_sent");
const st_sys_seq_rcvd = document.getElementById("st_sys_seq_rcvd");
const st_sys_seq_rtt = document.getElementById("st_sys_seq_rtt");
const st_cpu_model = document.getElementById("st_cpu_model");
const st_cpu_cores = document.getElementById("st_cpu_cores");
const st_cpu_load_1m = document.getElementById("st_cpu_load_1m");
const st_cpu_load_5m = document.getElementById("st_cpu_load_5m");
const st_cpu_load_15m = document.getElementById("st_cpu_load_15m");
const st_cpu_util = document.getElementById("st_cpu_util");
const st_mem_txt_total = document.getElementById("st_mem_txt_total");
const st_mem_bar_total = document.getElementById("st_mem_bar_total");
const st_mem_txt_used = document.getElementById("st_mem_txt_used");
const st_mem_bar_used = document.getElementById("st_mem_bar_used");
const st_mem_txt_free = document.getElementById("st_mem_txt_free");
const st_mem_bar_free = document.getElementById("st_mem_bar_free");
const st_mem_txt_buffer = document.getElementById("st_mem_txt_buffer");
const st_mem_bar_buffer = document.getElementById("st_mem_bar_buffer");
const st_net_mac = document.getElementById("st_net_mac");
const st_net_int_ip = document.getElementById("st_net_int_ip");
const st_net_ext_ip = document.getElementById("st_net_ext_ip");
const st_net_rx_bytes = document.getElementById("st_net_rx_bytes");
const st_net_tx_bytes = document.getElementById("st_net_tx_bytes");
const st_rootfs_txt_total = document.getElementById("st_rootfs_txt_total");
const st_rootfs_bar_total = document.getElementById("st_rootfs_bar_total");
const st_rootfs_txt_used = document.getElementById("st_rootfs_txt_used");
const st_rootfs_bar_used = document.getElementById("st_rootfs_bar_used");
const st_rootfs_txt_free = document.getElementById("st_rootfs_txt_free");
const st_rootfs_bar_free = document.getElementById("st_rootfs_bar_free");
const st_sdcard_txt_total = document.getElementById("st_sdcard_txt_total");
const st_sdcard_bar_total = document.getElementById("st_sdcard_bar_total");
const st_sdcard_txt_used = document.getElementById("st_sdcard_txt_used");
const st_sdcard_bar_used = document.getElementById("st_sdcard_bar_used");
const st_sdcard_txt_free = document.getElementById("st_sdcard_txt_free");
const st_sdcard_bar_free = document.getElementById("st_sdcard_bar_free");
// Web elements (refresh)
const st_ref_once = document.getElementById("st_ref_once");
const st_ref_number = document.getElementById("st_ref_number");
const st_ref_range = document.getElementById("st_ref_range");
const st_ref_limit = document.getElementById("st_ref_limit");
// Web events (refresh)
st_ref_once.addEventListener ("click", function() { st_statistics(); });
st_ref_number.addEventListener("change", function() { st_align(st_ref_number.value); });
st_ref_number.addEventListener("change", function() { st_kickoff(); });
st_ref_range.addEventListener ("input", function() { st_align(st_ref_range.value); });
st_ref_range.addEventListener ("change", function() { st_kickoff(); });
st_ref_limit.addEventListener ("change", function() { st_ref_limit_on(); });
// Constants
const st_limit_c = 1000; // Sensible limit value for refresh rate
// Globals (general)
var st_timer; // Refresh timer
var st_sequence = 1; // Outgoing request sequence number
var st_net_ptime = 0; // Previous network timestamp
var st_net_prx = 0; // Previous network Rx bytes
var st_net_ptx = 0; // Previous network Tx bytes
var st_cpu_pidle = 0; // Previous CPU idle time
var st_cpu_ptotal = 0; // Previous CPU total time
// Globals (chart history)
var cpu_chart = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0];
var eth_rx_chart = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0];
var eth_tx_chart = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0];
// Format Kilobytes into Kilobytes, Megabytes, Gigabytes & Terabytes (2 decimal places)
function fmt_kbytes(value) {
if (value >= 1073741824) { value = (value / 1073741824).toFixed(2) + " Tb"; }
else if (value >= 1048576) { value = (value / 1048576).toFixed(2) + " Gb"; }
else if (value >= 1024) { value = (value / 1024).toFixed(2) + " Mb"; }
else { value = (value / 1).toFixed(2) + " Kb"; }
return value;
}
// Format uptime (fractions of a seconds) into days, hours, minutes & seconds
function fmt_uptime(value) {
value = Number(value);
const d = Math.floor(value / (3600*24));
const h = Math.floor(value % (3600*24) / 3600);
const m = Math.floor(value % 3600 / 60);
const s = Math.floor(value % 60);
const days = (d > 0) ? d + (d == 1 ? " day, " : " days, ") : "";
const hours = (d > 0 || h > 0) ? h + (h == 1 ? " hr, " : " hrs, ") : "";
const minutes = (d > 0 || h > 0 || m > 0) ? m + (m == 1 ? " min " : " mins ") : "";
const seconds = ((d > 0 || h > 0 || m > 0) ? " & " : "") + s + (s == 1 ? " sec" : " secs");
return days + hours + minutes + seconds;
}
// Format bytes per second (Bps) into Bits/Kilobits/Megabits & Gigabits per second
function fmt_bps_bits(value) {
if (value >= 125000000) { value = (value / 125000000).toFixed() + " Gbps"; }
else if (value >= 125000) { value = (value / 125000).toFixed() + " Mbps"; }
else if (value >= 125) { value = (value / 125).toFixed() + " Kbps"; }
else { value = (value / 1).toFixed() + " bps"; }
return value;
}
// Format bytes per second (Bps) into Bytes/Kilobytes/Megabytes & Gigabytes per second
function fmt_bps_bytes(value) {
if (value >= 1000000000) { value = (value / 1000000000).toFixed() + " GBps"; }
else if (value >= 1000000) { value = (value / 1000000).toFixed() + " MBps"; }
else if (value >= 1000) { value = (value / 1000).toFixed() + " KBps"; }
else { value = (value / 1).toFixed() + " Bps"; }
return value;
}
// Format milliseconds into milliseconds, seconds & minutes
function fmt_ms(value) {
if (value >= 60000) { value = (value / 60000).toFixed() + " m"; }
else if (value >= 1000) { value = (value / 1000).toFixed() + " s"; }
else { value = (value / 1).toFixed() + " ms"; }
return value;
}
// Update the CPU chart with new data
function update_cpu_chart(array, value, id) {
array.shift();
array.push(value);
html = '';
const min = 0.0;
const max = 100.0;
for (let i = 0; i < array.length; i++) {
height = Math.round(99 * ((array[i] - min) / max));
border = (array[i] == 0.0) ? 0 : 1;
html += '<div class="bar" style="border-width:'+ border + 'px; height:' + height + 'px; left:' + (7 * i) + 'px"></div>';
}
document.getElementById(id).innerHTML = html;
}
// Update the Network Rx/Tx chart with new data
function update_net_chart(array, value, id) {
array.shift();
array.push(value);
var html ='';
var max = array[0];
for (let i = 0; i < array.length; i++) {
if (max < array[i]) { max = array[i]; }
}
for (let i = 0; i < array.length; i++) {
height = Math.round( 46 * ((array[i] / max)) );
border = (array[i] == 0.0) ? 0 : 1;
html += '<div class="bar" style="border-width:'+ border + 'px; height:' + height + 'px; left:' + (7 * i) + 'px"></div>';
}
document.getElementById(id).innerHTML = html;
}
// Get statistics
function st_statistics() {
const url = "/cgi-bin/get_stats.cgi?" + st_sequence;
const ajaxReq = new XMLHttpRequest();
const start = Date.now();
st_sys_seq_sent.innerHTML = st_sequence;
st_sequence++;
ajaxReq.open("GET", url, true);
ajaxReq.onload = () => {
if (ajaxReq.readyState === XMLHttpRequest.DONE && ajaxReq.status === 200) {
st_sys_seq_rtt.innerHTML = fmt_ms(Date.now() - start);
const respText = ajaxReq.responseText;
fields = respText.split(/\r?\n/);
// Update System table
st_sys_hostname.innerHTML = fields[cgi_sys_hostname]; // CGI: Hostname
st_sys_time.innerHTML = fields[cgi_sys_time]; // CGI: Date & Time
st_sys_uptime.innerHTML = fmt_uptime(fields[cgi_sys_uptime]); // CGI: Uptime
// // JS: Sequence - Packet - Sent
st_sys_seq_rcvd.innerHTML = fields[cgi_sys_seq]; // CGI: Sequence - Packet - Received
st_sys_seq_rcvd.style.color = (st_sequence - Number(st_sys_seq_rcvd.innerHTML) > 2) ? "red" : "black";
// // JS: Sequence - Turnaround
// Update CPU table
st_cpu_model.innerHTML = fields[cgi_cpu_model]; // CGI: Model
st_cpu_cores.innerHTML = fields[cgi_cpu_cores]; // CGI: Cores
const loads = fields[cgi_cpu_load].split(" "); // CGI: Load
st_cpu_load_1m.innerHTML = loads[0];
st_cpu_load_5m.innerHTML = loads[1];
st_cpu_load_15m.innerHTML = loads[2];
// Calculate CPU usage // CGI & JS: Usage
const st_cpu_idle = fields[cgi_cpu_idle];
const st_cpu_total = fields[cgi_cpu_total];
if (!isNaN(st_cpu_idle) && !isNaN(st_cpu_total)) {
const diff_total = st_cpu_total - st_cpu_ptotal;
if (st_cpu_pidle > 0 && diff_total > 0) {
const diff_idle = st_cpu_idle - st_cpu_pidle;
const diff_usage = ((100*(diff_total-diff_idle)/diff_total));
st_cpu_util.innerHTML = diff_usage.toFixed(2);
update_cpu_chart(cpu_chart, diff_usage, "st_cpu_chart");
}
st_cpu_pidle = st_cpu_idle;
st_cpu_ptotal = st_cpu_total;
}
// Update Memory table
// CGI: Total
st_mem_bar_total.max = fields[cgi_mem_total];
st_mem_bar_total.value = fields[cgi_mem_total];
st_mem_pct_total.innerHTML = (100*fields[cgi_mem_total]/fields[cgi_mem_total]).toFixed(2);
st_mem_txt_total.innerHTML = fmt_kbytes(fields[cgi_mem_total]);
// CGI: Used
st_mem_bar_used.max = fields[cgi_mem_total];
st_mem_bar_used.value = fields[cgi_mem_used];
st_mem_pct_used.innerHTML = (100*fields[cgi_mem_used]/fields[cgi_mem_total]).toFixed(2);
st_mem_txt_used.innerHTML = fmt_kbytes(fields[cgi_mem_used]);
// CGI: Free
st_mem_bar_free.max = fields[cgi_mem_total];
st_mem_bar_free.value = fields[cgi_mem_free];
st_mem_pct_free.innerHTML = (100*fields[cgi_mem_free]/fields[cgi_mem_total]).toFixed(2);
st_mem_txt_free.innerHTML = fmt_kbytes(fields[cgi_mem_free]);
// CGI: Buffer/Cache
st_mem_bar_buffer.max = fields[cgi_mem_total];
st_mem_bar_buffer.value = fields[cgi_mem_buffer];
st_mem_pct_buffer.innerHTML = (100*fields[cgi_mem_buffer]/fields[cgi_mem_total]).toFixed(2);
st_mem_txt_buffer.innerHTML = fmt_kbytes(fields[cgi_mem_buffer]);
// Update Network table
st_net_mac.innerHTML = fields[cgi_net_mac]; // CGI: MAC Address
st_net_int_ip.innerHTML = fields[cgi_net_int_ip]; // CGI: Internal IP
st_net_ext_ip.innerHTML = fields[cgi_net_ext_ip]; // CGI: External IP
// Calculate Ethernet usage // CGI & JS: Speed
const st_net_time = fields[cgi_net_time];
const st_net_rx = fields[cgi_net_rx_bytes];
const st_net_tx = fields[cgi_net_tx_bytes];
if (!isNaN(st_net_time) && !isNaN(st_net_rx) && !isNaN(st_net_tx) && st_net_time != st_net_ptime) {
const interval = st_net_time - st_net_ptime;
if (st_net_ptime > 0 && interval > 0) {
const rx_rate = (st_net_rx-st_net_prx)/interval;
const tx_rate = (st_net_tx-st_net_ptx)/interval;
st_net_rx_bytes.innerHTML = fmt_bps_bytes(rx_rate); // CGI & JS: Speed - Rx
st_net_tx_bytes.innerHTML = fmt_bps_bytes(tx_rate); // CGI & JS: Speed - Tx
update_net_chart(eth_rx_chart, rx_rate, "st_rx_chart");
update_net_chart(eth_tx_chart, tx_rate, "st_tx_chart");
}
st_net_ptime = st_net_time;
st_net_prx = st_net_rx;
st_net_ptx = st_net_tx;
}
// Update Disks (rootfs) table
// CGI: Total
st_rootfs_bar_total.max = fields[cgi_rootfs_total];
st_rootfs_bar_total.value = fields[cgi_rootfs_total];
st_rootfs_pct_total.innerHTML = (100*fields[cgi_rootfs_total]/fields[cgi_rootfs_total]).toFixed(2);
st_rootfs_txt_total.innerHTML = fmt_kbytes(fields[cgi_rootfs_total]);
// CGI: Used
st_rootfs_bar_used.max = fields[cgi_rootfs_total];
st_rootfs_bar_used.value = fields[cgi_rootfs_used];
st_rootfs_pct_used.innerHTML = (100*fields[cgi_rootfs_used]/fields[cgi_rootfs_total]).toFixed(2);
st_rootfs_txt_used.innerHTML = fmt_kbytes(fields[cgi_rootfs_used]);
// CGI: Free
st_rootfs_bar_free.max = fields[cgi_rootfs_total];
st_rootfs_bar_free.value = fields[cgi_rootfs_free];
st_rootfs_pct_free.innerHTML = (100*fields[cgi_rootfs_free]/fields[cgi_rootfs_total]).toFixed(2);
st_rootfs_txt_free.innerHTML = fmt_kbytes(fields[cgi_rootfs_free]);
// Update Disks (mmcblk0p1) table
// CGI: Total
st_sdcard_bar_total.max = fields[cgi_sdcard_total];
st_sdcard_bar_total.value = fields[cgi_sdcard_total];
st_sdcard_pct_total.innerHTML = (100*fields[cgi_sdcard_total]/fields[cgi_sdcard_total]).toFixed(2);
st_sdcard_txt_total.innerHTML = fmt_kbytes(fields[cgi_sdcard_total]);
// CGI: Used
st_sdcard_bar_used.max = fields[cgi_sdcard_total];
st_sdcard_bar_used.value = fields[cgi_sdcard_used];
st_sdcard_pct_used.innerHTML = (100*fields[cgi_sdcard_used]/fields[cgi_sdcard_total]).toFixed(2);
st_sdcard_txt_used.innerHTML = fmt_kbytes(fields[cgi_sdcard_used]);
// CGI: Free
st_sdcard_bar_free.max = fields[cgi_sdcard_total];
st_sdcard_bar_free.value = fields[cgi_sdcard_free];
st_sdcard_pct_free.innerHTML = (100*fields[cgi_sdcard_free]/fields[cgi_sdcard_total]).toFixed(2);
st_sdcard_txt_free.innerHTML = fmt_kbytes(fields[cgi_sdcard_free]);
}
}
ajaxReq.send(null);
}
// Update statistics timer
function st_kickoff() {
clearInterval(st_timer);
const interval = st_ref_range.value;
if (interval > 0) {
st_timer = setInterval("st_statistics()", interval);
}
}
// Align slider & number values
function st_align(value) {
if (st_ref_limit.checked && value != 0 && value < st_limit_c) {
st_ref_number.value = st_ref_range.value = st_limit_c;
} else {
st_ref_number.value = st_ref_range.value = value;
}
}
// Apply limited on checkbox
function st_ref_limit_on() {
if (st_ref_limit.checked && st_ref_range.value != 0 && st_ref_range.value < st_limit_c) {
st_align(st_limit_c);
st_kickoff();
}
}
Check out the changes.
Note: The System time is incorrect for the United Kingdom (it is one hour behind, the UK is currently on British Summer Time).
After the reload sequence has finished...
The Timestamp & Hash shown from GIT (1st entry) should marry up perfectly with the displayed Operating System Information.