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

Compare commits

base: Obbart:575730a34054c54ec69a8590d9f099462af8f1a6
Branches Tags
Obbart:main Obbart:ioexpander Obbart:task-refactor Obbart:datasave Obbart:adc Obbart:debug
...
compare: Obbart:task-refactor
Branches Tags
Obbart:ioexpander Obbart:main Obbart:task-refactor Obbart:datasave Obbart:adc Obbart:debug

15 Commits
575730a340 ... task-refac

Author SHA1 Message Date
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
Emanuele Trabattoni
9c012efef1 refactor led class 2026-04-11 11:37:40 +02:00
Emanuele Trabattoni
d41a99ee88 rgb led 2026-04-11 00:40:33 +02:00
Emanuele Trabattoni
eaeb515074 Modified Task display to order based on task number or arbitraruy function 2026-04-10 23:33:22 +02:00
Emanuele Trabattoni
246ba7eeb2 Task A+B concurrency <check ok without ADC 2026-04-10 22:03:09 +02:00
Emanuele Trabattoni
736a8d8bd5 modified to also read channel B 2026-04-10 12:12:28 +02:00
Emanuele Trabattoni
2083119d79 Updated interface to show Box A+B 2026-04-10 09:27:41 +02:00
30 changed files with 1753 additions and 803 deletions
Expand all files Collapse all files

3
RotaxMonitor/.vscode/extensions.json vendored
View File

@@ -1,8 +1,7 @@
{ {
"recommendations": [ "recommendations": [
"Jason2866.esp-decoder", "Jason2866.esp-decoder",
"pioarduino.pioarduino-ide", "pioarduino.pioarduino-ide"
"platformio.platformio-ide"
], ],
"unwantedRecommendations": [ "unwantedRecommendations": [
"ms-vscode.cpptools-extension-pack" "ms-vscode.cpptools-extension-pack"

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

File diff suppressed because one or more lines are too long

264
RotaxMonitor/data/index.html
View File

@@ -17,90 +17,196 @@
</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 style="max-width: 900px; margin: 0 auto; text-align: left;"> <!-- TAB 1 (contenuto attuale) -->
<p><strong>Timestamp:</strong> <span id="timestamp">-</span></p> <div id="tab1" class="tab-content active">
<p><strong>Data Valid:</strong> <span id="datavalid">-</span></p>
<p><strong>Generator voltage:</strong> <span id="volts_gen">-</span></p>
<p><strong>Engine RPM:</strong> <span id="eng_rpm">-</span></p>
<p><strong>ADC read time:</strong> <span id="adc_read_time">-</span></p>
<p><strong>Queue errors:</strong> <span id="n_queue_errors">-</span></p>
<table> <div id="loadingIndicator" class="loading-indicator">
<thead> <span class="spinner"></span> Waiting for data...
<tr> </div>
<th>Property</th>
<th>Pickup 12</th> <div class="tables-container">
<th>Pickup 34</th> <div class="box">
</tr> <h2>Box_A</h2>
</thead> <div class="box-data">
<tbody> <p><strong>Timestamp:</strong> <span id="a_timestamp">-</span></p>
<tr> <p><strong>Data Valid:</strong> <span id="a_datavalid">-</span></p>
<td>Spark delay</td> <p><strong>Generator voltage:</strong> <span id="a_volts_gen">-</span></p>
<td id="coils12_spark_delay">-</td> <p><strong>ADC read time:</strong> <span id="a_adc_read_time">-</span></p>
<td id="coils34_spark_delay">-</td> <p><strong>Queue errors:</strong> <span id="a_n_queue_errors">-</span></p>
</tr> </div>
<tr> <div class="rpm-highlight">
<td>Spark status</td> <strong>Engine RPM:</strong> <span id="a_eng_rpm">-</span>
<td id="coils12_spark_status">-</td> </div>
<td id="coils34_spark_status">-</td> <table>
</tr> <thead>
<tr> <tr>
<td>Soft start status</td> <th>Property</th>
<td id="coils12_sstart_status">-</td> <th>Pickup 12</th>
<td id="coils34_sstart_status">-</td> <th>Pickup 34</th>
</tr> </tr>
<tr> </thead>
<td>Peak P in</td> <tbody>
<td id="coils12_peak_p_in">-</td> <tr>
<td id="coils34_peak_p_in">-</td> <td>Spark delay</td>
</tr> <td id="a_coils12_spark_delay">-</td>
<tr> <td id="a_coils34_spark_delay">-</td>
<td>Peak N in</td> </tr>
<td id="coils12_peak_n_in">-</td> <tr>
<td id="coils34_peak_n_in">-</td> <td>Spark status</td>
</tr> <td id="a_coils12_spark_status">-</td>
<tr> <td id="a_coils34_spark_status">-</td>
<td>Peak P out</td> </tr>
<td id="coils12_peak_p_out">-</td> <tr>
<td id="coils34_peak_p_out">-</td> <td>Soft start status</td>
</tr> <td id="a_coils12_sstart_status">-</td>
<tr> <td id="a_coils34_sstart_status">-</td>
<td>Peak N out</td> </tr>
<td id="coils12_peak_n_out">-</td> <tr>
<td id="coils34_peak_n_out">-</td> <td>Peak P in</td>
</tr> <td id="a_coils12_peak_p_in">-</td>
<tr> <td id="a_coils34_peak_p_in">-</td>
<td>Level spark</td> </tr>
<td id="coils12_level_spark">-</td> <tr>
<td id="coils34_level_spark">-</td> <td>Peak N in</td>
</tr> <td id="a_coils12_peak_n_in">-</td>
<tr> <td id="a_coils34_peak_n_in">-</td>
<td>Spark Events</td> </tr>
<td id="coils12_n_events">-</td> <tr>
<td id="coils34_n_events">-</td> <td>Peak P out</td>
</tr> <td id="a_coils12_peak_p_out">-</td>
<tr> <td id="a_coils34_peak_p_out">-</td>
<td>Missed Events</td> </tr>
<td id="coils12_n_missed_firing">-</td> <tr>
<td id="coils34_n_missed_firing">-</td> <td>Peak N out</td>
</tr> <td id="a_coils12_peak_n_out">-</td>
</tbody> <td id="a_coils34_peak_n_out">-</td>
</table> </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 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>
</div> <!-- END TAB1 -->
<!-- TAB 2 (grafico) -->
<div id="tab2" class="tab-content">
<div class="chart-container">
<h3>Box A</h3>
<canvas id="chartA" height="100"></canvas>
</div>
<div class="chart-container">
<h3>Box B</h3>
<canvas id="chartB" height="100"></canvas>
</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>

223
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,39 +71,125 @@ function connectWS() {
lastMessageTimestamp = Date.now(); lastMessageTimestamp = Date.now();
setLoadingIndicator(false); setLoadingIndicator(false);
document.getElementById("datavalid").textContent = data.datavalid ?? "-"; updateCharts(data)
document.getElementById("timestamp").textContent = data.timestamp ?? "-";
document.getElementById("volts_gen").textContent = data.volts_gen ?? "-";
document.getElementById("eng_rpm").textContent = data.eng_rpm ?? "-";
document.getElementById("adc_read_time").textContent = data.adc_read_time ?? "-";
document.getElementById("n_queue_errors").textContent = data.n_queue_errors ?? "-";
const coils12 = data.coils12 || {}; // Update Box_A
const coils34 = data.coils34 || {}; if (data.box_a) {
const boxA = data.box_a;
document.getElementById("a_datavalid").textContent = boxA.datavalid ?? "-";
document.getElementById("a_timestamp").textContent = boxA.timestamp ?? "-";
document.getElementById("a_volts_gen").textContent = boxA.volts_gen ?? "-";
document.getElementById("a_eng_rpm").textContent = boxA.eng_rpm ?? "-";
document.getElementById("a_adc_read_time").textContent = boxA.adc_read_time ?? "-";
document.getElementById("a_n_queue_errors").textContent = boxA.n_queue_errors ?? "-";
document.getElementById("coils12_spark_delay").textContent = coils12.spark_delay ?? "-"; const coils12A = boxA.coils12 || {};
document.getElementById("coils34_spark_delay").textContent = coils34.spark_delay ?? "-"; const coils34A = boxA.coils34 || {};
document.getElementById("coils12_spark_status").textContent = coils12.spark_status ?? "-";
document.getElementById("coils34_spark_status").textContent = coils34.spark_status ?? "-"; document.getElementById("a_coils12_spark_delay").textContent = coils12A.spark_delay ?? "-";
document.getElementById("coils12_sstart_status").textContent = coils12.sstart_status ?? "-"; document.getElementById("a_coils34_spark_delay").textContent = coils34A.spark_delay ?? "-";
document.getElementById("coils34_sstart_status").textContent = coils34.sstart_status ?? "-"; document.getElementById("a_coils12_spark_status").textContent = coils12A.spark_status ?? "-";
document.getElementById("coils12_peak_p_in").textContent = coils12.peak_p_in ?? "-"; document.getElementById("a_coils34_spark_status").textContent = coils34A.spark_status ?? "-";
document.getElementById("coils34_peak_p_in").textContent = coils34.peak_p_in ?? "-"; document.getElementById("a_coils12_sstart_status").textContent = coils12A.sstart_status ?? "-";
document.getElementById("coils12_peak_n_in").textContent = coils12.peak_n_in ?? "-"; document.getElementById("a_coils34_sstart_status").textContent = coils34A.sstart_status ?? "-";
document.getElementById("coils34_peak_n_in").textContent = coils34.peak_n_in ?? "-"; document.getElementById("a_coils12_peak_p_in").textContent = coils12A.peak_p_in ?? "-";
document.getElementById("coils12_peak_p_out").textContent = coils12.peak_p_out ?? "-"; document.getElementById("a_coils34_peak_p_in").textContent = coils34A.peak_p_in ?? "-";
document.getElementById("coils34_peak_p_out").textContent = coils34.peak_p_out ?? "-"; document.getElementById("a_coils12_peak_n_in").textContent = coils12A.peak_n_in ?? "-";
document.getElementById("coils12_peak_n_out").textContent = coils12.peak_n_out ?? "-"; document.getElementById("a_coils34_peak_n_in").textContent = coils34A.peak_n_in ?? "-";
document.getElementById("coils34_peak_n_out").textContent = coils34.peak_n_out ?? "-"; document.getElementById("a_coils12_peak_p_out").textContent = coils12A.peak_p_out ?? "-";
document.getElementById("coils12_level_spark").textContent = coils12.level_spark ?? "-"; document.getElementById("a_coils34_peak_p_out").textContent = coils34A.peak_p_out ?? "-";
document.getElementById("coils34_level_spark").textContent = coils34.level_spark ?? "-"; document.getElementById("a_coils12_peak_n_out").textContent = coils12A.peak_n_out ?? "-";
document.getElementById("coils12_n_events").textContent = coils12.n_events ?? "-"; document.getElementById("a_coils34_peak_n_out").textContent = coils34A.peak_n_out ?? "-";
document.getElementById("coils34_n_events").textContent = coils34.n_events ?? "-"; document.getElementById("a_coils12_level_spark").textContent = coils12A.level_spark ?? "-";
document.getElementById("coils12_n_missed_firing").textContent = coils12.n_missed_firing ?? "-"; document.getElementById("a_coils34_level_spark").textContent = coils34A.level_spark ?? "-";
document.getElementById("coils34_n_missed_firing").textContent = coils34.n_missed_firing ?? "-"; document.getElementById("a_coils12_n_events").textContent = coils12A.n_events ?? "-";
document.getElementById("a_coils34_n_events").textContent = coils34A.n_events ?? "-";
document.getElementById("a_coils12_n_missed_firing").textContent = coils12A.n_missed_firing ?? "-";
document.getElementById("a_coils34_n_missed_firing").textContent = coils34A.n_missed_firing ?? "-";
}
// Update Box_B
if (data.box_b) {
const boxB = data.box_b;
document.getElementById("b_datavalid").textContent = boxB.datavalid ?? "-";
document.getElementById("b_timestamp").textContent = boxB.timestamp ?? "-";
document.getElementById("b_volts_gen").textContent = boxB.volts_gen ?? "-";
document.getElementById("b_eng_rpm").textContent = boxB.eng_rpm ?? "-";
document.getElementById("b_adc_read_time").textContent = boxB.adc_read_time ?? "-";
document.getElementById("b_n_queue_errors").textContent = boxB.n_queue_errors ?? "-";
const coils12B = boxB.coils12 || {};
const coils34B = boxB.coils34 || {};
document.getElementById("b_coils12_spark_delay").textContent = coils12B.spark_delay ?? "-";
document.getElementById("b_coils34_spark_delay").textContent = coils34B.spark_delay ?? "-";
document.getElementById("b_coils12_spark_status").textContent = coils12B.spark_status ?? "-";
document.getElementById("b_coils34_spark_status").textContent = coils34B.spark_status ?? "-";
document.getElementById("b_coils12_sstart_status").textContent = coils12B.sstart_status ?? "-";
document.getElementById("b_coils34_sstart_status").textContent = coils34B.sstart_status ?? "-";
document.getElementById("b_coils12_peak_p_in").textContent = coils12B.peak_p_in ?? "-";
document.getElementById("b_coils34_peak_p_in").textContent = coils34B.peak_p_in ?? "-";
document.getElementById("b_coils12_peak_n_in").textContent = coils12B.peak_n_in ?? "-";
document.getElementById("b_coils34_peak_n_in").textContent = coils34B.peak_n_in ?? "-";
document.getElementById("b_coils12_peak_p_out").textContent = coils12B.peak_p_out ?? "-";
document.getElementById("b_coils34_peak_p_out").textContent = coils34B.peak_p_out ?? "-";
document.getElementById("b_coils12_peak_n_out").textContent = coils12B.peak_n_out ?? "-";
document.getElementById("b_coils34_peak_n_out").textContent = coils34B.peak_n_out ?? "-";
document.getElementById("b_coils12_level_spark").textContent = coils12B.level_spark ?? "-";
document.getElementById("b_coils34_level_spark").textContent = coils34B.level_spark ?? "-";
document.getElementById("b_coils12_n_events").textContent = coils12B.n_events ?? "-";
document.getElementById("b_coils34_n_events").textContent = coils34B.n_events ?? "-";
document.getElementById("b_coils12_n_missed_firing").textContent = coils12B.n_missed_firing ?? "-";
document.getElementById("b_coils34_n_missed_firing").textContent = coils34B.n_missed_firing ?? "-";
}
}; };
} }
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");
} }
@@ -121,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();

