Obbart/AstroRotaxMonitor
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

merge into: Obbart:datasave
Branches Tags
Obbart:main Obbart:ioexpander Obbart:task-refactor Obbart:datasave Obbart:adc Obbart:debug
...
pull from: Obbart:ioexpander
Branches Tags
Obbart:ioexpander Obbart:main Obbart:task-refactor Obbart:datasave Obbart:adc Obbart:debug

10 Commits
datasave ... ioexpander

Author SHA1 Message Date
Emanuele Trabattoni
782aa95ee6 Merge branch 'task-refactor' 2026-04-13 10:28:24 +02:00
Emanuele Trabattoni
212b37c95f updated and fixed charts 2026-04-13 10:26:55 +02:00
Emanuele Trabattoni
f8c3c69e80 fix graph 2026-04-12 14:42:40 +02:00
Emanuele Trabattoni
7da58c8a49 Set time from browser 2026-04-12 14:40:58 +02:00
Emanuele Trabattoni
a153402d28 webpage chats 2026-04-12 02:38:27 +02:00
Emanuele Trabattoni
095aa59f36 task refactoring working, sometimes misses events, check priorities 2026-04-12 01:45:32 +02:00
Emanuele Trabattoni
fdba6d5ad5 refactor continued, at least it compiles 2026-04-11 16:39:59 +02:00
Emanuele Trabattoni
d1b96e932c task refactoring work in progress 2026-04-11 15:49:40 +02:00
Emanuele Trabattoni
684c34e209 adding pins and task class 2026-04-11 12:27:19 +02:00
Emanuele Trabattoni
37fa6a686f Merge branch 'datasave' 2026-04-11 11:40:20 +02:00
18 changed files with 1240 additions and 618 deletions
Expand all files Collapse all files

16
RotaxMonitor/data/chart.js Normal file
View File

File diff suppressed because one or more lines are too long

338
RotaxMonitor/data/index.html
View File

@@ -13,176 +13,200 @@
<img src="logo_astro_dev.svg" alt="Astro Tecnologie" class="logo"> <img src="logo_astro_dev.svg" alt="Astro Tecnologie" class="logo">
</div> </div>
<div> <div>
<h1>Rotax Ignition Box Monitor</h1> <h1>Rotax Ignition Box Monitor</h1>
</div> </div>
</header> </header>
<div id="loadingIndicator" class="loading-indicator"> <!-- TAB BUTTONS -->
<span class="spinner"></span> Waiting for data... <div class="tabs">
<button class="tab-button active" onclick="openTab('tab1')">Monitor</button>
<button class="tab-button" onclick="openTab('tab2')">Grafico</button>
</div> </div>
<div class="tables-container"> <!-- TAB 1 (contenuto attuale) -->
<div class="box"> <div id="tab1" class="tab-content active">
<h2>Box_A</h2>
<div class="box-data"> <div id="loadingIndicator" class="loading-indicator">
<p><strong>Timestamp:</strong> <span id="a_timestamp">-</span></p> <span class="spinner"></span> Waiting for data...
<p><strong>Data Valid:</strong> <span id="a_datavalid">-</span></p>
<p><strong>Generator voltage:</strong> <span id="a_volts_gen">-</span></p>
<p><strong>ADC read time:</strong> <span id="a_adc_read_time">-</span></p>
<p><strong>Queue errors:</strong> <span id="a_n_queue_errors">-</span></p>
</div>
<div class="rpm-highlight">
<strong>Engine RPM:</strong> <span id="a_eng_rpm">-</span>
</div>
<table>
<thead>
<tr>
<th>Property</th>
<th>Pickup 12</th>
<th>Pickup 34</th>
</tr>
</thead>
<tbody>
<tr>
<td>Spark delay</td>
<td id="a_coils12_spark_delay">-</td>
<td id="a_coils34_spark_delay">-</td>
</tr>
<tr>
<td>Spark status</td>
<td id="a_coils12_spark_status">-</td>
<td id="a_coils34_spark_status">-</td>
</tr>
<tr>
<td>Soft start status</td>
<td id="a_coils12_sstart_status">-</td>
<td id="a_coils34_sstart_status">-</td>
</tr>
<tr>
<td>Peak P in</td>
<td id="a_coils12_peak_p_in">-</td>
<td id="a_coils34_peak_p_in">-</td>
</tr>
<tr>
<td>Peak N in</td>
<td id="a_coils12_peak_n_in">-</td>
<td id="a_coils34_peak_n_in">-</td>
</tr>
<tr>
<td>Peak P out</td>
<td id="a_coils12_peak_p_out">-</td>
<td id="a_coils34_peak_p_out">-</td>
</tr>
<tr>
<td>Peak N out</td>
<td id="a_coils12_peak_n_out">-</td>
<td id="a_coils34_peak_n_out">-</td>
</tr>
<tr>
<td>Level spark</td>
<td id="a_coils12_level_spark">-</td>
<td id="a_coils34_level_spark">-</td>
</tr>
<tr>
<td>Spark Events</td>
<td id="a_coils12_n_events">-</td>
<td id="a_coils34_n_events">-</td>
</tr>
<tr>
<td>Missed Events</td>
<td id="a_coils12_n_missed_firing">-</td>
<td id="a_coils34_n_missed_firing">-</td>
</tr>
</tbody>
</table>
</div> </div>
<div class="box"> <div class="tables-container">
<h2>Box_B</h2> <div class="box">
<div class="box-data"> <h2>Box_A</h2>
<p><strong>Timestamp:</strong> <span id="b_timestamp">-</span></p> <div class="box-data">
<p><strong>Data Valid:</strong> <span id="b_datavalid">-</span></p> <p><strong>Timestamp:</strong> <span id="a_timestamp">-</span></p>
<p><strong>Generator voltage:</strong> <span id="b_volts_gen">-</span></p> <p><strong>Data Valid:</strong> <span id="a_datavalid">-</span></p>
<p><strong>ADC read time:</strong> <span id="b_adc_read_time">-</span></p> <p><strong>Generator voltage:</strong> <span id="a_volts_gen">-</span></p>
<p><strong>Queue errors:</strong> <span id="b_n_queue_errors">-</span></p> <p><strong>ADC read time:</strong> <span id="a_adc_read_time">-</span></p>
<p><strong>Queue errors:</strong> <span id="a_n_queue_errors">-</span></p>
</div>
<div class="rpm-highlight">
<strong>Engine RPM:</strong> <span id="a_eng_rpm">-</span>
</div>
<table>
<thead>
<tr>
<th>Property</th>
<th>Pickup 12</th>
<th>Pickup 34</th>
</tr>
</thead>
<tbody>
<tr>
<td>Spark delay</td>
<td id="a_coils12_spark_delay">-</td>
<td id="a_coils34_spark_delay">-</td>
</tr>
<tr>
<td>Spark status</td>
<td id="a_coils12_spark_status">-</td>
<td id="a_coils34_spark_status">-</td>
</tr>
<tr>
<td>Soft start status</td>
<td id="a_coils12_sstart_status">-</td>
<td id="a_coils34_sstart_status">-</td>
</tr>
<tr>
<td>Peak P in</td>
<td id="a_coils12_peak_p_in">-</td>
<td id="a_coils34_peak_p_in">-</td>
</tr>
<tr>
<td>Peak N in</td>
<td id="a_coils12_peak_n_in">-</td>
<td id="a_coils34_peak_n_in">-</td>
</tr>
<tr>
<td>Peak P out</td>
<td id="a_coils12_peak_p_out">-</td>
<td id="a_coils34_peak_p_out">-</td>
</tr>
<tr>
<td>Peak N out</td>
<td id="a_coils12_peak_n_out">-</td>
<td id="a_coils34_peak_n_out">-</td>
</tr>
<tr>
<td>Level spark</td>
<td id="a_coils12_level_spark">-</td>
<td id="a_coils34_level_spark">-</td>
</tr>
<tr>
<td>Spark Events</td>
<td id="a_coils12_n_events">-</td>
<td id="a_coils34_n_events">-</td>
</tr>
<tr>
<td>Missed Events</td>
<td id="a_coils12_n_missed_firing">-</td>
<td id="a_coils34_n_missed_firing">-</td>
</tr>
</tbody>
</table>
</div> </div>
<div class="rpm-highlight">
<strong>Engine RPM:</strong> <span id="b_eng_rpm">-</span> <div class="box">
<h2>Box_B</h2>
<div class="box-data">
<p><strong>Timestamp:</strong> <span id="b_timestamp">-</span></p>
<p><strong>Data Valid:</strong> <span id="b_datavalid">-</span></p>
<p><strong>Generator voltage:</strong> <span id="b_volts_gen">-</span></p>
<p><strong>ADC read time:</strong> <span id="b_adc_read_time">-</span></p>
<p><strong>Queue errors:</strong> <span id="b_n_queue_errors">-</span></p>
</div>
<div class="rpm-highlight">
<strong>Engine RPM:</strong> <span id="b_eng_rpm">-</span>
</div>
<table>
<thead>
<tr>
<th>Property</th>
<th>Pickup 12</th>
<th>Pickup 34</th>
</tr>
</thead>
<tbody>
<tr>
<td>Spark delay</td>
<td id="b_coils12_spark_delay">-</td>
<td id="b_coils34_spark_delay">-</td>
</tr>
<tr>
<td>Spark status</td>
<td id="b_coils12_spark_status">-</td>
<td id="b_coils34_spark_status">-</td>
</tr>
<tr>
<td>Soft start status</td>
<td id="b_coils12_sstart_status">-</td>
<td id="b_coils34_sstart_status">-</td>
</tr>
<tr>
<td>Peak P in</td>
<td id="b_coils12_peak_p_in">-</td>
<td id="b_coils34_peak_p_in">-</td>
</tr>
<tr>
<td>Peak N in</td>
<td id="b_coils12_peak_n_in">-</td>
<td id="b_coils34_peak_n_in">-</td>
</tr>
<tr>
<td>Peak P out</td>
<td id="b_coils12_peak_p_out">-</td>
<td id="b_coils34_peak_p_out">-</td>
</tr>
<tr>
<td>Peak N out</td>
<td id="b_coils12_peak_n_out">-</td>
<td id="b_coils34_peak_n_out">-</td>
</tr>
<tr>
<td>Level spark</td>
<td id="b_coils12_level_spark">-</td>
<td id="b_coils34_level_spark">-</td>
</tr>
<tr>
<td>Spark Events</td>
<td id="b_coils12_n_events">-</td>
<td id="b_coils34_n_events">-</td>
</tr>
<tr>
<td>Missed Events</td>
<td id="b_coils12_n_missed_firing">-</td>
<td id="b_coils34_n_missed_firing">-</td>
</tr>
</tbody>
</table>
</div> </div>
<table> </div>
<thead> </div> <!-- END TAB1 -->
<tr>
<th>Property</th> <!-- TAB 2 (grafico) -->
<th>Pickup 12</th> <div id="tab2" class="tab-content">
<th>Pickup 34</th> <div class="chart-container">
</tr> <h3>Box A</h3>
</thead> <canvas id="chartA" height="100"></canvas>
<tbody> </div>
<tr>
<td>Spark delay</td> <div class="chart-container">
<td id="b_coils12_spark_delay">-</td> <h3>Box B</h3>
<td id="b_coils34_spark_delay">-</td> <canvas id="chartB" height="100"></canvas>
</tr>
<tr>
<td>Spark status</td>
<td id="b_coils12_spark_status">-</td>
<td id="b_coils34_spark_status">-</td>
</tr>
<tr>
<td>Soft start status</td>
<td id="b_coils12_sstart_status">-</td>
<td id="b_coils34_sstart_status">-</td>
</tr>
<tr>
<td>Peak P in</td>
<td id="b_coils12_peak_p_in">-</td>
<td id="b_coils34_peak_p_in">-</td>
</tr>
<tr>
<td>Peak N in</td>
<td id="b_coils12_peak_n_in">-</td>
<td id="b_coils34_peak_n_in">-</td>
</tr>
<tr>
<td>Peak P out</td>
<td id="b_coils12_peak_p_out">-</td>
<td id="b_coils34_peak_p_out">-</td>
</tr>
<tr>
<td>Peak N out</td>
<td id="b_coils12_peak_n_out">-</td>
<td id="b_coils34_peak_n_out">-</td>
</tr>
<tr>
<td>Level spark</td>
<td id="b_coils12_level_spark">-</td>
<td id="b_coils34_level_spark">-</td>
</tr>
<tr>
<td>Spark Events</td>
<td id="b_coils12_n_events">-</td>
<td id="b_coils34_n_events">-</td>
</tr>
<tr>
<td>Missed Events</td>
<td id="b_coils12_n_missed_firing">-</td>
<td id="b_coils34_n_missed_firing">-</td>
</tr>
</tbody>
</table>
</div> </div>
</div> </div>
<div class="upload-section">
<h3>Upload file to Flash</h3>
<p>Select a file and upload it to Flash.</p>
<input type="file" id="littlefsFile">
<button onclick="uploadLittleFS()">Upload</button>
<div id="uploadStatus" class="upload-status">No file uploaded yet.</div>
</div>
<script src="script.js"></script>
</body> </body>
<div class="upload-section">
<h3>Upload file to Flash</h3>
<p>Select a file and upload it to Flash.</p>
<input type="file" id="littlefsFile">
<button onclick="uploadLittleFS()">Upload</button>
<div id="uploadStatus" class="upload-status">No file uploaded yet.</div>
</div>
<script src="chart.js"></script>
<script src="script.js"></script>
</html> </html>