87
RotaxMonitor/data/style.css
View File

@@ -35,10 +35,13 @@ body {
.logo { .logo {
height: 50px; height: 50px;
width: auto; width: auto;
margin: auto;
} }
.page-header h1 { .page-header h1 {
margin: 5px; margin: auto;
margin-top: 20px;
text-align: center;
font-size: 28px; font-size: 28px;
font-weight: 600; font-weight: 600;
} }
@@ -159,24 +162,98 @@ button:hover {
} }
} }
/* Data section */ .tables-container {
div[style*="max-width: 900px"] { display: flex;
gap: 20px;
max-width: 1800px;
margin: 0 auto;
padding: 0 20px;
}
.box {
flex: 1;
background: white; background: white;
padding: 20px; padding: 20px;
border-radius: 6px; border-radius: 6px;
box-shadow: 0 1px 3px rgba(0, 0, 0, 0.08); box-shadow: 0 1px 3px rgba(0, 0, 0, 0.08);
}
.box h2 {
margin-top: 0;
margin-bottom: 16px;
color: var(--primary-blue);
font-size: 18px;
font-weight: 700;
text-align: center;
}
.box-data {
margin-bottom: 20px; margin-bottom: 20px;
} }
div[style*="max-width: 900px"] p { .box-data p {
margin: 8px 0; margin: 8px 0;
font-size: 14px; font-size: 14px;
} }
div[style*="max-width: 900px"] strong { .box-data strong {
color: var(--primary-blue);
}
.rpm-highlight {
background: #c6e4fa;
border: 3px double var(--primary-blue);
border-radius: 8px;
padding: 12px 16px;
margin-bottom: 20px;
text-align: center;
font-size: 18px;
font-weight: bold;
color: var(--text-dark);
}
.rpm-highlight strong {
color: var(--primary-blue); color: var(--primary-blue);
} }
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);
}

32
RotaxMonitor/lib/led/led.cpp Normal file
View File

@@ -0,0 +1,32 @@
#include <led.h>
RGBled::RGBled(const uint8_t pin) : m_led(pin)
{
pinMode(m_led, OUTPUT);
writeStatus(RGBled::ERROR);
}
RGBled::~RGBled()
{
pinMode(m_led, INPUT);
}
void RGBled::setStatus(const LedStatus s)
{
if (m_status == s)
return;
std::lock_guard<std::mutex> lock(m_mutex);
m_status = s;
writeStatus(m_status);
}
const RGBled::LedStatus RGBled::getSatus(void)
{
return m_status;
}
void RGBled::writeStatus(const RGBled::LedStatus s)
{
RGBled::color_u u{.status = s};
rgbLedWrite(m_led, u.color.r, u.color.g, u.color.b);
}

63
RotaxMonitor/lib/led/led.h Normal file
View File

@@ -0,0 +1,63 @@
#pragma once
// System Inlcudes
#include <Arduino.h>
#include <mutex>
#define RED 0x00FF00
#define GREEN 0xFF0000
#define BLUE 0x0000FF
#define WHITE 0xFFFFFF
#define YELLOW 0xFFFF00
#define CYAN 0xFF00FF
#define MAGENTA 0x00FFFF
#define ORANGE 0xA5FF00
#define PURPLE 0x008080
#define PINK 0x69FFB4
#define LIME 0xCD3232
#define SKY_BLUE 0xCE87EB
#define GOLD 0xD7FF00
#define TURQUOISE 0xE040D0
#define INDIGO 0x004B82
#define GRAY 0x808080
class RGBled
{
public:
enum LedStatus
{
OK = GREEN,
ERROR = RED,
INIT = YELLOW,
DATA_A = CYAN,
DATA_B = MAGENTA,
DATA_ALL = ORANGE,
IDLE = GRAY
};
struct color_t
{
uint8_t a, r, g, b;
};
union color_u
{
uint32_t status;
color_t color;
};
public:
RGBled(const uint8_t pin = 48);
~RGBled();
void setStatus(const LedStatus s);
const LedStatus getSatus(void);
private:
void writeStatus(const LedStatus s);
private:
LedStatus m_status = LedStatus::IDLE;
std::mutex m_mutex;
const uint8_t m_led;
};

22
RotaxMonitor/platformio.ini
View File

@@ -20,23 +20,22 @@ lib_deps =
hideakitai/PCA95x5@^0.1.3 hideakitai/PCA95x5@^0.1.3
me-no-dev/AsyncTCP@^3.3.2 me-no-dev/AsyncTCP@^3.3.2
me-no-dev/ESPAsyncWebServer@^3.6.0 me-no-dev/ESPAsyncWebServer@^3.6.0
adafruit/Adafruit NeoPixel@^1.15.4
upload_protocol = esptool upload_protocol = esptool
upload_port = COM8 upload_port = /dev/ttyACM1
upload_speed = 921600 upload_speed = 921600
monitor_port = COM4 monitor_port = /dev/ttyACM0
monitor_speed = 921600 monitor_speed = 921600
build_type = release build_type = release
build_flags = build_flags =
-DCORE_DEBUG_LEVEL=1 -DCORE_DEBUG_LEVEL=1
-DARDUINO_USB_CDC_ON_BOOT=0 -DARDUINO_USB_CDC_ON_BOOT=0
-DARDUINO_USB_MODE=0 -DARDUINO_USB_MODE=0
-DCONFIG_FREERTOS_GENERATE_RUN_TIME_STATS=1
-DCONFIG_FREERTOS_USE_TRACE_FACILITY=1
-DCONFIG_ASYNC_TCP_MAX_ACK_TIME=5000 -DCONFIG_ASYNC_TCP_MAX_ACK_TIME=5000
-DCONFIG_ASYNC_TCP_PRIORITY=20 -DCONFIG_ASYNC_TCP_PRIORITY=21
-DCONFIG_ASYNC_TCP_QUEUE_SIZE=128 -DCONFIG_ASYNC_TCP_QUEUE_SIZE=64
-DCONFIG_ASYNC_TCP_RUNNING_CORE=1 -DCONFIG_ASYNC_TCP_RUNNING_CORE=1
-DCONFIG_ASYNC_TCP_STACK_SIZE=8192 -DCONFIG_ASYNC_TCP_STACK_SIZE=4096
-fstack-protector-all -fstack-protector-all
[env:esp32-s3-devkitc1-n16r8-debug] [env:esp32-s3-devkitc1-n16r8-debug]
@@ -47,10 +46,11 @@ platform = ${env:esp32-s3-devkitc1-n16r8.platform}
framework = ${env:esp32-s3-devkitc1-n16r8.framework} framework = ${env:esp32-s3-devkitc1-n16r8.framework}
lib_deps = lib_deps =
${env:esp32-s3-devkitc1-n16r8.lib_deps} ${env:esp32-s3-devkitc1-n16r8.lib_deps}
adafruit/Adafruit NeoPixel@^1.15.4
upload_protocol = esptool upload_protocol = esptool
upload_port = COM8 upload_port = /dev/ttyACM1
upload_speed = 921600 upload_speed = 921600
monitor_port = COM4 monitor_port = /dev/ttyACM0
monitor_speed = 921600 monitor_speed = 921600
debug_tool = esp-builtin debug_tool = esp-builtin
debug_speed = 15000 debug_speed = 15000
@@ -62,10 +62,8 @@ build_flags =
-DCORE_DEBUG_LEVEL=3 -DCORE_DEBUG_LEVEL=3
-DARDUINO_USB_CDC_ON_BOOT=0 -DARDUINO_USB_CDC_ON_BOOT=0
-DARDUINO_USB_MODE=0 -DARDUINO_USB_MODE=0
-DCONFIG_FREERTOS_GENERATE_RUN_TIME_STATS=1
-DCONFIG_FREERTOS_USE_TRACE_FACILITY=1
-DCONFIG_ASYNC_TCP_MAX_ACK_TIME=5000 -DCONFIG_ASYNC_TCP_MAX_ACK_TIME=5000
-DCONFIG_ASYNC_TCP_PRIORITY=20 -DCONFIG_ASYNC_TCP_PRIORITY=21
-DCONFIG_ASYNC_TCP_QUEUE_SIZE=128 -DCONFIG_ASYNC_TCP_QUEUE_SIZE=128
-DCONFIG_ASYNC_TCP_RUNNING_CORE=1 -DCONFIG_ASYNC_TCP_RUNNING_CORE=1
-DCONFIG_ASYNC_TCP_STACK_SIZE=8192 -DCONFIG_ASYNC_TCP_STACK_SIZE=8192

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);

5
RotaxMonitor/src/datastruct.h
View File

@@ -1,6 +1,7 @@
#pragma once #pragma once
#include <Arduino.h> #include <Arduino.h>
#include <map> #include <map>
#include <psvector.h>
// ===================== // =====================
// Event Flags (bitmask) // Event Flags (bitmask)
@@ -88,3 +89,7 @@ struct ignitionBoxStatus
uint32_t n_queue_errors = 0; uint32_t n_queue_errors = 0;
int32_t adc_read_time = 0; int32_t adc_read_time = 0;
}; };
template <typename T>
using PSRAMVector = std::vector<T, PSRAMAllocator<T>>;

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

53
RotaxMonitor/src/isr.cpp
View File

@@ -4,7 +4,7 @@
// ISR (Pass return bitmask to ISR management function) // ISR (Pass return bitmask to ISR management function)
// one function for each wake up pin conncted to a trigger // one function for each wake up pin conncted to a trigger
// ===================== // =====================
void trig_isr(void *arg) void trig_isr_A(void *arg)
{ {
const int64_t time_us = esp_timer_get_time(); const int64_t time_us = esp_timer_get_time();
@@ -50,4 +50,53 @@ void trig_isr(void *arg)
if (xHigherPriorityTaskWoken) if (xHigherPriorityTaskWoken)
portYIELD_FROM_ISR(); portYIELD_FROM_ISR();
} }
void trig_isr_B(void *arg)
{
const int64_t time_us = esp_timer_get_time();
// exit if invalid args
if (!arg)
return;
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
isrParams *params = (isrParams *)arg;
ignitionBoxStatus *box = params->ign_stat;
TaskHandle_t task_handle = params->rt_handle_ptr;
// exit if task not running
if (!task_handle)
return;
switch (params->flag)
{
case TRIG_FLAG_12P:
case TRIG_FLAG_12N:
// only on first trigger to avoid multiple firing due to noise, to be fixed with hardware debounce
box->coils12.trig_time = time_us;
xTaskNotifyFromISR(task_handle, params->flag, eSetValueWithOverwrite, &xHigherPriorityTaskWoken);
break;
case TRIG_FLAG_34P:
case TRIG_FLAG_34N:
// only on first trigger to avoid multiple firing due to noise, to be fixed with hardware debounce
box->coils34.trig_time = time_us;
xTaskNotifyFromISR(task_handle, params->flag, eSetValueWithOverwrite, &xHigherPriorityTaskWoken);
break;
case SPARK_FLAG_12:
box->coils12.spark_time = time_us;
xTaskNotifyFromISR(task_handle, params->flag, eSetValueWithOverwrite, &xHigherPriorityTaskWoken);
break;
case SPARK_FLAG_34:
box->coils34.spark_time = time_us;
xTaskNotifyFromISR(task_handle, params->flag, eSetValueWithOverwrite, &xHigherPriorityTaskWoken);
break;
default:
break;
}
if (xHigherPriorityTaskWoken)
portYIELD_FROM_ISR();
}

7
RotaxMonitor/src/isr.h
View File

@@ -16,8 +16,8 @@
#define CORE_0 0 #define CORE_0 0
#define CORE_1 1 #define CORE_1 1
#define RT_TASK_STACK 4096 // in words #define RT_TASK_STACK 2048 // in words
#define RT_TASK_PRIORITY (configMAX_PRIORITIES - 4) // highest priority after wifi tasks #define RT_TASK_PRIORITY (configMAX_PRIORITIES - 5) // highest priority after wifi tasks
struct isrParams struct isrParams
{ {
@@ -26,4 +26,5 @@ struct isrParams
TaskHandle_t rt_handle_ptr; TaskHandle_t rt_handle_ptr;
}; };
void IRAM_ATTR trig_isr(void *arg); void IRAM_ATTR trig_isr_A(void *arg);
void IRAM_ATTR trig_isr_B(void *arg);