128
RotaxMonitor/data/script.js
View File

@@ -3,6 +3,26 @@ let lastMessageTimestamp = 0;
const IDLE_THRESHOLD_MS = 1000; const IDLE_THRESHOLD_MS = 1000;
const loadingIndicator = document.getElementById("loadingIndicator"); const loadingIndicator = document.getElementById("loadingIndicator");
let chartA, chartB;
let dataA = {
labels: [],
datasets: [
{ label: "RPM", data: [] },
{ label: "Coils12 Delay", data: [] },
{ label: "Coils34 Delay", data: [] }
]
};
let dataB = {
labels: [],
datasets: [
{ label: "RPM", data: [] },
{ label: "Coils12 Delay", data: [] },
{ label: "Coils34 Delay", data: [] }
]
};
function setLoadingIndicator(visible) { function setLoadingIndicator(visible) {
if (!loadingIndicator) { if (!loadingIndicator) {
return; return;
@@ -25,6 +45,11 @@ function connectWS() {
console.log("WebSocket connesso"); console.log("WebSocket connesso");
lastMessageTimestamp = Date.now(); lastMessageTimestamp = Date.now();
setLoadingIndicator(false); setLoadingIndicator(false);
ws.send(JSON.stringify({
cmd: "setTime",
time: Math.floor(Date.now() / 1000)
}));
}; };
ws.onclose = () => { ws.onclose = () => {
@@ -46,6 +71,8 @@ function connectWS() {
lastMessageTimestamp = Date.now(); lastMessageTimestamp = Date.now();
setLoadingIndicator(false); setLoadingIndicator(false);
updateCharts(data)
// Update Box_A // Update Box_A
if (data.box_a) { if (data.box_a) {
const boxA = data.box_a; const boxA = data.box_a;
@@ -118,6 +145,51 @@ function connectWS() {
}; };
} }
function updateCharts(data) {
const t = new Date().toLocaleTimeString();
// ===== BOX A =====
dataA.labels.push(t);
if (data.box_a) {
dataA.datasets[0].data.push(data.box_a.eng_rpm / 10);
dataA.datasets[1].data.push(data.box_a.coils12.spark_delay);
dataA.datasets[2].data.push(data.box_a.coils34.spark_delay);
} else {
dataA.datasets[0].data.push(undefined);
dataA.datasets[1].data.push(undefined);
dataA.datasets[2].data.push(undefined);
}
// ===== BOX B =====
dataB.labels.push(t);
if (data.box_b) {
dataB.datasets[0].data.push(data.box_b.eng_rpm / 10);
dataB.datasets[1].data.push(data.box_b.coils12.spark_delay);
dataB.datasets[2].data.push(data.box_b.coils34.spark_delay);
} else {
dataB.datasets[0].data.push(undefined);
dataB.datasets[1].data.push(undefined);
dataB.datasets[2].data.push(undefined);
}
// limite buffer
const maxPoints = 100;
if (dataA.labels.length > maxPoints) {
dataA.labels.shift();
dataA.datasets.forEach(d => d.data.shift());
}
if (dataB.labels.length > maxPoints) {
dataB.labels.shift();
dataB.datasets.forEach(d => d.data.shift());
}
chartA.update();
chartB.update();
}
function start() { function start() {
fetch("/start"); fetch("/start");
} }
@@ -160,5 +232,61 @@ function uploadLittleFS() {
}); });
} }
function openTab(tabId) {
document.querySelectorAll('.tab-content').forEach(tab => {
tab.classList.remove('active');
});
document.querySelectorAll('.tab-button').forEach(btn => {
btn.classList.remove('active');
});
document.getElementById(tabId).classList.add('active');
event.target.classList.add('active');
}
function initCharts() {
const ctxA = document.getElementById('chartA').getContext('2d');
const ctxB = document.getElementById('chartB').getContext('2d');
chartA = new Chart(ctxA, {
type: 'line',
data: dataA,
options: {
animation: false,
responsive: true,
scales: {
x: {
display: true
},
y: {
beginAtZero: true
}
}
}
});
chartB = new Chart(ctxB, {
type: 'line',
data: dataB,
options: {
animation: false,
responsive: true,
scales: {
x: {
display: true
},
y: {
beginAtZero: true
}
}
}
});
}
window.onload = () => {
initCharts();
};
setInterval(updateLoadingState, 200); setInterval(updateLoadingState, 200);
connectWS(); connectWS();

38
RotaxMonitor/data/style.css
View File