307
RotaxMonitor/src/main.cpp
View File

@@ -14,13 +14,11 @@
#include <datasave.h> #include <datasave.h>
#include <webserver.h> #include <webserver.h>
#include <ui.h> #include <ui.h>
#include <led.h>
// FreeRTOS directives // Defines to enable channel B
#include "freertos/FreeRTOS.h" #define CH_B_ENABLE
#include "freertos/task.h" // #define TEST
// #define CH_B_ENABLE
#define TEST
// Debug Defines // Debug Defines
#define WIFI_SSID "AstroRotaxMonitor" #define WIFI_SSID "AstroRotaxMonitor"
@@ -33,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());
@@ -54,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");
@@ -75,80 +74,28 @@ void setup()
initSparkPinInputs(); initSparkPinInputs();
} }
////////////////////// MAIN LOOP //////////////////////
void loop() void loop()
{ {
// global variables // global variables
RGBled led;
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);
PSRAMVector<ignitionBoxStatus> ignA_history_1(max_history);
auto *active_history = &ignA_history_0;
auto *writable_history = &ignA_history_1;
// Resources Initialization //////// INIT SPI PORTS ////////
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_handle_ptr = &trigA_TaskHandle,
.rt_queue = rt_taskA_queue,
.rt_int = rtTaskInterrupts{
.isr_ptr = trig_isr,
.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, .rst_io_sh = RST_EXT_SAMPLE_HOLD}};
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");
#ifdef CH_B_ENABLE
QueueHandle_t rt_taskB_queue = xQueueCreate(max_queue, sizeof(ignitionBoxStatus));
rtTaskParams taskB_params{
.rt_running = true,
.dev = &dev,
.rt_handle_ptr = &trigB_TaskHandle,
.rt_queue = rt_taskB_queue,
.rt_int = rtTaskInterrupts{
.isr_ptr = trig_isr,
.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_12p = RST_EXT_B12P, .rst_io_12n = RST_EXT_B12N, .rst_io_34p = RST_EXT_B34P, .rst_io_34n = RST_EXT_B34N}};
#endif
// 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
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
if (!spiA_ok || !spiB_ok) if (!spiA_ok || !spiB_ok)
{ {
LOG_ERROR("Unable to Initialize SPI Busses"); LOG_ERROR("Unable to Initialize SPI Busses");
@@ -158,48 +105,92 @@ void loop()
} }
LOG_DEBUG("Init SPI OK"); LOG_DEBUG("Init SPI OK");
// Init ADC_A // Resources Initialization
dev.adc_a = new ADS1256(ADC_A_DRDY, ADS1256::PIN_UNUSED, ADS1256::PIN_UNUSED, ADC_A_CS, 2.5, &SPI_A); std::shared_ptr<Devices> dev = std::make_shared<Devices>();
dev.adc_a->InitializeADC(); // dev->m_spi_a = std::make_unique<SPIClass>(SPI_A);
dev.adc_a->setPGA(PGA_1); // dev->m_spi_b = std::make_unique<SPIClass>(SPI_B);
dev.adc_a->setDRATE(DRATE_7500SPS);
#ifdef CH_B_ENABLE // // Init ADC_A
// Init ADC_B // 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.adc_a = new ADS1256(ADC_B_DRDY, ADC_B_RST, ADC_B_SYNC, ADC_B_CS, 2.5, &SPI_B); // 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.adc_a->InitializeADC();
dev.adc_a->setPGA(PGA_1);
dev.adc_a->setDRATE(DRATE_1000SPS);
#endif
LOG_DEBUG("Init ADC OK"); // 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,
"rtIgnitionTask_boxA",
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,
"rtIgnitionTask_boxB",
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");
@@ -208,65 +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);
////////////////////// MAIN LOOP ////////////////////// AstroWebServer webPage(80, LittleFS); // Initialize webserver and Websocket
bool partial_save = false; // flag to indicate if a partial save has been done after a timeout ArduinoJson::JsonDocument json_data;
uint32_t counter = 0; bool data_a, data_b;
uint32_t wait_count = 0; task_A.onMessage([&webPage, &json_data, &data_a](ignitionBoxStatusFiltered sts){
ignitionBoxStatus ign_info; json_data["box_a"] = sts.toJson();
ignitionBoxStatusAverage ign_info_avg(filter_k); data_a = true;
LITTLEFSGuard fsGuard; });
WebPage webPage(80, LittleFS); // Initialize webserver and Websocket
task_B.onMessage([&webPage, &json_data, &data_b](ignitionBoxStatusFiltered sts){
json_data["box_b"] = sts.toJson();
data_b = true;
});
// task_A.enableSave(true, "ignitionA_test.csv");
// task_B.enableSave(true, "ignitionB_test.csv");
uint32_t monitor_loop = millis();
uint32_t data_loop = monitor_loop;
//////////////// INNER LOOP /////////////////////
while (running) while (running)
{ {
if (counter >= active_history->size()) // not concurrent with write task uint32_t this_loop = millis();
if (this_loop - monitor_loop > 2000)
{ {
counter = 0; clearScreen();
partial_save = false; // reset partial save flag on new data cycle printRunningTasksMod(Serial);
auto *temp = active_history; monitor_loop = millis();
active_history = writable_history; // switch active and writable buffers
writable_history = temp; // ensure writable_history points to the buffer we just filled
dataSaveParams save_params{
.history = writable_history,
.file_path = "ignition_history.csv"};
save_history(*writable_history, "ignition_history.csv"); // directly call the save task function to save without delay
} }
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 /////////////////////
if (xQueueReceive(rt_taskA_queue, &ign_info, pdMS_TO_TICKS(1000)) == pdTRUE) } ////////////////////// MAIN LOOP //////////////////////
{
// printInfo(ign_info);
auto &hist = *active_history;
hist[counter++ % active_history->size()] = ign_info;
ign_info_avg.update(ign_info); // update moving average with latest ignition status
Serial.printf("\033[2K Data Received: %d/%d\r", counter, hist.size());
if ( counter % filter_k == 0) // send data every 10 samples
{
Serial.println();
LOG_DEBUG("Sending average ignition status to websocket clients...");
webPage.sendWsData(ign_info_avg.toJson().as<String>());
}
}
else
{
Serial.printf("[%d] Waiting for data...\r", wait_count++);
if (!partial_save && counter > 0) // if timeout occurs but we have unsaved data, save it before next timeout
{
active_history->resize(counter); // resize active history to actual number of records received to avoid saving empty records
save_history(*active_history, "ignition_history.csv");
active_history->resize(max_history); // resize back to max history size for next data cycle
counter = 0; // reset counter after saving
partial_save = true;
first_save = true;
}
delay(500);
}
}
if (trigA_TaskHandle)
vTaskDelete(trigA_TaskHandle);
if (trigB_TaskHandle)
vTaskDelete(trigB_TaskHandle);
////////////////////// 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 0
#define RST_EXT_SAMPLE_HOLD 1 // --- DIGITAL POT CHIP SELECT LINES ---
#define BTN_1 2 #define POT_CS_A12 0
#define BTN_2 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 A_EXT_RELAY 8 #define RELAY_IN_A12 9
#define B_EXT_RELAY 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 A_EXT_RELAY 8 #define SH_ARM_A34 8
// Init Pin Functions // Init Pin Functions

3
RotaxMonitor/src/psvector.h
View File

@@ -25,6 +25,3 @@ struct PSRAMAllocator {
heap_caps_free(p); heap_caps_free(p);
} }
}; };
template <typename T>
using PSRAMVector = std::vector<T, PSRAMAllocator<T>>;

326
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
@@ -17,53 +31,59 @@ void rtIgnitionTask(void *pvParameters)
LOG_ERROR("Null rt_task_ptr parameters"); LOG_ERROR("Null rt_task_ptr parameters");
vTaskDelete(NULL); vTaskDelete(NULL);
} }
LOG_INFO("rtTask Params OK");
// 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;
TaskHandle_t rt_handle_ptr = *params->rt_handle_ptr; Devices *dev = params->dev.get();
Devices *dev = params->dev; ADS1256 *adc = dev->m_adc_a.get();
ADS1256 *adc = dev->adc_a; PCA9555 *io = dev->m_expander_a.get();
PCA9555 *io = dev->io;
TaskStatus_t rt_task_info;
vTaskGetInfo(NULL, &rt_task_info, pdFALSE, eInvalid);
const auto rt_task_name = pcTaskGetName(rt_task_info.xHandle);
LOG_INFO("rtTask Params OK [", rt_task_name, "]");
ignitionBoxStatus ign_box_sts; ignitionBoxStatus ign_box_sts;
// Variables for ISR, static to be fixed in memory locations // Variables for ISR, static to be fixed in memory locations
static isrParams isr_params_t12p{ isrParams isr_params_t12p{
.flag = TRIG_FLAG_12P, .flag = TRIG_FLAG_12P,
.ign_stat = &ign_box_sts, .ign_stat = &ign_box_sts,
.rt_handle_ptr = rt_handle_ptr}; .rt_handle_ptr = rt_task_info.xHandle};
static isrParams isr_params_t12n{ isrParams isr_params_t12n{
.flag = TRIG_FLAG_12N, .flag = TRIG_FLAG_12N,
.ign_stat = &ign_box_sts, .ign_stat = &ign_box_sts,
.rt_handle_ptr = rt_handle_ptr}; .rt_handle_ptr = rt_task_info.xHandle};
static isrParams isr_params_t34p{ isrParams isr_params_t34p{
.flag = TRIG_FLAG_34P, .flag = TRIG_FLAG_34P,
.ign_stat = &ign_box_sts, .ign_stat = &ign_box_sts,
.rt_handle_ptr = rt_handle_ptr}; .rt_handle_ptr = rt_task_info.xHandle};
static isrParams isr_params_t34n{ isrParams isr_params_t34n{
.flag = TRIG_FLAG_34N, .flag = TRIG_FLAG_34N,
.ign_stat = &ign_box_sts, .ign_stat = &ign_box_sts,
.rt_handle_ptr = rt_handle_ptr}; .rt_handle_ptr = rt_task_info.xHandle};
static isrParams isr_params_sp12{ isrParams isr_params_sp12{
.flag = SPARK_FLAG_12, .flag = SPARK_FLAG_12,
.ign_stat = &ign_box_sts, .ign_stat = &ign_box_sts,
.rt_handle_ptr = rt_handle_ptr}; .rt_handle_ptr = rt_task_info.xHandle};
static isrParams isr_params_sp34{ isrParams isr_params_sp34{
.flag = SPARK_FLAG_34, .flag = SPARK_FLAG_34,
.ign_stat = &ign_box_sts, .ign_stat = &ign_box_sts,
.rt_handle_ptr = rt_handle_ptr}; .rt_handle_ptr = rt_task_info.xHandle};
LOG_INFO("rtTask ISR Params OK"); LOG_DEBUG("rtTask HDL Params OK, HDL* [", (uint32_t)rt_task_info.xHandle, "]");
LOG_DEBUG("rtTask ISR Params OK, ISR* [", (uint32_t)rt_int.isr_ptr, "]");
LOG_DEBUG("rtTask QUE Params OK, QUE* [", (uint32_t)rt_queue, "]");
// Create esp_timer for microsecond precision timeout // Create esp_timer for microsecond precision timeout
esp_timer_handle_t timeout_timer; esp_timer_handle_t timeout_timer;
esp_timer_create_args_t timer_args = { esp_timer_create_args_t timer_args = {
.callback = spark_timeout_callback, .callback = spark_timeout_callback,
.arg = (void *)rt_handle_ptr, .arg = (void *)rt_task_info.xHandle,
.dispatch_method = ESP_TIMER_TASK, .dispatch_method = ESP_TIMER_TASK,
.name = "spark_timeout"}; .name = "spark_timeout"};
esp_timer_create(&timer_args, &timeout_timer); esp_timer_create(&timer_args, &timeout_timer);
@@ -76,7 +96,7 @@ void rtIgnitionTask(void *pvParameters)
attachInterruptArg(digitalPinToInterrupt(rt_int.spark_pin_12), rt_int.isr_ptr, (void *)&isr_params_sp12, RISING); attachInterruptArg(digitalPinToInterrupt(rt_int.spark_pin_12), rt_int.isr_ptr, (void *)&isr_params_sp12, RISING);
attachInterruptArg(digitalPinToInterrupt(rt_int.spark_pin_34), rt_int.isr_ptr, (void *)&isr_params_sp34, RISING); attachInterruptArg(digitalPinToInterrupt(rt_int.spark_pin_34), rt_int.isr_ptr, (void *)&isr_params_sp34, RISING);
LOG_INFO("rtTask ISR Attach OK"); LOG_INFO("rtTask ISR Attach OK [", rt_task_name, "]");
// Global rt_task_ptr variables // Global rt_task_ptr variables
bool first_cycle = true; bool first_cycle = true;
@@ -227,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));
@@ -253,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);
@@ -264,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());
}

151
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,34 +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;
TaskHandle_t* rt_handle_ptr; const uint8_t pot_cs_34;
const QueueHandle_t rt_queue; const uint8_t ss_force;
const rtTaskInterrupts rt_int; // interrupt pins to attach const uint8_t ss_inhibit_12;
const rtTaskResets rt_resets; // reset ping for peak detectors 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
};

188
RotaxMonitor/src/ui.h
View File

@@ -14,191 +14,3 @@ void printField(const char name[], const char *val);
void printInfo(const ignitionBoxStatus &info); void printInfo(const ignitionBoxStatus &info);
static const std::string htmlTest = R"rawliteral(
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>ESP32 Dashboard</title>
<style>
body {
font-family: Arial;
text-align: center;
margin-top: 40px;
}
table {
margin: auto;
border-collapse: collapse;
width: 100%;
max-width: 900px;
}
th, td {
border: 1px solid #ccc;
padding: 10px;
font-size: 16px;
text-align: left;
}
th {
background-color: #f4f4f4;
}
button {
margin: 10px;
padding: 10px 20px;
font-size: 16px;
}
</style>
</head>
<body>
<h2>RotaxMonitor realtime data</h2>
<button onclick="start()">Start</button>
<button onclick="stop()">Stop</button>
<div style="max-width: 900px; margin: 0 auto; text-align: left;">
<p><strong>Timestamp:</strong> <span id="timestamp">-</span></p>
<p><strong>Data Valid:</strong> <span id="datavalid">-</span></p>
<p><strong>Generator voltage:</strong> <span id="volts_gen">-</span></p>
<p><strong>Engine RPM:</strong> <span id="eng_rpm">-</span></p>
<p><strong>ADC read time:</strong> <span id="adc_read_time">-</span></p>
<p><strong>Queue errors:</strong> <span id="n_queue_errors">-</span></p>
<table>
<thead>
<tr>
<th>Property</th>
<th>Coils 12</th>
<th>Coils 34</th>
</tr>
</thead>
<tbody>
<tr>
<td>Spark delay</td>
<td id="coils12_spark_delay">-</td>
<td id="coils34_spark_delay">-</td>
</tr>
<tr>
<td>Spark status</td>
<td id="coils12_spark_status">-</td>
<td id="coils34_spark_status">-</td>
</tr>
<tr>
<td>Soft start status</td>
<td id="coils12_sstart_status">-</td>
<td id="coils34_sstart_status">-</td>
</tr>
<tr>
<td>Peak P in</td>
<td id="coils12_peak_p_in">-</td>
<td id="coils34_peak_p_in">-</td>
</tr>
<tr>
<td>Peak N in</td>
<td id="coils12_peak_n_in">-</td>
<td id="coils34_peak_n_in">-</td>
</tr>
<tr>
<td>Peak P out</td>
<td id="coils12_peak_p_out">-</td>
<td id="coils34_peak_p_out">-</td>
</tr>
<tr>
<td>Peak N out</td>
<td id="coils12_peak_n_out">-</td>
<td id="coils34_peak_n_out">-</td>
</tr>
<tr>
<td>Level spark</td>
<td id="coils12_level_spark">-</td>
<td id="coils34_level_spark">-</td>
</tr>
<tr>
<td>Events</td>
<td id="coils12_n_events">-</td>
<td id="coils34_n_events">-</td>
</tr>
<tr>
<td>Missed firings</td>
<td id="coils12_n_missed_firing">-</td>
<td id="coils34_n_missed_firing">-</td>
</tr>
</tbody>
</table>
</div>
<script>
let ws;
function connectWS() {
ws = new WebSocket("ws://" + location.host + "/ws");
ws.onopen = () => {
console.log("WebSocket connesso");
};
ws.onclose = () => {
console.log("WebSocket disconnesso, retry...");
setTimeout(connectWS, 5000);
};
ws.onmessage = (event) => {
let data;
try {
data = JSON.parse(event.data);
} catch (e) {
console.error("Invalid JSON received", e);
return;
}
document.getElementById("datavalid").textContent = data.datavalid ?? "-";
document.getElementById("timestamp").textContent = data.timestamp ?? "-";
document.getElementById("volts_gen").textContent = data.volts_gen ?? "-";
document.getElementById("eng_rpm").textContent = data.eng_rpm ?? "-";
document.getElementById("adc_read_time").textContent = data.adc_read_time ?? "-";
document.getElementById("n_queue_errors").textContent = data.n_queue_errors ?? "-";
const coils12 = data.coils12 || {};
const coils34 = data.coils34 || {};
document.getElementById("coils12_spark_delay").textContent = coils12.spark_delay ?? "-";
document.getElementById("coils34_spark_delay").textContent = coils34.spark_delay ?? "-";
document.getElementById("coils12_spark_status").textContent = coils12.spark_status ?? "-";
document.getElementById("coils34_spark_status").textContent = coils34.spark_status ?? "-";
document.getElementById("coils12_sstart_status").textContent = coils12.sstart_status ?? "-";
document.getElementById("coils34_sstart_status").textContent = coils34.sstart_status ?? "-";
document.getElementById("coils12_peak_p_in").textContent = coils12.peak_p_in ?? "-";
document.getElementById("coils34_peak_p_in").textContent = coils34.peak_p_in ?? "-";
document.getElementById("coils12_peak_n_in").textContent = coils12.peak_n_in ?? "-";
document.getElementById("coils34_peak_n_in").textContent = coils34.peak_n_in ?? "-";
document.getElementById("coils12_peak_p_out").textContent = coils12.peak_p_out ?? "-";
document.getElementById("coils34_peak_p_out").textContent = coils34.peak_p_out ?? "-";
document.getElementById("coils12_peak_n_out").textContent = coils12.peak_n_out ?? "-";
document.getElementById("coils34_peak_n_out").textContent = coils34.peak_n_out ?? "-";
document.getElementById("coils12_level_spark").textContent = coils12.level_spark ?? "-";
document.getElementById("coils34_level_spark").textContent = coils34.level_spark ?? "-";
document.getElementById("coils12_n_events").textContent = coils12.n_events ?? "-";
document.getElementById("coils34_n_events").textContent = coils34.n_events ?? "-";
document.getElementById("coils12_n_missed_firing").textContent = coils12.n_missed_firing ?? "-";
document.getElementById("coils34_n_missed_firing").textContent = coils34.n_missed_firing ?? "-";
};
}
function start() {
fetch("/start");
}
function stop() {
fetch("/stop");
}
connectWS();
</script>
</body>
</html>
)rawliteral";