@@ -219,3 +219,41 @@ button:hover {
span { span {
color: var(--text-dark); color: var(--text-dark);
} }
/* TABS */
.tabs {
display: flex;
justify-content: center;
margin: 20px;
}
.tab-button {
padding: 10px 20px;
margin: 0 5px;
border: none;
cursor: pointer;
background: var(--border-color);
border-radius: 4px;
}
.tab-button.active {
background: var(--primary-blue);
color: white;
}
.tab-content {
display: none;
}
.tab-content.active {
display: block;
}
.chart-container {
max-width: 1000px;
margin: 20px auto;
background: white;
padding: 20px;
border-radius: 6px;
box-shadow: 0 1px 3px rgba(0,0,0,0.08);
}

2
RotaxMonitor/lib/led/led.h
View File

@@ -37,7 +37,7 @@ public:
struct color_t struct color_t
{ {
uint8_t a, g, r, b; uint8_t a, r, g, b;
}; };
union color_u union color_u

4
RotaxMonitor/platformio.ini
View File

@@ -64,7 +64,7 @@ build_flags =
-DARDUINO_USB_MODE=0 -DARDUINO_USB_MODE=0
-DCONFIG_ASYNC_TCP_MAX_ACK_TIME=5000 -DCONFIG_ASYNC_TCP_MAX_ACK_TIME=5000
-DCONFIG_ASYNC_TCP_PRIORITY=21 -DCONFIG_ASYNC_TCP_PRIORITY=21
-DCONFIG_ASYNC_TCP_QUEUE_SIZE=64 -DCONFIG_ASYNC_TCP_QUEUE_SIZE=128
-DCONFIG_ASYNC_TCP_RUNNING_CORE=1 -DCONFIG_ASYNC_TCP_RUNNING_CORE=1
-DCONFIG_ASYNC_TCP_STACK_SIZE=4096 -DCONFIG_ASYNC_TCP_STACK_SIZE=8192
-fstack-protector-all -fstack-protector-all

108
RotaxMonitor/src/datasave.cpp
View File

@@ -1,7 +1,7 @@
#include "datasave.h" #include "datasave.h"
#include <math.h> #include <math.h>
static const size_t min_free = 1024 * 1024; // minimum free space in LittleFS to allow saving history (1MB)
LITTLEFSGuard::LITTLEFSGuard() LITTLEFSGuard::LITTLEFSGuard()
{ {
@@ -22,26 +22,26 @@ LITTLEFSGuard::~LITTLEFSGuard()
LOG_INFO("LittleFS unmounted successfully"); LOG_INFO("LittleFS unmounted successfully");
} }
void ignitionBoxStatusAverage::filter(int32_t &old, const int32_t value, const uint32_t k) void ignitionBoxStatusFiltered::filter(int32_t &old, const int32_t value, const uint32_t k)
{ {
float alpha = 1.0f / (float)k; float alpha = 1.0f / (float)k;
old = old + (int32_t)(alpha * (float)(value - old)); old = old + (int32_t)(alpha * (float)(value - old));
} }
void ignitionBoxStatusAverage::filter(float &old, const float value, const uint32_t k) void ignitionBoxStatusFiltered::filter(float &old, const float value, const uint32_t k)
{ {
float alpha = 1.0f / (float)k; float alpha = 1.0f / (float)k;
old = old + (float)(alpha * (float)(value - old)); old = old + (float)(alpha * (float)(value - old));
} }
void ignitionBoxStatusAverage::reset() void ignitionBoxStatusFiltered::reset()
{ {
m_last = ignitionBoxStatus(); m_last = ignitionBoxStatus();
m_count = 0; m_count = 0;
m_data_valid = false; m_data_valid = false;
} }
void ignitionBoxStatusAverage::update(const ignitionBoxStatus &new_status) void ignitionBoxStatusFiltered::update(const ignitionBoxStatus &new_status)
{ {
if (m_count == 0 && !m_data_valid) if (m_count == 0 && !m_data_valid)
{ {
@@ -81,7 +81,7 @@ void ignitionBoxStatusAverage::update(const ignitionBoxStatus &new_status)
} }
} }
const bool ignitionBoxStatusAverage::get(ignitionBoxStatus &status) const const bool ignitionBoxStatusFiltered::get(ignitionBoxStatus &status) const
{ {
if (m_data_valid) if (m_data_valid)
{ {
@@ -90,7 +90,7 @@ const bool ignitionBoxStatusAverage::get(ignitionBoxStatus &status) const
return m_data_valid; return m_data_valid;
} }
const ArduinoJson::JsonDocument ignitionBoxStatusAverage::toJson() const const ArduinoJson::JsonDocument ignitionBoxStatusFiltered::toJson() const
{ {
ArduinoJson::JsonDocument doc; ArduinoJson::JsonDocument doc;
if (m_data_valid) if (m_data_valid)
@@ -125,97 +125,3 @@ const ArduinoJson::JsonDocument ignitionBoxStatusAverage::toJson() const
return doc; return doc;
} }
void saveHistoryTask(void *pvParameters)
{
const auto *params = static_cast<dataSaveParams *>(pvParameters);
const auto &history = *params->history;
const auto &file_path = params->file_path;
if (!params)
{
LOG_ERROR("Invalid parameters for saveHistoryTask");
return;
}
LOG_DEBUG("Starting saving: ", file_path.c_str());
save_history(history, file_path);
vTaskDelete(NULL);
}
void save_history(const PSRAMVector<ignitionBoxStatus> &history, const std::filesystem::path &file_name)
{
// Initialize SPIFFS
if (!SAVE_HISTORY_TO_LITTLEFS)
return;
auto littlefs_guard = LITTLEFSGuard(); // use RAII guard to ensure LittleFS is properly mounted and unmounted
if (LittleFS.totalBytes() - LittleFS.usedBytes() < min_free) // check if at least 1MB is free for saving history
{
LOG_ERROR("Not enough space in SPIFFS to save history");
return;
}
std::filesystem::path file_path = file_name;
if (file_name.root_path() != "/littlefs")
file_path = std::filesystem::path("/littlefs") / file_name;
auto save_flags = std::ios::out;
if (first_save && LittleFS.exists(file_path.c_str()))
{
first_save = false;
save_flags |= std::ios::trunc; // overwrite existing file
LittleFS.remove(file_path.c_str()); // ensure file is removed before saving to avoid issues with appending to existing file in SPIFFS
LOG_INFO("Saving history to LittleFS, new file:", file_path.c_str());
}
else
{
save_flags |= std::ios::app; // append to new file
LOG_INFO("Saving history to LittleFS, appending to existing file:", file_path.c_str());
}
std::ofstream ofs(file_path, save_flags);
if (ofs.fail())
{
LOG_ERROR("Failed to open file for writing");
return;
}
// write csv header
if (first_save)
{
ofs << "TS,\
EVENTS_12,DLY_12,STAT_12,V_12_1,V_12_2,V_12_3,V_12_4,IGNITION_MODE_12,\
EVENTS_34,DLY_34,STAT_34,V_34_1,V_34_2,V_34_3,V_34_4,IGNITION_MODE_34,\
ENGINE_RPM,ADC_READTIME,N_QUEUE_ERRORS"
<< std::endl;
ofs.flush();
}
for (const auto &entry : history)
{
ofs << std::to_string(entry.timestamp) << ","
<< std::to_string(entry.coils12.n_events) << ","
<< std::to_string(entry.coils12.spark_delay) << ","
<< std::string(sparkStatusNames.at(entry.coils12.spark_status)) << ","
<< std::to_string(entry.coils12.peak_p_in) << ","
<< std::to_string(entry.coils12.peak_n_in) << ","
<< std::to_string(entry.coils12.peak_p_out) << ","
<< std::to_string(entry.coils12.peak_n_out) << ","
<< std::string(softStartStatusNames.at(entry.coils12.sstart_status)) << ","
<< std::to_string(entry.coils34.n_events) << ","
<< std::to_string(entry.coils34.spark_delay) << ","
<< std::string(sparkStatusNames.at(entry.coils34.spark_status)) << ","
<< std::to_string(entry.coils34.peak_p_in) << ","
<< std::to_string(entry.coils34.peak_n_in) << ","
<< std::to_string(entry.coils34.peak_p_out) << ","
<< std::to_string(entry.coils34.peak_n_out) << ","
<< std::string(softStartStatusNames.at(entry.coils34.sstart_status)) << ","
<< std::to_string(entry.eng_rpm) << ","
<< std::to_string(entry.adc_read_time) << ","
<< std::to_string(entry.n_queue_errors);
ofs << std::endl;
ofs.flush();
}
ofs.close();
LOG_INFO("Ignition A history saved to LittleFS, records written: ", history.size());
}

18
RotaxMonitor/src/datasave.h
View File

@@ -15,14 +15,6 @@
#include "psvector.h" #include "psvector.h"
const uint32_t max_history = 256; const uint32_t max_history = 256;
const bool SAVE_HISTORY_TO_LITTLEFS = false; // Set to true to enable saving history to LittleFS, false to disable
static bool first_save = true; // flag to indicate if this is the first save (to write header)
struct dataSaveParams
{
const PSRAMVector<ignitionBoxStatus> *history;
const std::filesystem::path file_path;
};
class LITTLEFSGuard class LITTLEFSGuard
{ {
@@ -31,7 +23,7 @@ public:
~LITTLEFSGuard(); ~LITTLEFSGuard();
}; };
class ignitionBoxStatusAverage class ignitionBoxStatusFiltered
{ {
private: private:
ignitionBoxStatus m_last; ignitionBoxStatus m_last;
@@ -40,8 +32,8 @@ private:
bool m_data_valid = false; // flag to indicate if the average data is valid (i.e. at least one sample has been added) bool m_data_valid = false; // flag to indicate if the average data is valid (i.e. at least one sample has been added)
public: public:
ignitionBoxStatusAverage() = default; ignitionBoxStatusFiltered() = default;
ignitionBoxStatusAverage(const uint32_t max_count) : m_max_count(max_count) ignitionBoxStatusFiltered(const uint32_t max_count) : m_max_count(max_count)
{ {
m_data_valid = false; m_data_valid = false;
m_count = 0; m_count = 0;
@@ -56,7 +48,3 @@ private:
void filter(int32_t &old, const int32_t value, const uint32_t k); void filter(int32_t &old, const int32_t value, const uint32_t k);
void filter(float &old, const float value, const uint32_t k); void filter(float &old, const float value, const uint32_t k);
}; };
// Task and function declarations
void saveHistoryTask(void *pvParameters);
void save_history(const PSRAMVector<ignitionBoxStatus> &history, const std::filesystem::path &file_path);

48
RotaxMonitor/src/devices.h
View File

@@ -3,33 +3,53 @@
// Library defines // Library defines
#define ADS1256_SPI_ALREADY_STARTED #define ADS1256_SPI_ALREADY_STARTED
// System Includes
#include <memory>
// Device Libraries // Device Libraries
#include <ADS1256.h> #include <ADS1256.h>
#include <AD5292.h> #include <AD5292.h>
#include <PCA95x5.h> #include <PCA95x5.h>
// ADC Channel mapping // ADC Channel mapping
#define ADC_CH_PEAK_12P_IN SING_0 #define ADC_CH_PEAK_12P_IN SING_0
#define ADC_CH_PEAK_12N_IN SING_1 #define ADC_CH_PEAK_12N_IN SING_1
#define ADC_CH_PEAK_34P_IN SING_2 #define ADC_CH_PEAK_34P_IN SING_2
#define ADC_CH_PEAK_34N_IN SING_3 #define ADC_CH_PEAK_34N_IN SING_3
#define ADC_CH_PEAK_12P_OUT SING_4 #define ADC_CH_PEAK_12P_OUT SING_4
#define ADC_CH_PEAK_12N_OUT SING_5 #define ADC_CH_PEAK_12N_OUT SING_5
#define ADC_CH_PEAK_34P_OUT SING_6 #define ADC_CH_PEAK_34P_OUT SING_6
#define ADC_CH_PEAK_34N_OUT SING_7 #define ADC_CH_PEAK_34N_OUT SING_7
// Device Pointer structs for tasks // Device Pointer structs for tasks
struct Devices { struct Devices
AD5292 *pot_a = NULL, *pot_b = NULL; {
ADS1256 *adc_a = NULL, *adc_b = NULL; std::unique_ptr<SPIClass> m_spi_a = nullptr;
PCA9555* io = NULL; std::unique_ptr<SPIClass> m_spi_b = nullptr;
std::unique_ptr<AD5292> m_pot_a = nullptr;
std::unique_ptr<AD5292> m_pot_b = nullptr;
std::unique_ptr<ADS1256> m_adc_a = nullptr;
std::unique_ptr<ADS1256> m_adc_b = nullptr;
std::unique_ptr<PCA9555> m_expander_a = nullptr;
std::unique_ptr<PCA9555> m_expander_b = nullptr;
std::unique_ptr<PCA9555> m_expander_inputs_ab = nullptr;
std::mutex m_spi_a_mutex;
std::mutex m_spi_b_mutex;
std::mutex m_i2c_mutex;
}; };
// Adc read channel wrapper to selet mux before reading // Adc read channel wrapper to selet mux before reading
inline float adcReadChannel(ADS1256* adc, const uint8_t ch){ inline float adcReadChannel(ADS1256 *adc, const uint8_t ch)
{
adc->setMUX(ch); adc->setMUX(ch);
// scarta 3 conversioni // scarta 3 conversioni
for (int i = 0; i < 3; i++) { for (int i = 0; i < 3; i++)
{
adc->readSingle(); adc->readSingle();
} }
// ora lettura valida a 30kSPS → ~100 µs di settling // ora lettura valida a 30kSPS → ~100 µs di settling

2
RotaxMonitor/src/isr.h
View File

@@ -17,7 +17,7 @@
#define CORE_0 0 #define CORE_0 0
#define CORE_1 1 #define CORE_1 1
#define RT_TASK_STACK 2048 // in words #define RT_TASK_STACK 2048 // in words
#define RT_TASK_PRIORITY (configMAX_PRIORITIES - 6) // highest priority after wifi tasks #define RT_TASK_PRIORITY (configMAX_PRIORITIES - 5) // highest priority after wifi tasks
struct isrParams struct isrParams
{ {

355
RotaxMonitor/src/main.cpp
View File

@@ -18,7 +18,7 @@
// Defines to enable channel B // Defines to enable channel B
#define CH_B_ENABLE #define CH_B_ENABLE
#define TEST // #define TEST
// Debug Defines // Debug Defines
#define WIFI_SSID "AstroRotaxMonitor" #define WIFI_SSID "AstroRotaxMonitor"
@@ -31,7 +31,7 @@ void setup()
// Setup Logger // Setup Logger
LOG_ATTACH_SERIAL(Serial); LOG_ATTACH_SERIAL(Serial);
LOG_SET_LEVEL(DebugLogLevel::LVL_INFO); LOG_SET_LEVEL(DebugLogLevel::LVL_DEBUG);
// Print Processor Info // Print Processor Info
LOG_DEBUG("ESP32 Chip:", ESP.getChipModel()); LOG_DEBUG("ESP32 Chip:", ESP.getChipModel());
@@ -52,6 +52,7 @@ void setup()
IPAddress gateway(10, 11, 12, 1); IPAddress gateway(10, 11, 12, 1);
IPAddress subnet(255, 255, 255, 0); IPAddress subnet(255, 255, 255, 0);
WiFi.softAPConfig(local_IP, gateway, subnet); WiFi.softAPConfig(local_IP, gateway, subnet);
WiFi.setTxPower(WIFI_POWER_13dBm); // reduce wifi power
if (WiFi.softAP(WIFI_SSID, WIFI_PASSWORD)) if (WiFi.softAP(WIFI_SSID, WIFI_PASSWORD))
{ {
LOG_INFO("WiFi AP Mode Started"); LOG_INFO("WiFi AP Mode Started");
@@ -80,84 +81,21 @@ void loop()
RGBled led; RGBled led;
led.setStatus(RGBled::LedStatus::INIT); led.setStatus(RGBled::LedStatus::INIT);
bool running = true; bool running = true;
const uint32_t max_queue = 128; std::mutex fs_mutex;
const uint32_t filter_k = 10; LITTLEFSGuard fsGuard;
PSRAMVector<ignitionBoxStatus> ignA_history_0(max_history); //////// INIT SPI PORTS ////////
PSRAMVector<ignitionBoxStatus> ignA_history_1(max_history);
auto *active_history_A = &ignA_history_0;
auto *writable_history_A = &ignA_history_1;
#ifdef CH_B_ENABLE
PSRAMVector<ignitionBoxStatus> ignB_history_0(max_history);
PSRAMVector<ignitionBoxStatus> ignB_history_1(max_history);
auto *active_history_B = &ignB_history_0;
auto *writable_history_B = &ignB_history_1;
#endif
// Resources Initialization
Devices dev;
// Task handle
TaskHandle_t trigA_TaskHandle = NULL;
TaskHandle_t trigB_TaskHandle = NULL;
// Data Queue for real time task to main loop communication
QueueHandle_t rt_taskA_queue = xQueueCreate(max_queue, sizeof(ignitionBoxStatus));
QueueHandle_t rt_taskB_queue = xQueueCreate(max_queue, sizeof(ignitionBoxStatus));
rtTaskParams taskA_params{
.rt_running = true,
.dev = &dev,
.rt_queue = rt_taskA_queue,
.rt_int = rtTaskInterrupts{
.isr_ptr = &trig_isr_A,
.trig_pin_12p = TRIG_PIN_A12P,
.trig_pin_12n = TRIG_PIN_A12N,
.trig_pin_34p = TRIG_PIN_A34P,
.trig_pin_34n = TRIG_PIN_A34N,
.spark_pin_12 = SPARK_PIN_A12,
.spark_pin_34 = SPARK_PIN_A34},
.rt_resets = rtTaskResets{.rst_io_peak = RST_EXT_PEAK_DETECT_A, .rst_io_sh = RST_EXT_SAMPLE_HOLD_A}};
#ifdef CH_B_ENABLE
rtTaskParams taskB_params{
.rt_running = true,
.dev = &dev,
.rt_queue = rt_taskB_queue,
.rt_int = rtTaskInterrupts{
.isr_ptr = &trig_isr_B,
.trig_pin_12p = TRIG_PIN_B12P,
.trig_pin_12n = TRIG_PIN_B12N,
.trig_pin_34p = TRIG_PIN_B34P,
.trig_pin_34n = TRIG_PIN_B34N,
.spark_pin_12 = SPARK_PIN_B12,
.spark_pin_34 = SPARK_PIN_B34},
.rt_resets = rtTaskResets{.rst_io_peak = RST_EXT_PEAK_DETECT_B, .rst_io_sh = RST_EXT_SAMPLE_HOLD_B}};
#endif
if (!rt_taskA_queue || !rt_taskB_queue)
{
LOG_ERROR("Unable To Create task queues");
LOG_ERROR("5 seconds to restart...");
vTaskDelay(pdMS_TO_TICKS(5000));
esp_restart();
}
else
LOG_DEBUG("Task Variables OK");
// Spi ok flags
bool spiA_ok = true; bool spiA_ok = true;
bool spiB_ok = true; bool spiB_ok = true;
// Init 2 SPI interfaces // Init 2 SPI interfaces
SPIClass SPI_A(FSPI); // SPIClass SPI_A(FSPI);
spiA_ok = SPI_A.begin(SPI_A_SCK, SPI_A_MISO, SPI_A_MOSI); // spiA_ok = SPI_A.begin(SPI_A_SCK, SPI_A_MISO, SPI_A_MOSI);
SPI_A.setDataMode(SPI_MODE1); // ADS1256 requires SPI mode 1 // SPI_A.setDataMode(SPI_MODE1); // ADS1256 requires SPI mode 1
#ifdef CH_B_ENABLE // #ifdef CH_B_ENABLE
#ifndef TEST // SPIClass SPI_B(HSPI);
SPIClass SPI_B(HSPI); // spiB_ok = SPI_B.begin(SPI_B_SCK, SPI_B_MISO, SPI_B_MOSI);
spiB_ok = SPI_B.begin(SPI_B_SCK, SPI_B_MISO, SPI_B_MOSI); // SPI_B.setDataMode(SPI_MODE1); // ADS1256 requires SPI mode 1
SPI_B.setDataMode(SPI_MODE1); // ADS1256 requires SPI mode 1 // #endif
#endif
#endif
if (!spiA_ok || !spiB_ok) if (!spiA_ok || !spiB_ok)
{ {
LOG_ERROR("Unable to Initialize SPI Busses"); LOG_ERROR("Unable to Initialize SPI Busses");
@@ -167,52 +105,92 @@ void loop()
} }
LOG_DEBUG("Init SPI OK"); LOG_DEBUG("Init SPI OK");
#ifndef TEST // Resources Initialization
// Init ADC_A std::shared_ptr<Devices> dev = std::make_shared<Devices>();
dev.adc_a = new ADS1256(ADC_A_DRDY, ADS1256::PIN_UNUSED, ADS1256::PIN_UNUSED, ADC_A_CS, 2.5, &SPI_A); // dev->m_spi_a = std::make_unique<SPIClass>(SPI_A);
dev.adc_a->InitializeADC(); // dev->m_spi_b = std::make_unique<SPIClass>(SPI_B);
dev.adc_a->setPGA(PGA_1);
dev.adc_a->setDRATE(DRATE_7500SPS);
#endif
#ifdef CH_B_ENABLE
#ifndef TEST
// Init ADC_B
dev.adc_a = new ADS1256(ADC_B_DRDY, ADS1256::PIN_UNUSED, ADS1256::PIN_UNUSED, ADC_B_CS, 2.5, &SPI_B);
dev.adc_a->InitializeADC();
dev.adc_a->setPGA(PGA_1);
dev.adc_a->setDRATE(DRATE_1000SPS);
#endif
#endif
LOG_DEBUG("Init ADC OK"); // // Init ADC_A
// dev->m_adc_a = std::make_unique<ADS1256>(ADC_A_DRDY, ADS1256::PIN_UNUSED, ADS1256::PIN_UNUSED, ADC_A_CS, 2.5, &SPI_A);
// dev->m_adc_b = std::make_unique<ADS1256>(ADC_B_DRDY, ADS1256::PIN_UNUSED, ADS1256::PIN_UNUSED, ADC_B_CS, 2.5, &SPI_B);
// dev->m_adc_a->InitializeADC();
// dev->m_adc_a->setPGA(PGA_1);
// dev->m_adc_a->setDRATE(DRATE_7500SPS);
// dev->m_adc_b->InitializeADC();
// dev->m_adc_b->setPGA(PGA_1);
// dev->m_adc_b->setDRATE(DRATE_7500SPS);
const rtIgnitionTask::rtTaskParams taskA_params{
.rt_running = true,
.name = "rtIgnTask_A",
.rt_stack_size = RT_TASK_STACK,
.rt_priority = RT_TASK_PRIORITY,
.rt_int = rtIgnitionTask::rtTaskInterruptParams{
.isr_ptr = &trig_isr_A,
.trig_pin_12p = TRIG_PIN_A12P,
.trig_pin_12n = TRIG_PIN_A12N,
.trig_pin_34p = TRIG_PIN_A34P,
.trig_pin_34n = TRIG_PIN_A34N,
.spark_pin_12 = SPARK_PIN_A12,
.spark_pin_34 = SPARK_PIN_A34},
.rt_io = rtIgnitionTask::rtTaskIOParams{
.pot_cs_12 = POT_CS_A12,
.pot_cs_34 = POT_CS_A34,
.ss_force = SS_FORCE_A,
.ss_inhibit_12 = SS_INIBHIT_A12,
.ss_inhibit_34 = SS_INHIBIT_A34,
.sh_disch_12 = SH_DISCH_A12,
.sh_disch_34 = SH_DISCH_A34,
.sh_arm_12 = SH_ARM_A12,
.sh_arm_34 = SH_ARM_A34,
.relay_in_12 = RELAY_IN_A12,
.relay_in_34 = RELAY_OUT_A12,
.relay_out_12 = RELAY_IN_A34,
.relay_out_34 = RELAY_OUT_A34,
},
.rt_queue = nullptr,
.dev = dev};
const rtIgnitionTask::rtTaskParams taskB_params{
.rt_running = true,
.name = "rtIgnTask_B",
.rt_stack_size = RT_TASK_STACK,
.rt_priority = RT_TASK_PRIORITY,
.rt_int = rtIgnitionTask::rtTaskInterruptParams{
.isr_ptr = &trig_isr_B,
.trig_pin_12p = TRIG_PIN_B12P,
.trig_pin_12n = TRIG_PIN_B12N,
.trig_pin_34p = TRIG_PIN_B34P,
.trig_pin_34n = TRIG_PIN_B34N,
.spark_pin_12 = SPARK_PIN_B12,
.spark_pin_34 = SPARK_PIN_B34},
.rt_io = rtIgnitionTask::rtTaskIOParams{
.pot_cs_12 = POT_CS_B12,
.pot_cs_34 = POT_CS_B34,
.ss_force = SS_FORCE_B,
.ss_inhibit_12 = SS_INIBHIT_B12,
.ss_inhibit_34 = SS_INHIBIT_B34,
.sh_disch_12 = SH_DISCH_B12,
.sh_disch_34 = SH_DISCH_B34,
.sh_arm_12 = SH_ARM_B12,
.sh_arm_34 = SH_ARM_B34,
.relay_in_12 = RELAY_IN_B12,
.relay_in_34 = RELAY_OUT_B12,
.relay_out_12 = RELAY_IN_B34,
.relay_out_34 = RELAY_OUT_B34,
},
.rt_queue = nullptr,
.dev = dev};
auto task_A = rtIgnitionTask(taskA_params, 4096, 256, CORE_0, fs_mutex);
delay(50);
auto task_B = rtIgnitionTask(taskB_params, 4096, 256, CORE_1, fs_mutex);
// Ignition A on Core 0 // Ignition A on Core 0
auto ignA_task_success = pdPASS; auto ignA_task_success = task_A.getStatus() == rtIgnitionTask::OK ? pdPASS : pdFAIL;
ignA_task_success = xTaskCreatePinnedToCore( auto ignB_task_success = task_B.getStatus() == rtIgnitionTask::OK ? pdPASS : pdFAIL;
rtIgnitionTask,
"rtTask_A",
RT_TASK_STACK,
(void *)&taskA_params,
RT_TASK_PRIORITY,
&trigA_TaskHandle,
CORE_0);
delay(100); // give some time to the thread to start
// Ignition B on Core 1
auto ignB_task_success = pdPASS;
#ifdef CH_B_ENABLE
ignB_task_success = xTaskCreatePinnedToCore(
rtIgnitionTask,
"rtTask_B",
RT_TASK_STACK,
(void *)&taskB_params,
RT_TASK_PRIORITY, // priorità leggermente più alta
&trigB_TaskHandle,
CORE_1);
delay(100); // give some time to the thread to start
#endif
if (ignA_task_success != pdPASS || ignB_task_success != pdPASS) if (ignA_task_success != pdPASS || ignB_task_success != pdPASS)
{ {
LOG_ERROR("Unable to initialize ISR task"); LOG_ERROR("Unable to initialize ISR task");
@@ -221,126 +199,51 @@ void loop()
esp_restart(); esp_restart();
} }
const bool tasK_A_rt = task_A.start();
delay(50);
const bool task_B_rt = task_B.start();
if (tasK_A_rt != true || task_B_rt != true)
{
led.setStatus(RGBled::LedStatus::ERROR);
LOG_ERROR("Unable to start realtime tasks");
} else
LOG_DEBUG("Real Time Tasks A & B initialized"); LOG_DEBUG("Real Time Tasks A & B initialized");
led.setStatus(RGBled::LedStatus::OK); led.setStatus(RGBled::LedStatus::OK);
bool partial_save = false; // flag to indicate if a partial save has been done after a timeout AstroWebServer webPage(80, LittleFS); // Initialize webserver and Websocket
auto last_data = millis(); ArduinoJson::JsonDocument json_data;
auto last_info = millis(); bool data_a, data_b;
task_A.onMessage([&webPage, &json_data, &data_a](ignitionBoxStatusFiltered sts){
json_data["box_a"] = sts.toJson();
data_a = true;
});
uint32_t counter_a = 0; task_B.onMessage([&webPage, &json_data, &data_b](ignitionBoxStatusFiltered sts){
uint32_t counter_b = 0; json_data["box_b"] = sts.toJson();
uint32_t wait_count = 0; data_b = true;
});
ignitionBoxStatus ign_info_A; // task_A.enableSave(true, "ignitionA_test.csv");
ignitionBoxStatus ign_info_B; // task_B.enableSave(true, "ignitionB_test.csv");
ignitionBoxStatusAverage ign_info_avg_A(filter_k);
ignitionBoxStatusAverage ign_info_avg_B(filter_k);
LITTLEFSGuard fsGuard;
WebPage webPage(80, LittleFS); // Initialize webserver and Websocket
uint32_t monitor_loop = millis();
uint32_t data_loop = monitor_loop;
//////////////// INNER LOOP ///////////////////// //////////////// INNER LOOP /////////////////////
while (running) while (running)
{ {
auto dataA = pdFALSE; uint32_t this_loop = millis();
auto dataB = pdFALSE; if (this_loop - monitor_loop > 2000)
dataA = xQueueReceive(rt_taskA_queue, &ign_info_A, 0);
if (counter_a >= active_history_A->size()) // not concurrent with write task
{
counter_a = 0;
partial_save = false; // reset partial save flag on new data cycle
swapHistory(active_history_A, writable_history_A);
save_history(*writable_history_A, "ignition_historyA.csv"); // directly call the save task function to save without delay
}
#ifdef CH_B_ENABLE
dataB = xQueueReceive(rt_taskB_queue, &ign_info_B, 0);
if (counter_b >= active_history_B->size()) // not concurrent with write task
{
counter_b = 0;
partial_save = false; // reset partial save flag on new data cycle
swapHistory(active_history_B, writable_history_B);
save_history(*writable_history_B, "ignition_historyB.csv"); // directly call the save task function to save without delay
}
#endif
// Update last data
if (dataA == pdTRUE || dataB == pdTRUE)
last_data = millis();
// Update Led color
if (dataA == pdTRUE && dataB == pdFALSE)
led.setStatus(RGBled::DATA_A);
else if (dataB == pdTRUE && dataA == pdFALSE)
led.setStatus(RGBled::DATA_B);
else
led.setStatus(RGBled::DATA_ALL);
if (dataA == pdTRUE)
{
(*active_history_A)[counter_a++ % active_history_A->size()] = ign_info_A;
ign_info_avg_A.update(ign_info_A); // update moving average with latest ignition status
// Serial.printf("Data Received A: %d/%d\n\r", counter_a, (*active_history_A).size());
if (counter_a % filter_k == 0) // send data every 10 samples
{
ArduinoJson::JsonDocument wsData;
wsData["box_a"] = ign_info_avg_A.toJson();
wsData["box_b"] = JsonObject();
webPage.sendWsData(wsData.as<String>());
}
}
#ifdef CH_B_ENABLE
if (dataB == pdTRUE)
{
(*active_history_B)[counter_b++ % active_history_B->size()] = ign_info_B;
ign_info_avg_B.update(ign_info_B); // update moving average with latest ignition status
// Serial.printf("Data Received B: %d/%d\n\r", counter_b, (*active_history_B).size());
if (counter_b % filter_k == 0) // send data every 10 samples
{
ArduinoJson::JsonDocument wsData;
wsData["box_a"] = JsonObject();
wsData["box_b"] = ign_info_avg_B.toJson();
webPage.sendWsData(wsData.as<String>());
}
}
#endif
if (dataA == pdFALSE && dataB == pdFALSE && (millis() - last_data) > 2000)
{
if (!partial_save && counter_a > 0) // if timeout occurs but we have unsaved data, save it before next timeout
{
active_history_A->resize(counter_a); // resize active history to actual number of records received to avoid saving empty records
save_history(*active_history_A, "ignition_history_A.csv");
active_history_A->resize(max_history); // resize back to max history size for next data cycle
#ifdef CH_B_ENABLE
active_history_B->resize(counter_a); // resize active history to actual number of records received to avoid saving empty records
save_history(*active_history_B, "ignition_history_B.csv");
active_history_B->resize(max_history); // resize back to max history size for next data cycle
#endif
counter_a = 0; // reset counter after saving
counter_b = 0; // reset counter after saving
partial_save = true;
first_save = true;
}
// Serial.printf("[%d] Waiting for data...\r", wait_count++);
led.setStatus(RGBled::LedStatus::IDLE);
delay(100);
}
if ((millis() - last_info) > 1000)
{ {
clearScreen(); clearScreen();
Serial.println();
printRunningTasksMod(Serial); printRunningTasksMod(Serial);
last_info = millis(); monitor_loop = millis();
}
if ((data_a && data_b) || (this_loop - data_loop > 500)) {
webPage.sendWsData(json_data.as<String>());
json_data.clear();
data_a = data_b = false;
data_loop = millis();
} }
} //////////////// INNER LOOP ///////////////////// } //////////////// INNER LOOP /////////////////////
if (trigA_TaskHandle)
vTaskDelete(trigA_TaskHandle);
if (trigB_TaskHandle)
vTaskDelete(trigB_TaskHandle);
} ////////////////////// MAIN LOOP ////////////////////// } ////////////////////// MAIN LOOP //////////////////////

85
RotaxMonitor/src/pins.h
View File

@@ -80,31 +80,86 @@
#define SPARK_PIN_B34 2 #define SPARK_PIN_B34 2
// ===================== // =====================
// PCA9555 (I2C EXPANDER) // PCA9555 I/O EXPANDER BOX_A
// ===================== // =====================
// --- RESET LINES --- #define EXPANDER_A_ADDR 0x010101
#define RST_EXT_PEAK_DETECT_A 0
#define RST_EXT_SAMPLE_HOLD_A 1 // --- DIGITAL POT CHIP SELECT LINES ---
#define RST_EXT_PEAK_DETECT_B 2 #define POT_CS_A12 0
#define RST_EXT_SAMPLE_HOLD_B 3 #define POT_CS_A34 1
#define BTN_3 4
#define BTN_4 5 // --- SOFT START FORCE LINES ---
#define BTN_5 6 #define SS_FORCE_A 2
#define BTN_6 7 #define SS_INIBHIT_A12 3
#define SS_INHIBIT_A34 4
// --- SAMPLE AND HOLD ARM AND DISCHARGE ---
#define SH_DISCH_A12 5
#define SH_DISCH_A34 6
#define SH_ARM_A12 7
#define SH_ARM_A34 8
// --- RELAY --- // --- RELAY ---
#define EXT_RELAY_A 8 #define RELAY_IN_A12 9
#define EXT_RELAY_B 9 #define RELAY_OUT_A12 10
#define RELAY_IN_A34 11
#define RELAY_OUT_A34 12
// --- STATUS / BUTTON --- // --- STATUS / BUTTON ---
#define BTN_7 10
#define BTN_8 11
#define STA_1 12
#define STA_2 13 #define STA_2 13
#define STA_3 14 #define STA_3 14
#define STA_4 15 #define STA_4 15
// =====================
// PCA9555 I/O EXPANDER BOX_B
// =====================
#define EXPANDER_B_ADDR 0x101010
// --- DIGITAL POT CHIP SELECT LINES ---
#define POT_CS_B12 0
#define POT_CS_B34 1
// --- SOFT START FORCE LINES ---
#define SS_FORCE_B 2
#define SS_INIBHIT_B12 3
#define SS_INHIBIT_B34 4
// --- SAMPLE AND HOLD ARM AND DISCHARGE ---
#define SH_DISCH_B12 5
#define SH_DISCH_B34 6
#define SH_ARM_B12 7
#define SH_ARM_B34 8
// --- RELAY ---
#define RELAY_IN_B12 9
#define RELAY_OUT_B12 10
#define RELAY_IN_B34 11
#define RELAY_OUT_B34 12
// --- STATUS / BUTTON ---
#define STA_2 13
#define STA_3 14
#define STA_4 15
// =====================
// PCA9555 I/O EXPANDER INPUTS A+B
// =====================
#define EXPANDER_IN_ADDR 0x0a0a0a
#define SS_A12_ON
#define SS_A12_OFF
#define SS_A34_ON
#define SS_A34_OFF
#define SS_B12_ON
#define SS_B12_OFF
#define SS_B34_ON
#define SS_B34_OFF
// Init Pin Functions // Init Pin Functions
inline void initTriggerPinsInputs() inline void initTriggerPinsInputs()
{ {

2
RotaxMonitor/src/pins_test.h
View File

@@ -65,7 +65,7 @@
#define RST_EXT_A34N 3 #define RST_EXT_A34N 3
// --- RELAY --- // --- RELAY ---
#define EXT_RELAY_A 8 #define SH_ARM_A34 8
// Init Pin Functions // Init Pin Functions

288
RotaxMonitor/src/tasks.cpp
View File

@@ -1,5 +1,8 @@
#include "tasks.h" #include "tasks.h"
#include <esp_timer.h> #include <esp_timer.h>
#include <datasave.h>
//// GLOBAL STATIC FUNCTIONS
// Timeout callback for microsecond precision // Timeout callback for microsecond precision
void spark_timeout_callback(void *arg) void spark_timeout_callback(void *arg)
@@ -8,7 +11,18 @@ void spark_timeout_callback(void *arg)
xTaskNotify(handle, SPARK_FLAG_TIMEOUT, eSetValueWithOverwrite); xTaskNotify(handle, SPARK_FLAG_TIMEOUT, eSetValueWithOverwrite);
} }
void rtIgnitionTask(void *pvParameters) // Manages queue receive, save data and callback to external tasks for communication
void rtIgnitionTask::rtIgnitionTask_manager(void *pvParameters)
{
rtIgnitionTask *cls = (rtIgnitionTask *)pvParameters;
while (cls->m_running)
{
cls->run();
}
}
// Static task function
void rtIgnitionTask::rtIgnitionTask_realtime(void *pvParameters)
{ {
// Invalid real time rt_task_ptr parameters, exit immediate // Invalid real time rt_task_ptr parameters, exit immediate
@@ -18,15 +32,14 @@ void rtIgnitionTask(void *pvParameters)
vTaskDelete(NULL); vTaskDelete(NULL);
} }
// Task Parameters and Devices // Task Parameters and Devices
rtTaskParams *params = (rtTaskParams *)pvParameters; rtTaskParams *params = (rtTaskParams *)pvParameters;
const rtTaskInterrupts rt_int = params->rt_int; // copy to avoid external override const rtTaskInterruptParams rt_int = params->rt_int; // copy to avoid external override
const rtTaskResets rt_rst = params->rt_resets; // copy to avoid external override const rtTaskIOParams rt_rst = params->rt_io; // copy to avoid external override
QueueHandle_t rt_queue = params->rt_queue; QueueHandle_t rt_queue = params->rt_queue;
Devices *dev = params->dev; Devices *dev = params->dev.get();
ADS1256 *adc = dev->adc_a; ADS1256 *adc = dev->m_adc_a.get();
PCA9555 *io = dev->io; PCA9555 *io = dev->m_expander_a.get();
TaskStatus_t rt_task_info; TaskStatus_t rt_task_info;
vTaskGetInfo(NULL, &rt_task_info, pdFALSE, eInvalid); vTaskGetInfo(NULL, &rt_task_info, pdFALSE, eInvalid);
@@ -75,7 +88,6 @@ void rtIgnitionTask(void *pvParameters)
.name = "spark_timeout"}; .name = "spark_timeout"};
esp_timer_create(&timer_args, &timeout_timer); esp_timer_create(&timer_args, &timeout_timer);
// Attach Pin Interrupts // Attach Pin Interrupts
attachInterruptArg(digitalPinToInterrupt(rt_int.trig_pin_12p), rt_int.isr_ptr, (void *)&isr_params_t12p, RISING); attachInterruptArg(digitalPinToInterrupt(rt_int.trig_pin_12p), rt_int.isr_ptr, (void *)&isr_params_t12p, RISING);
attachInterruptArg(digitalPinToInterrupt(rt_int.trig_pin_12n), rt_int.isr_ptr, (void *)&isr_params_t12n, RISING); attachInterruptArg(digitalPinToInterrupt(rt_int.trig_pin_12n), rt_int.isr_ptr, (void *)&isr_params_t12n, RISING);
@@ -235,17 +247,13 @@ void rtIgnitionTask(void *pvParameters)
ign_box_sts.adc_read_time = (int32_t)(esp_timer_get_time() - start_adc_read); ign_box_sts.adc_read_time = (int32_t)(esp_timer_get_time() - start_adc_read);
} }
else // simulate adc read timig else // simulate adc read timig
vTaskDelay(pdMS_TO_TICKS(1)); vTaskDelay(pdMS_TO_TICKS(c_adc_time));
// reset peak detectors + sample and hold // reset peak detectors + sample and hold
// outputs on io expander // outputs on io expander
if (io) if (io)
{ {
const uint16_t iostat = io->read(); // [TODO] code to reset sample and hold and arm trigger level detectors
const uint16_t rst_bitmask = (0x0001 << rt_rst.rst_io_peak);
io->write(iostat | rst_bitmask);
vTaskDelay(pdMS_TO_TICKS(1));
io->write(iostat & ~rst_bitmask);
} }
else else
vTaskDelay(pdMS_TO_TICKS(1)); vTaskDelay(pdMS_TO_TICKS(1));
@@ -261,7 +269,7 @@ void rtIgnitionTask(void *pvParameters)
} }
// Delete the timeout timer // Delete the timeout timer
esp_timer_delete(timeout_timer); esp_timer_delete(timeout_timer);
LOG_WARN("Ending realTime Task"); LOG_WARN("rtTask Ending [", rt_task_name, "]");
// Ignition A Interrupts DETACH // Ignition A Interrupts DETACH
detachInterrupt(rt_int.trig_pin_12p); detachInterrupt(rt_int.trig_pin_12p);
detachInterrupt(rt_int.trig_pin_12n); detachInterrupt(rt_int.trig_pin_12n);
@@ -272,3 +280,253 @@ void rtIgnitionTask(void *pvParameters)
// delete present task // delete present task
vTaskDelete(NULL); vTaskDelete(NULL);
} }
///////////// CLASS MEMBER DEFINITIONS /////////////
rtIgnitionTask::rtIgnitionTask(const rtTaskParams params, const uint32_t history_size, const uint32_t queue_size, const uint8_t core, std::mutex &fs_mutex, fs::FS &filesystem) : m_params(params), m_filesystem(filesystem), m_fs_mutex(fs_mutex), m_core(core), m_max_history(history_size)
{
// create queue buffers
m_queue = xQueueCreate(queue_size, sizeof(ignitionBoxStatus));
if (!m_queue)
{
LOG_ERROR("Unable To Create Task [", params.name.c_str(), "] queues");
m_manager_status = rtTaskStatus::ERROR;
return;
}
else
m_params.rt_queue = m_queue;
// create PSram history vectors
m_history_0 = PSHistory(history_size);
m_history_1 = PSHistory(history_size);
// assing active and writable history
m_active_history = std::unique_ptr<PSHistory>(&m_history_0);
m_save_history = std::unique_ptr<PSHistory>(&m_history_1);
LOG_WARN("Starting Manager for [", m_params.name.c_str(), "]");
// auto task_success = pdPASS;
auto task_success = xTaskCreatePinnedToCore(
rtIgnitionTask_manager,
(std::string("man_") + m_params.name).c_str(),
8192,
(void *)this,
m_params.rt_priority >> 2,
&m_manager_handle,
m_core);
if (task_success != pdPASS)
{
LOG_ERROR("Unable To Create Manager for [", params.name.c_str(), "]");
m_manager_status = rtTaskStatus::ERROR;
return;
}
// average every 10 samples
m_info_filtered = ignitionBoxStatusFiltered(10);
m_last_data = millis();
m_manager_status = rtTaskStatus::OK;
}
rtIgnitionTask::~rtIgnitionTask()
{
if (m_rt_handle)
vTaskDelete(m_rt_handle);
if (m_manager_handle)
vTaskDelete(m_manager_handle);
if (m_queue)
vQueueDelete(m_queue);
}
void rtIgnitionTask::run()
{
// receive new data from the queue
auto new_data = xQueueReceive(m_queue, &m_last_status, 0); // non blocking receive
if (new_data == pdPASS)
{
m_last_data = millis();
m_manager_status = rtTaskStatus::RUNNING;
// if history buffer is full swap buffers and if enabled save history buffer
if (m_counter_status >= m_active_history->size())
{
LOG_DEBUG("Save for Buffer Full: ", m_counter_status);
m_counter_status = 0;
m_partial_save = false; // reset partial save flag on new data cycle
std::swap(m_active_history, m_save_history);
if (m_enable_save)
saveHistory(*m_save_history, m_history_path); // directly call the save task function to save without delay
}
// update filtered data
m_info_filtered.update(m_last_status);
(*m_active_history)[m_counter_status] = m_last_status;
if (m_on_message_cb && m_counter_status % 10 == 0)
{
m_on_message_cb(m_info_filtered);
}
// update data counter
m_counter_status++;
}
else
{
if (millis() - m_last_data > c_idle_time)
{
if (m_counter_status > 0 && !m_partial_save)
{
LOG_DEBUG("Save Partial: ", m_counter_status);
m_active_history->resize(m_counter_status);
saveHistory(*m_active_history, m_history_path);
m_active_history->resize(m_max_history);
m_counter_status = 0;
m_partial_save = true;
}
m_manager_status = rtTaskStatus::IDLE;
}
delay(5); // yeld to another task
}
}
const bool rtIgnitionTask::start()
{
LOG_WARN("Starting rtTask [", m_params.name.c_str(), "]");
auto task_success = xTaskCreatePinnedToCore(
rtIgnitionTask_realtime,
m_params.name.c_str(),
m_params.rt_stack_size,
(void *)&m_params,
m_params.rt_priority,
&m_rt_handle,
m_core);
const bool success = task_success == pdPASS && m_rt_handle != nullptr;
if (success)
m_manager_status = rtTaskStatus::IDLE;
return success;
}
const bool rtIgnitionTask::stop()
{
LOG_WARN("Ending Task [", m_params.name.c_str(), "]");
if (m_rt_handle)
{
m_params.rt_running = false;
m_rt_handle = nullptr;
m_manager_status = rtTaskStatus::STOPPED;
return true;
}
return false;
}
const ignitionBoxStatus rtIgnitionTask::getLast() const
{
return m_last_status;
}
const ignitionBoxStatusFiltered rtIgnitionTask::getFiltered() const
{
return m_info_filtered;
}
const rtIgnitionTask::rtTaskStatus rtIgnitionTask::getStatus() const
{
return m_manager_status;
}
void rtIgnitionTask::enableSave(const bool enable, const std::filesystem::path filename)
{
m_enable_save = enable;
if (enable && !filename.empty())
{
LOG_WARN("Save History Enabled Task [", m_params.name.c_str(), "]");
m_history_path = m_filesystem.mountpoint() / filename;
}
else
{
LOG_WARN("Save History Disabled Task [", m_params.name.c_str(), "]");
}
}
void rtIgnitionTask::onMessage(std::function<void(ignitionBoxStatusFiltered)> callaback)
{
m_on_message_cb = callaback;
}
void rtIgnitionTask::saveHistory(const rtIgnitionTask::PSHistory &history, const std::filesystem::path &file_name)
{
// Lock filesystem mutex to avoid concurrent access
std::lock_guard<std::mutex> fs_lock(m_fs_mutex);
// Check for free space
if (LittleFS.totalBytes() - LittleFS.usedBytes() < history.size() * sizeof(ignitionBoxStatus)) // check if at least 1MB is free for saving history
{
LOG_ERROR("Not enough space in SPIFFS to save history");
return;
}
// create complete file path
const std::filesystem::path mount_point = std::filesystem::path(m_filesystem.mountpoint());
std::filesystem::path file_path = file_name;
if (file_name.root_path() != mount_point)
file_path = mount_point / file_name;
// if firt save remove old file and create new
auto save_flags = std::ios::out;
if (m_first_save)
{
save_flags |= std::ios::trunc; // overwrite existing file
m_filesystem.remove(file_path.c_str()); // ensure file is removed before saving to avoid issues with appending to existing file in SPIFFS
LOG_INFO("Saving history to Flash, new file:", file_path.c_str());
}
else // else append to existing file
{
save_flags |= std::ios::app; // append to new file
LOG_INFO("Saving history to Flash, appending to existing file:", file_path.c_str());
}
std::ofstream ofs(file_path, save_flags);
if (ofs.fail())
{
LOG_ERROR("Failed to open file for writing");
return;
}
// write csv header
if (m_first_save)
{
ofs << "TS,EVENTS_12,DLY_12,STAT_12,V_12_1,V_12_2,V_12_3,V_12_4,IGNITION_MODE_12,"
<< "EVENTS_34,DLY_34,STAT_34,V_34_1,V_34_2,V_34_3,V_34_4,IGNITION_MODE_34,"
<< "ENGINE_RPM,ADC_READTIME,N_QUEUE_ERRORS"
<< std::endl;
ofs.flush();
m_first_save = false;
}
for (const auto &entry : history)
{
ofs << std::to_string(entry.timestamp) << ","
<< std::to_string(entry.coils12.n_events) << ","
<< std::to_string(entry.coils12.spark_delay) << ","
<< std::string(sparkStatusNames.at(entry.coils12.spark_status)) << ","
<< std::to_string(entry.coils12.peak_p_in) << ","
<< std::to_string(entry.coils12.peak_n_in) << ","
<< std::to_string(entry.coils12.peak_p_out) << ","
<< std::to_string(entry.coils12.peak_n_out) << ","
<< std::string(softStartStatusNames.at(entry.coils12.sstart_status)) << ","
<< std::to_string(entry.coils34.n_events) << ","
<< std::to_string(entry.coils34.spark_delay) << ","
<< std::string(sparkStatusNames.at(entry.coils34.spark_status)) << ","
<< std::to_string(entry.coils34.peak_p_in) << ","
<< std::to_string(entry.coils34.peak_n_in) << ","
<< std::to_string(entry.coils34.peak_p_out) << ","
<< std::to_string(entry.coils34.peak_n_out) << ","
<< std::string(softStartStatusNames.at(entry.coils34.sstart_status)) << ","
<< std::to_string(entry.eng_rpm) << ","
<< std::to_string(entry.adc_read_time) << ","
<< std::to_string(entry.n_queue_errors);
ofs << std::endl;
ofs.flush();
}
ofs.close();
LOG_INFO("Ignition Box history saved to Flash, records written: ", history.size());
}

150
RotaxMonitor/src/tasks.h
View File

@@ -2,12 +2,19 @@
#define DEBUGLOG_DEFAULT_LOG_LEVEL_DEBUG #define DEBUGLOG_DEFAULT_LOG_LEVEL_DEBUG
// Serial debug flag // Serial debug flag
//#define DEBUG // #define DEBUG
// Arduino Libraries // Arduino Libraries
#include <Arduino.h> #include <Arduino.h>
#include <DebugLog.h> #include <DebugLog.h>
#include "utils.h" #include "utils.h"
#include <memory>
#include <mutex>
#include <filesystem>
#include <FS.h>
#include <LittleFS.h>
#include <datasave.h>
#include <functional>
// ISR // ISR
#include "isr.h" #include "isr.h"
@@ -31,33 +38,122 @@ static const std::map<const uint32_t, const char *> names = {
}; };
#endif #endif
// RT task Interrupt parameters class rtIgnitionTask
struct rtTaskInterrupts
{ {
void (*isr_ptr)(void *); using PSHistory = PSRAMVector<ignitionBoxStatus>;
const uint8_t trig_pin_12p;
const uint8_t trig_pin_12n;
const uint8_t trig_pin_34p;
const uint8_t trig_pin_34n;
const uint8_t spark_pin_12;
const uint8_t spark_pin_34;
};
// RT Task Peak Detector Reset pins public:
struct rtTaskResets // RT task Interrupt parameters
{ struct rtTaskInterruptParams
const uint8_t rst_io_peak; {
const uint8_t rst_io_sh; void (*isr_ptr)(void *);
}; const uint8_t trig_pin_12p;
const uint8_t trig_pin_12n;
const uint8_t trig_pin_34p;
const uint8_t trig_pin_34n;
const uint8_t spark_pin_12;
const uint8_t spark_pin_34;
};
// RT task parameters // RT Task Peak Detector Reset pins
struct rtTaskParams struct rtTaskIOParams
{ {
bool rt_running; // run flag, false to terminate const uint32_t expander_addr;
Devices *dev; const uint8_t pot_cs_12;
const QueueHandle_t rt_queue; const uint8_t pot_cs_34;
const rtTaskInterrupts rt_int; // interrupt pins to attach const uint8_t ss_force;
const rtTaskResets rt_resets; // reset ping for peak detectors const uint8_t ss_inhibit_12;
}; const uint8_t ss_inhibit_34;
const uint8_t sh_disch_12;
const uint8_t sh_disch_34;
const uint8_t sh_arm_12;
const uint8_t sh_arm_34;
const uint8_t relay_in_12;
const uint8_t relay_in_34;
const uint8_t relay_out_12;
const uint8_t relay_out_34;
};
void rtIgnitionTask(void *pvParameters); // RT task parameters
struct rtTaskParams
{
bool rt_running; // run flag, false to terminate
const std::string name;
const uint32_t rt_stack_size;
const uint32_t rt_priority;
const rtTaskInterruptParams rt_int; // interrupt pins to attach
const rtTaskIOParams rt_io; // reset ping for peak detectors
QueueHandle_t rt_queue; // queue for task io
const std::shared_ptr<Devices> dev;
};
enum rtTaskStatus
{
INIT,
OK,
ERROR,
RUNNING,
IDLE,
STOPPED
};
public:
rtIgnitionTask(const rtTaskParams params, const uint32_t history_size, const uint32_t queue_size, const uint8_t core, std::mutex &fs_mutex, fs::FS &filesystem = LittleFS);
~rtIgnitionTask();
void run();
const bool start();
const bool stop();
const ignitionBoxStatus getLast() const;
const ignitionBoxStatusFiltered getFiltered() const;
const rtTaskStatus getStatus() const;
void enableSave(const bool enable, const std::filesystem::path filename);
void onMessage(std::function<void(ignitionBoxStatusFiltered)> callaback);
private:
void saveHistory(const rtIgnitionTask::PSHistory &history, const std::filesystem::path &file_name);
private: // static functions for FreeRTOS
static void rtIgnitionTask_manager(void *pvParameters);
static void rtIgnitionTask_realtime(void *pvParameters);
private:
bool m_running = true;
rtTaskStatus m_manager_status = INIT;
rtTaskParams m_params;
const uint8_t m_core;
TaskHandle_t m_rt_handle = nullptr;
TaskHandle_t m_manager_handle = nullptr;
QueueHandle_t m_queue = nullptr;
bool m_enable_save = false;
std::filesystem::path m_history_path;
const uint32_t m_max_history;
PSHistory m_history_0;
PSHistory m_history_1;
std::unique_ptr<PSHistory> m_active_history;
std::unique_ptr<PSHistory> m_save_history;
fs::FS &m_filesystem;
std::mutex &m_fs_mutex;
bool m_partial_save = false;
bool m_first_save = true;
uint32_t m_counter_status = 0;
uint32_t m_last_data = 0;
ignitionBoxStatus m_last_status;
ignitionBoxStatusFiltered m_info_filtered;
std::function<void(ignitionBoxStatusFiltered)> m_on_message_cb = nullptr;
static const uint32_t c_idle_time = 10000; // in mS
static const uint32_t c_spark_timeout_max = 500; // uS
static const uint8_t c_adc_time = 4; // in mS
static const uint8_t c_io_time = 2; // in mS
};

120
RotaxMonitor/src/utils.cpp
View File

@@ -5,25 +5,69 @@
#include "freertos/FreeRTOS.h" #include "freertos/FreeRTOS.h"
#include "freertos/portable.h" #include "freertos/portable.h"
#include "esp_heap_caps.h"
#include "esp_system.h"
#include "esp_spi_flash.h"
#include "esp_partition.h"
#include "LittleFS.h"
#include <vector> #include <vector>
#include <algorithm> #include <algorithm>
#include <functional> #include <functional>
#define FREERTOS_TASK_NUMBER_MAX_NUM 256 // RunTime stats for how many Tasks to be stored #define FREERTOS_TASK_NUMBER_MAX_NUM 256 // RunTime stats for how many Tasks to be stored
std::string printBits(uint32_t value) { std::string printBits(uint32_t value)
{
std::string result; std::string result;
for (int i = 31; i >= 0; i--) { for (int i = 31; i >= 0; i--)
{
// ottieni il singolo bit // ottieni il singolo bit
result += ((value >> i) & 1) ? '1' : '0'; result += ((value >> i) & 1) ? '1' : '0';
// aggiungi uno spazio ogni 8 bit, tranne dopo l'ultimo // aggiungi uno spazio ogni 8 bit, tranne dopo l'ultimo
if (i % 8 == 0 && i != 0) { if (i % 8 == 0 && i != 0)
{
result += ' '; result += ' ';
} }
} }
return result; return result;
} }
// ANSI colors
#define BAR_WIDTH 30
#define COLOR_RESET "\033[0m"
#define COLOR_RED "\033[31m"
#define COLOR_GREEN "\033[32m"
#define COLOR_BLUE "\033[34m"
#define COLOR_MAGENTA "\033[35m"
#define COLOR_CYAN "\033[36m"
#define COLOR_YELLOW "\033[33m"
#define COLOR_WHITE "\033[37m"
#define COLOR_LBLUE "\033[94m"
void printBar(Print &printer, const char *label, size_t used, size_t total, const char *color)
{
float perc = total > 0 ? ((float)used / total) : 0;
int filled = perc * BAR_WIDTH;
printer.printf("%s%-12s [" COLOR_RESET, color, label);
for (int i = 0; i < BAR_WIDTH; i++)
{
if (i < filled)
printer.printf("%s#%s", color, COLOR_RESET);
else
printer.printf("-");
}
printer.printf("] %s%6.2f%%%s (%5.3f/%5.3f)MB\n",
color,
perc * 100.0,
COLOR_RESET,
(used / 1024.0f / 1024.0f),
(total / 1024.0f / 1024.0f));
}
void printRunningTasksMod(Print &printer, std::function<bool(const TaskStatus_t &a, const TaskStatus_t &b)> orderBy) void printRunningTasksMod(Print &printer, std::function<bool(const TaskStatus_t &a, const TaskStatus_t &b)> orderBy)
{ {
static const char *taskStates[] = {"Running", "Ready", "Blocked", "Suspended", "Deleted", "Invalid"}; static const char *taskStates[] = {"Running", "Ready", "Blocked", "Suspended", "Deleted", "Invalid"};
@@ -53,6 +97,75 @@ void printRunningTasksMod(Print &printer, std::function<bool(const TaskStatus_t
ulCurrentRunTime = ulTotalRunTime - ulLastRunTime; ulCurrentRunTime = ulTotalRunTime - ulLastRunTime;
ulLastRunTime = ulTotalRunTime; ulLastRunTime = ulTotalRunTime;
// PRINT MEMORY INFO
printer.printf("\033[H");
printer.printf(COLOR_LBLUE "=================== ESP32 SYSTEM MONITOR ===================\n" COLOR_RESET);
std::string buffer;
time_t now = time(nullptr);
struct tm *t = localtime(&now);
buffer.resize(64);
strftime(buffer.data(), sizeof(buffer), "%Y-%m-%d %H:%M:%S", t);
printer.printf(COLOR_YELLOW "=============== Datetime: %s ===============\n\n" COLOR_RESET, buffer.c_str());
// ===== HEAP =====
size_t freeHeap = esp_get_free_heap_size();
size_t totalHeap = heap_caps_get_total_size(MALLOC_CAP_DEFAULT);
printBar(printer, "HEAP", totalHeap - freeHeap, totalHeap, COLOR_GREEN);
// ===== RAM INTERNA =====
size_t freeInternal = heap_caps_get_free_size(MALLOC_CAP_INTERNAL);
size_t totalInternal = heap_caps_get_total_size(MALLOC_CAP_INTERNAL);
printBar(printer, "INTERNAL", totalInternal - freeInternal, totalInternal, COLOR_BLUE);
// ===== PSRAM =====
size_t totalPsram = heap_caps_get_total_size(MALLOC_CAP_SPIRAM);
if (totalPsram > 0)
{
size_t freePsram = heap_caps_get_free_size(MALLOC_CAP_SPIRAM);
printBar(printer, "PSRAM", totalPsram - freePsram, totalPsram, COLOR_MAGENTA);
}
printer.printf("\n");
// ===== FLASH APP (approssimato) =====
const esp_partition_t *app_partition =
esp_partition_find_first(ESP_PARTITION_TYPE_APP,
ESP_PARTITION_SUBTYPE_APP_FACTORY,
NULL);
if (app_partition)
{
size_t totalAPP = app_partition->size; // dimensione reale partizione
size_t sketchSize = ESP.getSketchSize();
printBar(printer, "FLASH APP", sketchSize, totalAPP, COLOR_CYAN);
}
else
{
printer.printf(COLOR_YELLOW "%-12s [NOT FOUND]\n" COLOR_RESET, "FLASH APP");
}
// ===== LITTLEFS (corretto con partition table) =====
const esp_partition_t *fs_partition =
esp_partition_find_first(ESP_PARTITION_TYPE_DATA,
ESP_PARTITION_SUBTYPE_DATA_LITTLEFS,
"littlefs");
if (fs_partition)
{
size_t totalFS = fs_partition->size; // dimensione reale partizione
size_t usedFS = LittleFS.usedBytes(); // spazio usato reale
printBar(printer, "LITTLEFS", usedFS, totalFS, COLOR_YELLOW);
}
else
{
printer.printf(COLOR_YELLOW "%-12s [NOT FOUND]\n" COLOR_RESET, "LITTLEFS");
}
// ===== MIN HEAP =====
size_t minHeap = esp_get_minimum_free_heap_size();
printer.printf("%s\nMin Heap Ever:%s %u KB\n\n", COLOR_RED, COLOR_RESET, minHeap / 1024);
// Print Runtime Information // Print Runtime Information
printer.printf("Tasks: %u, Runtime: %lus, Period: %luus\r\n", uxArraySize, ulTotalRunTime / 1000000, ulCurrentRunTime); printer.printf("Tasks: %u, Runtime: %lus, Period: %luus\r\n", uxArraySize, ulTotalRunTime / 1000000, ulCurrentRunTime);
@@ -79,4 +192,3 @@ void printRunningTasksMod(Print &printer, std::function<bool(const TaskStatus_t
} }
printer.println(); printer.println();
} }

122
RotaxMonitor/src/webserver.cpp
View File

@@ -1,7 +1,22 @@
#include <webserver.h> #include <webserver.h>
#include <ArduinoJson.h>
WebPage::WebPage(const uint8_t port, fs::FS &filesystem) : m_port(port), m_webserver(AsyncWebServer(port)), m_websocket(AsyncWebSocket("/ws")), m_filesystem(filesystem) static std::map<const std::string, AstroWebServer::c_commandEnum> s_webserverCommands = {
{"setTime", AstroWebServer::SET_TIME},
};
void on_ping(TimerHandle_t xTimer)
{ {
if (!xTimer)
return;
auto ws = (AsyncWebSocket *)pvTimerGetTimerID(xTimer);
ws->pingAll();
ws->cleanupClients();
}
AstroWebServer::AstroWebServer(const uint8_t port, fs::FS &filesystem) : m_port(port), m_webserver(AsyncWebServer(port)), m_websocket(AsyncWebSocket("/ws")), m_filesystem(filesystem)
{
LOG_DEBUG("Initializing Web Server");
m_websocket.onEvent([this](AsyncWebSocket *server, AsyncWebSocketClient *client, m_websocket.onEvent([this](AsyncWebSocket *server, AsyncWebSocketClient *client,
AwsEventType type, void *arg, uint8_t *data, size_t len) AwsEventType type, void *arg, uint8_t *data, size_t len)
{ onWsEvent(server, client, type, arg, data, len); }); { onWsEvent(server, client, type, arg, data, len); });
@@ -9,61 +24,114 @@ WebPage::WebPage(const uint8_t port, fs::FS &filesystem) : m_port(port), m_webse
m_webserver.addHandler(&m_websocket); m_webserver.addHandler(&m_websocket);
m_webserver.serveStatic("/", m_filesystem, "/").setDefaultFile("index.html"); m_webserver.serveStatic("/", m_filesystem, "/").setDefaultFile("index.html");
m_webserver.on("/upload", HTTP_POST, m_webserver.on("/upload", HTTP_POST, [this](AsyncWebServerRequest *request)
[this](AsyncWebServerRequest *request) { onUploadRequest(request); }, [this](AsyncWebServerRequest *request, const String &filename, size_t index, uint8_t *data, size_t len, bool final)
{ onUploadRequest(request); }, { onUploadHandler(request, filename, index, data, len, final); });
[this](AsyncWebServerRequest *request, const String &filename, size_t index, uint8_t *data, size_t len, bool final)
{ onUploadHandler(request, filename, index, data, len, final); }
);
m_webserver.begin(); m_webserver.begin();
m_websocket.enable(true);
m_pingTimer = xTimerCreate("wsPingTimer", pdMS_TO_TICKS(2000), pdTRUE, (void *)&m_websocket, on_ping);
LOG_DEBUG("Webserver Init OK");
} }
WebPage::~WebPage() AstroWebServer::~AstroWebServer()
{ {
xTimerDelete(m_pingTimer, pdMS_TO_TICKS(10));
m_webserver.removeHandler(&m_websocket); m_webserver.removeHandler(&m_websocket);
m_webserver.end(); m_webserver.end();
} }
void WebPage::sendWsData(const String &data){ void AstroWebServer::sendWsData(const String &data)
if (m_websocket.count()){ {
if (m_websocket.count())
{
m_websocket.textAll(data); m_websocket.textAll(data);
} }
} }
void WebPage::onWsEvent(AsyncWebSocket *server, AsyncWebSocketClient *client, AwsEventType type, void *arg, uint8_t *data, size_t len) void AstroWebServer::onWsEvent(AsyncWebSocket *server, AsyncWebSocketClient *client, AwsEventType type, void *arg, uint8_t *data, size_t len)
{ {
switch (type) switch (type)
{ {
case WS_EVT_CONNECT: case WS_EVT_CONNECT:
Serial.printf("WS client IP[%s]-ID[%u] CONNECTED\r\n", client->remoteIP().toString().c_str(), client->id()); LOG_DEBUG("WS client IP[", client->remoteIP().toString().c_str(), "]-ID[", client->id(), "] CONNECTED");
break; break;
case WS_EVT_DISCONNECT: case WS_EVT_DISCONNECT:
Serial.printf("WS client ID[%u] DISCONNECTED\r\n", client->remoteIP().toString().c_str(), client->id()); LOG_DEBUG("WS client IP[", client->remoteIP().toString().c_str(), "]-ID[", client->id(), "] DISCONNECTED");
break; break;
case WS_EVT_PONG:
LOG_DEBUG("WS client IP[", client->remoteIP().toString().c_str(), "]-ID[", client->id(), "] PONG");
break;
case WS_EVT_DATA:
{
AwsFrameInfo *info = (AwsFrameInfo *)arg;
if (info->final && info->index == 0 && info->len == len)
{
std::string data_str((char *)data, len);
ArduinoJson::JsonDocument doc;
if (auto rv = ArduinoJson::deserializeJson(doc, data_str) != ArduinoJson::DeserializationError::Ok)
{
LOG_ERROR("WS Client unable to deserialize Json");
return;
}
if (!doc["cmd"].is<std::string>() || !s_webserverCommands.contains(doc["cmd"]))
{
LOG_WARN("WS Client Invalid Json command [", doc["cmd"].as<std::string>().c_str(), "]");
return;
}
std::string buffer;
switch (s_webserverCommands.at(doc["cmd"]))
{
case SET_TIME:
{
auto epoch = doc["time"].as<time_t>();
timeval te{
.tv_sec = epoch,
.tv_usec = 0,
};
timezone tz{
.tz_minuteswest = 0,
.tz_dsttime = DST_MET,
};
settimeofday(&te, &tz);
time_t now = time(nullptr);
struct tm *t = localtime(&now);
buffer.resize(64);
strftime(buffer.data(), sizeof(buffer), "%Y-%m-%d %H:%M:%S", t);
LOG_DEBUG("WS Client set Datetime to: ", buffer.c_str());
break;
}
default:
// call external command callback
break;
}
}
}
} }
} }
void WebPage::onUploadRequest(AsyncWebServerRequest *request) void AstroWebServer::onUploadRequest(AsyncWebServerRequest *request)
{ {
if (m_upload_failed) if (m_uploadFailed)
request->send(500, "text/plain", "Upload failed"); request->send(500, "text/plain", "Upload failed");
else else
request->send(200, "text/plain", "Upload successful"); request->send(200, "text/plain", "Upload successful");
} }
void WebPage::onUploadHandler(AsyncWebServerRequest *request, const String &filename, size_t index, uint8_t *data, size_t len, bool final) void AstroWebServer::onUploadHandler(AsyncWebServerRequest *request, const String &filename, size_t index, uint8_t *data, size_t len, bool final)
{ {
if (index == 0) // only on first iteration to open file if (index == 0) // only on first iteration to open file
{ {
m_upload_failed = false; m_uploadFailed = false;
String safeName = filename; String safeName = filename;
int slashIndex = safeName.lastIndexOf('/'); int slashIndex = safeName.lastIndexOf('/');
if (slashIndex >= 0) if (slashIndex >= 0)
safeName = safeName.substring(slashIndex + 1); safeName = safeName.substring(slashIndex + 1);
if (safeName.length() == 0) if (safeName.length() == 0)
{ {
m_upload_failed = true; m_uploadFailed = true;
LOG_ERROR("Invalid file name"); LOG_ERROR("Invalid file name");
return; return;
} }
@@ -72,27 +140,27 @@ void WebPage::onUploadHandler(AsyncWebServerRequest *request, const String &file
if (m_filesystem.exists(filePath.c_str())) if (m_filesystem.exists(filePath.c_str()))
m_filesystem.remove(filePath.c_str()); m_filesystem.remove(filePath.c_str());
m_upload_file = m_filesystem.open(filePath.c_str(), FILE_WRITE); m_uploadFile = m_filesystem.open(filePath.c_str(), FILE_WRITE);
if (!m_upload_file) if (!m_uploadFile)
{ {
m_upload_failed = true; m_uploadFailed = true;
LOG_ERROR("Failed to open upload file:", filePath.c_str()); LOG_ERROR("Failed to open upload file:", filePath.c_str());
return; return;
} }
} }
// Actual write of file data // Actual write of file data
if (!m_upload_failed && m_upload_file) if (!m_uploadFailed && m_uploadFile)
{ {
if (m_upload_file.write(data, len) != len) if (m_uploadFile.write(data, len) != len)
m_upload_failed = true; m_uploadFailed = true;
} }
// close the file and save on final call // close the file and save on final call
if (final && m_upload_file) if (final && m_uploadFile)
{ {
m_upload_file.close(); m_uploadFile.close();
if (!m_upload_failed) if (!m_uploadFailed)
LOG_INFO("Uploaded file to LittleFS:", filename.c_str()); LOG_INFO("Uploaded file to LittleFS:", filename.c_str());
} }
} }

32
RotaxMonitor/src/webserver.h
View File

@@ -1,5 +1,5 @@
#pragma once #pragma once
#define DEBUGLOG_DEFAULT_LOG_LEVEL_INFO #define DEBUGLOG_DEFAULT_LOG_LEVEL_DEBUG
// System includes // System includes
#include <Arduino.h> #include <Arduino.h>
@@ -7,26 +7,22 @@
#include <ESPAsyncWebServer.h> #include <ESPAsyncWebServer.h>
#include <AsyncTCP.h> #include <AsyncTCP.h>
#include <filesystem> #include <filesystem>
#include <map>
#include <FS.h> #include <FS.h>
class WebPage class AstroWebServer
{ {
const uint8_t m_port = 80;
fs::FS &m_filesystem;
AsyncWebServer m_webserver;
AsyncWebSocket m_websocket;
bool m_upload_failed = false;
fs::File m_upload_file;
public: public:
WebPage(const uint8_t port, fs::FS &filesystem); AstroWebServer(const uint8_t port, fs::FS &filesystem);
~WebPage(); ~AstroWebServer();
void sendWsData(const String &data); void sendWsData(const String &data);
private: private:
void onWsEvent(AsyncWebSocket *server, AsyncWebSocketClient *client, void onWsEvent(AsyncWebSocket *server, AsyncWebSocketClient *client,
AwsEventType type, void *arg, uint8_t *data, size_t len); AwsEventType type, void *arg, uint8_t *data, size_t len);
void onUploadRequest(AsyncWebServerRequest *request); void onUploadRequest(AsyncWebServerRequest *request);
void onUploadHandler(AsyncWebServerRequest *request, const String &filename, size_t index, uint8_t *data, size_t len, bool final); void onUploadHandler(AsyncWebServerRequest *request, const String &filename, size_t index, uint8_t *data, size_t len, bool final);
@@ -35,4 +31,18 @@ private:
void onStop(AsyncWebServerRequest *request); void onStop(AsyncWebServerRequest *request);
void onDownload(AsyncWebServerRequest *request); void onDownload(AsyncWebServerRequest *request);
private:
const uint8_t m_port = 80;
fs::FS &m_filesystem;
AsyncWebServer m_webserver;
AsyncWebSocket m_websocket;
bool m_uploadFailed = false;
fs::File m_uploadFile;
TimerHandle_t m_pingTimer = NULL;
public:
enum c_commandEnum
{
SET_TIME
};
}; };