186
RotaxMonitor/src/utils.cpp
View File

@@ -1,14 +1,194 @@
#include "utils.h" #include "utils.h"
#include "freertos_stats.h"
#include "sdkconfig.h"
std::string printBits(uint32_t value) { #include "freertos/FreeRTOS.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 <algorithm>
#include <functional>
#define FREERTOS_TASK_NUMBER_MAX_NUM 256 // RunTime stats for how many Tasks to be stored
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)
{
static const char *taskStates[] = {"Running", "Ready", "Blocked", "Suspended", "Deleted", "Invalid"};
static uint32_t ulRunTimeCounters[FREERTOS_TASK_NUMBER_MAX_NUM];
static uint32_t ulLastRunTime = 0;
uint32_t ulCurrentRunTime = 0, ulTaskRunTime = 0;
uint32_t ulTotalRunTime = 0;
std::vector<TaskStatus_t> pxTaskStatusArray;
UBaseType_t uxArraySize = 0;
// Take a snapshot of the number of tasks in case it changes while this function is executing.
uxArraySize = uxTaskGetNumberOfTasks();
pxTaskStatusArray.resize(uxArraySize);
// Generate raw status information about each task.
uxArraySize = uxTaskGetSystemState(pxTaskStatusArray.data(), uxArraySize, &ulTotalRunTime);
if (orderBy == nullptr)
std::sort(pxTaskStatusArray.begin(), pxTaskStatusArray.end(), [](const TaskStatus_t &a, const TaskStatus_t &b)
{ return a.xTaskNumber < b.xTaskNumber; });
else
std::sort(pxTaskStatusArray.begin(), pxTaskStatusArray.end(), orderBy);
// Compute system total runtime
ulCurrentRunTime = ulTotalRunTime - ulLastRunTime;
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
printer.printf("Tasks: %u, Runtime: %lus, Period: %luus\r\n", uxArraySize, ulTotalRunTime / 1000000, ulCurrentRunTime);
// Print Task Headers
printer.printf("Num\t Name\tLoad\tPrio\t Free\tCore\tState\r\n");
for (const auto &task : pxTaskStatusArray)
{
ulTaskRunTime = (task.ulRunTimeCounter - ulRunTimeCounters[task.xTaskNumber]);
ulRunTimeCounters[task.xTaskNumber] = task.ulRunTimeCounter;
ulTaskRunTime = (ulTaskRunTime * 100) / ulCurrentRunTime; // in percentage
printer.printf(
"%3u\t%16s"
"\t%3lu%%"
"\t%4u\t%5lu"
"\t%4c"
"\t%s\r\n",
task.xTaskNumber, task.pcTaskName,
ulTaskRunTime,
task.uxCurrentPriority, task.usStackHighWaterMark,
(task.xCoreID == tskNO_AFFINITY) ? '*' : ('0' + task.xCoreID),
taskStates[task.eCurrentState]);
}
printer.println();
}

9
RotaxMonitor/src/utils.h
View File

@@ -2,5 +2,14 @@
#include <Arduino.h> #include <Arduino.h>
#include <string> #include <string>
#include <datastruct.h>
std::string printBits(uint32_t value); std::string printBits(uint32_t value);
void printRunningTasksMod(Print &printer, std::function<bool(const TaskStatus_t &a, const TaskStatus_t &b)> orderBy = nullptr);
inline void swapHistory(PSRAMVector<ignitionBoxStatus>* active, PSRAMVector<ignitionBoxStatus>* writable) {
auto *temp = active;
active = writable; // switch active and writable buffers
writable = temp; // ensure writable_history points to the buffer we just filled
}

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
};
}; };

3
RotaxMonitorTester/.vscode/extensions.json vendored
View File

@@ -1,8 +1,7 @@
{ {
"recommendations": [ "recommendations": [
"Jason2866.esp-decoder", "Jason2866.esp-decoder",
"pioarduino.pioarduino-ide", "pioarduino.pioarduino-ide"
"platformio.platformio-ide"
], ],
"unwantedRecommendations": [ "unwantedRecommendations": [
"ms-vscode.cpptools-extension-pack" "ms-vscode.cpptools-extension-pack"

121
RotaxMonitorTester/src/main.cpp
View File

@@ -1,3 +1,5 @@
#define DEBUGLOG_DEFAULT_LOG_LEVEL_DEBUG
#include <Arduino.h> #include <Arduino.h>
#include <DebugLog.h> #include <DebugLog.h>
@@ -16,15 +18,16 @@ static uint32_t count = 0;
#define SPARK_DLY_MAX 490 #define SPARK_DLY_MAX 490
#define PAUSE_LONG_MIN 5000 #define PAUSE_LONG_MIN 5000
#define PAUSE_LONG_MAX PAUSE_LONG_MIN*100 #define PAUSE_LONG_MAX PAUSE_LONG_MIN * 100
#define RPM_MIN 800 #define RPM_MIN 250
#define RPM_MAX 5500 #define RPM_MAX 5500
void clearScreen(){ void clearScreen()
Serial.print("\033[2J"); // clear screen {
Serial.print("\033[H"); // cursor home Serial.print("\033[2J"); // clear screen
Serial.flush(); Serial.print("\033[H"); // cursor home
Serial.flush();
} }
static double filtered_rpm = 0; static double filtered_rpm = 0;
@@ -46,20 +49,44 @@ static const std::map<const uint32_t, const char *> pin2Name = {
{State::S_WAIT_10MS, "S_WAIT_10MS"}}; {State::S_WAIT_10MS, "S_WAIT_10MS"}};
static timerStatus stsA = { static timerStatus stsA = {
.clock_period_us = (uint32_t)PERIOD_US, .clock_period_us = (uint32_t)PERIOD_US,
.pause_long_us = 10000, .pause_long_us = 10000,
.pause_short_us = 1000, .pause_short_us = 1000,
.coil_pulse_us = 1000, .coil_pulse_us = 1000,
.spark_pulse_us = 100, .spark_pulse_us = 100,
.spark_delay_us = 50, .spark_delay_us = 50,
.main_task = NULL}; .pins = {
.pin_trig_12p = PIN_TRIG_A12P,
.pin_trig_12n = PIN_TRIG_A12N,
.pin_trig_34p = PIN_TRIG_A34P,
.pin_trig_34n = PIN_TRIG_A34N,
.pin_spark_12 = SPARK_A12,
.pin_spark_34 = SPARK_A34},
.main_task = NULL};
static bool isEnabled = false; static timerStatus stsB = {
.clock_period_us = (uint32_t)PERIOD_US,
.pause_long_us = 10000,
.pause_short_us = 1000,
.coil_pulse_us = 1000,
.spark_pulse_us = 100,
.spark_delay_us = 50,
.pins = {
.pin_trig_12p = PIN_TRIG_B12P,
.pin_trig_12n = PIN_TRIG_B12N,
.pin_trig_34p = PIN_TRIG_B34P,
.pin_trig_34n = PIN_TRIG_B34N,
.pin_spark_12 = SPARK_B12,
.pin_spark_34 = SPARK_B34},
.main_task = NULL};
static bool isEnabled_A = false;
static bool isEnabled_B = false;
void setup() void setup()
{ {
Serial.begin(921600); Serial.begin(115200);
delay(1000); delay(1000);
LOG_ATTACH_SERIAL(Serial); LOG_ATTACH_SERIAL(Serial);
@@ -80,14 +107,26 @@ void setup()
pinMode(SPARK_DELAY_POT, ANALOG); pinMode(SPARK_DELAY_POT, ANALOG);
pinMode(FREQ_POT, ANALOG); pinMode(FREQ_POT, ANALOG);
pinMode(ENABLE_PIN, INPUT_PULLUP); pinMode(ENABLE_PIN_A, INPUT_PULLUP);
pinMode(ENABLE_PIN_B, INPUT_PULLUP);
// get the task handle for the main loop
stsA.main_task = xTaskGetCurrentTaskHandleForCore(1); stsA.main_task = xTaskGetCurrentTaskHandleForCore(1);
stsB.main_task = xTaskGetCurrentTaskHandleForCore(1);
// Begin timer with preset fixed frequency
timerA = timerBegin(FREQUENCY); timerA = timerBegin(FREQUENCY);
timerB = timerBegin(FREQUENCY);
// Stop timers because of autostart
timerStop(timerA); timerStop(timerA);
timerStop(timerB);
// Attach interrupts and call callback every timer expiry
timerAttachInterruptArg(timerA, &onTimer, (void *)&stsA); timerAttachInterruptArg(timerA, &onTimer, (void *)&stsA);
timerAlarm(timerA, 1, true, 0); timerAttachInterruptArg(timerB, &onTimer, (void *)&stsB);
timerAlarm(timerA, 1, true, 0); // infinite number of reloads
timerAlarm(timerB, 1, true, 0);
LOG_INFO("Setup Complete"); LOG_INFO("Setup Complete");
} }
@@ -97,34 +136,58 @@ void loop()
LOG_INFO("Loop: ", count++); LOG_INFO("Loop: ", count++);
uint32_t spark_delay = (uint32_t)(map(analogRead(SPARK_DELAY_POT), 0, 4096, SPARK_DLY_MIN, SPARK_DLY_MAX) / PERIOD_US); uint32_t spark_delay = (uint32_t)(map(analogRead(SPARK_DELAY_POT), 0, 4096, SPARK_DLY_MIN, SPARK_DLY_MAX) / PERIOD_US);
stsA.spark_delay_us = spark_delay * PERIOD_US; stsA.spark_delay_us = spark_delay * PERIOD_US;
if (stsA.spark_delay_us > (SPARK_DLY_MIN + SPARK_DLY_MAX) / 2) { if (stsA.spark_delay_us > (SPARK_DLY_MIN + SPARK_DLY_MAX) / 2)
{
stsA.soft_start = true; stsA.soft_start = true;
stsA.spark_delay_us -= (SPARK_DLY_MIN + SPARK_DLY_MAX) / 2; stsA.spark_delay_us -= (SPARK_DLY_MIN + SPARK_DLY_MAX) / 2;
} else { }
else
{
stsA.soft_start = false; stsA.soft_start = false;
} }
stsB.soft_start = stsA.soft_start;
stsB.spark_delay_us = stsA.spark_delay_us;
double new_rpm = (double)(map(analogRead(FREQ_POT), 0, 4096, RPM_MIN, RPM_MAX)); double new_rpm = (double)(map(analogRead(FREQ_POT), 0, 4096, RPM_MIN, RPM_MAX));
filtered_rpm = filtered_rpm + 0.1 * (new_rpm - filtered_rpm); filtered_rpm = filtered_rpm + 0.1 * (new_rpm - filtered_rpm);
stsA.pause_long_us = (uint32_t)(60000000.0f / filtered_rpm / 2.0f); stsA.pause_long_us = (uint32_t)(60000000.0f / filtered_rpm / 2.0f);
stsB.pause_long_us = stsA.pause_long_us;
if (isEnabled) { if (isEnabled_A)
LOG_INFO("==== System is ENABLED ===="); LOG_INFO("==== System A is ENABLED ====");
} else { else
LOG_INFO("==== System is DISABLED ===="); LOG_INFO("==== System A is DISABLED ====");
}
if (isEnabled_B)
LOG_INFO("==== System B is ENABLED ====");
else
LOG_INFO("==== System B is DISABLED ====");
LOG_INFO("Spark Delay uS: ", stsA.spark_delay_us, "\tSoft Start: ", stsA.soft_start ? "TRUE" : "FALSE"); LOG_INFO("Spark Delay uS: ", stsA.spark_delay_us, "\tSoft Start: ", stsA.soft_start ? "TRUE" : "FALSE");
LOG_INFO("Engine Rpm: ", (uint32_t)(filtered_rpm)); LOG_INFO("Engine Rpm: ", (uint32_t)(filtered_rpm));
LOG_INFO("Coil Pulse: ", stsA.coil_pulse_us, "us"); LOG_INFO("Coil Pulse: ", stsA.coil_pulse_us, "us");
LOG_INFO("Spark Pulse: ", stsA.spark_pulse_us, "us"); LOG_INFO("Spark Pulse: ", stsA.spark_pulse_us, "us");
if (digitalRead(ENABLE_PIN) == LOW && !isEnabled) { if (digitalRead(ENABLE_PIN_A) == LOW && !isEnabled_A)
{
timerStart(timerA); timerStart(timerA);
isEnabled = true; isEnabled_A = true;
} else if (digitalRead(ENABLE_PIN) == HIGH && isEnabled) { }
else if (digitalRead(ENABLE_PIN_A) == HIGH && isEnabled_A)
{
timerStop(timerA); timerStop(timerA);
isEnabled = false; isEnabled_A = false;
}
if (digitalRead(ENABLE_PIN_B) == LOW && !isEnabled_B)
{
timerStart(timerB);
isEnabled_B = true;
}
else if (digitalRead(ENABLE_PIN_B) == HIGH && isEnabled_B)
{
timerStop(timerB);
isEnabled_B = false;
} }
delay(100); delay(100);

3
RotaxMonitorTester/src/pins.h
View File

@@ -1,7 +1,8 @@
#pragma once #pragma once
// Enable Pin // Enable Pin
#define ENABLE_PIN 16 #define ENABLE_PIN_A 16
#define ENABLE_PIN_B 15
///// Ignition Box A ///// ///// Ignition Box A /////
#define PIN_TRIG_A12P 18 #define PIN_TRIG_A12P 18

57
RotaxMonitorTester/src/timer.cpp
View File

@@ -7,20 +7,18 @@ void onTimer(void *arg)
BaseType_t xHigherPriorityTaskWoken = pdFALSE; BaseType_t xHigherPriorityTaskWoken = pdFALSE;
timerStatus *params = (timerStatus *)(arg); timerStatus *params = (timerStatus *)(arg);
TaskHandle_t task = params->main_task; TaskHandle_t task = params->main_task;
const timerPins pins = params->pins;
// increment state time // increment state time
params->state_time += params->clock_period_us; params->state_time += params->clock_period_us;
digitalWrite(PIN_TRIG_B12P, HIGH);
switch (params->state) switch (params->state)
{ {
case S_12P: case S_12P:
if (params->state_time == params->clock_period_us && !params->coil12p_high) if (params->state_time == params->clock_period_us && !params->coil12p_high)
{ {
// xTaskNotifyFromISR(task, PIN_TRIG_A12P, eSetValueWithOverwrite, &xHigherPriorityTaskWoken); digitalWrite(pins.pin_trig_12p, HIGH);
digitalWrite(PIN_TRIG_A12P, HIGH);
params->coil12p_high = true; params->coil12p_high = true;
wait_sent = false; wait_sent = false;
} }
@@ -29,21 +27,18 @@ void onTimer(void *arg)
{ {
if (params->state_time == params->spark_delay_us) if (params->state_time == params->spark_delay_us)
{ {
// xTaskNotifyFromISR(task, SPARK_A12, eSetValueWithOverwrite, &xHigherPriorityTaskWoken); digitalWrite(pins.pin_spark_12, HIGH);
digitalWrite(SPARK_A12, HIGH);
} }
if (params->state_time == (params->spark_delay_us + params->spark_pulse_us)) if (params->state_time == (params->spark_delay_us + params->spark_pulse_us))
{ {
// xTaskNotifyFromISR(task, ~SPARK_A12, eSetValueWithOverwrite, &xHigherPriorityTaskWoken); digitalWrite(pins.pin_spark_12, LOW);
digitalWrite(SPARK_A12, LOW);
} }
} }
if (params->state_time >= params->coil_pulse_us && params->coil12p_high) if (params->state_time >= params->coil_pulse_us && params->coil12p_high)
{ {
// xTaskNotifyFromISR(task, ~PIN_TRIG_A12P, eSetValueWithOverwrite, &xHigherPriorityTaskWoken); digitalWrite(pins.pin_trig_12p, LOW);
digitalWrite(PIN_TRIG_A12P, LOW);
params->coil12p_high = false; params->coil12p_high = false;
} }
@@ -57,8 +52,7 @@ void onTimer(void *arg)
case S_12N: case S_12N:
if (params->state_time == params->clock_period_us && !params->coil12n_high) if (params->state_time == params->clock_period_us && !params->coil12n_high)
{ {
// xTaskNotifyFromISR(task, PIN_TRIG_A12N, eSetValueWithOverwrite, &xHigherPriorityTaskWoken); digitalWrite(pins.pin_trig_12n, HIGH);
digitalWrite(PIN_TRIG_A12N, HIGH);
params->coil12n_high = true; params->coil12n_high = true;
} }
@@ -66,21 +60,18 @@ void onTimer(void *arg)
{ {
if (params->state_time == params->spark_delay_us) if (params->state_time == params->spark_delay_us)
{ {
// xTaskNotifyFromISR(task, SPARK_A12, eSetValueWithOverwrite, &xHigherPriorityTaskWoken); digitalWrite(pins.pin_spark_12, HIGH);
digitalWrite(SPARK_A12, HIGH);
} }
if (params->state_time == (params->spark_delay_us + params->spark_pulse_us)) if (params->state_time == (params->spark_delay_us + params->spark_pulse_us))
{ {
// xTaskNotifyFromISR(task, ~SPARK_A12, eSetValueWithOverwrite, &xHigherPriorityTaskWoken); digitalWrite(pins.pin_spark_12, LOW);
digitalWrite(SPARK_A12, LOW);
} }
} }
if (params->state_time >= params->coil_pulse_us && params->coil12n_high) if (params->state_time >= params->coil_pulse_us && params->coil12n_high)
{ {
// xTaskNotifyFromISR(task, ~PIN_TRIG_A12N, eSetValueWithOverwrite, &xHigherPriorityTaskWoken); digitalWrite(pins.pin_trig_12n, LOW);
digitalWrite(PIN_TRIG_A12N, LOW);
params->coil12n_high = false; params->coil12n_high = false;
params->state = S_WAIT_10MS; params->state = S_WAIT_10MS;
params->state_time = 0; params->state_time = 0;
@@ -90,7 +81,6 @@ void onTimer(void *arg)
case S_WAIT_10MS: case S_WAIT_10MS:
if (!wait_sent) if (!wait_sent)
{ {
// xTaskNotifyFromISR(task, S_WAIT_10MS, eSetValueWithOverwrite, &xHigherPriorityTaskWoken);
wait_sent = true; wait_sent = true;
} }
if (params->state_time >= params->pause_long_us) if (params->state_time >= params->pause_long_us)
@@ -103,8 +93,7 @@ void onTimer(void *arg)
case S_34P: case S_34P:
if (params->state_time == params->clock_period_us && !params->coil34p_high) if (params->state_time == params->clock_period_us && !params->coil34p_high)
{ {
// xTaskNotifyFromISR(task, PIN_TRIG_A34P, eSetValueWithOverwrite, &xHigherPriorityTaskWoken); digitalWrite(pins.pin_trig_34p, HIGH);
digitalWrite(PIN_TRIG_A34P, HIGH);
params->coil34p_high = true;; params->coil34p_high = true;;
wait_sent = false; wait_sent = false;
} }
@@ -113,21 +102,18 @@ void onTimer(void *arg)
{ {
if (params->state_time == params->spark_delay_us) if (params->state_time == params->spark_delay_us)
{ {
// xTaskNotifyFromISR(task, SPARK_A34, eSetValueWithOverwrite, &xHigherPriorityTaskWoken); digitalWrite(pins.pin_spark_34, HIGH);
digitalWrite(SPARK_A34, HIGH);
} }
if (params->state_time == params->spark_delay_us + params->spark_pulse_us) if (params->state_time == params->spark_delay_us + params->spark_pulse_us)
{ {
// xTaskNotifyFromISR(task, ~SPARK_A34, eSetValueWithOverwrite, &xHigherPriorityTaskWoken); digitalWrite(pins.pin_spark_34, LOW);
digitalWrite(SPARK_A34, LOW);
} }
} }
if (params->state_time >= params->coil_pulse_us && params->coil34p_high) if (params->state_time >= params->coil_pulse_us && params->coil34p_high)
{ {
// xTaskNotifyFromISR(task, ~PIN_TRIG_A34P, eSetValueWithOverwrite, &xHigherPriorityTaskWoken); digitalWrite(pins.pin_trig_34p, LOW);
digitalWrite(PIN_TRIG_A34P, LOW);
params->coil34p_high = false; params->coil34p_high = false;
} }
@@ -141,8 +127,7 @@ void onTimer(void *arg)
case S_34N: case S_34N:
if (params->state_time == params->clock_period_us && !params->coil34n_high) if (params->state_time == params->clock_period_us && !params->coil34n_high)
{ {
// xTaskNotifyFromISR(task, PIN_TRIG_A34N, eSetValueWithOverwrite, &xHigherPriorityTaskWoken); digitalWrite(pins.pin_trig_34n, HIGH);
digitalWrite(PIN_TRIG_A34N, HIGH);
params->coil34n_high = true; params->coil34n_high = true;
} }
@@ -150,21 +135,18 @@ void onTimer(void *arg)
{ {
if (params->state_time == params->spark_delay_us) if (params->state_time == params->spark_delay_us)
{ {
// xTaskNotifyFromISR(task, SPARK_A34, eSetValueWithOverwrite, &xHigherPriorityTaskWoken); digitalWrite(pins.pin_spark_34, HIGH);
digitalWrite(SPARK_A34, HIGH);
} }
if (params->state_time == params->spark_delay_us + params->spark_pulse_us) if (params->state_time == params->spark_delay_us + params->spark_pulse_us)
{ {
// xTaskNotifyFromISR(task, ~SPARK_A34, eSetValueWithOverwrite, &xHigherPriorityTaskWoken); digitalWrite(pins.pin_spark_34, LOW);
digitalWrite(SPARK_A34, LOW);
} }
} }
if (params->state_time >= params->coil_pulse_us && params->coil34n_high) if (params->state_time >= params->coil_pulse_us && params->coil34n_high)
{ {
// xTaskNotifyFromISR(task, ~PIN_TRIG_A34N, eSetValueWithOverwrite, &xHigherPriorityTaskWoken); digitalWrite(pins.pin_trig_34n, LOW);
digitalWrite(PIN_TRIG_A34N, LOW);
params->coil34n_high = false; params->coil34n_high = false;
params->state = S_WAIT_10MS_END; params->state = S_WAIT_10MS_END;
params->state_time = 0; params->state_time = 0;
@@ -174,7 +156,6 @@ void onTimer(void *arg)
case S_WAIT_10MS_END: case S_WAIT_10MS_END:
if (!wait_sent) if (!wait_sent)
{ {
// xTaskNotifyFromISR(task, S_WAIT_10MS_END, eSetValueWithOverwrite, &xHigherPriorityTaskWoken);
wait_sent = true; wait_sent = true;
} }
if (params->state_time >= params->pause_long_us) if (params->state_time >= params->pause_long_us)
@@ -184,9 +165,7 @@ void onTimer(void *arg)
} }
break; break;
} }
digitalWrite(PIN_TRIG_B12P, LOW);
if (xHigherPriorityTaskWoken) if (xHigherPriorityTaskWoken)
portYIELD_FROM_ISR(); portYIELD_FROM_ISR();
} }

12
RotaxMonitorTester/src/timer.h
View File

@@ -1,5 +1,7 @@
#pragma once #pragma once
#define DEBUGLOG_DEFAULT_LOG_LEVEL_DEBUG
#include <Arduino.h> #include <Arduino.h>
#include <DebugLog.h> #include <DebugLog.h>
#include "pins.h" #include "pins.h"
@@ -19,6 +21,15 @@ enum State
S_WAIT_10MS_END S_WAIT_10MS_END
}; };
struct timerPins {
const uint8_t pin_trig_12p;
const uint8_t pin_trig_12n;
const uint8_t pin_trig_34p;
const uint8_t pin_trig_34n;
const uint8_t pin_spark_12;
const uint8_t pin_spark_34;
};
struct timerStatus struct timerStatus
{ {
State state = State::S_12P; State state = State::S_12P;
@@ -34,6 +45,7 @@ struct timerStatus
bool coil34p_high = false; bool coil34p_high = false;
bool coil12n_high = false; bool coil12n_high = false;
bool coil34n_high = false; bool coil34n_high = false;
timerPins pins;
TaskHandle_t main_task; TaskHandle_t main_task;
}; };