From ed678af4ca01e7364005768fc98285a0350fb891 Mon Sep 17 00:00:00 2001
From: Lloyd <lloyd@rightup.co.uk>
Date: Wed, 29 Oct 2025 00:08:06 +0000
Subject: [PATCH 01/12] Add TraceHandler for network diagnostics

---
 repeater/main.py | 108 ++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 88 insertions(+), 20 deletions(-)

diff --git a/repeater/main.py b/repeater/main.py
index 8e88715..1835ec5 100644
--- a/repeater/main.py
+++ b/repeater/main.py
@@ -6,6 +6,14 @@ import sys
 from repeater.config import get_radio_for_board, load_config
 from repeater.engine import RepeaterHandler
 from repeater.http_server import HTTPStatsServer, _log_buffer
+from pymc_core.node.handlers.trace import TraceHandler
+from pymc_core.protocol.constants import MAX_PATH_SIZE, ROUTE_TYPE_DIRECT
+
+logger = logging.getLogger("RepeaterDaemon")
+
+
+
+
 
 logger = logging.getLogger("RepeaterDaemon")
 
@@ -21,6 +29,7 @@ class RepeaterDaemon:
         self.local_hash = None
         self.local_identity = None
         self.http_server = None
+        self.trace_handler = None
 
         # Setup logging
         log_level = config.get("logging", {}).get("level", "INFO")
@@ -81,6 +90,16 @@ class RepeaterDaemon:
             self.dispatcher.register_fallback_handler(self._repeater_callback)
             logger.info("Repeater handler registered (forwarder mode)")
 
+            self.trace_handler = TraceHandler(log_fn=logger.info)
+            
+            self.dispatcher.register_handler(
+                TraceHandler.payload_type(),
+                self._trace_callback,
+            )
+            logger.info("Trace handler registered for network diagnostics")
+
+            
+
         except Exception as e:
             logger.error(f"Failed to initialize dispatcher: {e}")
             raise
@@ -96,30 +115,79 @@ class RepeaterDaemon:
             }
             await self.repeater_handler(packet, metadata)
 
-    def _get_keypair(self):
-        """Create a PyNaCl SigningKey for map API."""
+    async def _trace_callback(self, packet):
+
         try:
-            from nacl.signing import SigningKey
+            # Only process direct route trace packets
+            if packet.get_route_type() != ROUTE_TYPE_DIRECT or packet.path_len >= MAX_PATH_SIZE:
+                return
 
-            if not self.local_identity:
-                return None
-
-            # Get the seed from config
-            identity_key = self.config.get("mesh", {}).get("identity_key")
-            if not identity_key:
-                return None
-
-            # Convert to bytes if it's a hex string, otherwise use as-is
-            if isinstance(identity_key, str):
-                seed_bytes = bytes.fromhex(identity_key)
+         
+            parsed_data = self.trace_handler._parse_trace_payload(packet.payload)
+            
+            if not parsed_data.get("valid", False):
+                logger.warning(f"[TraceHandler] Invalid trace packet: {parsed_data.get('error', 'Unknown error')}")
+                return
+            
+            trace_path = parsed_data["trace_path"]
+            trace_path_len = len(trace_path)
+            
+        
+            path_snrs = []
+            path_hashes = []
+            for i in range(packet.path_len):
+                if i < len(packet.path):
+                    snr_val = packet.path[i]
+                    path_snrs.append(f"{snr_val}({snr_val/4:.1f}dB)")
+                if i < len(trace_path):
+                    path_hashes.append(f"0x{trace_path[i]:02x}")
+            
+       
+            parsed_data["snr"] = packet.get_snr()
+            parsed_data["rssi"] = getattr(packet, "rssi", 0)
+            formatted_response = self.trace_handler._format_trace_response(parsed_data)
+            
+            logger.info(f"[TraceHandler] {formatted_response}")
+            logger.info(f"[TraceHandler] Path SNRs: [{', '.join(path_snrs)}], Hashes: [{', '.join(path_hashes)}]")
+            
+     
+            if (packet.path_len < trace_path_len and 
+                len(trace_path) > packet.path_len and
+                trace_path[packet.path_len] == self.local_hash and
+                self.repeater_handler and not self.repeater_handler.is_duplicate(packet)):
+                
+   
+                snr_scaled = int(packet.get_snr() * 4)
+                snr_byte = snr_scaled & 0xFF
+                
+                while len(packet.path) <= packet.path_len:
+                    packet.path.append(0)
+                    
+                packet.path[packet.path_len] = snr_byte
+                packet.path_len += 1
+                
+                logger.info(f"[TraceHandler] Forwarding trace, stored SNR {packet.get_snr():.1f}dB ({snr_byte}) at position {packet.path_len-1}")
+                
+                # Mark as seen and forward directly (bypass normal routing, no ACK required)
+                self.repeater_handler.mark_seen(packet)
+                if self.dispatcher:
+                    await self.dispatcher.send_packet(packet, wait_for_ack=False)
             else:
-                seed_bytes = identity_key
+                # Show why we didn't forward
+                if packet.path_len >= trace_path_len:
+                    logger.info(f"[TraceHandler] Trace completed (reached end of path)")
+                elif len(trace_path) <= packet.path_len:
+                    logger.info(f"[TraceHandler] Path index out of bounds")
+                elif trace_path[packet.path_len] != self.local_hash:
+                    expected_hash = trace_path[packet.path_len] if packet.path_len < len(trace_path) else None
+                    logger.info(f"[TraceHandler] Not our turn (next hop: 0x{expected_hash:02x})")
+                elif self.repeater_handler and self.repeater_handler.is_duplicate(packet):
+                    logger.info(f"[TraceHandler] Duplicate packet, ignoring")
 
-            signing_key = SigningKey(seed_bytes)
-            return signing_key
         except Exception as e:
-            logger.warning(f"Failed to create keypair for map API: {e}")
-            return None
+            logger.error(f"[TraceHandler] Error processing trace packet: {e}")
+
+
 
     def get_stats(self) -> dict:
 
@@ -165,7 +233,7 @@ class RepeaterDaemon:
             )
 
             # Send via dispatcher
-            await self.dispatcher.send_packet(packet)
+            await self.dispatcher.send_packet(packet, wait_for_ack=False)
 
             # Mark our own advert as seen to prevent re-forwarding it
             if self.repeater_handler:

From 85df2c5b0f9b55ae5d0644aa52a09e04d2a2fa07 Mon Sep 17 00:00:00 2001
From: Lloyd <lloyd@rightup.co.uk>
Date: Thu, 30 Oct 2025 00:11:04 +0000
Subject: [PATCH 02/12] Implement trace packet logging and SNR display
 enhancements

---
 repeater/engine.py                |  16 +++-
 repeater/main.py                  |  61 +++++++++++-
 repeater/templates/dashboard.html | 154 +++++++++++++++++++++++++++++-
 3 files changed, 222 insertions(+), 9 deletions(-)

diff --git a/repeater/engine.py b/repeater/engine.py
index d6252dc..3d58c76 100644
--- a/repeater/engine.py
+++ b/repeater/engine.py
@@ -239,6 +239,18 @@ class RepeaterHandler(BaseHandler):
         if len(self.recent_packets) > self.max_recent_packets:
             self.recent_packets.pop(0)
 
+    def log_trace_record(self, packet_record: dict) -> None:
+        self.recent_packets.append(packet_record)
+        
+        self.rx_count += 1
+        if packet_record.get("transmitted", False):
+            self.forwarded_count += 1
+        else:
+            self.dropped_count += 1
+        
+        if len(self.recent_packets) > self.max_recent_packets:
+            self.recent_packets.pop(0)
+
     def cleanup_cache(self):
 
         now = time.time()
@@ -564,10 +576,6 @@ class RepeaterHandler(BaseHandler):
                 logger.error(f"Error sending periodic advert: {e}", exc_info=True)
 
     def get_noise_floor(self) -> Optional[float]:
-        """
-        Get the current noise floor (instantaneous RSSI) from the radio in dBm.
-        Returns None if radio is not available or reading fails.
-        """
         try:
             radio = self.dispatcher.radio if self.dispatcher else None
             if radio and hasattr(radio, 'get_noise_floor'):
diff --git a/repeater/main.py b/repeater/main.py
index 1835ec5..234585f 100644
--- a/repeater/main.py
+++ b/repeater/main.py
@@ -132,7 +132,59 @@ class RepeaterDaemon:
             trace_path = parsed_data["trace_path"]
             trace_path_len = len(trace_path)
             
-        
+          
+            if self.repeater_handler:
+                import time
+                
+                trace_path_bytes = [f"{h:02X}" for h in trace_path[:8]]
+                if len(trace_path) > 8:
+                    trace_path_bytes.append("...")
+                path_hash = "[" + ", ".join(trace_path_bytes) + "]"
+                
+                path_snrs = []
+                path_snr_details = []
+                for i in range(packet.path_len):
+                    if i < len(packet.path):
+                        snr_val = packet.path[i]
+                        snr_db = snr_val / 4.0
+                        path_snrs.append(f"{snr_val}({snr_db:.1f}dB)")
+                        # Create hash->SNR mapping for display
+                        if i < len(trace_path):
+                            path_snr_details.append({
+                                "hash": f"{trace_path[i]:02X}",
+                                "snr_raw": snr_val,
+                                "snr_db": snr_db
+                            })
+                
+                packet_record = {
+                    "timestamp": time.time(),
+                    "type": packet.get_payload_type(),  # 0x09 for trace
+                    "route": packet.get_route_type(),   # Should be direct (1)
+                    "length": len(packet.payload or b""),
+                    "rssi": getattr(packet, "rssi", 0),
+                    "snr": getattr(packet, "snr", 0.0),
+                    "score": self.repeater_handler.calculate_packet_score(
+                        getattr(packet, "snr", 0.0), 
+                        len(packet.payload or b""), 
+                        self.repeater_handler.radio_config.get("spreading_factor", 8)
+                    ),
+                    "tx_delay_ms": 0,  
+                    "transmitted": False,  
+                    "is_duplicate": False,  
+                    "packet_hash": packet.calculate_packet_hash().hex()[:16],
+                    "drop_reason": "trace_received",
+                    "path_hash": path_hash,
+                    "src_hash": None,  
+                    "dst_hash": None,
+                    "original_path": [f"{h:02X}" for h in trace_path],  
+                    "forwarded_path": None,
+                    # Add trace-specific SNR path information
+                    "path_snrs": path_snrs,  # ["58(14.5dB)", "19(4.8dB)"]
+                    "path_snr_details": path_snr_details,  # [{"hash": "29", "snr_raw": 58, "snr_db": 14.5}]
+                    "is_trace": True,  
+                }
+                self.repeater_handler.log_trace_record(packet_record)
+    
             path_snrs = []
             path_hashes = []
             for i in range(packet.path_len):
@@ -156,6 +208,13 @@ class RepeaterDaemon:
                 trace_path[packet.path_len] == self.local_hash and
                 self.repeater_handler and not self.repeater_handler.is_duplicate(packet)):
                 
+                if self.repeater_handler and hasattr(self.repeater_handler, 'recent_packets'):
+                    packet_hash = packet.calculate_packet_hash().hex()[:16]
+                    for record in reversed(self.repeater_handler.recent_packets):
+                        if record.get("packet_hash") == packet_hash:
+                            record["transmitted"] = True
+                            record["drop_reason"] = "trace_forwarded"
+                            break
    
                 snr_scaled = int(packet.get_snr() * 4)
                 snr_byte = snr_scaled & 0xFF
diff --git a/repeater/templates/dashboard.html b/repeater/templates/dashboard.html
index 50946f9..da558db 100644
--- a/repeater/templates/dashboard.html
+++ b/repeater/templates/dashboard.html
@@ -229,6 +229,61 @@
                 <span class="signal-bars ${className}" title="Signal: ${className.replace('signal-', '')}">${'<span class="signal-bar"></span>'.repeat(4)}</span>
                 <span class="snr-value">${snr.toFixed(1)} dB</span>
             </div>`;
+        }
+
+        // Helper function to display SNR for trace packets with path information
+        function getTraceSnrDisplay(pkt, localHash) {
+            if (!pkt.is_trace || !pkt.path_snr_details || pkt.path_snr_details.length === 0) {
+                // Regular packet or no path SNR data
+                return getSignalBars(pkt.snr);
+            }
+
+            // Build trace path SNR display
+            let pathSnrHtml = `<div class="trace-snr-container">`;
+            
+            // Show received packet SNR first
+            pathSnrHtml += `<div class="rx-snr">${getSignalBars(pkt.snr)}</div>`;
+            
+            // Show path SNRs if available
+            if (pkt.path_snr_details.length > 0) {
+                pathSnrHtml += `<div class="path-snrs">`;
+                pathSnrHtml += `<div class="path-snr-label">Path (${pkt.path_snr_details.length} hops):</div>`;
+                
+                // Handle many hops - show first few and indicate if there are more
+                const maxDisplayHops = 4;
+                const hopsToShow = pkt.path_snr_details.slice(0, maxDisplayHops);
+                const hasMoreHops = pkt.path_snr_details.length > maxDisplayHops;
+                
+                hopsToShow.forEach((pathSnr, index) => {
+                    const isMyHash = localHash && pathSnr.hash === localHash;
+                    const hashClass = isMyHash ? 'my-hash' : 'path-hash';
+                    
+                    // Get signal quality class for color coding
+                    let snrClass = 'snr-poor';
+                    if (pathSnr.snr_db >= 10) snrClass = 'snr-excellent';
+                    else if (pathSnr.snr_db >= 5) snrClass = 'snr-good';
+                    else if (pathSnr.snr_db >= 0) snrClass = 'snr-fair';
+                    
+                    pathSnrHtml += `<div class="path-snr-item">
+                        <span class="hop-index">${index + 1}.</span>
+                        <span class="${hashClass}">${pathSnr.hash}</span>
+                        <span class="snr-value ${snrClass}">${pathSnr.snr_db.toFixed(1)}dB</span>
+                    </div>`;
+                });
+                
+                // Show indicator if there are more hops
+                if (hasMoreHops) {
+                    const remainingCount = pkt.path_snr_details.length - maxDisplayHops;
+                    pathSnrHtml += `<div class="path-snr-item">
+                        <span class="more-hops">+${remainingCount} more hop${remainingCount > 1 ? 's' : ''}</span>
+                    </div>`;
+                }
+                
+                pathSnrHtml += `</div>`;
+            }
+            
+            pathSnrHtml += `</div>`;
+            return pathSnrHtml;
         }        function updatePacketTable(packets, localHash) {
             const tbody = document.getElementById('packet-table');
 
@@ -244,7 +299,13 @@
             }
 
             tbody.innerHTML = packets.slice(-20).map(pkt => {
-                const time = new Date(pkt.timestamp * 1000).toLocaleTimeString();
+                const time = new Date(pkt.timestamp * 1000).toLocaleTimeString('en-US', {
+                    hour12: false,
+                    hour: '2-digit',
+                    minute: '2-digit',
+                    second: '2-digit',
+                    fractionalSecondDigits: 3
+                });
                 // Match pyMC_core PAYLOAD_TYPES exactly (from constants.py)
                 const typeNames = {
                     0: 'REQ',
@@ -327,7 +388,7 @@
                         <td data-label="Len">${pkt.length}B</td>
                         <td data-label="Path/Hashes">${pathHashesHtml}</td>
                         <td data-label="RSSI">${pkt.rssi}</td>
-                        <td data-label="SNR">${getSignalBars(pkt.snr)}</td>
+                        <td data-label="SNR">${getTraceSnrDisplay(pkt, localHash)}</td>
                         <td data-label="Score"><span class="score">${pkt.score.toFixed(2)}</span></td>
                         <td data-label="TX Delay">${pkt.tx_delay_ms.toFixed(0)}ms</td>
                         <td data-label="Status">${statusHtml}</td>
@@ -337,7 +398,13 @@
                 // Add duplicate rows (always visible)
                 if (hasDuplicates) {
                     mainRow += pkt.duplicates.map(dupe => {
-                        const dupeTime = new Date(dupe.timestamp * 1000).toLocaleTimeString();
+                        const dupeTime = new Date(dupe.timestamp * 1000).toLocaleTimeString('en-US', {
+                            hour12: false,
+                            hour: '2-digit',
+                            minute: '2-digit',
+                            second: '2-digit',
+                            fractionalSecondDigits: 3
+                        });
                         const dupeRoute = routeNames[dupe.route] || `UNKNOWN_${dupe.route}`;
 
                         // Format duplicate path/hashes - match main row format
@@ -375,7 +442,7 @@
                                 <td data-label="Len">${dupe.length}B</td>
                                 <td data-label="Path/Hashes">${dupePathHashesHtml}</td>
                                 <td data-label="RSSI">${dupe.rssi}</td>
-                                <td data-label="SNR">${getSignalBars(dupe.snr)}</td>
+                                <td data-label="SNR">${getTraceSnrDisplay(dupe, localHash)}</td>
                                 <td data-label="Score"><span class="score">${dupe.score.toFixed(2)}</span></td>
                                 <td data-label="TX Delay">${dupe.tx_delay_ms.toFixed(0)}ms</td>
                                 <td data-label="Status">${dupeStatusHtml}</td>
@@ -589,6 +656,85 @@
             font-size: 0.8em;
             color: #999;
             white-space: nowrap;
+        }
+
+        /* Trace packet SNR display */
+        .trace-snr-container {
+            display: flex;
+            flex-direction: column;
+            gap: 6px;
+            align-items: center;
+            min-width: 120px;
+        }
+        .rx-snr {
+            border-bottom: 1px solid rgba(255, 255, 255, 0.1);
+            padding-bottom: 4px;
+        }
+        .path-snrs {
+            display: flex;
+            flex-direction: column;
+            gap: 2px;
+            font-size: 0.85em;
+            width: 100%;
+        }
+        .path-snr-label {
+            font-size: 0.75em;
+            color: #888;
+            text-align: center;
+            margin-bottom: 2px;
+            font-weight: 500;
+        }
+        .path-snr-item {
+            display: flex;
+            align-items: center;
+            gap: 4px;
+            white-space: nowrap;
+            justify-content: space-between;
+        }
+        .hop-index {
+            font-size: 0.7em;
+            color: #666;
+            min-width: 16px;
+            text-align: right;
+        }
+        .path-snr-item .path-hash {
+            font-family: 'Courier New', monospace;
+            font-size: 0.75em;
+            color: #dcdcaa;
+            background: rgba(220, 220, 170, 0.1);
+            padding: 1px 3px;
+            border-radius: 3px;
+            min-width: 24px;
+            text-align: center;
+        }
+        .path-snr-item .my-hash {
+            font-family: 'Courier New', monospace;
+            font-size: 0.75em;
+            background: rgba(86, 156, 214, 0.2);
+            color: #569cd6;
+            font-weight: 700;
+            padding: 1px 3px;
+            border-radius: 3px;
+            min-width: 24px;
+            text-align: center;
+        }
+        .path-snr-item .snr-value {
+            font-size: 0.75em;
+            font-weight: 500;
+            min-width: 48px;
+            text-align: right;
+        }
+        /* SNR quality color coding */
+        .snr-excellent { color: #4ade80; }
+        .snr-good { color: #4ec9b0; }
+        .snr-fair { color: #fbbf24; }
+        .snr-poor { color: #f48771; }
+        .more-hops {
+            font-size: 0.7em;
+            color: #888;
+            font-style: italic;
+            text-align: center;
+            width: 100%;
         }        /* Path/Hashes column layout */
         .path-info {
             display: flex;

From 1c5b67de95064d7c4f1014cb9c8ce5428c9d1077 Mon Sep 17 00:00:00 2001
From: Lloyd <lloyd@rightup.co.uk>
Date: Fri, 31 Oct 2025 00:15:41 +0000
Subject: [PATCH 03/12] CAD radio initialization and SNR handling in
 RepeaterDaemon

---
 repeater/main.py | 54 ++++++++++++++++++++++++++++++++++++++----------
 1 file changed, 43 insertions(+), 11 deletions(-)

diff --git a/repeater/main.py b/repeater/main.py
index 234585f..617da3c 100644
--- a/repeater/main.py
+++ b/repeater/main.py
@@ -31,14 +31,13 @@ class RepeaterDaemon:
         self.http_server = None
         self.trace_handler = None
 
-        # Setup logging
+
         log_level = config.get("logging", {}).get("level", "INFO")
         logging.basicConfig(
             level=getattr(logging, log_level),
             format=config.get("logging", {}).get("format"),
         )
 
-        # Add log buffer handler to capture logs for web display
         root_logger = logging.getLogger()
         _log_buffer.setLevel(getattr(logging, log_level))
         root_logger.addHandler(_log_buffer)
@@ -51,12 +50,32 @@ class RepeaterDaemon:
             logger.info("Initializing radio hardware...")
             try:
                 self.radio = get_radio_for_board(self.config)
+                
+
+                if hasattr(self.radio, 'set_custom_cad_thresholds'):
+                    self.radio.set_custom_cad_thresholds(peak=23, min_val=11)
+                    logger.info("CAD thresholds set: peak=23, min=11")
+                else:
+                    logger.warning("Radio does not support CAD configuration")
+                
+
+                if hasattr(self.radio, 'get_frequency'):
+                    logger.info(f"Radio config - Freq: {self.radio.get_frequency():.1f}MHz")
+                if hasattr(self.radio, 'get_spreading_factor'):
+                    logger.info(f"Radio config - SF: {self.radio.get_spreading_factor()}")
+                if hasattr(self.radio, 'get_bandwidth'):
+                    logger.info(f"Radio config - BW: {self.radio.get_bandwidth()}kHz")
+                if hasattr(self.radio, 'get_coding_rate'):
+                    logger.info(f"Radio config - CR: {self.radio.get_coding_rate()}")
+                if hasattr(self.radio, 'get_tx_power'):
+                    logger.info(f"Radio config - TX Power: {self.radio.get_tx_power()}dBm")
+                
                 logger.info("Radio hardware initialized")
             except Exception as e:
                 logger.error(f"Failed to initialize radio hardware: {e}")
                 raise RuntimeError("Repeater requires real LoRa hardware") from e
 
-        # Create dispatcher from pymc_core
+
         try:
             from pymc_core import LocalIdentity
             from pymc_core.node.dispatcher import Dispatcher
@@ -73,14 +92,14 @@ class RepeaterDaemon:
             self.local_identity = local_identity
             self.dispatcher.local_identity = local_identity
 
-            # Get the actual hash from the identity (first byte of public key)
+
             pubkey = local_identity.get_public_key()
             self.local_hash = pubkey[0]
             logger.info(f"Local identity set: {local_identity.get_address_bytes().hex()}")
             local_hash_hex = f"0x{self.local_hash: 02x}"
             logger.info(f"Local node hash (from identity): {local_hash_hex}")
 
-            # Override _is_own_packet to always return False
+
             self.dispatcher._is_own_packet = lambda pkt: False
 
             self.repeater_handler = RepeaterHandler(
@@ -146,9 +165,11 @@ class RepeaterDaemon:
                 for i in range(packet.path_len):
                     if i < len(packet.path):
                         snr_val = packet.path[i]
-                        snr_db = snr_val / 4.0
+                   
+                        snr_signed = snr_val if snr_val < 128 else snr_val - 256
+                        snr_db = snr_signed / 4.0
                         path_snrs.append(f"{snr_val}({snr_db:.1f}dB)")
-                        # Create hash->SNR mapping for display
+                 
                         if i < len(trace_path):
                             path_snr_details.append({
                                 "hash": f"{trace_path[i]:02X}",
@@ -190,7 +211,9 @@ class RepeaterDaemon:
             for i in range(packet.path_len):
                 if i < len(packet.path):
                     snr_val = packet.path[i]
-                    path_snrs.append(f"{snr_val}({snr_val/4:.1f}dB)")
+                    snr_signed = snr_val if snr_val < 128 else snr_val - 256
+                    snr_db = snr_signed / 4.0
+                    path_snrs.append(f"{snr_val}({snr_db:.1f}dB)")
                 if i < len(trace_path):
                     path_hashes.append(f"0x{trace_path[i]:02x}")
             
@@ -216,16 +239,25 @@ class RepeaterDaemon:
                             record["drop_reason"] = "trace_forwarded"
                             break
    
-                snr_scaled = int(packet.get_snr() * 4)
-                snr_byte = snr_scaled & 0xFF
+                current_snr = packet.get_snr()
                 
+    
+                snr_scaled = int(current_snr * 4)
+       
+                if snr_scaled > 127:
+                    snr_scaled = 127
+                elif snr_scaled < -128:
+                    snr_scaled = -128
+
+                snr_byte = snr_scaled if snr_scaled >= 0 else (256 + snr_scaled)
+        
                 while len(packet.path) <= packet.path_len:
                     packet.path.append(0)
                     
                 packet.path[packet.path_len] = snr_byte
                 packet.path_len += 1
                 
-                logger.info(f"[TraceHandler] Forwarding trace, stored SNR {packet.get_snr():.1f}dB ({snr_byte}) at position {packet.path_len-1}")
+                logger.info(f"[TraceHandler] Forwarding trace, stored SNR {current_snr:.1f}dB at position {packet.path_len-1}")
                 
                 # Mark as seen and forward directly (bypass normal routing, no ACK required)
                 self.repeater_handler.mark_seen(packet)

From 2564f4b7728705075e91c07372732e753b7c4dc2 Mon Sep 17 00:00:00 2001
From: Lloyd <lloyd@rightup.co.uk>
Date: Fri, 31 Oct 2025 08:51:31 +0000
Subject: [PATCH 04/12] Fix formatting in log messages and debug statements for
 consistency

---
 repeater/engine.py | 40 ++++++++++++++++++++--------------------
 1 file changed, 20 insertions(+), 20 deletions(-)

diff --git a/repeater/engine.py b/repeater/engine.py
index 3d58c76..163c342 100644
--- a/repeater/engine.py
+++ b/repeater/engine.py
@@ -90,7 +90,7 @@ class RepeaterHandler(BaseHandler):
         monitor_mode = mode == "monitor"
 
         logger.debug(
-            f"RX packet: header=0x{packet.header: 02x}, payload_len={len(packet.payload or b'')}, "
+            f"RX packet: header=0x{packet.header:02x}, payload_len={len(packet.payload or b'')}, "
             f"path_len={len(packet.path) if packet.path else 0}, "
             f"rssi={metadata.get('rssi', 'N/A')}, snr={metadata.get('snr', 'N/A')}, mode={mode}"
         )
@@ -123,8 +123,8 @@ class RepeaterHandler(BaseHandler):
 
             if not can_tx:
                 logger.warning(
-                    f"Duty-cycle limit exceeded. Airtime={airtime_ms: .1f}ms, "
-                    f"wait={wait_time: .1f}s before retry"
+                    f"Duty-cycle limit exceeded. Airtime={airtime_ms:.1f}ms, "
+                    f"wait={wait_time:.1f}s before retry"
                 )
                 self.dropped_count += 1
                 drop_reason = "Duty cycle limit"
@@ -152,7 +152,7 @@ class RepeaterHandler(BaseHandler):
             payload_type = header_info["payload_type"]
             route_type = header_info["route_type"]
             logger.debug(
-                f"Packet header=0x{packet.header: 02x}, type={payload_type}, route={route_type}"
+                f"Packet header=0x{packet.header:02x}, type={payload_type}, route={route_type}"
             )
 
         # Check if this is a duplicate
@@ -173,7 +173,7 @@ class RepeaterHandler(BaseHandler):
         )
         if display_path and len(display_path) > 0:
             # Format path as array of uppercase hex bytes
-            path_bytes = [f"{b: 02X}" for b in display_path[:8]]  # First 8 bytes max
+            path_bytes = [f"{b:02X}" for b in display_path[:8]]  # First 8 bytes max
             if len(display_path) > 8:
                 path_bytes.append("...")
             path_hash = "[" + ", ".join(path_bytes) + "]"
@@ -184,13 +184,13 @@ class RepeaterHandler(BaseHandler):
         # Payload types with dest_hash and src_hash as first 2 bytes
         if payload_type in [0x00, 0x01, 0x02, 0x08]:
             if hasattr(packet, "payload") and packet.payload and len(packet.payload) >= 2:
-                dst_hash = f"{packet.payload[0]: 02X}"
-                src_hash = f"{packet.payload[1]: 02X}"
+                dst_hash = f"{packet.payload[0]:02X}"
+                src_hash = f"{packet.payload[1]:02X}"
 
         # ADVERT packets have source identifier as first byte
         elif payload_type == PAYLOAD_TYPE_ADVERT:
             if hasattr(packet, "payload") and packet.payload and len(packet.payload) >= 1:
-                src_hash = f"{packet.payload[0]: 02X}"
+                src_hash = f"{packet.payload[0]:02X}"
 
         # Record packet for charts
         packet_record = {
@@ -211,9 +211,9 @@ class RepeaterHandler(BaseHandler):
             "path_hash": path_hash,
             "src_hash": src_hash,
             "dst_hash": dst_hash,
-            "original_path": ([f"{b: 02X}" for b in original_path] if original_path else None),
+            "original_path": ([f"{b:02X}" for b in original_path] if original_path else None),
             "forwarded_path": (
-                [f"{b: 02X}" for b in forwarded_path] if forwarded_path is not None else None
+                [f"{b:02X}" for b in forwarded_path] if forwarded_path is not None else None
             ),
         }
 
@@ -421,7 +421,7 @@ class RepeaterHandler(BaseHandler):
         next_hop = packet.path[0]
         if next_hop != self.local_hash:
             logger.debug(
-                f"Direct: not our hop (next={next_hop: 02X}, local={self.local_hash: 02X})"
+                f"Direct: not our hop (next={next_hop:02X}, local={self.local_hash:02X})"
             )
             return None
 
@@ -429,8 +429,8 @@ class RepeaterHandler(BaseHandler):
         packet.path = bytearray(packet.path[1:])
         packet.path_len = len(packet.path)
 
-        old_path = [f"{b: 02X}" for b in original_path]
-        new_path = [f"{b: 02X}" for b in packet.path]
+        old_path = [f"{b:02X}" for b in original_path]
+        new_path = [f"{b:02X}" for b in packet.path]
         logger.debug(f"Direct: forwarding, path {old_path} -> {new_path}")
 
         return packet
@@ -495,8 +495,8 @@ class RepeaterHandler(BaseHandler):
             score_multiplier = max(0.2, 1.0 - score)
             delay_s = delay_s * score_multiplier
             logger.debug(
-                f"Congestion detected (delay >= 50ms), score={score: .2f}, "
-                f"delay multiplier={score_multiplier: .2f}"
+                f"Congestion detected (delay >= 50ms), score={score:.2f}, "
+                f"delay multiplier={score_multiplier:.2f}"
             )
 
         # Cap at 5 seconds maximum
@@ -504,7 +504,7 @@ class RepeaterHandler(BaseHandler):
 
         logger.debug(
             f"Route={'FLOOD' if route_type == ROUTE_TYPE_FLOOD else 'DIRECT'}, "
-            f"len={packet_len}B, airtime={airtime_ms: .1f}ms, delay={delay_s: .3f}s"
+            f"len={packet_len}B, airtime={airtime_ms:.1f}ms, delay={delay_s:.3f}s"
         )
 
         return delay_s
@@ -542,7 +542,7 @@ class RepeaterHandler(BaseHandler):
                     self.airtime_mgr.record_tx(airtime_ms)
                 packet_size = len(fwd_pkt.payload)
                 logger.info(
-                    f"Retransmitted packet ({packet_size} bytes, {airtime_ms: .1f}ms airtime)"
+                    f"Retransmitted packet ({packet_size} bytes, {airtime_ms:.1f}ms airtime)"
                 )
             except Exception as e:
                 logger.error(f"Retransmit failed: {e}")
@@ -561,8 +561,8 @@ class RepeaterHandler(BaseHandler):
         # Check if interval has elapsed
         if time_since_last_advert >= interval_seconds:
             logger.info(
-                f"Periodic advert interval elapsed ({time_since_last_advert: .0f}s >= "
-                f"{interval_seconds: .0f}s). Sending advert..."
+                f"Periodic advert interval elapsed ({time_since_last_advert:.0f}s >= "
+                f"{interval_seconds:.0f}s). Sending advert..."
             )
             try:
                 # Call the send_advert function
@@ -607,7 +607,7 @@ class RepeaterHandler(BaseHandler):
         noise_floor_dbm = self.get_noise_floor()
 
         stats = {
-            "local_hash": f"0x{self.local_hash: 02x}",
+            "local_hash": f"0x{self.local_hash:02x}",
             "duplicate_cache_size": len(self.seen_packets),
             "cache_ttl": self.cache_ttl,
             "rx_count": self.rx_count,

From 3fc295e26cb06f377ce63b19bfb4ab6598c1ccbb Mon Sep 17 00:00:00 2001
From: Lloyd <lloyd@rightup.co.uk>
Date: Fri, 31 Oct 2025 22:10:45 +0000
Subject: [PATCH 05/12] Add CAD calibration tool and endpoints for real-time
 detection optimization

---
 repeater/http_server.py                 | 271 +++++++++-
 repeater/main.py                        |   2 +
 repeater/templates/cad-calibration.html | 634 ++++++++++++++++++++++++
 repeater/templates/configuration.html   |   9 +
 4 files changed, 915 insertions(+), 1 deletion(-)
 create mode 100644 repeater/templates/cad-calibration.html

diff --git a/repeater/http_server.py b/repeater/http_server.py
index ee519c4..35bb83d 100644
--- a/repeater/http_server.py
+++ b/repeater/http_server.py
@@ -1,9 +1,13 @@
+import asyncio
+import json
 import logging
 import os
 import re
+import threading
+import time
 from collections import deque
 from datetime import datetime
-from typing import Callable, Optional
+from typing import Callable, Optional, Dict, Any
 
 import cherrypy
 from pymc_core.protocol.utils import PAYLOAD_TYPES, ROUTE_TYPES
@@ -40,6 +44,190 @@ class LogBuffer(logging.Handler):
 _log_buffer = LogBuffer(max_lines=100)
 
 
+class CADCalibrationEngine:
+    """Real-time CAD calibration engine"""
+    
+    def __init__(self, stats_getter: Optional[Callable] = None, event_loop=None):
+        self.stats_getter = stats_getter
+        self.event_loop = event_loop
+        self.running = False
+        self.results = {}
+        self.current_test = None
+        self.progress = {"current": 0, "total": 0}
+        self.clients = set()  # SSE clients
+        self.calibration_thread = None
+        
+    def get_test_ranges(self, spreading_factor: int):
+        """Get CAD test ranges based on spreading factor"""
+        sf_ranges = {
+            7:  (range(16, 29, 1), range(6, 15, 1)),
+            8:  (range(16, 29, 1), range(6, 15, 1)),  
+            9:  (range(18, 31, 1), range(7, 16, 1)),
+            10: (range(20, 33, 1), range(8, 16, 1)),
+            11: (range(22, 35, 1), range(9, 17, 1)),
+            12: (range(24, 37, 1), range(10, 18, 1)),
+        }
+        return sf_ranges.get(spreading_factor, sf_ranges[8])
+    
+    async def test_cad_config(self, radio, det_peak: int, det_min: int, samples: int = 8) -> Dict[str, Any]:
+        """Test a single CAD configuration with multiple samples"""
+        detections = 0
+        
+        for _ in range(samples):
+            try:
+                result = await radio.perform_cad(det_peak=det_peak, det_min=det_min, timeout=0.6)
+                if result:
+                    detections += 1
+            except Exception:
+                pass
+            await asyncio.sleep(0.03)
+        
+        return {
+            'det_peak': det_peak,
+            'det_min': det_min,
+            'samples': samples,  
+            'detections': detections,
+            'detection_rate': (detections / samples) * 100,
+        }
+    
+    def broadcast_to_clients(self, data):
+        """Send data to all connected SSE clients"""
+        message = f"data: {json.dumps(data)}\n\n"
+        for client in self.clients.copy():
+            try:
+                client.write(message.encode())
+                client.flush()
+            except Exception:
+                self.clients.discard(client)
+    
+    def calibration_worker(self, samples: int, delay_ms: int):
+        """Worker thread for calibration process"""
+        try:
+            # Get radio from stats
+            if not self.stats_getter:
+                self.broadcast_to_clients({"type": "error", "message": "No stats getter available"})
+                return
+                
+            stats = self.stats_getter()
+            if not stats or "radio_instance" not in stats:
+                self.broadcast_to_clients({"type": "error", "message": "Radio instance not available"})
+                return
+                
+            radio = stats["radio_instance"]
+            if not hasattr(radio, 'perform_cad'):
+                self.broadcast_to_clients({"type": "error", "message": "Radio does not support CAD"})
+                return
+            
+            # Get spreading factor
+            config = stats.get("config", {})
+            radio_config = config.get("radio", {})
+            sf = radio_config.get("spreading_factor", 8)
+            
+            # Get test ranges
+            peak_range, min_range = self.get_test_ranges(sf)
+            
+            total_tests = len(peak_range) * len(min_range)
+            self.progress = {"current": 0, "total": total_tests}
+            
+            self.broadcast_to_clients({
+                "type": "status", 
+                "message": f"Starting calibration: SF{sf}, {total_tests} tests"
+            })
+            
+            current = 0
+            
+            # Run calibration in event loop
+            if self.event_loop:
+                for det_peak in peak_range:
+                    if not self.running:
+                        break
+                        
+                    for det_min in min_range:
+                        if not self.running:
+                            break
+                            
+                        current += 1
+                        self.progress["current"] = current
+                        
+                        # Update progress
+                        self.broadcast_to_clients({
+                            "type": "progress",
+                            "current": current,
+                            "total": total_tests,
+                            "peak": det_peak,
+                            "min": det_min
+                        })
+                        
+                        # Run the test
+                        future = asyncio.run_coroutine_threadsafe(
+                            self.test_cad_config(radio, det_peak, det_min, samples),
+                            self.event_loop
+                        )
+                        
+                        try:
+                            result = future.result(timeout=30)  # 30 second timeout per test
+                            
+                            # Store result
+                            key = f"{det_peak}-{det_min}"
+                            self.results[key] = result
+                            
+                            # Send result to clients
+                            self.broadcast_to_clients({
+                                "type": "result",
+                                **result
+                            })
+                        except Exception as e:
+                            logger.error(f"CAD test failed for peak={det_peak}, min={det_min}: {e}")
+                            
+                        # Delay between tests
+                        if self.running and delay_ms > 0:
+                            time.sleep(delay_ms / 1000.0)
+            
+            if self.running:
+                self.broadcast_to_clients({"type": "completed", "message": "Calibration completed"})
+            else:
+                self.broadcast_to_clients({"type": "status", "message": "Calibration stopped"})
+                
+        except Exception as e:
+            logger.error(f"Calibration worker error: {e}")
+            self.broadcast_to_clients({"type": "error", "message": str(e)})
+        finally:
+            self.running = False
+    
+    def start_calibration(self, samples: int = 8, delay_ms: int = 100):
+        """Start calibration process"""
+        if self.running:
+            return False
+            
+        self.running = True
+        self.results.clear()
+        self.progress = {"current": 0, "total": 0}
+        
+        # Start calibration in separate thread
+        self.calibration_thread = threading.Thread(
+            target=self.calibration_worker,
+            args=(samples, delay_ms)
+        )
+        self.calibration_thread.daemon = True
+        self.calibration_thread.start()
+        
+        return True
+    
+    def stop_calibration(self):
+        """Stop calibration process"""
+        self.running = False
+        if self.calibration_thread:
+            self.calibration_thread.join(timeout=2)
+    
+    def add_client(self, response_stream):
+        """Add SSE client"""
+        self.clients.add(response_stream)
+    
+    def remove_client(self, response_stream):
+        """Remove SSE client"""
+        self.clients.discard(response_stream)
+
+
 class APIEndpoints:
 
     def __init__(
@@ -54,6 +242,9 @@ class APIEndpoints:
         self.send_advert_func = send_advert_func
         self.config = config or {}
         self.event_loop = event_loop  # Store reference to main event loop
+        
+        # Initialize CAD calibration engine
+        self.cad_calibration = CADCalibrationEngine(stats_getter, event_loop)
 
     @cherrypy.expose
     @cherrypy.tools.json_out()
@@ -167,6 +358,78 @@ class APIEndpoints:
             logger.error(f"Error fetching logs: {e}")
             return {"error": str(e), "logs": []}
 
+    # CAD Calibration endpoints
+    @cherrypy.expose
+    @cherrypy.tools.json_out()  
+    @cherrypy.tools.json_in()
+    def cad_calibration_start(self):
+        """Start CAD calibration"""
+        if cherrypy.request.method != "POST":
+            return {"success": False, "error": "Method not allowed"}
+        
+        try:
+            data = cherrypy.request.json or {}
+            samples = data.get("samples", 8)
+            delay = data.get("delay", 100)
+            
+            if self.cad_calibration.start_calibration(samples, delay):
+                return {"success": True, "message": "Calibration started"}
+            else:
+                return {"success": False, "error": "Calibration already running"}
+                
+        except Exception as e:
+            logger.error(f"Error starting CAD calibration: {e}")
+            return {"success": False, "error": str(e)}
+    
+    @cherrypy.expose
+    @cherrypy.tools.json_out()
+    def cad_calibration_stop(self):
+        """Stop CAD calibration"""
+        if cherrypy.request.method != "POST":
+            return {"success": False, "error": "Method not allowed"}
+        
+        try:
+            self.cad_calibration.stop_calibration()
+            return {"success": True, "message": "Calibration stopped"}
+        except Exception as e:
+            logger.error(f"Error stopping CAD calibration: {e}")
+            return {"success": False, "error": str(e)}
+    
+    @cherrypy.expose
+    def cad_calibration_stream(self):
+        """Server-Sent Events stream for real-time updates"""
+        cherrypy.response.headers['Content-Type'] = 'text/event-stream'
+        cherrypy.response.headers['Cache-Control'] = 'no-cache'
+        cherrypy.response.headers['Connection'] = 'keep-alive'
+        cherrypy.response.headers['Access-Control-Allow-Origin'] = '*'
+        
+        def generate():
+            # Add client to calibration engine
+            response = cherrypy.response
+            self.cad_calibration.add_client(response)
+            
+            try:
+                # Send initial connection message
+                yield f"data: {json.dumps({'type': 'connected', 'message': 'Connected to CAD calibration stream'})}\n\n"
+                
+                # Keep connection alive - the calibration engine will send data
+                while True:
+                    time.sleep(1)
+                    # Send keepalive every second
+                    yield f"data: {json.dumps({'type': 'keepalive'})}\n\n"
+                    
+            except Exception as e:
+                logger.error(f"SSE stream error: {e}")
+            finally:
+                # Remove client when connection closes
+                self.cad_calibration.remove_client(response)
+        
+        return generate()
+    
+    cad_calibration_stream._cp_config = {'response.stream': True}
+
+
+
 
 class StatsApp:
 
@@ -231,6 +494,11 @@ class StatsApp:
         """Serve help documentation."""
         return self._serve_template("help.html")
 
+    @cherrypy.expose
+    def cad_calibration(self):
+        """Serve CAD calibration page."""
+        return self._serve_template("cad-calibration.html")
+
     def _serve_template(self, template_name: str):
         """Serve HTML template with stats."""
         if not self.template_dir:
@@ -270,6 +538,7 @@ class StatsApp:
                 "neighbors.html": "neighbors",
                 "statistics.html": "statistics",
                 "configuration.html": "configuration",
+                "cad-calibration.html": "cad-calibration",
                 "logs.html": "logs",
                 "help.html": "help",
             }
diff --git a/repeater/main.py b/repeater/main.py
index 617da3c..7f78e74 100644
--- a/repeater/main.py
+++ b/repeater/main.py
@@ -291,6 +291,8 @@ class RepeaterDaemon:
                     stats["public_key"] = pubkey.hex()
                 except Exception:
                     stats["public_key"] = None
+            if self.radio:
+                stats["radio_instance"] = self.radio
             return stats
         return {}
 
diff --git a/repeater/templates/cad-calibration.html b/repeater/templates/cad-calibration.html
new file mode 100644
index 0000000..f3222f4
--- /dev/null
+++ b/repeater/templates/cad-calibration.html
@@ -0,0 +1,634 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>pyMC Repeater - CAD Calibration</title>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <link rel="stylesheet" href="/static/style.css">
+    <style>
+        .calibration-controls {
+            background: var(--bg-secondary);
+            border-radius: 8px;
+            padding: 20px;
+            margin: 20px 0;
+            border: 1px solid var(--border-color);
+        }
+        
+        .heatmap-container {
+            background: var(--bg-secondary);
+            border-radius: 8px;
+            padding: 20px;
+            margin: 20px 0;
+            border: 1px solid var(--border-color);
+            min-height: 400px;
+        }
+        
+        .heatmap-grid {
+            display: grid;
+            gap: 2px;
+            margin: 20px 0;
+            font-size: 11px;
+        }
+        
+        .heatmap-cell {
+            width: 30px;
+            height: 30px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            border-radius: 3px;
+            cursor: pointer;
+            transition: all 0.2s ease;
+            color: white;
+            font-weight: bold;
+            text-shadow: 1px 1px 1px rgba(0,0,0,0.5);
+        }
+        
+        .heatmap-cell:hover {
+            transform: scale(1.1);
+            z-index: 10;
+            position: relative;
+        }
+        
+        .heatmap-cell.testing {
+            animation: pulse 1s infinite;
+        }
+        
+        @keyframes pulse {
+            0%, 100% { opacity: 1; }
+            50% { opacity: 0.6; }
+        }
+        
+        .status-bar {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            background: var(--bg-tertiary);
+            padding: 10px 15px;
+            border-radius: 5px;
+            margin: 10px 0;
+        }
+        
+        .controls-row {
+            display: flex;
+            gap: 15px;
+            align-items: center;
+            margin: 15px 0;
+            flex-wrap: wrap;
+        }
+        
+        .control-group {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+        }
+        
+        .control-group label {
+            font-weight: 500;
+            min-width: 80px;
+        }
+        
+        .control-group select, .control-group input {
+            padding: 5px 8px;
+            border: 1px solid var(--border-color);
+            border-radius: 4px;
+            background: var(--bg-primary);
+            color: var(--text-primary);
+        }
+        
+        .btn {
+            padding: 8px 16px;
+            border: none;
+            border-radius: 5px;
+            cursor: pointer;
+            font-weight: 500;
+            transition: all 0.2s ease;
+        }
+        
+        .btn-primary {
+            background: var(--accent-color);
+            color: white;
+        }
+        
+        .btn-primary:hover:not(:disabled) {
+            background: var(--accent-hover);
+        }
+        
+        .btn-secondary {
+            background: var(--bg-tertiary);
+            color: var(--text-primary);
+            border: 1px solid var(--border-color);
+        }
+        
+        .btn-secondary:hover:not(:disabled) {
+            background: var(--bg-secondary);
+        }
+        
+        .btn:disabled {
+            opacity: 0.6;
+            cursor: not-allowed;
+        }
+        
+        .legend {
+            display: flex;
+            gap: 15px;
+            align-items: center;
+            margin: 15px 0;
+            font-size: 12px;
+        }
+        
+        .legend-item {
+            display: flex;
+            align-items: center;
+            gap: 5px;
+        }
+        
+        .legend-color {
+            width: 16px;
+            height: 16px;
+            border-radius: 2px;
+        }
+        
+        .progress-container {
+            margin: 15px 0;
+        }
+        
+        .progress-bar {
+            width: 100%;
+            height: 8px;
+            background: var(--bg-tertiary);
+            border-radius: 4px;
+            overflow: hidden;
+        }
+        
+        .progress-fill {
+            height: 100%;
+            background: var(--accent-color);
+            transition: width 0.3s ease;
+            width: 0%;
+        }
+        
+        .results-summary {
+            background: var(--bg-tertiary);
+            padding: 15px;
+            border-radius: 5px;
+            margin: 15px 0;
+        }
+        
+        .results-row {
+            display: flex;
+            justify-content: space-between;
+            margin: 5px 0;
+        }
+        
+        .tooltip {
+            position: absolute;
+            background: rgba(0,0,0,0.9);
+            color: white;
+            padding: 8px 12px;
+            border-radius: 4px;
+            font-size: 11px;
+            pointer-events: none;
+            z-index: 1000;
+            display: none;
+        }
+    </style>
+</head>
+<body>
+    <div class="layout">
+        <!-- Navigation Component -->
+        <!-- NAVIGATION_PLACEHOLDER -->
+
+        <!-- Main Content -->
+        <main class="content">
+            <header>
+                <h1>CAD Calibration</h1>
+                <p>Real-time Channel Activity Detection calibration tool</p>
+            </header>
+
+            <div class="info-box">
+                This tool helps you find optimal CAD thresholds for your environment. Lower detection rates (blue/green) are better for mesh networking.
+            </div>
+
+            <!-- Controls -->
+            <div class="calibration-controls">
+                <h3>Calibration Settings</h3>
+                
+                <div class="controls-row">
+                    <div class="control-group">
+                        <label for="samples">Samples:</label>
+                        <select id="samples">
+                            <option value="4">4 (Fast)</option>
+                            <option value="8" selected>8 (Standard)</option>
+                            <option value="16">16 (Thorough)</option>
+                        </select>
+                    </div>
+                    
+                    <div class="control-group">
+                        <label for="delay">Delay (ms):</label>
+                        <input type="number" id="delay" value="100" min="50" max="1000" step="50">
+                    </div>
+                    
+                    <button id="startBtn" class="btn btn-primary">Start Calibration</button>
+                    <button id="stopBtn" class="btn btn-secondary" disabled>Stop</button>
+                    <button id="resetBtn" class="btn btn-secondary">Reset</button>
+                </div>
+
+                <div class="status-bar">
+                    <div>
+                        <strong>Status:</strong> <span id="status">Ready</span>
+                    </div>
+                    <div>
+                        <strong>Progress:</strong> <span id="progress">0/0</span>
+                    </div>
+                    <div>
+                        <strong>Current:</strong> Peak=<span id="currentPeak">-</span>, Min=<span id="currentMin">-</span>
+                    </div>
+                </div>
+
+                <div class="progress-container">
+                    <div class="progress-bar">
+                        <div class="progress-fill" id="progressFill"></div>
+                    </div>
+                </div>
+            </div>
+
+            <!-- Heatmap -->
+            <div class="heatmap-container">
+                <h3>Detection Rate Heatmap</h3>
+                
+                <div class="legend">
+                    <div class="legend-item">
+                        <div class="legend-color" style="background: #2563eb;"></div>
+                        <span>0% (Quiet)</span>
+                    </div>
+                    <div class="legend-item">
+                        <div class="legend-color" style="background: #16a34a;"></div>
+                        <span>1-10% (Low)</span>
+                    </div>
+                    <div class="legend-item">
+                        <div class="legend-color" style="background: #eab308;"></div>
+                        <span>11-30% (Medium)</span>
+                    </div>
+                    <div class="legend-item">
+                        <div class="legend-color" style="background: #dc2626;"></div>
+                        <span>31%+ (High)</span>
+                    </div>
+                    <div class="legend-item">
+                        <div class="legend-color" style="background: #6b7280;"></div>
+                        <span>Not tested</span>
+                    </div>
+                </div>
+
+                <div class="heatmap-grid" id="heatmapGrid">
+                    <!-- Grid will be populated by JavaScript -->
+                </div>
+            </div>
+
+            <!-- Results Summary -->
+            <div class="results-summary" id="resultsSummary" style="display: none;">
+                <h3>Best Results</h3>
+                <div id="bestResults">
+                    <!-- Best results will be populated here -->
+                </div>
+            </div>
+        </main>
+    </div>
+
+    <!-- Tooltip -->
+    <div class="tooltip" id="tooltip"></div>
+
+    <script>
+        let calibrationState = {
+            running: false,
+            results: new Map(),
+            currentIndex: 0,
+            totalTests: 0,
+            peakRange: [],
+            minRange: [],
+            samples: 8,
+            delay: 100
+        };
+
+        let eventSource = null;
+
+        function initializeCalibration() {
+            // Get radio config to determine ranges
+            fetch('/api/stats')
+                .then(r => r.json())
+                .then(data => {
+                    const config = data.config || {};
+                    const radio = config.radio || {};
+                    const sf = radio.spreading_factor || 8;
+                    
+                    // Set ranges based on spreading factor (same logic as Python tool)
+                    const ranges = {
+                        7:  { peak: [16, 28], min: [6, 14] },
+                        8:  { peak: [16, 28], min: [6, 14] },
+                        9:  { peak: [18, 30], min: [7, 15] },
+                        10: { peak: [20, 32], min: [8, 15] },
+                        11: { peak: [22, 34], min: [9, 16] },
+                        12: { peak: [24, 36], min: [10, 17] }
+                    };
+                    
+                    const range = ranges[sf] || ranges[8];
+                    calibrationState.peakRange = [];
+                    calibrationState.minRange = [];
+                    
+                    for (let i = range.peak[0]; i <= range.peak[1]; i++) {
+                        calibrationState.peakRange.push(i);
+                    }
+                    for (let i = range.min[0]; i <= range.min[1]; i++) {
+                        calibrationState.minRange.push(i);
+                    }
+                    
+                    calibrationState.totalTests = calibrationState.peakRange.length * calibrationState.minRange.length;
+                    
+                    setupHeatmapGrid();
+                    updateStatus('Ready - SF' + sf + ' ranges loaded');
+                })
+                .catch(e => {
+                    console.error('Error loading radio config:', e);
+                    updateStatus('Error loading radio configuration');
+                });
+        }
+
+        function setupHeatmapGrid() {
+            const grid = document.getElementById('heatmapGrid');
+            grid.innerHTML = '';
+            
+            // Set grid template columns based on min range length
+            grid.style.gridTemplateColumns = `60px repeat(${calibrationState.minRange.length}, 30px)`;
+            
+            // Add header row
+            const cornerCell = document.createElement('div');
+            cornerCell.className = 'heatmap-cell';
+            cornerCell.style.background = 'transparent';
+            cornerCell.style.color = 'var(--text-primary)';
+            cornerCell.style.fontWeight = 'bold';
+            cornerCell.textContent = 'Peak\\Min';
+            grid.appendChild(cornerCell);
+            
+            calibrationState.minRange.forEach(minVal => {
+                const headerCell = document.createElement('div');
+                headerCell.className = 'heatmap-cell';
+                headerCell.style.background = 'var(--bg-tertiary)';
+                headerCell.style.color = 'var(--text-primary)'; 
+                headerCell.style.fontWeight = 'bold';
+                headerCell.textContent = minVal;
+                grid.appendChild(headerCell);
+            });
+            
+            // Add data rows
+            calibrationState.peakRange.forEach(peakVal => {
+                // Row header
+                const rowHeader = document.createElement('div');
+                rowHeader.className = 'heatmap-cell';
+                rowHeader.style.background = 'var(--bg-tertiary)';
+                rowHeader.style.color = 'var(--text-primary)';
+                rowHeader.style.fontWeight = 'bold';
+                rowHeader.textContent = peakVal;
+                grid.appendChild(rowHeader);
+                
+                // Data cells
+                calibrationState.minRange.forEach(minVal => {
+                    const cell = document.createElement('div');
+                    cell.className = 'heatmap-cell';
+                    cell.id = `cell-${peakVal}-${minVal}`;
+                    cell.style.background = '#6b7280'; // Not tested
+                    cell.textContent = '-';
+                    
+                    cell.addEventListener('mouseenter', (e) => showTooltip(e, peakVal, minVal));
+                    cell.addEventListener('mouseleave', hideTooltip);
+                    
+                    grid.appendChild(cell);
+                });
+            });
+        }
+
+        function showTooltip(event, peak, min) {
+            const tooltip = document.getElementById('tooltip');
+            const key = `${peak}-${min}`;
+            const result = calibrationState.results.get(key);
+            
+            let content = `Peak: ${peak}, Min: ${min}`;
+            if (result) {
+                content += `<br>Detection Rate: ${result.detection_rate.toFixed(1)}%`;
+                content += `<br>Detections: ${result.detections}/${result.samples}`;
+                content += `<br>Status: ${getStatusText(result.detection_rate)}`;
+            } else {
+                content += '<br>Not tested yet';
+            }
+            
+            tooltip.innerHTML = content;
+            tooltip.style.display = 'block';
+            tooltip.style.left = event.pageX + 10 + 'px';
+            tooltip.style.top = event.pageY + 10 + 'px';
+        }
+
+        function hideTooltip() {
+            document.getElementById('tooltip').style.display = 'none';
+        }
+
+        function getStatusText(rate) {
+            if (rate === 0) return 'QUIET';
+            if (rate < 10) return 'LOW';
+            if (rate < 30) return 'MEDIUM';
+            return 'HIGH';
+        }
+
+        function getColorForRate(rate) {
+            if (rate === 0) return '#2563eb';      // Blue - Quiet
+            if (rate < 10) return '#16a34a';      // Green - Low  
+            if (rate < 30) return '#eab308';      // Yellow - Medium
+            return '#dc2626';                     // Red - High
+        }
+
+        function updateHeatmapCell(peak, min, result) {
+            const cell = document.getElementById(`cell-${peak}-${min}`);
+            if (cell) {
+                const rate = result.detection_rate;
+                cell.style.background = getColorForRate(rate);
+                cell.textContent = Math.round(rate);
+                cell.classList.remove('testing');
+            }
+        }
+
+        function markCellTesting(peak, min) {
+            const cell = document.getElementById(`cell-${peak}-${min}`);
+            if (cell) {
+                cell.classList.add('testing');
+            }
+        }
+
+        function updateStatus(message) {
+            document.getElementById('status').textContent = message;
+        }
+
+        function updateProgress(current, total) {
+            document.getElementById('progress').textContent = `${current}/${total}`;
+            const percentage = total > 0 ? (current / total) * 100 : 0;
+            document.getElementById('progressFill').style.width = percentage + '%';
+        }
+
+        function updateCurrentTest(peak, min) {
+            document.getElementById('currentPeak').textContent = peak || '-';
+            document.getElementById('currentMin').textContent = min || '-';
+        }
+
+        function updateBestResults() {
+            const results = Array.from(calibrationState.results.values());
+            if (results.length === 0) return;
+            
+            // Sort by detection_rate, then by peak (lower is better)
+            results.sort((a, b) => {
+                if (a.detection_rate !== b.detection_rate) {
+                    return a.detection_rate - b.detection_rate;
+                }
+                return a.det_peak - b.det_peak;
+            });
+            
+            const top5 = results.slice(0, 5);
+            const summaryDiv = document.getElementById('resultsSummary');
+            const bestDiv = document.getElementById('bestResults');
+            
+            bestDiv.innerHTML = '';
+            top5.forEach((result, index) => {
+                const div = document.createElement('div');
+                div.className = 'results-row';
+                div.innerHTML = `
+                    <span>#${index + 1}: Peak=${result.det_peak}, Min=${result.det_min}</span>
+                    <span>${result.detection_rate.toFixed(1)}% (${result.detections}/${result.samples})</span>
+                `;
+                bestDiv.appendChild(div);
+            });
+            
+            summaryDiv.style.display = 'block';
+        }
+
+        function startCalibration() {
+            if (calibrationState.running) return;
+            
+            calibrationState.running = true;
+            calibrationState.currentIndex = 0;
+            calibrationState.samples = parseInt(document.getElementById('samples').value);
+            calibrationState.delay = parseInt(document.getElementById('delay').value);
+            
+            document.getElementById('startBtn').disabled = true;
+            document.getElementById('stopBtn').disabled = false;
+            document.getElementById('samples').disabled = true;
+            document.getElementById('delay').disabled = true;
+            
+            updateStatus('Starting calibration...');
+            
+            // Start Server-Sent Events connection
+            eventSource = new EventSource('/api/cad-calibration-stream');
+            
+            eventSource.onmessage = function(event) {
+                const data = JSON.parse(event.data);
+                
+                if (data.type === 'progress') {
+                    updateProgress(data.current, data.total);
+                    updateCurrentTest(data.peak, data.min);
+                    
+                    if (data.peak && data.min) {
+                        markCellTesting(data.peak, data.min);
+                    }
+                }
+                else if (data.type === 'result') {
+                    const key = `${data.det_peak}-${data.det_min}`;
+                    calibrationState.results.set(key, data);
+                    updateHeatmapCell(data.det_peak, data.det_min, data);
+                    updateBestResults();
+                }
+                else if (data.type === 'status') {
+                    updateStatus(data.message);
+                }
+                else if (data.type === 'completed') {
+                    stopCalibration();
+                    updateStatus('Calibration completed');
+                }
+                else if (data.type === 'error') {
+                    stopCalibration();
+                    updateStatus('Error: ' + data.message);
+                }
+            };
+            
+            eventSource.onerror = function() {
+                stopCalibration();
+                updateStatus('Connection error');
+            };
+            
+            // Start the calibration process
+            fetch('/api/cad-calibration-start', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    samples: calibrationState.samples,
+                    delay: calibrationState.delay
+                })
+            })
+            .catch(e => {
+                stopCalibration();
+                updateStatus('Failed to start calibration');
+                console.error('Start calibration error:', e);
+            });
+        }
+
+        function stopCalibration() {
+            calibrationState.running = false;
+            
+            if (eventSource) {
+                eventSource.close();
+                eventSource = null;
+            }
+            
+            // Stop the calibration process
+            fetch('/api/cad-calibration-stop', { method: 'POST' })
+                .catch(e => console.error('Stop calibration error:', e));
+            
+            document.getElementById('startBtn').disabled = false;
+            document.getElementById('stopBtn').disabled = true;
+            document.getElementById('samples').disabled = false;
+            document.getElementById('delay').disabled = false;
+            
+            updateCurrentTest();
+            
+            // Remove all testing classes
+            document.querySelectorAll('.heatmap-cell.testing').forEach(cell => {
+                cell.classList.remove('testing');
+            });
+        }
+
+        function resetCalibration() {
+            if (calibrationState.running) {
+                stopCalibration();
+            }
+            
+            calibrationState.results.clear();
+            calibrationState.currentIndex = 0;
+            
+            setupHeatmapGrid();
+            updateProgress(0, calibrationState.totalTests);
+            updateCurrentTest();
+            updateStatus('Reset - Ready to start');
+            document.getElementById('resultsSummary').style.display = 'none';
+        }
+
+        // Event listeners
+        document.getElementById('startBtn').addEventListener('click', startCalibration);
+        document.getElementById('stopBtn').addEventListener('click', stopCalibration);
+        document.getElementById('resetBtn').addEventListener('click', resetCalibration);
+
+        // Initialize on page load
+        document.addEventListener('DOMContentLoaded', initializeCalibration);
+
+        // Cleanup on page unload
+        window.addEventListener('beforeunload', () => {
+            if (eventSource) {
+                eventSource.close();
+            }
+        });
+    </script>
+</body>
+</html>
\ No newline at end of file
diff --git a/repeater/templates/configuration.html b/repeater/templates/configuration.html
index 79e053d..1de67bc 100644
--- a/repeater/templates/configuration.html
+++ b/repeater/templates/configuration.html
@@ -22,6 +22,15 @@
                 Configuration is read-only. To modify settings, edit the config file and restart the daemon.
             </div>
 
+            <!-- CAD Calibration Tool -->
+            <div class="info-box" style="background: var(--accent-color); color: white; border: none;">
+                <strong>CAD Calibration Tool Available</strong>
+                <p style="margin: 8px 0 0 0;">
+                    Optimize your Channel Activity Detection settings for better mesh performance. 
+                    <a href="/cad-calibration" style="color: white; text-decoration: underline;">Launch CAD Calibration Tool →</a>
+                </p>
+            </div>
+
             <!-- Radio Configuration -->
             <h2>Radio Settings</h2>
             <div class="config-section">

From 32c6b4f490aa6ba93e6cc34ac3c343df70e984cd Mon Sep 17 00:00:00 2001
From: Lloyd <lloyd@rightup.co.uk>
Date: Fri, 31 Oct 2025 22:16:52 +0000
Subject: [PATCH 06/12] Refactor CAD calibration engine to use daemon instance
 instead of stats getter

---
 repeater/http_server.py | 26 ++++++++++++++------------
 repeater/main.py        |  3 +--
 2 files changed, 15 insertions(+), 14 deletions(-)

diff --git a/repeater/http_server.py b/repeater/http_server.py
index 35bb83d..74eea1c 100644
--- a/repeater/http_server.py
+++ b/repeater/http_server.py
@@ -47,8 +47,8 @@ _log_buffer = LogBuffer(max_lines=100)
 class CADCalibrationEngine:
     """Real-time CAD calibration engine"""
     
-    def __init__(self, stats_getter: Optional[Callable] = None, event_loop=None):
-        self.stats_getter = stats_getter
+    def __init__(self, daemon_instance=None, event_loop=None):
+        self.daemon_instance = daemon_instance
         self.event_loop = event_loop
         self.running = False
         self.results = {}
@@ -103,17 +103,15 @@ class CADCalibrationEngine:
     def calibration_worker(self, samples: int, delay_ms: int):
         """Worker thread for calibration process"""
         try:
-            # Get radio from stats
-            if not self.stats_getter:
-                self.broadcast_to_clients({"type": "error", "message": "No stats getter available"})
+            # Get radio from daemon instance
+            if not self.daemon_instance:
+                self.broadcast_to_clients({"type": "error", "message": "No daemon instance available"})
                 return
                 
-            stats = self.stats_getter()
-            if not stats or "radio_instance" not in stats:
+            radio = getattr(self.daemon_instance, 'radio', None)
+            if not radio:
                 self.broadcast_to_clients({"type": "error", "message": "Radio instance not available"})
                 return
-                
-            radio = stats["radio_instance"]
             if not hasattr(radio, 'perform_cad'):
                 self.broadcast_to_clients({"type": "error", "message": "Radio does not support CAD"})
                 return
@@ -236,15 +234,17 @@ class APIEndpoints:
         send_advert_func: Optional[Callable] = None,
         config: Optional[dict] = None,
         event_loop=None,
+        daemon_instance=None,
     ):
 
         self.stats_getter = stats_getter
         self.send_advert_func = send_advert_func
         self.config = config or {}
         self.event_loop = event_loop  # Store reference to main event loop
+        self.daemon_instance = daemon_instance  # Store reference to daemon instance
         
         # Initialize CAD calibration engine
-        self.cad_calibration = CADCalibrationEngine(stats_getter, event_loop)
+        self.cad_calibration = CADCalibrationEngine(daemon_instance, event_loop)
 
     @cherrypy.expose
     @cherrypy.tools.json_out()
@@ -442,6 +442,7 @@ class StatsApp:
         send_advert_func: Optional[Callable] = None,
         config: Optional[dict] = None,
         event_loop=None,
+        daemon_instance=None,
     ):
 
         self.stats_getter = stats_getter
@@ -452,7 +453,7 @@ class StatsApp:
         self.config = config or {}
 
         # Create nested API object for routing
-        self.api = APIEndpoints(stats_getter, send_advert_func, self.config, event_loop)
+        self.api = APIEndpoints(stats_getter, send_advert_func, self.config, event_loop, daemon_instance)
 
         # Load template on init
         if template_dir:
@@ -669,12 +670,13 @@ class HTTPStatsServer:
         send_advert_func: Optional[Callable] = None,
         config: Optional[dict] = None,
         event_loop=None,
+        daemon_instance=None,
     ):
 
         self.host = host
         self.port = port
         self.app = StatsApp(
-            stats_getter, template_dir, node_name, pub_key, send_advert_func, config, event_loop
+            stats_getter, template_dir, node_name, pub_key, send_advert_func, config, event_loop, daemon_instance
         )
 
     def start(self):
diff --git a/repeater/main.py b/repeater/main.py
index 7f78e74..44c7c0f 100644
--- a/repeater/main.py
+++ b/repeater/main.py
@@ -291,8 +291,6 @@ class RepeaterDaemon:
                     stats["public_key"] = pubkey.hex()
                 except Exception:
                     stats["public_key"] = None
-            if self.radio:
-                stats["radio_instance"] = self.radio
             return stats
         return {}
 
@@ -376,6 +374,7 @@ class RepeaterDaemon:
             send_advert_func=self.send_advert,
             config=self.config,  # Pass the config reference
             event_loop=current_loop,  # Pass the main event loop
+            daemon_instance=self,  # Pass the daemon instance for CAD calibration
         )
 
         try:

From 24514543c291913d3dd454d7789f06d4064b2444 Mon Sep 17 00:00:00 2001
From: Lloyd <lloyd@rightup.co.uk>
Date: Fri, 31 Oct 2025 22:24:02 +0000
Subject: [PATCH 07/12] Add CAD Calibration Tool HTML template with real-time
 data visualization and controls

- Implemented a responsive layout with navigation and calibration controls.
---
 repeater/http_server.py                 |   4 +-
 repeater/templates/cad-calibration.html | 918 +++++++++++-------------
 2 files changed, 403 insertions(+), 519 deletions(-)

diff --git a/repeater/http_server.py b/repeater/http_server.py
index 74eea1c..2c9bd16 100644
--- a/repeater/http_server.py
+++ b/repeater/http_server.py
@@ -116,8 +116,8 @@ class CADCalibrationEngine:
                 self.broadcast_to_clients({"type": "error", "message": "Radio does not support CAD"})
                 return
             
-            # Get spreading factor
-            config = stats.get("config", {})
+            # Get spreading factor from daemon instance
+            config = getattr(self.daemon_instance, 'config', {})
             radio_config = config.get("radio", {})
             sf = radio_config.get("spreading_factor", 8)
             
diff --git a/repeater/templates/cad-calibration.html b/repeater/templates/cad-calibration.html
index f3222f4..d0bf5a1 100644
--- a/repeater/templates/cad-calibration.html
+++ b/repeater/templates/cad-calibration.html
@@ -5,6 +5,8 @@
     <meta charset="utf-8">
     <meta name="viewport" content="width=device-width, initial-scale=1">
     <link rel="stylesheet" href="/static/style.css">
+    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/chartjs-chart-matrix@2.0.1/dist/chartjs-chart-matrix.min.js"></script>
     <style>
         .calibration-controls {
             background: var(--bg-secondary);
@@ -12,145 +14,58 @@
             padding: 20px;
             margin: 20px 0;
             border: 1px solid var(--border-color);
-        }
-        
-        .heatmap-container {
-            background: var(--bg-secondary);
-            border-radius: 8px;
-            padding: 20px;
-            margin: 20px 0;
-            border: 1px solid var(--border-color);
-            min-height: 400px;
-        }
-        
-        .heatmap-grid {
-            display: grid;
-            gap: 2px;
-            margin: 20px 0;
-            font-size: 11px;
-        }
-        
-        .heatmap-cell {
-            width: 30px;
-            height: 30px;
             display: flex;
+            gap: 20px;
             align-items: center;
-            justify-content: center;
-            border-radius: 3px;
-            cursor: pointer;
-            transition: all 0.2s ease;
-            color: white;
-            font-weight: bold;
-            text-shadow: 1px 1px 1px rgba(0,0,0,0.5);
-        }
-        
-        .heatmap-cell:hover {
-            transform: scale(1.1);
-            z-index: 10;
-            position: relative;
-        }
-        
-        .heatmap-cell.testing {
-            animation: pulse 1s infinite;
-        }
-        
-        @keyframes pulse {
-            0%, 100% { opacity: 1; }
-            50% { opacity: 0.6; }
-        }
-        
-        .status-bar {
-            display: flex;
-            justify-content: space-between;
-            align-items: center;
-            background: var(--bg-tertiary);
-            padding: 10px 15px;
-            border-radius: 5px;
-            margin: 10px 0;
-        }
-        
-        .controls-row {
-            display: flex;
-            gap: 15px;
-            align-items: center;
-            margin: 15px 0;
             flex-wrap: wrap;
         }
         
         .control-group {
             display: flex;
-            align-items: center;
-            gap: 8px;
+            flex-direction: column;
+            gap: 5px;
         }
         
         .control-group label {
-            font-weight: 500;
-            min-width: 80px;
+            font-weight: 600;
+            color: var(--text-secondary);
         }
         
-        .control-group select, .control-group input {
-            padding: 5px 8px;
+        .control-group input {
+            padding: 8px 12px;
             border: 1px solid var(--border-color);
             border-radius: 4px;
             background: var(--bg-primary);
             color: var(--text-primary);
+            width: 80px;
         }
         
-        .btn {
-            padding: 8px 16px;
-            border: none;
-            border-radius: 5px;
-            cursor: pointer;
-            font-weight: 500;
-            transition: all 0.2s ease;
+        .buttons {
+            display: flex;
+            gap: 10px;
+            margin-left: auto;
         }
         
-        .btn-primary {
-            background: var(--accent-color);
-            color: white;
+        .chart-container {
+            background: var(--bg-secondary);
+            border-radius: 8px;
+            padding: 20px;
+            margin: 20px 0;
+            border: 1px solid var(--border-color);
+            height: 500px;
+            position: relative;
         }
         
-        .btn-primary:hover:not(:disabled) {
-            background: var(--accent-hover);
-        }
-        
-        .btn-secondary {
-            background: var(--bg-tertiary);
-            color: var(--text-primary);
+        .status-container {
+            background: var(--bg-secondary);
+            border-radius: 8px;
+            padding: 15px;
+            margin: 20px 0;
             border: 1px solid var(--border-color);
         }
         
-        .btn-secondary:hover:not(:disabled) {
-            background: var(--bg-secondary);
-        }
-        
-        .btn:disabled {
-            opacity: 0.6;
-            cursor: not-allowed;
-        }
-        
-        .legend {
-            display: flex;
-            gap: 15px;
-            align-items: center;
-            margin: 15px 0;
-            font-size: 12px;
-        }
-        
-        .legend-item {
-            display: flex;
-            align-items: center;
-            gap: 5px;
-        }
-        
-        .legend-color {
-            width: 16px;
-            height: 16px;
-            border-radius: 2px;
-        }
-        
         .progress-container {
-            margin: 15px 0;
+            margin-top: 15px;
         }
         
         .progress-bar {
@@ -163,468 +78,437 @@
         
         .progress-fill {
             height: 100%;
-            background: var(--accent-color);
-            transition: width 0.3s ease;
+            background: linear-gradient(90deg, var(--accent), var(--primary));
             width: 0%;
-        }
-        
-        .results-summary {
-            background: var(--bg-tertiary);
-            padding: 15px;
-            border-radius: 5px;
-            margin: 15px 0;
-        }
-        
-        .results-row {
-            display: flex;
-            justify-content: space-between;
-            margin: 5px 0;
-        }
-        
-        .tooltip {
-            position: absolute;
-            background: rgba(0,0,0,0.9);
-            color: white;
-            padding: 8px 12px;
+            transition: width 0.3s ease;
             border-radius: 4px;
-            font-size: 11px;
-            pointer-events: none;
-            z-index: 1000;
+        }
+        
+        .stats-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
+            gap: 15px;
+            margin: 20px 0;
+        }
+        
+        .stat-card {
+            background: var(--bg-tertiary);
+            border-radius: 6px;
+            padding: 15px;
+            text-align: center;
+            border: 1px solid var(--border-color);
+        }
+        
+        .stat-value {
+            font-size: 1.5em;
+            font-weight: bold;
+            color: var(--primary);
+            margin-bottom: 5px;
+        }
+        
+        .stat-label {
+            color: var(--text-secondary);
+            font-size: 0.9em;
+        }
+        
+        .results-container {
+            background: var(--bg-secondary);
+            border-radius: 8px;
+            padding: 20px;
+            margin: 20px 0;
+            border: 1px solid var(--border-color);
+        }
+        
+        .best-result {
+            background: var(--success-bg);
+            border: 2px solid var(--success);
+            border-radius: 6px;
+            padding: 15px;
+            margin-top: 15px;
+            color: var(--success-text);
+        }
+        
+        .hidden {
             display: none;
         }
     </style>
 </head>
 <body>
-    <div class="layout">
-        <!-- Navigation Component -->
-        <!-- NAVIGATION_PLACEHOLDER -->
+    <div class="container">
+        <!-- Include navigation -->
+        <nav class="nav-container">
+            <div class="nav-brand">
+                <a href="/" class="nav-link">
+                    <i class="nav-icon">📡</i>
+                    <span>{{ node_name }}</span>
+                </a>
+            </div>
+            <div class="nav-links">
+                <a href="/" class="nav-link">Dashboard</a>
+                <a href="/configuration" class="nav-link">Configuration</a>
+                <a href="/cad-calibration" class="nav-link active">CAD Calibration</a>
+            </div>
+        </nav>
 
-        <!-- Main Content -->
-        <main class="content">
-            <header>
-                <h1>CAD Calibration</h1>
-                <p>Real-time Channel Activity Detection calibration tool</p>
-            </header>
-
-            <div class="info-box">
-                This tool helps you find optimal CAD thresholds for your environment. Lower detection rates (blue/green) are better for mesh networking.
+        <div class="content">
+            <div class="page-header">
+                <h1>CAD Calibration Tool</h1>
+                <p>Real-time Channel Activity Detection calibration with heatmap visualization</p>
             </div>
 
             <!-- Controls -->
             <div class="calibration-controls">
-                <h3>Calibration Settings</h3>
-                
-                <div class="controls-row">
-                    <div class="control-group">
-                        <label for="samples">Samples:</label>
-                        <select id="samples">
-                            <option value="4">4 (Fast)</option>
-                            <option value="8" selected>8 (Standard)</option>
-                            <option value="16">16 (Thorough)</option>
-                        </select>
-                    </div>
-                    
-                    <div class="control-group">
-                        <label for="delay">Delay (ms):</label>
-                        <input type="number" id="delay" value="100" min="50" max="1000" step="50">
-                    </div>
-                    
-                    <button id="startBtn" class="btn btn-primary">Start Calibration</button>
-                    <button id="stopBtn" class="btn btn-secondary" disabled>Stop</button>
-                    <button id="resetBtn" class="btn btn-secondary">Reset</button>
+                <div class="control-group">
+                    <label for="samples">Samples per test:</label>
+                    <input type="number" id="samples" value="50" min="10" max="200">
                 </div>
-
-                <div class="status-bar">
-                    <div>
-                        <strong>Status:</strong> <span id="status">Ready</span>
-                    </div>
-                    <div>
-                        <strong>Progress:</strong> <span id="progress">0/0</span>
-                    </div>
-                    <div>
-                        <strong>Current:</strong> Peak=<span id="currentPeak">-</span>, Min=<span id="currentMin">-</span>
-                    </div>
+                <div class="control-group">
+                    <label for="delay">Delay (ms):</label>
+                    <input type="number" id="delay" value="100" min="50" max="500">
                 </div>
+                <div class="buttons">
+                    <button id="start-btn" class="btn btn-primary">Start Calibration</button>
+                    <button id="stop-btn" class="btn btn-danger" disabled>Stop</button>
+                </div>
+            </div>
 
+            <!-- Status and Progress -->
+            <div class="status-container">
+                <div id="status-message">Ready to start calibration</div>
                 <div class="progress-container">
                     <div class="progress-bar">
-                        <div class="progress-fill" id="progressFill"></div>
+                        <div id="progress-fill" class="progress-fill"></div>
                     </div>
+                    <div id="progress-text">0 / 0 tests completed</div>
                 </div>
             </div>
 
-            <!-- Heatmap -->
-            <div class="heatmap-container">
-                <h3>Detection Rate Heatmap</h3>
-                
-                <div class="legend">
-                    <div class="legend-item">
-                        <div class="legend-color" style="background: #2563eb;"></div>
-                        <span>0% (Quiet)</span>
-                    </div>
-                    <div class="legend-item">
-                        <div class="legend-color" style="background: #16a34a;"></div>
-                        <span>1-10% (Low)</span>
-                    </div>
-                    <div class="legend-item">
-                        <div class="legend-color" style="background: #eab308;"></div>
-                        <span>11-30% (Medium)</span>
-                    </div>
-                    <div class="legend-item">
-                        <div class="legend-color" style="background: #dc2626;"></div>
-                        <span>31%+ (High)</span>
-                    </div>
-                    <div class="legend-item">
-                        <div class="legend-color" style="background: #6b7280;"></div>
-                        <span>Not tested</span>
-                    </div>
+            <!-- Statistics -->
+            <div class="stats-grid">
+                <div class="stat-card">
+                    <div id="tests-completed" class="stat-value">0</div>
+                    <div class="stat-label">Tests Completed</div>
                 </div>
-
-                <div class="heatmap-grid" id="heatmapGrid">
-                    <!-- Grid will be populated by JavaScript -->
+                <div class="stat-card">
+                    <div id="best-rate" class="stat-value">0%</div>
+                    <div class="stat-label">Best Detection Rate</div>
+                </div>
+                <div class="stat-card">
+                    <div id="avg-rate" class="stat-value">0%</div>
+                    <div class="stat-label">Average Rate</div>
+                </div>
+                <div class="stat-card">
+                    <div id="elapsed-time" class="stat-value">0s</div>
+                    <div class="stat-label">Elapsed Time</div>
                 </div>
             </div>
 
-            <!-- Results Summary -->
-            <div class="results-summary" id="resultsSummary" style="display: none;">
-                <h3>Best Results</h3>
-                <div id="bestResults">
-                    <!-- Best results will be populated here -->
+            <!-- Chart -->
+            <div class="chart-container">
+                <canvas id="heatmapChart"></canvas>
+            </div>
+
+            <!-- Results -->
+            <div id="results-container" class="results-container hidden">
+                <h3>Calibration Results</h3>
+                <div id="best-result" class="best-result hidden">
+                    <h4>Optimal Settings Found:</h4>
+                    <p id="best-settings"></p>
                 </div>
             </div>
-        </main>
+        </div>
     </div>
 
-    <!-- Tooltip -->
-    <div class="tooltip" id="tooltip"></div>
-
     <script>
-        let calibrationState = {
-            running: false,
-            results: new Map(),
-            currentIndex: 0,
-            totalTests: 0,
-            peakRange: [],
-            minRange: [],
-            samples: 8,
-            delay: 100
-        };
-
         let eventSource = null;
+        let heatmapChart = null;
+        let isRunning = false;
+        let startTime = null;
+        let calibrationData = {};
+        let peakRange = [];
+        let minRange = [];
 
-        function initializeCalibration() {
-            // Get radio config to determine ranges
-            fetch('/api/stats')
-                .then(r => r.json())
-                .then(data => {
-                    const config = data.config || {};
-                    const radio = config.radio || {};
-                    const sf = radio.spreading_factor || 8;
-                    
-                    // Set ranges based on spreading factor (same logic as Python tool)
-                    const ranges = {
-                        7:  { peak: [16, 28], min: [6, 14] },
-                        8:  { peak: [16, 28], min: [6, 14] },
-                        9:  { peak: [18, 30], min: [7, 15] },
-                        10: { peak: [20, 32], min: [8, 15] },
-                        11: { peak: [22, 34], min: [9, 16] },
-                        12: { peak: [24, 36], min: [10, 17] }
-                    };
-                    
-                    const range = ranges[sf] || ranges[8];
-                    calibrationState.peakRange = [];
-                    calibrationState.minRange = [];
-                    
-                    for (let i = range.peak[0]; i <= range.peak[1]; i++) {
-                        calibrationState.peakRange.push(i);
+        // Initialize Chart.js heatmap
+        function initChart() {
+            const ctx = document.getElementById('heatmapChart').getContext('2d');
+            
+            heatmapChart = new Chart(ctx, {
+                type: 'scatter',
+                data: {
+                    datasets: [{
+                        label: 'Detection Rate (%)',
+                        data: [],
+                        backgroundColor: function(context) {
+                            const value = context.parsed.v || 0;
+                            return getHeatmapColor(value);
+                        },
+                        pointRadius: function(context) {
+                            const canvas = context.chart.canvas;
+                            const width = canvas.width;
+                            const height = canvas.height;
+                            return Math.min(width, height) / 50; // Adjust based on canvas size
+                        },
+                        pointHoverRadius: function(context) {
+                            const canvas = context.chart.canvas;
+                            const width = canvas.width;
+                            const height = canvas.height;
+                            return Math.min(width, height) / 40;
+                        }
+                    }]
+                },
+                options: {
+                    responsive: true,
+                    maintainAspectRatio: false,
+                    plugins: {
+                        legend: {
+                            display: false
+                        },
+                        tooltip: {
+                            callbacks: {
+                                title: function(context) {
+                                    const point = context[0];
+                                    return `Peak: ${point.parsed.x}, Min: ${point.parsed.y}`;
+                                },
+                                label: function(context) {
+                                    return `Detection Rate: ${context.parsed.v.toFixed(1)}%`;
+                                }
+                            }
+                        }
+                    },
+                    scales: {
+                        x: {
+                            type: 'linear',
+                            position: 'bottom',
+                            title: {
+                                display: true,
+                                text: 'CAD Peak Threshold'
+                            },
+                            grid: {
+                                display: true
+                            }
+                        },
+                        y: {
+                            type: 'linear',
+                            title: {
+                                display: true,
+                                text: 'CAD Min Threshold'
+                            },
+                            grid: {
+                                display: true
+                            }
+                        }
+                    },
+                    onHover: function(event, activeElements) {
+                        event.native.target.style.cursor = activeElements.length > 0 ? 'pointer' : 'default';
                     }
-                    for (let i = range.min[0]; i <= range.min[1]; i++) {
-                        calibrationState.minRange.push(i);
-                    }
-                    
-                    calibrationState.totalTests = calibrationState.peakRange.length * calibrationState.minRange.length;
-                    
-                    setupHeatmapGrid();
-                    updateStatus('Ready - SF' + sf + ' ranges loaded');
-                })
-                .catch(e => {
-                    console.error('Error loading radio config:', e);
-                    updateStatus('Error loading radio configuration');
-                });
-        }
-
-        function setupHeatmapGrid() {
-            const grid = document.getElementById('heatmapGrid');
-            grid.innerHTML = '';
-            
-            // Set grid template columns based on min range length
-            grid.style.gridTemplateColumns = `60px repeat(${calibrationState.minRange.length}, 30px)`;
-            
-            // Add header row
-            const cornerCell = document.createElement('div');
-            cornerCell.className = 'heatmap-cell';
-            cornerCell.style.background = 'transparent';
-            cornerCell.style.color = 'var(--text-primary)';
-            cornerCell.style.fontWeight = 'bold';
-            cornerCell.textContent = 'Peak\\Min';
-            grid.appendChild(cornerCell);
-            
-            calibrationState.minRange.forEach(minVal => {
-                const headerCell = document.createElement('div');
-                headerCell.className = 'heatmap-cell';
-                headerCell.style.background = 'var(--bg-tertiary)';
-                headerCell.style.color = 'var(--text-primary)'; 
-                headerCell.style.fontWeight = 'bold';
-                headerCell.textContent = minVal;
-                grid.appendChild(headerCell);
-            });
-            
-            // Add data rows
-            calibrationState.peakRange.forEach(peakVal => {
-                // Row header
-                const rowHeader = document.createElement('div');
-                rowHeader.className = 'heatmap-cell';
-                rowHeader.style.background = 'var(--bg-tertiary)';
-                rowHeader.style.color = 'var(--text-primary)';
-                rowHeader.style.fontWeight = 'bold';
-                rowHeader.textContent = peakVal;
-                grid.appendChild(rowHeader);
-                
-                // Data cells
-                calibrationState.minRange.forEach(minVal => {
-                    const cell = document.createElement('div');
-                    cell.className = 'heatmap-cell';
-                    cell.id = `cell-${peakVal}-${minVal}`;
-                    cell.style.background = '#6b7280'; // Not tested
-                    cell.textContent = '-';
-                    
-                    cell.addEventListener('mouseenter', (e) => showTooltip(e, peakVal, minVal));
-                    cell.addEventListener('mouseleave', hideTooltip);
-                    
-                    grid.appendChild(cell);
-                });
-            });
-        }
-
-        function showTooltip(event, peak, min) {
-            const tooltip = document.getElementById('tooltip');
-            const key = `${peak}-${min}`;
-            const result = calibrationState.results.get(key);
-            
-            let content = `Peak: ${peak}, Min: ${min}`;
-            if (result) {
-                content += `<br>Detection Rate: ${result.detection_rate.toFixed(1)}%`;
-                content += `<br>Detections: ${result.detections}/${result.samples}`;
-                content += `<br>Status: ${getStatusText(result.detection_rate)}`;
-            } else {
-                content += '<br>Not tested yet';
-            }
-            
-            tooltip.innerHTML = content;
-            tooltip.style.display = 'block';
-            tooltip.style.left = event.pageX + 10 + 'px';
-            tooltip.style.top = event.pageY + 10 + 'px';
-        }
-
-        function hideTooltip() {
-            document.getElementById('tooltip').style.display = 'none';
-        }
-
-        function getStatusText(rate) {
-            if (rate === 0) return 'QUIET';
-            if (rate < 10) return 'LOW';
-            if (rate < 30) return 'MEDIUM';
-            return 'HIGH';
-        }
-
-        function getColorForRate(rate) {
-            if (rate === 0) return '#2563eb';      // Blue - Quiet
-            if (rate < 10) return '#16a34a';      // Green - Low  
-            if (rate < 30) return '#eab308';      // Yellow - Medium
-            return '#dc2626';                     // Red - High
-        }
-
-        function updateHeatmapCell(peak, min, result) {
-            const cell = document.getElementById(`cell-${peak}-${min}`);
-            if (cell) {
-                const rate = result.detection_rate;
-                cell.style.background = getColorForRate(rate);
-                cell.textContent = Math.round(rate);
-                cell.classList.remove('testing');
-            }
-        }
-
-        function markCellTesting(peak, min) {
-            const cell = document.getElementById(`cell-${peak}-${min}`);
-            if (cell) {
-                cell.classList.add('testing');
-            }
-        }
-
-        function updateStatus(message) {
-            document.getElementById('status').textContent = message;
-        }
-
-        function updateProgress(current, total) {
-            document.getElementById('progress').textContent = `${current}/${total}`;
-            const percentage = total > 0 ? (current / total) * 100 : 0;
-            document.getElementById('progressFill').style.width = percentage + '%';
-        }
-
-        function updateCurrentTest(peak, min) {
-            document.getElementById('currentPeak').textContent = peak || '-';
-            document.getElementById('currentMin').textContent = min || '-';
-        }
-
-        function updateBestResults() {
-            const results = Array.from(calibrationState.results.values());
-            if (results.length === 0) return;
-            
-            // Sort by detection_rate, then by peak (lower is better)
-            results.sort((a, b) => {
-                if (a.detection_rate !== b.detection_rate) {
-                    return a.detection_rate - b.detection_rate;
                 }
-                return a.det_peak - b.det_peak;
             });
-            
-            const top5 = results.slice(0, 5);
-            const summaryDiv = document.getElementById('resultsSummary');
-            const bestDiv = document.getElementById('bestResults');
-            
-            bestDiv.innerHTML = '';
-            top5.forEach((result, index) => {
-                const div = document.createElement('div');
-                div.className = 'results-row';
-                div.innerHTML = `
-                    <span>#${index + 1}: Peak=${result.det_peak}, Min=${result.det_min}</span>
-                    <span>${result.detection_rate.toFixed(1)}% (${result.detections}/${result.samples})</span>
-                `;
-                bestDiv.appendChild(div);
-            });
-            
-            summaryDiv.style.display = 'block';
         }
 
-        function startCalibration() {
-            if (calibrationState.running) return;
+        // Color mapping for heatmap
+        function getHeatmapColor(value) {
+            if (value >= 80) return '#4CAF50';  // Green - Excellent
+            if (value >= 60) return '#8BC34A';  // Light Green - Good
+            if (value >= 40) return '#FFC107';  // Yellow - Moderate
+            if (value >= 20) return '#FF9800';  // Orange - Poor
+            if (value > 0) return '#F44336';    // Red - Very poor
+            return '#9E9E9E';                   // Gray - No data
+        }
+
+        // Update chart with new data
+        function updateChart(peak, min, rate) {
+            if (!heatmapChart) return;
             
-            calibrationState.running = true;
-            calibrationState.currentIndex = 0;
-            calibrationState.samples = parseInt(document.getElementById('samples').value);
-            calibrationState.delay = parseInt(document.getElementById('delay').value);
+            const dataPoint = {
+                x: peak,
+                y: min,
+                v: rate
+            };
             
-            document.getElementById('startBtn').disabled = true;
-            document.getElementById('stopBtn').disabled = false;
-            document.getElementById('samples').disabled = true;
-            document.getElementById('delay').disabled = true;
+            heatmapChart.data.datasets[0].data.push(dataPoint);
+            heatmapChart.update('none'); // No animation for real-time updates
+        }
+
+        // Start calibration
+        async function startCalibration() {
+            const samples = parseInt(document.getElementById('samples').value);
+            const delay = parseInt(document.getElementById('delay').value);
             
-            updateStatus('Starting calibration...');
+            try {
+                const response = await fetch('/api/cad-calibration-start', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ samples, delay_ms: delay })
+                });
+                
+                if (!response.ok) {
+                    throw new Error(`HTTP error! status: ${response.status}`);
+                }
+                
+                const result = await response.json();
+                if (result.success) {
+                    isRunning = true;
+                    startTime = Date.now();
+                    calibrationData = {};
+                    
+                    // Clear chart
+                    if (heatmapChart) {
+                        heatmapChart.data.datasets[0].data = [];
+                        heatmapChart.update();
+                    }
+                    
+                    // Update UI
+                    document.getElementById('start-btn').disabled = true;
+                    document.getElementById('stop-btn').disabled = false;
+                    document.getElementById('results-container').classList.add('hidden');
+                    
+                    // Start SSE connection
+                    connectEventSource();
+                } else {
+                    showError(result.error || 'Failed to start calibration');
+                }
+            } catch (error) {
+                showError('Failed to start calibration: ' + error.message);
+            }
+        }
+
+        // Stop calibration
+        async function stopCalibration() {
+            try {
+                const response = await fetch('/api/cad-calibration-stop', {
+                    method: 'POST'
+                });
+                
+                if (response.ok) {
+                    isRunning = false;
+                    document.getElementById('start-btn').disabled = false;
+                    document.getElementById('stop-btn').disabled = true;
+                    
+                    if (eventSource) {
+                        eventSource.close();
+                        eventSource = null;
+                    }
+                }
+            } catch (error) {
+                console.error('Failed to stop calibration:', error);
+            }
+        }
+
+        // Connect to Server-Sent Events
+        function connectEventSource() {
+            if (eventSource) {
+                eventSource.close();
+            }
             
-            // Start Server-Sent Events connection
             eventSource = new EventSource('/api/cad-calibration-stream');
             
             eventSource.onmessage = function(event) {
-                const data = JSON.parse(event.data);
-                
-                if (data.type === 'progress') {
-                    updateProgress(data.current, data.total);
-                    updateCurrentTest(data.peak, data.min);
+                try {
+                    const data = JSON.parse(event.data);
+                    handleCalibrationUpdate(data);
+                } catch (error) {
+                    console.error('Failed to parse SSE data:', error);
+                }
+            };
+            
+            eventSource.onerror = function(event) {
+                console.error('SSE connection error:', event);
+                if (!isRunning) {
+                    eventSource.close();
+                    eventSource = null;
+                }
+            };
+        }
+
+        // Handle calibration updates
+        function handleCalibrationUpdate(data) {
+            switch (data.type) {
+                case 'status':
+                    document.getElementById('status-message').textContent = data.message;
+                    break;
                     
-                    if (data.peak && data.min) {
-                        markCellTesting(data.peak, data.min);
+                case 'progress':
+                    const percent = data.total > 0 ? (data.current / data.total) * 100 : 0;
+                    document.getElementById('progress-fill').style.width = percent + '%';
+                    document.getElementById('progress-text').textContent = `${data.current} / ${data.total} tests completed`;
+                    document.getElementById('tests-completed').textContent = data.current;
+                    break;
+                    
+                case 'result':
+                    // Store result and update chart
+                    const key = `${data.det_peak}_${data.det_min}`;
+                    calibrationData[key] = data;
+                    updateChart(data.det_peak, data.det_min, data.detection_rate);
+                    updateStats();
+                    break;
+                    
+                case 'complete':
+                    isRunning = false;
+                    document.getElementById('start-btn').disabled = false;
+                    document.getElementById('stop-btn').disabled = true;
+                    document.getElementById('status-message').textContent = 'Calibration completed';
+                    showResults(data.results);
+                    
+                    if (eventSource) {
+                        eventSource.close();
+                        eventSource = null;
                     }
-                }
-                else if (data.type === 'result') {
-                    const key = `${data.det_peak}-${data.det_min}`;
-                    calibrationState.results.set(key, data);
-                    updateHeatmapCell(data.det_peak, data.det_min, data);
-                    updateBestResults();
-                }
-                else if (data.type === 'status') {
-                    updateStatus(data.message);
-                }
-                else if (data.type === 'completed') {
+                    break;
+                    
+                case 'error':
+                    showError(data.message);
                     stopCalibration();
-                    updateStatus('Calibration completed');
-                }
-                else if (data.type === 'error') {
-                    stopCalibration();
-                    updateStatus('Error: ' + data.message);
-                }
-            };
-            
-            eventSource.onerror = function() {
-                stopCalibration();
-                updateStatus('Connection error');
-            };
-            
-            // Start the calibration process
-            fetch('/api/cad-calibration-start', {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({
-                    samples: calibrationState.samples,
-                    delay: calibrationState.delay
-                })
-            })
-            .catch(e => {
-                stopCalibration();
-                updateStatus('Failed to start calibration');
-                console.error('Start calibration error:', e);
-            });
-        }
-
-        function stopCalibration() {
-            calibrationState.running = false;
-            
-            if (eventSource) {
-                eventSource.close();
-                eventSource = null;
+                    break;
             }
             
-            // Stop the calibration process
-            fetch('/api/cad-calibration-stop', { method: 'POST' })
-                .catch(e => console.error('Stop calibration error:', e));
-            
-            document.getElementById('startBtn').disabled = false;
-            document.getElementById('stopBtn').disabled = true;
-            document.getElementById('samples').disabled = false;
-            document.getElementById('delay').disabled = false;
-            
-            updateCurrentTest();
-            
-            // Remove all testing classes
-            document.querySelectorAll('.heatmap-cell.testing').forEach(cell => {
-                cell.classList.remove('testing');
-            });
+            // Update elapsed time
+            if (startTime) {
+                const elapsed = Math.floor((Date.now() - startTime) / 1000);
+                document.getElementById('elapsed-time').textContent = elapsed + 's';
+            }
         }
 
-        function resetCalibration() {
-            if (calibrationState.running) {
-                stopCalibration();
+        // Update statistics
+        function updateStats() {
+            const rates = Object.values(calibrationData).map(d => d.detection_rate);
+            if (rates.length === 0) return;
+            
+            const bestRate = Math.max(...rates);
+            const avgRate = rates.reduce((a, b) => a + b, 0) / rates.length;
+            
+            document.getElementById('best-rate').textContent = bestRate.toFixed(1) + '%';
+            document.getElementById('avg-rate').textContent = avgRate.toFixed(1) + '%';
+        }
+
+        // Show results
+        function showResults(results) {
+            document.getElementById('results-container').classList.remove('hidden');
+            
+            if (results && results.best) {
+                const best = results.best;
+                document.getElementById('best-result').classList.remove('hidden');
+                document.getElementById('best-settings').innerHTML = 
+                    `Peak: <strong>${best.det_peak}</strong>, Min: <strong>${best.det_min}</strong>, Rate: <strong>${best.detection_rate.toFixed(1)}%</strong>`;
             }
-            
-            calibrationState.results.clear();
-            calibrationState.currentIndex = 0;
-            
-            setupHeatmapGrid();
-            updateProgress(0, calibrationState.totalTests);
-            updateCurrentTest();
-            updateStatus('Reset - Ready to start');
-            document.getElementById('resultsSummary').style.display = 'none';
+        }
+
+        // Show error message
+        function showError(message) {
+            document.getElementById('status-message').textContent = 'Error: ' + message;
+            document.getElementById('status-message').style.color = 'var(--error)';
         }
 
         // Event listeners
-        document.getElementById('startBtn').addEventListener('click', startCalibration);
-        document.getElementById('stopBtn').addEventListener('click', stopCalibration);
-        document.getElementById('resetBtn').addEventListener('click', resetCalibration);
+        document.getElementById('start-btn').addEventListener('click', startCalibration);
+        document.getElementById('stop-btn').addEventListener('click', stopCalibration);
 
-        // Initialize on page load
-        document.addEventListener('DOMContentLoaded', initializeCalibration);
+        // Initialize chart when page loads
+        document.addEventListener('DOMContentLoaded', function() {
+            initChart();
+        });
 
         // Cleanup on page unload
-        window.addEventListener('beforeunload', () => {
+        window.addEventListener('beforeunload', function() {
             if (eventSource) {
                 eventSource.close();
             }

From 6a7dca0bca106f9cb42de229a26fdf5f6cf42ad5 Mon Sep 17 00:00:00 2001
From: Lloyd <lloyd@rightup.co.uk>
Date: Sat, 1 Nov 2025 22:41:26 +0000
Subject: [PATCH 08/12] add heatmap chat

---
 pyproject.toml                          |    4 +-
 repeater/http_server.py                 |  305 +++++--
 repeater/main.py                        |   25 +-
 repeater/templates/cad-calibration.html | 1038 +++++++++++++++++++----
 repeater/templates/configuration.html   |    2 +-
 5 files changed, 1111 insertions(+), 263 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index b88f506..0a99108 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -29,14 +29,16 @@ classifiers = [
 keywords = ["mesh", "networking", "lora", "repeater", "daemon", "iot"]
 
 
+
 dependencies = [
-    "pymc_core[hardware]>=1.0.2",
+    "pymc_core[hardware] @ git+https://github.com/rightup/pyMC_core.git@feat/cad",
     "pyyaml>=6.0.0",
     "cherrypy>=18.0.0",
 ]
 
 
 
+
 [project.optional-dependencies]
 dev = [
     "pytest>=7.4.0",
diff --git a/repeater/http_server.py b/repeater/http_server.py
index 2c9bd16..9c41278 100644
--- a/repeater/http_server.py
+++ b/repeater/http_server.py
@@ -58,14 +58,14 @@ class CADCalibrationEngine:
         self.calibration_thread = None
         
     def get_test_ranges(self, spreading_factor: int):
-        """Get CAD test ranges based on spreading factor"""
+        """Get CAD test ranges based on spreading factor - comprehensive coverage"""
         sf_ranges = {
-            7:  (range(16, 29, 1), range(6, 15, 1)),
-            8:  (range(16, 29, 1), range(6, 15, 1)),  
-            9:  (range(18, 31, 1), range(7, 16, 1)),
-            10: (range(20, 33, 1), range(8, 16, 1)),
-            11: (range(22, 35, 1), range(9, 17, 1)),
-            12: (range(24, 37, 1), range(10, 18, 1)),
+            7:  (range(17, 26, 1), range(7, 15, 1)),   # Full range coverage
+            8:  (range(17, 26, 1), range(7, 15, 1)),   # Full range coverage
+            9:  (range(19, 28, 1), range(8, 16, 1)),   # Full range coverage
+            10: (range(21, 30, 1), range(9, 17, 1)),   # Full range coverage
+            11: (range(23, 32, 1), range(10, 18, 1)),  # Full range coverage
+            12: (range(25, 34, 1), range(11, 19, 1)),  # Full range coverage
         }
         return sf_ranges.get(spreading_factor, sf_ranges[8])
     
@@ -75,12 +75,12 @@ class CADCalibrationEngine:
         
         for _ in range(samples):
             try:
-                result = await radio.perform_cad(det_peak=det_peak, det_min=det_min, timeout=0.6)
+                result = await radio.perform_cad(det_peak=det_peak, det_min=det_min, timeout=0.3)
                 if result:
                     detections += 1
             except Exception:
                 pass
-            await asyncio.sleep(0.03)
+            await asyncio.sleep(0.01)  # Reduced sleep time
         
         return {
             'det_peak': det_peak,
@@ -92,13 +92,12 @@ class CADCalibrationEngine:
     
     def broadcast_to_clients(self, data):
         """Send data to all connected SSE clients"""
-        message = f"data: {json.dumps(data)}\n\n"
-        for client in self.clients.copy():
-            try:
-                client.write(message.encode())
-                client.flush()
-            except Exception:
-                self.clients.discard(client)
+        # Store the message for clients to pick up
+        self.last_message = data
+        # Also store in a queue for clients to consume
+        if not hasattr(self, 'message_queue'):
+            self.message_queue = []
+        self.message_queue.append(data)
     
     def calibration_worker(self, samples: int, delay_ms: int):
         """Worker thread for calibration process"""
@@ -129,60 +128,105 @@ class CADCalibrationEngine:
             
             self.broadcast_to_clients({
                 "type": "status", 
-                "message": f"Starting calibration: SF{sf}, {total_tests} tests"
+                "message": f"Starting calibration: SF{sf}, {total_tests} tests",
+                "test_ranges": {
+                    "peak_min": min(peak_range),
+                    "peak_max": max(peak_range),
+                    "min_min": min(min_range),
+                    "min_max": max(min_range),
+                    "spreading_factor": sf,
+                    "total_tests": total_tests
+                }
             })
             
             current = 0
             
-            # Run calibration in event loop
+            import random
+            
+
+            peak_list = list(peak_range)
+            min_list = list(min_range)
+            
+            # Create all test combinations
+            test_combinations = []
+            for det_peak in peak_list:
+                for det_min in min_list:
+                    test_combinations.append((det_peak, det_min))
+            
+            # Sort by distance from center for center-out pattern
+            peak_center = (max(peak_list) + min(peak_list)) / 2
+            min_center = (max(min_list) + min(min_list)) / 2
+            
+            def distance_from_center(combo):
+                peak, min_val = combo
+                return ((peak - peak_center) ** 2 + (min_val - min_center) ** 2) ** 0.5
+            
+            # Sort by distance from center
+            test_combinations.sort(key=distance_from_center)
+            
+
+            band_size = max(1, len(test_combinations) // 8)  # Create 8 bands
+            randomized_combinations = []
+            
+            for i in range(0, len(test_combinations), band_size):
+                band = test_combinations[i:i + band_size]
+                random.shuffle(band)  # Randomize within each band
+                randomized_combinations.extend(band)
+            
+            # Run calibration in event loop with center-out randomized pattern
             if self.event_loop:
-                for det_peak in peak_range:
+                for det_peak, det_min in randomized_combinations:
                     if not self.running:
                         break
                         
-                    for det_min in min_range:
-                        if not self.running:
-                            break
-                            
-                        current += 1
-                        self.progress["current"] = current
+                    current += 1
+                    self.progress["current"] = current
+                    
+                    # Update progress
+                    self.broadcast_to_clients({
+                        "type": "progress",
+                        "current": current,
+                        "total": total_tests,
+                        "peak": det_peak,
+                        "min": det_min
+                    })
+                    
+                    # Run the test
+                    future = asyncio.run_coroutine_threadsafe(
+                        self.test_cad_config(radio, det_peak, det_min, samples),
+                        self.event_loop
+                    )
+                    
+                    try:
+                        result = future.result(timeout=30)  # 30 second timeout per test
                         
-                        # Update progress
+                        # Store result
+                        key = f"{det_peak}-{det_min}"
+                        self.results[key] = result
+                        
+                        # Send result to clients
                         self.broadcast_to_clients({
-                            "type": "progress",
-                            "current": current,
-                            "total": total_tests,
-                            "peak": det_peak,
-                            "min": det_min
+                            "type": "result",
+                            **result
                         })
+                    except Exception as e:
+                        logger.error(f"CAD test failed for peak={det_peak}, min={det_min}: {e}")
                         
-                        # Run the test
-                        future = asyncio.run_coroutine_threadsafe(
-                            self.test_cad_config(radio, det_peak, det_min, samples),
-                            self.event_loop
-                        )
-                        
-                        try:
-                            result = future.result(timeout=30)  # 30 second timeout per test
-                            
-                            # Store result
-                            key = f"{det_peak}-{det_min}"
-                            self.results[key] = result
-                            
-                            # Send result to clients
-                            self.broadcast_to_clients({
-                                "type": "result",
-                                **result
-                            })
-                        except Exception as e:
-                            logger.error(f"CAD test failed for peak={det_peak}, min={det_min}: {e}")
-                            
-                        # Delay between tests
-                        if self.running and delay_ms > 0:
-                            time.sleep(delay_ms / 1000.0)
+                    # Delay between tests
+                    if self.running and delay_ms > 0:
+                        time.sleep(delay_ms / 1000.0)
             
             if self.running:
-                self.broadcast_to_clients({"type": "completed", "message": "Calibration completed"})
+                # Find best result
+                best_result = None
+                if self.results:
+                    best_result = max(self.results.values(), key=lambda x: x['detection_rate'])
+                
+                self.broadcast_to_clients({
+                    "type": "completed", 
+                    "message": "Calibration completed",
+                    "results": {"best": best_result} if best_result else None
+                })
             else:
                 self.broadcast_to_clients({"type": "status", "message": "Calibration stopped"})
                 
@@ -200,6 +244,7 @@ class CADCalibrationEngine:
         self.running = True
         self.results.clear()
         self.progress = {"current": 0, "total": 0}
+        self.clear_message_queue()  # Clear any old messages
         
         # Start calibration in separate thread
         self.calibration_thread = threading.Thread(
@@ -217,15 +262,10 @@ class CADCalibrationEngine:
         if self.calibration_thread:
             self.calibration_thread.join(timeout=2)
     
-    def add_client(self, response_stream):
-        """Add SSE client"""
-        self.clients.add(response_stream)
-    
-    def remove_client(self, response_stream):
-        """Remove SSE client"""
-        self.clients.discard(response_stream)
-
-
+    def clear_message_queue(self):
+        """Clear the message queue when starting a new calibration"""
+        if hasattr(self, 'message_queue'):
+            self.message_queue.clear()
 class APIEndpoints:
 
     def __init__(
@@ -235,13 +275,15 @@ class APIEndpoints:
         config: Optional[dict] = None,
         event_loop=None,
         daemon_instance=None,
+        config_path=None,
     ):
 
         self.stats_getter = stats_getter
         self.send_advert_func = send_advert_func
         self.config = config or {}
-        self.event_loop = event_loop  # Store reference to main event loop
-        self.daemon_instance = daemon_instance  # Store reference to daemon instance
+        self.event_loop = event_loop
+        self.daemon_instance = daemon_instance
+        self._config_path = config_path or '/etc/pymc_repeater/config.yaml'
         
         # Initialize CAD calibration engine
         self.cad_calibration = CADCalibrationEngine(daemon_instance, event_loop)
@@ -395,6 +437,72 @@ class APIEndpoints:
             logger.error(f"Error stopping CAD calibration: {e}")
             return {"success": False, "error": str(e)}
     
+    @cherrypy.expose
+    @cherrypy.tools.json_out()
+    @cherrypy.tools.json_in()
+    def save_cad_settings(self):
+        """Save CAD calibration settings to config"""
+        if cherrypy.request.method != "POST":
+            return {"success": False, "error": "Method not allowed"}
+        
+        try:
+            data = cherrypy.request.json or {}
+            peak = data.get("peak")
+            min_val = data.get("min_val")
+            detection_rate = data.get("detection_rate", 0)
+            
+            if peak is None or min_val is None:
+                return {"success": False, "error": "Missing peak or min_val parameters"}
+            
+            # Update the radio immediately if available
+            if self.daemon_instance and hasattr(self.daemon_instance, 'radio') and self.daemon_instance.radio:
+                if hasattr(self.daemon_instance.radio, 'set_custom_cad_thresholds'):
+                    self.daemon_instance.radio.set_custom_cad_thresholds(peak=peak, min_val=min_val)
+                    logger.info(f"Applied CAD settings to radio: peak={peak}, min={min_val}")
+            
+            # Update the in-memory config
+            if "radio" not in self.config:
+                self.config["radio"] = {}
+            if "cad" not in self.config["radio"]:
+                self.config["radio"]["cad"] = {}
+            
+            self.config["radio"]["cad"]["peak_threshold"] = peak
+            self.config["radio"]["cad"]["min_threshold"] = min_val
+            
+            # Save to config file
+            config_path = getattr(self, '_config_path', '/etc/pymc_repeater/config.yaml')
+            self._save_config_to_file(config_path)
+            
+            logger.info(f"Saved CAD settings to config: peak={peak}, min={min_val}, rate={detection_rate:.1f}%")
+            return {
+                "success": True, 
+                "message": f"CAD settings saved: peak={peak}, min={min_val}",
+                "settings": {"peak": peak, "min_val": min_val, "detection_rate": detection_rate}
+            }
+            
+        except Exception as e:
+            logger.error(f"Error saving CAD settings: {e}")
+            return {"success": False, "error": str(e)}
+
+    def _save_config_to_file(self, config_path):
+        """Save current config to YAML file"""
+        try:
+            import yaml
+            import os
+            
+            # Ensure directory exists
+            os.makedirs(os.path.dirname(config_path), exist_ok=True)
+            
+            # Write config to file
+            with open(config_path, 'w') as f:
+                yaml.dump(self.config, f, default_flow_style=False, indent=2)
+                
+            logger.info(f"Configuration saved to {config_path}")
+            
+        except Exception as e:
+            logger.error(f"Failed to save config to {config_path}: {e}")
+            raise
+
     @cherrypy.expose
     def cad_calibration_stream(self):
         """Server-Sent Events stream for real-time updates"""
@@ -404,25 +512,62 @@ class APIEndpoints:
         cherrypy.response.headers['Access-Control-Allow-Origin'] = '*'
         
         def generate():
-            # Add client to calibration engine
-            response = cherrypy.response
-            self.cad_calibration.add_client(response)
+            
+            if not hasattr(self.cad_calibration, 'message_queue'):
+                self.cad_calibration.message_queue = []
             
             try:
-                # Send initial connection message
+          
                 yield f"data: {json.dumps({'type': 'connected', 'message': 'Connected to CAD calibration stream'})}\n\n"
                 
-                # Keep connection alive - the calibration engine will send data
+               
+                if self.cad_calibration.running:
+             
+                    config = getattr(self.cad_calibration.daemon_instance, 'config', {})
+                    radio_config = config.get("radio", {})
+                    sf = radio_config.get("spreading_factor", 8)
+                    
+         
+                    peak_range, min_range = self.cad_calibration.get_test_ranges(sf)
+                    total_tests = len(peak_range) * len(min_range)
+                    
+              
+                    status_message = {
+                        "type": "status", 
+                        "message": f"Calibration in progress: SF{sf}, {total_tests} tests",
+                        "test_ranges": {
+                            "peak_min": min(peak_range),
+                            "peak_max": max(peak_range),
+                            "min_min": min(min_range),
+                            "min_max": max(min_range),
+                            "spreading_factor": sf,
+                            "total_tests": total_tests
+                        }
+                    }
+                    yield f"data: {json.dumps(status_message)}\n\n"
+                
+                last_message_index = len(self.cad_calibration.message_queue)
+                
+               
                 while True:
-                    time.sleep(1)
-                    # Send keepalive every second
-                    yield f"data: {json.dumps({'type': 'keepalive'})}\n\n"
+                   
+                    current_queue_length = len(self.cad_calibration.message_queue)
+                    if current_queue_length > last_message_index:
+                    
+                        for i in range(last_message_index, current_queue_length):
+                            message = self.cad_calibration.message_queue[i]
+                            yield f"data: {json.dumps(message)}\n\n"
+                        last_message_index = current_queue_length
+                    else:
+                       
+                        yield f"data: {json.dumps({'type': 'keepalive'})}\n\n"
+                    
+                    time.sleep(0.5)  
                     
             except Exception as e:
                 logger.error(f"SSE stream error: {e}")
             finally:
-                # Remove client when connection closes
-                self.cad_calibration.remove_client(response)
+                pass  
         
         return generate()
     
@@ -443,6 +588,7 @@ class StatsApp:
         config: Optional[dict] = None,
         event_loop=None,
         daemon_instance=None,
+        config_path=None,
     ):
 
         self.stats_getter = stats_getter
@@ -453,7 +599,7 @@ class StatsApp:
         self.config = config or {}
 
         # Create nested API object for routing
-        self.api = APIEndpoints(stats_getter, send_advert_func, self.config, event_loop, daemon_instance)
+        self.api = APIEndpoints(stats_getter, send_advert_func, self.config, event_loop, daemon_instance, config_path)
 
         # Load template on init
         if template_dir:
@@ -671,12 +817,13 @@ class HTTPStatsServer:
         config: Optional[dict] = None,
         event_loop=None,
         daemon_instance=None,
+        config_path=None,
     ):
 
         self.host = host
         self.port = port
         self.app = StatsApp(
-            stats_getter, template_dir, node_name, pub_key, send_advert_func, config, event_loop, daemon_instance
+            stats_getter, template_dir, node_name, pub_key, send_advert_func, config, event_loop, daemon_instance, config_path
         )
 
     def start(self):
diff --git a/repeater/main.py b/repeater/main.py
index 44c7c0f..e2a9b12 100644
--- a/repeater/main.py
+++ b/repeater/main.py
@@ -12,12 +12,6 @@ from pymc_core.protocol.constants import MAX_PATH_SIZE, ROUTE_TYPE_DIRECT
 logger = logging.getLogger("RepeaterDaemon")
 
 
-
-
-
-logger = logging.getLogger("RepeaterDaemon")
-
-
 class RepeaterDaemon:
 
     def __init__(self, config: dict, radio=None):
@@ -53,8 +47,13 @@ class RepeaterDaemon:
                 
 
                 if hasattr(self.radio, 'set_custom_cad_thresholds'):
-                    self.radio.set_custom_cad_thresholds(peak=23, min_val=11)
-                    logger.info("CAD thresholds set: peak=23, min=11")
+                    # Load CAD settings from config, with defaults
+                    cad_config = self.config.get("radio", {}).get("cad", {})
+                    peak_threshold = cad_config.get("peak_threshold", 23)
+                    min_threshold = cad_config.get("min_threshold", 11)
+                    
+                    self.radio.set_custom_cad_thresholds(peak=peak_threshold, min_val=min_threshold)
+                    logger.info(f"CAD thresholds set from config: peak={peak_threshold}, min={min_threshold}")
                 else:
                     logger.warning("Radio does not support CAD configuration")
                 
@@ -361,7 +360,6 @@ class RepeaterDaemon:
             else:
                 pub_key_formatted = pub_key_hex
 
-        # Get the current event loop (the main loop where the radio was initialized)
         current_loop = asyncio.get_event_loop()
 
         self.http_server = HTTPStatsServer(
@@ -372,9 +370,10 @@ class RepeaterDaemon:
             node_name=node_name,
             pub_key=pub_key_formatted,
             send_advert_func=self.send_advert,
-            config=self.config,  # Pass the config reference
-            event_loop=current_loop,  # Pass the main event loop
-            daemon_instance=self,  # Pass the daemon instance for CAD calibration
+            config=self.config, 
+            event_loop=current_loop, 
+            daemon_instance=self,  
+            config_path=getattr(self, 'config_path', '/etc/pymc_repeater/config.yaml'),
         )
 
         try:
@@ -410,12 +409,14 @@ def main():
 
     # Load configuration
     config = load_config(args.config)
+    config_path = args.config if args.config else '/etc/pymc_repeater/config.yaml'
 
     if args.log_level:
         config["logging"]["level"] = args.log_level
 
     # Don't initialize radio here - it will be done inside the async event loop
     daemon = RepeaterDaemon(config, radio=None)
+    daemon.config_path = config_path
 
     # Run
     try:
diff --git a/repeater/templates/cad-calibration.html b/repeater/templates/cad-calibration.html
index d0bf5a1..d5e1fa9 100644
--- a/repeater/templates/cad-calibration.html
+++ b/repeater/templates/cad-calibration.html
@@ -5,8 +5,9 @@
     <meta charset="utf-8">
     <meta name="viewport" content="width=device-width, initial-scale=1">
     <link rel="stylesheet" href="/static/style.css">
-    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
-    <script src="https://cdn.jsdelivr.net/npm/chartjs-chart-matrix@2.0.1/dist/chartjs-chart-matrix.min.js"></script>
+    <script src="https://d3js.org/d3.v7.min.js"></script>
+    <script src="https://d3js.org/d3-scale-chromatic.v1.min.js"></script>
+    <script src="https://d3js.org/d3-hexbin.v0.2.min.js"></script>
     <style>
         .calibration-controls {
             background: var(--bg-secondary);
@@ -15,35 +16,108 @@
             margin: 20px 0;
             border: 1px solid var(--border-color);
             display: flex;
-            gap: 20px;
+            justify-content: center;
             align-items: center;
-            flex-wrap: wrap;
-        }
-        
-        .control-group {
-            display: flex;
-            flex-direction: column;
-            gap: 5px;
-        }
-        
-        .control-group label {
-            font-weight: 600;
-            color: var(--text-secondary);
-        }
-        
-        .control-group input {
-            padding: 8px 12px;
-            border: 1px solid var(--border-color);
-            border-radius: 4px;
-            background: var(--bg-primary);
-            color: var(--text-primary);
-            width: 80px;
         }
         
         .buttons {
             display: flex;
-            gap: 10px;
-            margin-left: auto;
+            gap: 16px;
+        }
+
+        /* Control button styling - matching site design system */
+        .control-btn {
+            display: flex;
+            align-items: center;
+            gap: 12px;
+            padding: 12px 16px;
+            background: rgba(255, 255, 255, 0.05);
+            border: 1px solid rgba(255, 255, 255, 0.1);
+            border-radius: 6px;
+            color: #d4d4d4;
+            cursor: pointer;
+            transition: all 0.2s;
+            font-size: 0.875rem;
+            font-family: inherit;
+            min-width: 160px;
+        }
+
+        .control-btn:hover:not(:disabled) {
+            background: rgba(255, 255, 255, 0.1);
+            border-color: rgba(255, 255, 255, 0.2);
+            transform: translateY(-1px);
+        }
+
+        .control-btn:disabled {
+            opacity: 0.4;
+            cursor: not-allowed;
+            background: rgba(255, 255, 255, 0.02);
+        }
+
+        .control-btn-start {
+            background: rgba(16, 185, 129, 0.1);
+            border-color: rgba(16, 185, 129, 0.3);
+            color: #10b981;
+        }
+
+        .control-btn-start:hover:not(:disabled) {
+            background: rgba(16, 185, 129, 0.2);
+            border-color: rgba(16, 185, 129, 0.4);
+            box-shadow: 0 4px 12px rgba(16, 185, 129, 0.15);
+        }
+
+        .control-btn-danger {
+            background: rgba(239, 68, 68, 0.1);
+            border-color: rgba(239, 68, 68, 0.3);
+            color: #ef4444;
+        }
+
+        .control-btn-danger:hover:not(:disabled) {
+            background: rgba(239, 68, 68, 0.2);
+            border-color: rgba(239, 68, 68, 0.4);
+            box-shadow: 0 4px 12px rgba(239, 68, 68, 0.15);
+        }
+
+        .control-btn .icon {
+            width: 20px;
+            height: 20px;
+            flex-shrink: 0;
+        }
+
+        .control-label {
+            display: flex;
+            flex-direction: column;
+            align-items: flex-start;
+            flex-grow: 1;
+        }
+
+        .control-title {
+            font-weight: 500;
+            font-size: 0.875rem;
+            line-height: 1.2;
+        }
+
+        .control-value {
+            font-size: 0.75rem;
+            opacity: 0.8;
+            line-height: 1.1;
+        }
+
+        .control-btn-save {
+            background: rgba(59, 130, 246, 0.1);
+            border-color: rgba(59, 130, 246, 0.3);
+            color: #3b82f6;
+        }
+
+        .control-btn-save:hover:not(:disabled) {
+            background: rgba(59, 130, 246, 0.2);
+            border-color: rgba(59, 130, 246, 0.4);
+            box-shadow: 0 4px 12px rgba(59, 130, 246, 0.15);
+        }
+
+        .save-controls {
+            display: flex;
+            justify-content: center;
         }
         
         .chart-container {
@@ -52,8 +126,106 @@
             padding: 20px;
             margin: 20px 0;
             border: 1px solid var(--border-color);
-            height: 500px;
+            height: 600px; /* Increased to match new chart height */
             position: relative;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+        }
+        
+        .heatmap-svg {
+            border-radius: 4px;
+            background: var(--bg-primary);
+        }
+        
+        .heatmap-cell {
+            stroke: var(--border-color);
+            stroke-width: 1;
+            cursor: pointer;
+        }
+        
+        .heatmap-cell:hover {
+            stroke: var(--primary);
+            stroke-width: 2;
+        }
+        
+        .axis-label {
+            font-size: 12px;
+            fill: var(--text-secondary);
+        }
+        
+        .axis-title {
+            font-size: 14px;
+            font-weight: bold;
+            fill: var(--text-primary);
+        }
+        
+        .legend-title {
+            font-size: 12px;
+            font-weight: bold;
+            fill: var(--text-primary);
+        }
+        
+        .legend-label {
+            font-size: 10px;
+            fill: var(--text-secondary);
+        }
+        
+        .axis {
+            font-size: 12px;
+        }
+        
+        .axis path,
+        .axis line {
+            fill: none;
+            stroke: #888;
+            shape-rendering: crispEdges;
+        }
+        
+        .axis text {
+            fill: #fff !important;
+            font-weight: bold;
+        }
+        
+        .hexagon {
+            cursor: pointer;
+        }
+        
+        .hexagon:hover {
+            opacity: 1 !important;
+        }
+        
+        .non-detected {
+            cursor: pointer;
+        }
+        
+        .chart-background {
+            pointer-events: none;
+        }
+        
+        .heatmap-tooltip {
+            position: absolute;
+            background-color: white;
+            border: solid 2px #333;
+            border-radius: 5px;
+            padding: 8px;
+            font-size: 12px;
+            color: #333;
+            pointer-events: none;
+            opacity: 0;
+            z-index: 1000;
+            box-shadow: 0 2px 8px rgba(0,0,0,0.3);
+        }
+        
+        .heatmap-title {
+            fill: #fff !important;
+            font-size: 18px;
+            font-weight: bold;
+        }
+        
+        .heatmap-subtitle {
+            fill: #ccc !important;
+            font-size: 14px;
         }
         
         .status-container {
@@ -134,47 +306,72 @@
     </style>
 </head>
 <body>
-    <div class="container">
-        <!-- Include navigation -->
-        <nav class="nav-container">
-            <div class="nav-brand">
-                <a href="/" class="nav-link">
-                    <i class="nav-icon">📡</i>
-                    <span>{{ node_name }}</span>
-                </a>
-            </div>
-            <div class="nav-links">
-                <a href="/" class="nav-link">Dashboard</a>
-                <a href="/configuration" class="nav-link">Configuration</a>
-                <a href="/cad-calibration" class="nav-link active">CAD Calibration</a>
-            </div>
-        </nav>
+    <div class="layout">
+        <!-- Navigation Component -->
+        <!-- NAVIGATION_PLACEHOLDER -->
 
-        <div class="content">
-            <div class="page-header">
+        <!-- Main Content -->
+        <main class="content">
+            <header>
                 <h1>CAD Calibration Tool</h1>
-                <p>Real-time Channel Activity Detection calibration with heatmap visualization</p>
-            </div>
+                <p>Real-time Channel Activity Detection calibration</p>
+            </header>
 
             <!-- Controls -->
             <div class="calibration-controls">
-                <div class="control-group">
-                    <label for="samples">Samples per test:</label>
-                    <input type="number" id="samples" value="50" min="10" max="200">
-                </div>
-                <div class="control-group">
-                    <label for="delay">Delay (ms):</label>
-                    <input type="number" id="delay" value="100" min="50" max="500">
-                </div>
                 <div class="buttons">
-                    <button id="start-btn" class="btn btn-primary">Start Calibration</button>
-                    <button id="stop-btn" class="btn btn-danger" disabled>Stop</button>
+                    <button id="start-btn" class="control-btn control-btn-start">
+                        <svg class="icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                            <polygon points="5 3 19 12 5 21 5 3"></polygon>
+                        </svg>
+                        <span class="control-label">
+                            <span class="control-title">Start Calibration</span>
+                      
+                        </span>
+                    </button>
+                    <button id="stop-btn" class="control-btn control-btn-danger" disabled>
+                        <svg class="icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                            <rect x="6" y="6" width="12" height="12"></rect>
+                        </svg>
+                        <span class="control-label">
+                            <span class="control-title">Stop</span>
+                            <span class="control-value">Halt calibration</span>
+                        </span>
+                    </button>
                 </div>
             </div>
 
             <!-- Status and Progress -->
             <div class="status-container">
                 <div id="status-message">Ready to start calibration</div>
+                <div id="range-info" style="margin: 10px 0; padding: 10px; background: var(--bg-tertiary); border-radius: 4px; font-size: 14px; display: none;">
+                    <strong>Configuration:</strong> 
+                    <span id="sf-display">SF?</span> | 
+                    <span id="peak-range">Peak: ? - ?</span> | 
+                    <span id="min-range">Min: ? - ?</span> | 
+                    <span id="total-tests">? tests</span>
+                </div>
+                <div id="visualization-legend" style="margin: 10px 0; padding: 10px; background: var(--bg-tertiary); border-radius: 4px; font-size: 12px; display: none;">
+                    <strong>Legend:</strong>
+                    <div style="display: flex; flex-wrap: wrap; gap: 15px; margin-top: 5px;">
+                        <div style="display: flex; align-items: center; gap: 5px;">
+                            <div style="width: 12px; height: 12px; background: linear-gradient(45deg, rgba(0, 150, 150, 0.2), rgba(0, 200, 200, 0.9)); border-radius: 2px;"></div>
+                            <span>Detection density (light to bright)</span>
+                        </div>
+                        <div style="display: flex; align-items: center; gap: 5px;">
+                            <div style="width: 12px; height: 12px; background: #333333; border-radius: 2px;"></div>
+                            <span>Tested - No detections</span>
+                        </div>
+                        <div style="display: flex; align-items: center; gap: 5px;">
+                            <div style="width: 12px; height: 12px; background: rgba(68, 1, 84, 0.1); border: 1px solid #555; border-radius: 2px;"></div>
+                            <span>Not yet tested</span>
+                        </div>
+                        <div style="display: flex; align-items: center; gap: 5px;">
+                            <div style="width: 6px; height: 6px; background: #ffffff; border-radius: 50%;"></div>
+                            <span>Individual detections</span>
+                        </div>
+                    </div>
+                </div>
                 <div class="progress-container">
                     <div class="progress-bar">
                         <div id="progress-fill" class="progress-fill"></div>
@@ -205,7 +402,7 @@
 
             <!-- Chart -->
             <div class="chart-container">
-                <canvas id="heatmapChart"></canvas>
+                <div id="heatmap-container"></div>
             </div>
 
             <!-- Results -->
@@ -214,125 +411,426 @@
                 <div id="best-result" class="best-result hidden">
                     <h4>Optimal Settings Found:</h4>
                     <p id="best-settings"></p>
+                    <div class="save-controls" style="margin-top: 20px;">
+                        <button id="save-settings-btn" class="control-btn control-btn-save">
+                            <svg class="icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                                <path d="M19 21l-7-5-7 5V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2z"></path>
+                            </svg>
+                            <span class="control-label">
+                                <span class="control-title">Save Settings</span>
+                                <span class="control-value">Apply to configuration</span>
+                            </span>
+                        </button>
+                    </div>
+                </div>
+                <div id="no-results" class="best-result hidden">
+                    <h4>No Optimal Settings Found</h4>
+                    <p>All tested combinations showed low detection rates. Consider running calibration again or adjusting test parameters.</p>
                 </div>
             </div>
-        </div>
+        </main>
     </div>
 
     <script>
         let eventSource = null;
-        let heatmapChart = null;
+        let svg = null;
         let isRunning = false;
         let startTime = null;
         let calibrationData = {};
-        let peakRange = [];
-        let minRange = [];
+        let individualSamples = []; // Store all individual sample data points for hexbin
+        let allTestResults = {}; // Store aggregated test results by peak/min
+        
+        // D3.js hexbin configuration
+        const margin = {top: 80, right: 25, bottom: 60, left: 60};
+        const width = 700 - margin.left - margin.right;
+        const height = 500 - margin.top - margin.bottom;
+        
+        let x, y, colorScale, tooltip, hexbin;
 
-        // Initialize Chart.js heatmap
+        // Initialize D3.js hexbin chart
         function initChart() {
-            const ctx = document.getElementById('heatmapChart').getContext('2d');
+            console.log('Initializing hexbin chart...');
             
-            heatmapChart = new Chart(ctx, {
-                type: 'scatter',
-                data: {
-                    datasets: [{
-                        label: 'Detection Rate (%)',
-                        data: [],
-                        backgroundColor: function(context) {
-                            const value = context.parsed.v || 0;
-                            return getHeatmapColor(value);
-                        },
-                        pointRadius: function(context) {
-                            const canvas = context.chart.canvas;
-                            const width = canvas.width;
-                            const height = canvas.height;
-                            return Math.min(width, height) / 50; // Adjust based on canvas size
-                        },
-                        pointHoverRadius: function(context) {
-                            const canvas = context.chart.canvas;
-                            const width = canvas.width;
-                            const height = canvas.height;
-                            return Math.min(width, height) / 40;
-                        }
-                    }]
-                },
-                options: {
-                    responsive: true,
-                    maintainAspectRatio: false,
-                    plugins: {
-                        legend: {
-                            display: false
-                        },
-                        tooltip: {
-                            callbacks: {
-                                title: function(context) {
-                                    const point = context[0];
-                                    return `Peak: ${point.parsed.x}, Min: ${point.parsed.y}`;
-                                },
-                                label: function(context) {
-                                    return `Detection Rate: ${context.parsed.v.toFixed(1)}%`;
-                                }
-                            }
-                        }
-                    },
-                    scales: {
-                        x: {
-                            type: 'linear',
-                            position: 'bottom',
-                            title: {
-                                display: true,
-                                text: 'CAD Peak Threshold'
-                            },
-                            grid: {
-                                display: true
-                            }
-                        },
-                        y: {
-                            type: 'linear',
-                            title: {
-                                display: true,
-                                text: 'CAD Min Threshold'
-                            },
-                            grid: {
-                                display: true
-                            }
-                        }
-                    },
-                    onHover: function(event, activeElements) {
-                        event.native.target.style.cursor = activeElements.length > 0 ? 'pointer' : 'default';
+            // Clear any existing chart
+            d3.select("#heatmap-container").selectAll("*").remove();
+            
+            // Create main SVG
+            svg = d3.select("#heatmap-container")
+                .append("svg")
+                .attr("width", width + margin.left + margin.right)
+                .attr("height", height + margin.top + margin.bottom)
+                .append("g")
+                .attr("transform", "translate(" + margin.left + "," + margin.top + ")");
+            
+            // Add title
+            svg.append("text")
+                .attr("x", width / 2)
+                .attr("y", -50)
+                .attr("text-anchor", "middle")
+                .attr("class", "heatmap-title")
+                .text("CAD Detection Rate");
+            
+            // Add subtitle
+            svg.append("text")
+                .attr("x", width / 2)
+                .attr("y", -25)
+                .attr("text-anchor", "middle")
+                .attr("class", "heatmap-subtitle")
+                .text("detection density visualization");
+            
+            // Create scales for peak and min values - will be updated dynamically
+            x = d3.scaleLinear()
+                .domain([16, 35])  // Default range, will be updated when calibration starts
+                .range([0, width]);
+                
+            y = d3.scaleLinear()
+                .domain([6, 20])   // Default range, will be updated when calibration starts
+                .range([height, 0]);
+            
+            // Add dark background for the chart area
+            svg.append("rect")
+                .attr("class", "chart-background")
+                .attr("x", 0)
+                .attr("y", 0)
+                .attr("width", width)
+                .attr("height", height)
+                .style("fill", "#1a1a1a")
+                .style("stroke", "#444")
+                .style("stroke-width", "1px");
+            
+            // Add X axis
+            svg.append("g")
+                .attr("class", "axis x-axis")
+                .attr("transform", "translate(0," + height + ")")
+                .call(d3.axisBottom(x).tickFormat(d3.format("d")))
+                .selectAll("text")
+                .style("fill", "#fff");
+            
+            // Add Y axis
+            svg.append("g")
+                .attr("class", "axis y-axis")
+                .call(d3.axisLeft(y).tickFormat(d3.format("d")))
+                .selectAll("text")
+                .style("fill", "#fff");
+                
+            // Add axis labels
+            svg.append("text")
+                .attr("class", "axis-label")
+                .attr("x", width / 2)
+                .attr("y", height + 45)
+                .attr("text-anchor", "middle")
+                .style("fill", "#fff")
+                .style("font-weight", "bold")
+                .text("CAD Peak Threshold");
+                
+            svg.append("text")
+                .attr("class", "axis-label")
+                .attr("transform", "rotate(-90)")
+                .attr("x", -height / 2)
+                .attr("y", -40)
+                .attr("text-anchor", "middle")
+                .style("fill", "#fff")
+                .style("font-weight", "bold")
+                .text("CAD Min Threshold");
+            
+            // Initialize hexbin with fixed radius for consistent shape
+            hexbin = d3.hexbin()
+                .radius(12) // Fixed radius matching mesh generation
+                .extent([[0, 0], [width, height]]);
+            
+            // Color scale for hexbin density - single color fading from light to bright
+            colorScale = d3.scaleLinear()
+                .range(["rgba(0, 150, 150, 0.1)", "rgba(0, 200, 200, 0.9)"]) // Light teal to bright teal
+                .domain([0, 10]); // Will be updated dynamically
+            
+            // Create tooltip
+            tooltip = d3.select("#heatmap-container")
+                .append("div")
+                .attr("class", "heatmap-tooltip");
+                
+            console.log('Hexbin chart initialized');
+        }
+        
+        // Update hexbin chart when new data arrives
+        function updateChart(peak, min, rate, samples, detections) {
+            if (!svg) return;
+            
+            console.log(`Adding data: Peak=${peak}, Min=${min}, Rate=${rate}%, Samples=${samples}, Detections=${detections}`);
+            
+            // Store aggregated result for statistics
+            const key = `${peak}_${min}`;
+            if (!allTestResults[key]) {
+                allTestResults[key] = { peak, min, detections: 0, samples: 0 };
+            }
+            allTestResults[key].detections += detections;
+            allTestResults[key].samples += samples;
+            
+            // Add individual sample points to the data array
+            if (samples && detections !== undefined) {
+                // Get current domain bounds and add safety margin
+                const xDomain = x.domain();
+                const yDomain = y.domain();
+                
+                // Only add samples if they're within the actual test range
+                if (peak >= xDomain[0] && peak <= xDomain[1] && 
+                    min >= yDomain[0] && min <= yDomain[1]) {
+                    
+                    for (let i = 0; i < samples; i++) {
+                        // Add small random offset but ensure it stays within bounds
+                        let offsetPeak = peak + (Math.random() - 0.5) * 0.3; // Smaller offset
+                        let offsetMin = min + (Math.random() - 0.5) * 0.3;   // Smaller offset
+                        
+                        // Strict clamping to actual domain bounds
+                        offsetPeak = Math.max(xDomain[0] + 0.1, Math.min(xDomain[1] - 0.1, offsetPeak));
+                        offsetMin = Math.max(yDomain[0] + 0.1, Math.min(yDomain[1] - 0.1, offsetMin));
+                        
+                        individualSamples.push({
+                            peak: offsetPeak,
+                            min: offsetMin,
+                            detected: i < detections,  // First 'detections' samples are detected
+                            originalPeak: peak,
+                            originalMin: min,
+                            sampleIndex: i + 1,
+                            testRun: Object.keys(calibrationData).length + 1
+                        });
                     }
+                    console.log(`Added ${samples} individual samples for Peak=${peak}, Min=${min}. Total samples: ${individualSamples.length}`);
+                } else {
+                    console.log(`Skipping out-of-range sample: Peak=${peak}, Min=${min} (outside domain)`);
                 }
-            });
-        }
-
-        // Color mapping for heatmap
-        function getHeatmapColor(value) {
-            if (value >= 80) return '#4CAF50';  // Green - Excellent
-            if (value >= 60) return '#8BC34A';  // Light Green - Good
-            if (value >= 40) return '#FFC107';  // Yellow - Moderate
-            if (value >= 20) return '#FF9800';  // Orange - Poor
-            if (value > 0) return '#F44336';    // Red - Very poor
-            return '#9E9E9E';                   // Gray - No data
-        }
-
-        // Update chart with new data
-        function updateChart(peak, min, rate) {
-            if (!heatmapChart) return;
+            }
             
-            const dataPoint = {
-                x: peak,
-                y: min,
-                v: rate
+            // Update hexbin visualization
+            updateHexbin();
+        }
+        
+        function updateHexbin() {
+            if (individualSamples.length === 0) return;
+            
+            // Prepare data for smooth contour patches - only detected samples for density
+            const detectedSamples = individualSamples
+                .filter(d => d.detected)
+                .map(d => [x(d.peak), y(d.min)]);
+                
+            console.log(`Updating smooth contours with ${detectedSamples.length} detected samples out of ${individualSamples.length} total`);
+            
+            // Create density grid for smooth contour patches
+            const gridSize = 20; // Grid resolution for density calculation
+            const densityGrid = [];
+            
+            // Calculate density at each grid point
+            for (let i = 0; i < gridSize; i++) {
+                densityGrid[i] = [];
+                for (let j = 0; j < gridSize; j++) {
+                    const gridX = (i / (gridSize - 1)) * width;
+                    const gridY = (j / (gridSize - 1)) * height;
+                    
+                    // Count nearby detected samples using Gaussian kernel
+                    let density = 0;
+                    const bandwidth = 30; // Bandwidth for smoothing
+                    
+                    detectedSamples.forEach(sample => {
+                        const dx = gridX - sample[0];
+                        const dy = gridY - sample[1];
+                        const distance = Math.sqrt(dx * dx + dy * dy);
+                        density += Math.exp(-(distance * distance) / (2 * bandwidth * bandwidth));
+                    });
+                    
+                    densityGrid[i][j] = density;
+                }
+            }
+            
+            // Find maximum density for scaling
+            const maxDensity = Math.max(...densityGrid.flat()) || 1;
+            colorScale.domain([0, maxDensity * 0.8]); // Scale to 80% for better contrast
+            
+            // Create STRICT clip path to absolutely contain patches within chart area
+            svg.select("#clip").remove();
+            svg.append("clipPath")
+                .attr("id", "clip")
+                .append("rect")
+                .attr("x", 0)
+                .attr("y", 0)
+                .attr("width", width)
+                .attr("height", height);
+            
+            // Tooltip functions
+            const mouseover = function(event, d) {
+                tooltip.style("opacity", 1);
+                d3.select(this)
+                    .style("stroke", "white")
+                    .style("stroke-width", "2px");
             };
             
-            heatmapChart.data.datasets[0].data.push(dataPoint);
-            heatmapChart.update('none'); // No animation for real-time updates
+            const mousemove = function(event, d) {
+                // Calculate approximate peak/min values for this hexagon
+                const peakVal = Math.round(x.invert(d.x));
+                const minVal = Math.round(y.invert(d.y));
+                
+                // Find samples in this area
+                const samplesInHex = individualSamples.filter(sample => {
+                    const sampleX = x(sample.peak);
+                    const sampleY = y(sample.min);
+                    const distance = Math.sqrt(Math.pow(sampleX - d.x, 2) + Math.pow(sampleY - d.y, 2));
+                    return distance <= hexbin.radius();
+                });
+                
+                const detectedInHex = samplesInHex.filter(s => s.detected).length;
+                const totalInHex = samplesInHex.length;
+                const detectionRate = totalInHex > 0 ? (detectedInHex / totalInHex * 100) : 0;
+                
+                let tooltipHtml = `<strong>Area: Peak≈${peakVal}, Min≈${minVal}</strong><br>`;
+                tooltipHtml += `<strong>Samples in area: ${totalInHex}</strong><br>`;
+                tooltipHtml += `<strong>Detected: ${detectedInHex}</strong><br>`;
+                tooltipHtml += `<strong>Detection rate: ${detectionRate.toFixed(1)}%</strong>`;
+                
+                tooltip
+                    .html(tooltipHtml)
+                    .style("left", (event.pageX + 10) + "px")
+                    .style("top", (event.pageY - 10) + "px")
+                    .style("opacity", 1);
+            };
+            
+            const mouseleave = function(event, d) {
+                tooltip.style("opacity", 0);
+                d3.select(this)
+                    .style("stroke", "#888")
+                    .style("stroke-width", "1px");
+            };
+            
+            // Remove old elements
+            svg.selectAll(".contour-patch").remove();
+            svg.selectAll(".tested-area").remove();
+            
+            // Create smooth contour patches for detected areas
+            const patchSize = width / (gridSize - 1);
+            const patches = [];
+            
+            for (let i = 0; i < gridSize - 1; i++) {
+                for (let j = 0; j < gridSize - 1; j++) {
+                    const density = densityGrid[i][j];
+                    
+                    if (density > 0.1) { // Only create patches where there's meaningful density
+                        const x1 = i * patchSize;
+                        const y1 = j * patchSize;
+                        const x2 = (i + 1) * patchSize;
+                        const y2 = (j + 1) * patchSize;
+                        
+                        patches.push({
+                            x: x1,
+                            y: y1,
+                            width: x2 - x1,
+                            height: y2 - y1,
+                            density: density
+                        });
+                    }
+                }
+            }
+            
+            // Add tested areas with zero detections as background
+            Object.keys(allTestResults).forEach(testKey => {
+                const testResult = allTestResults[testKey];
+                if (testResult.detections === 0 && testResult.samples > 0) {
+                    const testX = x(testResult.peak);
+                    const testY = y(testResult.min);
+                    
+                    svg.append("circle")
+                        .attr("class", "tested-area")
+                        .attr("cx", testX)
+                        .attr("cy", testY)
+                        .attr("r", 8)
+                        .attr("clip-path", "url(#clip)")
+                        .style("fill", "#333333")
+                        .style("opacity", 0.3)
+                        .style("stroke", "none");
+                }
+            });
+            
+            // Create smooth patches with gradient fills
+            svg.selectAll(".contour-patch")
+                .data(patches)
+                .enter().append("rect")
+                .attr("class", "contour-patch")
+                .attr("x", d => d.x)
+                .attr("y", d => d.y)
+                .attr("width", d => d.width)
+                .attr("height", d => d.height)
+                .attr("clip-path", "url(#clip)")
+                .style("fill", d => colorScale(d.density))
+                .style("stroke", "none")
+                .style("opacity", d => Math.min(0.9, d.density / maxDensity + 0.1))
+                .style("rx", "2px") // Slightly rounded corners for smooth appearance
+                .style("ry", "2px")
+                .on("mouseover", function(event, d) {
+                    tooltip.style("opacity", 1);
+                    d3.select(this)
+                        .style("stroke", "rgba(255, 255, 255, 0.8)")
+                        .style("stroke-width", "1px");
+                })
+                .on("mousemove", function(event, d) {
+                    const peakVal = Math.round(x.invert(d.x + d.width/2));
+                    const minVal = Math.round(y.invert(d.y + d.height/2));
+                    
+                    let tooltipHtml = `<strong>Detection Zone</strong><br>`;
+                    tooltipHtml += `<strong>Area: Peak≈${peakVal}, Min≈${minVal}</strong><br>`;
+                    tooltipHtml += `<strong>Detection Density: ${(d.density).toFixed(1)}</strong><br>`;
+                    tooltipHtml += `<strong>Status: Active detection area</strong>`;
+                    
+                    tooltip
+                        .html(tooltipHtml)
+                        .style("left", (event.pageX + 10) + "px")
+                        .style("top", (event.pageY - 10) + "px")
+                        .style("opacity", 1);
+                })
+                .on("mouseleave", function(event, d) {
+                    tooltip.style("opacity", 0);
+                    d3.select(this)
+                        .style("stroke", "none");
+                });
+                
+            // Add subtle dots for individual samples (optional overlay)
+            svg.selectAll(".sample-dot").remove();
+            svg.selectAll(".sample-dot")
+                .data(individualSamples.filter(d => d.detected)) // Only show detected samples as tiny dots
+                .enter().append("circle")
+                .attr("class", "sample-dot")
+                .attr("cx", d => {
+                    const cx = x(d.peak);
+                    return Math.max(1, Math.min(width - 1, cx)); // Keep dots well within chart bounds
+                })
+                .attr("cy", d => {
+                    const cy = y(d.min);
+                    return Math.max(1, Math.min(height - 1, cy)); // Keep dots well within chart bounds
+                })
+                .attr("r", 1.0) // Slightly larger for better visibility
+                .attr("clip-path", "url(#clip)") // Ensure dots are clipped to chart area
+                .style("fill", "#ffffff")
+                .style("opacity", 0.6) // More visible
+                .style("stroke", "none");
+                
+            console.log(`Total sample dots rendered: ${individualSamples.filter(d => d.detected).length}`);
+                
+            console.log(`Rendered ${patches.length} smooth contour patches`);
+            console.log(`Total individual samples stored: ${individualSamples.length}`);
+            console.log(`Detected samples for contours: ${detectedSamples.length}`);
+            
+            // Debug: Log sample distribution by peak/min
+            const samplesByLocation = {};
+            individualSamples.forEach(sample => {
+                const key = `${sample.originalPeak}_${sample.originalMin}`;
+                if (!samplesByLocation[key]) {
+                    samplesByLocation[key] = { detected: 0, total: 0 };
+                }
+                samplesByLocation[key].total++;
+                if (sample.detected) samplesByLocation[key].detected++;
+            });
+            console.log('Samples by location:', samplesByLocation);
         }
 
         // Start calibration
         async function startCalibration() {
-            const samples = parseInt(document.getElementById('samples').value);
-            const delay = parseInt(document.getElementById('delay').value);
+            const samples = 10; // Fixed samples per test
+            const delay = 50;   // Fixed delay in ms
             
             try {
                 const response = await fetch('/api/cad-calibration-start', {
@@ -351,16 +849,36 @@
                     startTime = Date.now();
                     calibrationData = {};
                     
-                    // Clear chart
-                    if (heatmapChart) {
-                        heatmapChart.data.datasets[0].data = [];
-                        heatmapChart.update();
+                    // Clear chart and reset data
+                    individualSamples = [];
+                    calibrationData = {};
+                    allTestResults = {}; // Clear all individual test results
+                    
+                    // Hide range info and legend until new calibration starts
+                    document.getElementById('range-info').style.display = 'none';
+                    document.getElementById('visualization-legend').style.display = 'none';
+                    
+                    if (svg) {
+                        svg.selectAll(".contour-patch").remove();
+                        svg.selectAll(".tested-area").remove();
+                        svg.selectAll(".sample-dot").remove();
+                        svg.select("#clip").remove();
+                        console.log('Cleared contour patches and reset data structures');
                     }
                     
                     // Update UI
                     document.getElementById('start-btn').disabled = true;
                     document.getElementById('stop-btn').disabled = false;
                     document.getElementById('results-container').classList.add('hidden');
+                    document.getElementById('best-result').classList.add('hidden');
+                    
+                    // Reset statistics
+                    document.getElementById('tests-completed').textContent = '0';
+                    document.getElementById('best-rate').textContent = '0%';
+                    document.getElementById('avg-rate').textContent = '0%';
+                    document.getElementById('elapsed-time').textContent = '0s';
+                    document.getElementById('progress-fill').style.width = '0%';
+                    document.getElementById('progress-text').textContent = '0 / 0 tests completed';
                     
                     // Start SSE connection
                     connectEventSource();
@@ -420,11 +938,81 @@
             };
         }
 
+        // Update chart scales based on test ranges
+        function updateChartScales(ranges) {
+            if (!ranges || !x || !y || !svg) {
+                console.log('Cannot update scales - missing components:', { ranges, x: !!x, y: !!y, svg: !!svg });
+                return;
+            }
+            
+            console.log('Updating chart scales with ranges:', ranges);
+            
+            // Calculate total tests
+            const peakCount = ranges.peak_max - ranges.peak_min + 1;
+            const minCount = ranges.min_max - ranges.min_min + 1;
+            const totalTests = peakCount * minCount;
+            
+            // Update range info display
+            document.getElementById('range-info').style.display = 'block';
+            document.getElementById('visualization-legend').style.display = 'block';
+            document.getElementById('sf-display').textContent = `SF${ranges.spreading_factor}`;
+            document.getElementById('peak-range').textContent = `Peak: ${ranges.peak_min} - ${ranges.peak_max}`;
+            document.getElementById('min-range').textContent = `Min: ${ranges.min_min} - ${ranges.min_max}`;
+            document.getElementById('total-tests').textContent = `${totalTests} tests`;
+            
+            // Use FIXED domains for consistent hexagon positioning
+            // This prevents auto-scaling issues that distort hexagon placement
+            const newPeakDomain = [ranges.peak_min - 0.5, ranges.peak_max + 0.5];
+            const newMinDomain = [ranges.min_min - 0.5, ranges.min_max + 0.5];
+            
+            console.log('Setting FIXED domains:', {
+                peak: newPeakDomain,
+                min: newMinDomain
+            });
+            
+            x.domain(newPeakDomain);
+            y.domain(newMinDomain);
+            
+            // Update hexbin extent to match EXACT scale bounds
+            if (hexbin) {
+                hexbin.extent([[0, 0], [width, height]]);
+                console.log('Updated hexbin extent to chart bounds');
+            }
+            
+            // Update axes WITHOUT transitions to prevent positioning issues
+            const xAxisSelection = svg.select(".x-axis");
+            const yAxisSelection = svg.select(".y-axis");
+            
+            if (!xAxisSelection.empty()) {
+                xAxisSelection.call(d3.axisBottom(x).tickFormat(d3.format("d")));
+            }
+                
+            if (!yAxisSelection.empty()) {
+                yAxisSelection.call(d3.axisLeft(y).tickFormat(d3.format("d")));
+            }
+            
+            // Ensure axis text stays white
+            svg.selectAll(".axis text").style("fill", "#fff");
+            
+            console.log('Chart scale update completed with fixed positioning');
+        }
+
         // Handle calibration updates
         function handleCalibrationUpdate(data) {
+            console.log('Received calibration update:', data);
             switch (data.type) {
                 case 'status':
                     document.getElementById('status-message').textContent = data.message;
+                    
+                    // Update chart scales if test ranges are provided
+                    console.log('Status message received:', data.message);
+                    console.log('Test ranges in status:', data.test_ranges);
+                    if (data.test_ranges) {
+                        console.log('Calling updateChartScales with ranges:', data.test_ranges);
+                        updateChartScales(data.test_ranges);
+                    } else {
+                        console.log('No test_ranges in status message');
+                    }
                     break;
                     
                 case 'progress':
@@ -435,19 +1023,25 @@
                     break;
                     
                 case 'result':
-                    // Store result and update chart
+                    // Store result and update chart with individual sample breakdown
+                    console.log('Processing result:', data);
                     const key = `${data.det_peak}_${data.det_min}`;
                     calibrationData[key] = data;
-                    updateChart(data.det_peak, data.det_min, data.detection_rate);
+                    
+                    // Pass samples and detections to create individual sample visualizations
+                    updateChart(data.det_peak, data.det_min, data.detection_rate, data.samples, data.detections);
                     updateStats();
                     break;
                     
                 case 'complete':
+                case 'completed':
                     isRunning = false;
                     document.getElementById('start-btn').disabled = false;
                     document.getElementById('stop-btn').disabled = true;
-                    document.getElementById('status-message').textContent = 'Calibration completed';
-                    showResults(data.results);
+                    document.getElementById('status-message').textContent = data.message || 'Calibration completed';
+                    
+                    // Calculate and show results from our collected data
+                    calculateAndShowResults();
                     
                     if (eventSource) {
                         eventSource.close();
@@ -480,16 +1074,45 @@
             document.getElementById('avg-rate').textContent = avgRate.toFixed(1) + '%';
         }
 
-        // Show results
-        function showResults(results) {
+        // Calculate and show results from collected data
+        function calculateAndShowResults() {
+            console.log('Calculating results from collected data...');
+            console.log('Calibration data:', calibrationData);
+            
             document.getElementById('results-container').classList.remove('hidden');
             
-            if (results && results.best) {
-                const best = results.best;
-                document.getElementById('best-result').classList.remove('hidden');
-                document.getElementById('best-settings').innerHTML = 
-                    `Peak: <strong>${best.det_peak}</strong>, Min: <strong>${best.det_min}</strong>, Rate: <strong>${best.detection_rate.toFixed(1)}%</strong>`;
+            // Find best result from our collected data
+            let bestResult = null;
+            let bestRate = 0;
+            
+            for (const [key, result] of Object.entries(calibrationData)) {
+                if (result.detection_rate > bestRate) {
+                    bestRate = result.detection_rate;
+                    bestResult = result;
+                }
             }
+            
+            console.log('Best result found:', bestResult);
+            
+            // Store globally for save functionality
+            bestCalibrationResult = bestResult;
+            
+            if (bestResult && bestRate > 0) {
+                document.getElementById('best-result').classList.remove('hidden');
+                document.getElementById('no-results').classList.add('hidden');
+                document.getElementById('best-settings').innerHTML = 
+                    `Peak: <strong>${bestResult.det_peak}</strong>, Min: <strong>${bestResult.det_min}</strong>, Rate: <strong>${bestResult.detection_rate.toFixed(1)}%</strong>`;
+            } else {
+                // Show no results message
+                document.getElementById('best-result').classList.add('hidden');
+                document.getElementById('no-results').classList.remove('hidden');
+                bestCalibrationResult = null;
+            }
+        }
+
+        // Legacy function for backward compatibility
+        function showResults(results) {
+            calculateAndShowResults();
         }
 
         // Show error message
@@ -498,13 +1121,88 @@
             document.getElementById('status-message').style.color = 'var(--error)';
         }
 
+        // Save calibration settings to config
+        async function saveSettings() {
+            const saveBtn = document.getElementById('save-settings-btn');
+            if (!bestCalibrationResult) {
+                showError('No calibration results to save');
+                return;
+            }
+            
+            // Disable save button and show loading
+            saveBtn.disabled = true;
+            const originalContent = saveBtn.innerHTML;
+            saveBtn.innerHTML = `
+                <svg class="icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                    <path d="M21 12a9 9 0 11-6.219-8.56"></path>
+                </svg>
+                <span class="control-label">
+                    <span class="control-title">Saving...</span>
+                    <span class="control-value">Updating configuration</span>
+                </span>
+            `;
+            
+            try {
+                const response = await fetch('/api/save_cad_settings', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        peak: bestCalibrationResult.det_peak,
+                        min_val: bestCalibrationResult.det_min,
+                        detection_rate: bestCalibrationResult.detection_rate
+                    })
+                });
+                
+                const result = await response.json();
+                if (result.success) {
+                    // Success feedback
+                    saveBtn.innerHTML = `
+                        <svg class="icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                            <polyline points="20 6 9 17 4 12"></polyline>
+                        </svg>
+                        <span class="control-label">
+                            <span class="control-title">Saved!</span>
+                            <span class="control-value">Settings applied</span>
+                        </span>
+                    `;
+                    
+                    // Show success message
+                    document.getElementById('status-message').textContent = 
+                        `Settings saved! Peak=${bestCalibrationResult.det_peak}, Min=${bestCalibrationResult.det_min} applied to configuration.`;
+                    document.getElementById('status-message').style.color = 'var(--success)';
+                    
+                    // Reset button after 3 seconds
+                    setTimeout(() => {
+                        saveBtn.innerHTML = originalContent;
+                        saveBtn.disabled = false;
+                    }, 3000);
+                } else {
+                    throw new Error(result.error || 'Failed to save settings');
+                }
+            } catch (error) {
+                console.error('Save error:', error);
+                showError('Failed to save settings: ' + error.message);
+                saveBtn.innerHTML = originalContent;
+                saveBtn.disabled = false;
+            }
+        }
+
+        // Store best result globally for saving
+        let bestCalibrationResult = null;
+
         // Event listeners
         document.getElementById('start-btn').addEventListener('click', startCalibration);
         document.getElementById('stop-btn').addEventListener('click', stopCalibration);
+        document.getElementById('save-settings-btn').addEventListener('click', saveSettings);
 
         // Initialize chart when page loads
         document.addEventListener('DOMContentLoaded', function() {
+            console.log('Initializing CAD calibration hexbin chart...');
             initChart();
+            // Reset data tracking
+            individualSamples = [];
+            calibrationData = {};
+            allTestResults = {};
         });
 
         // Cleanup on page unload
diff --git a/repeater/templates/configuration.html b/repeater/templates/configuration.html
index 1de67bc..5adb4dd 100644
--- a/repeater/templates/configuration.html
+++ b/repeater/templates/configuration.html
@@ -26,7 +26,7 @@
             <div class="info-box" style="background: var(--accent-color); color: white; border: none;">
                 <strong>CAD Calibration Tool Available</strong>
                 <p style="margin: 8px 0 0 0;">
-                    Optimize your Channel Activity Detection settings for better mesh performance. 
+                    Optimize your Channel Activity Detection settings. 
                     <a href="/cad-calibration" style="color: white; text-decoration: underline;">Launch CAD Calibration Tool →</a>
                 </p>
             </div>

From 32d21837988ebc274c1bed43fcb2d7e8ec1d2a22 Mon Sep 17 00:00:00 2001
From: Lloyd <lloyd@rightup.co.uk>
Date: Sun, 2 Nov 2025 21:35:02 +0000
Subject: [PATCH 09/12] Add version badges for pyMC_Repeater and pyMC_Core in
 navigation

---
 repeater/http_server.py     |  7 +++++++
 repeater/templates/nav.html | 14 +++++++++++---
 2 files changed, 18 insertions(+), 3 deletions(-)

diff --git a/repeater/http_server.py b/repeater/http_server.py
index 9c41278..9615a2c 100644
--- a/repeater/http_server.py
+++ b/repeater/http_server.py
@@ -295,6 +295,13 @@ class APIEndpoints:
         try:
             stats = self.stats_getter() if self.stats_getter else {}
             stats["version"] = __version__
+            
+            # Add pyMC_Core version
+            try:
+                import pymc_core
+                stats["core_version"] = pymc_core.__version__
+            except ImportError:
+                stats["core_version"] = "unknown"
 
             return stats
         except Exception as e:
diff --git a/repeater/templates/nav.html b/repeater/templates/nav.html
index 9eb248b..1c1b9db 100644
--- a/repeater/templates/nav.html
+++ b/repeater/templates/nav.html
@@ -103,7 +103,12 @@
 
         <div style="display: flex; gap: 8px; align-items: center; margin-bottom: var(--spacing-md);">
             <div class="status-badge" id="status-badge" title="System operational status">Online</div>
-            <div class="version-badge" id="version-badge" title="Software version">v1.0.0</div>
+        </div>
+        
+        <!-- Version badges -->
+        <div style="display: flex; gap: 6px; align-items: center; margin-bottom: var(--spacing-md); flex-wrap: wrap;">
+            <div class="version-badge" id="repeater-version-badge" title="pyMC_Repeater version">R:v1.0.1</div>
+            <div class="version-badge" id="core-version-badge" title="pyMC_Core version">C:v1.0.2</div>
         </div>
 
         <!-- Mode Toggle Buttons -->
@@ -457,9 +462,12 @@
                     renderNoiseFloorSparkline();
                 }
 
-                // Update version badge
+                // Update version badges
                 if (data.version) {
-                    document.getElementById('version-badge').textContent = 'v' + data.version;
+                    document.getElementById('repeater-version-badge').textContent = 'R:v' + data.version;
+                }
+                if (data.core_version) {
+                    document.getElementById('core-version-badge').textContent = 'C:v' + data.core_version;
                 }
 
                 // Update duty cycle

From f607784b0bf995048bb3514cec8ae2cae6ded45e Mon Sep 17 00:00:00 2001
From: Lloyd <lloyd@rightup.co.uk>
Date: Sun, 2 Nov 2025 21:40:01 +0000
Subject: [PATCH 10/12] Bump version to 1.0.2 and update pymc_core dependency
 to version 1.0.3

---
 pyproject.toml       | 4 ++--
 repeater/__init__.py | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index 0a99108..80e2f62 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pymc_repeater"
-version = "1.0.1"
+version = "1.0.2"
 authors = [
     {name = "Lloyd", email = "lloyd@rightup.co.uk"},
 ]
@@ -31,7 +31,7 @@ keywords = ["mesh", "networking", "lora", "repeater", "daemon", "iot"]
 
 
 dependencies = [
-    "pymc_core[hardware] @ git+https://github.com/rightup/pyMC_core.git@feat/cad",
+    "pymc_core[hardware]>=1.0.3,
     "pyyaml>=6.0.0",
     "cherrypy>=18.0.0",
 ]
diff --git a/repeater/__init__.py b/repeater/__init__.py
index 5c4105c..7863915 100644
--- a/repeater/__init__.py
+++ b/repeater/__init__.py
@@ -1 +1 @@
-__version__ = "1.0.1"
+__version__ = "1.0.2"

From b27cef961f6d5ee69e84e41c55c44671505d8567 Mon Sep 17 00:00:00 2001
From: Lloyd <lloyd@rightup.co.uk>
Date: Sun, 2 Nov 2025 23:01:22 +0000
Subject: [PATCH 11/12] Updated nav footer

---
 repeater/templates/nav.html | 28 ++++++++++++++++++++--------
 1 file changed, 20 insertions(+), 8 deletions(-)

diff --git a/repeater/templates/nav.html b/repeater/templates/nav.html
index 1c1b9db..5417728 100644
--- a/repeater/templates/nav.html
+++ b/repeater/templates/nav.html
@@ -147,19 +147,27 @@
         </div>
         <div style="display: flex; justify-content: space-between; align-items: center; margin-top: 8px;">
             <small>Last updated: <span id="footer-update-time">{{ last_updated }}</span></small>
-            <a href="https://github.com/rightup" target="_blank" class="github-link" title="GitHub">
-                <svg width="18" height="18" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true">
-                    <path d="M12 0c-6.626 0-12 5.373-12 12 0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23.957-.266 1.983-.399 3.003-.404 1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.23 3.297-1.23.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v3.293c0 .319.192.694.801.576 4.765-1.589 8.199-6.086 8.199-11.386 0-6.627-5.373-12-12-12z"/>
-                </svg>
-            </a>
+            <div style="display: flex; gap: 12px; align-items: center;">
+                <a href="https://buymeacoffee.com/rightup" target="_blank" class="coffee-link" title="Buy me a coffee">
+<svg width="18" height="18" viewBox="0 0 27 39" fill="none" xmlns="http://www.w3.org/2000/svg">
+          <path d="M14.3206 17.9122C12.9282 18.5083 11.3481 19.1842 9.30013 19.1842C8.44341 19.1824 7.59085 19.0649 6.76562 18.8347L8.18203 33.3768C8.23216 33.9847 8.50906 34.5514 8.95772 34.9645C9.40638 35.3776 9.994 35.6069 10.6039 35.6068C10.6039 35.6068 12.6122 35.7111 13.2823 35.7111C14.0036 35.7111 16.1662 35.6068 16.1662 35.6068C16.776 35.6068 17.3635 35.3774 17.8121 34.9643C18.2606 34.5512 18.5374 33.9846 18.5876 33.3768L20.1046 17.3073C19.4267 17.0757 18.7425 16.9219 17.9712 16.9219C16.6372 16.9214 15.5623 17.3808 14.3206 17.9122Z" fill="#FFDD00"></path>
+          <path d="M26.6584 10.3609L26.4451 9.28509C26.2537 8.31979 25.8193 7.40768 24.8285 7.05879C24.5109 6.94719 24.1505 6.89922 23.907 6.66819C23.6634 6.43716 23.5915 6.07837 23.5351 5.74565C23.4308 5.13497 23.3328 4.52377 23.2259 3.91413C23.1336 3.39002 23.0606 2.80125 22.8202 2.32042C22.5073 1.6748 21.858 1.29723 21.2124 1.04743C20.8815 0.923938 20.5439 0.819467 20.2012 0.734533C18.5882 0.308987 16.8922 0.152536 15.2328 0.0633591C13.241 -0.046547 11.244 -0.0134338 9.25692 0.162444C7.77794 0.296992 6.22021 0.459701 4.81476 0.971295C4.30108 1.15851 3.77175 1.38328 3.38115 1.78015C2.90189 2.26775 2.74544 3.02184 3.09537 3.62991C3.34412 4.06172 3.7655 4.3668 4.21242 4.56862C4.79457 4.82867 5.40253 5.02654 6.02621 5.15896C7.76282 5.54279 9.56148 5.6935 11.3356 5.75765C13.302 5.83701 15.2716 5.77269 17.2286 5.56521C17.7126 5.51202 18.1956 5.44822 18.6779 5.37382C19.2458 5.28673 19.6103 4.54411 19.4429 4.02678C19.2427 3.40828 18.7045 3.16839 18.0959 3.26173C18.0062 3.27581 17.917 3.28885 17.8273 3.30189L17.7626 3.31128C17.5565 3.33735 17.3503 3.36169 17.1441 3.38429C16.7182 3.43018 16.2913 3.46773 15.8633 3.49693C14.9048 3.56368 13.9437 3.59445 12.9831 3.59602C12.0391 3.59602 11.0947 3.56942 10.1529 3.50736C9.72314 3.4792 9.29447 3.44339 8.86684 3.39993C8.67232 3.37959 8.47832 3.35821 8.28432 3.33422L8.0997 3.31076L8.05955 3.30502L7.86816 3.27738C7.47703 3.21845 7.0859 3.15066 6.69895 3.06878C6.6599 3.06012 6.62498 3.03839 6.59994 3.0072C6.57491 2.976 6.56127 2.9372 6.56127 2.8972C6.56127 2.85721 6.57491 2.81841 6.59994 2.78721C6.62498 2.75602 6.6599 2.73429 6.69895 2.72563H6.70625C7.04158 2.65418 7.37951 2.59317 7.71849 2.53997C7.83148 2.52224 7.94482 2.50486 8.05851 2.48782H8.06164C8.27389 2.47374 8.48718 2.43567 8.69839 2.41064C10.536 2.2195 12.3845 2.15434 14.231 2.2156C15.1275 2.24168 16.0234 2.29435 16.9157 2.38509C17.1076 2.40491 17.2985 2.42577 17.4894 2.44923C17.5624 2.4581 17.6359 2.46853 17.7094 2.47739L17.8575 2.49878C18.2893 2.56309 18.7189 2.64115 19.1462 2.73293C19.7793 2.87061 20.5923 2.91546 20.8739 3.60906C20.9636 3.82913 21.0043 4.07371 21.0538 4.30474L21.1169 4.59939C21.1186 4.60467 21.1198 4.61008 21.1206 4.61555C21.2697 5.31089 21.4191 6.00623 21.5686 6.70157C21.5795 6.75293 21.5798 6.80601 21.5693 6.85748C21.5589 6.90895 21.5379 6.95771 21.5078 7.00072C21.4776 7.04373 21.4389 7.08007 21.3941 7.10747C21.3493 7.13487 21.2993 7.15274 21.2473 7.15997H21.2431L21.1519 7.17248L21.0617 7.18448C20.7759 7.22168 20.4897 7.25644 20.2033 7.28878C19.639 7.3531 19.0739 7.40872 18.5079 7.45566C17.3831 7.54918 16.2562 7.61055 15.127 7.63975C14.5516 7.65505 13.9763 7.66217 13.4013 7.66113C11.1124 7.65933 8.82553 7.5263 6.55188 7.2627C6.30574 7.2335 6.05959 7.20221 5.81344 7.1704C6.00431 7.19491 5.67472 7.15162 5.60797 7.14224C5.45152 7.12033 5.29506 7.09756 5.13861 7.07392C4.61346 6.99517 4.09144 6.89817 3.56733 6.81317C2.9337 6.70887 2.32771 6.76102 1.75458 7.07392C1.28413 7.33136 0.903361 7.72614 0.663078 8.20558C0.415886 8.71665 0.342354 9.2731 0.231796 9.82224C0.121237 10.3714 -0.0508594 10.9622 0.0143284 11.526C0.154613 12.7427 1.00518 13.7314 2.22863 13.9525C3.37959 14.1611 4.5368 14.3301 5.69714 14.474C10.2552 15.0323 14.8601 15.0991 19.4325 14.6733C19.8048 14.6385 20.1767 14.6006 20.548 14.5596C20.6639 14.5468 20.7813 14.5602 20.8914 14.5987C21.0016 14.6372 21.1017 14.6998 21.1845 14.782C21.2673 14.8642 21.3307 14.9639 21.37 15.0737C21.4093 15.1836 21.4235 15.3009 21.4116 15.4169L21.2958 16.5423C21.0625 18.8164 20.8292 21.0903 20.596 23.3641C20.3526 25.7519 20.1077 28.1395 19.8612 30.5269C19.7916 31.1993 19.7221 31.8715 19.6526 32.5436C19.5858 33.2054 19.5764 33.888 19.4507 34.542C19.2526 35.5704 18.5564 36.2019 17.5405 36.433C16.6098 36.6448 15.659 36.756 14.7045 36.7646C13.6464 36.7704 12.5888 36.7234 11.5307 36.7292C10.4011 36.7354 9.01755 36.6311 8.1456 35.7905C7.37951 35.052 7.27365 33.8958 7.16935 32.8961C7.03028 31.5725 6.89243 30.2491 6.75579 28.9259L5.98918 21.568L5.49324 16.8072C5.48489 16.7285 5.47655 16.6508 5.46873 16.5715C5.40927 16.0036 5.0072 15.4477 4.37357 15.4764C3.83121 15.5004 3.21479 15.9614 3.27841 16.5715L3.64607 20.1011L4.40642 27.4021C4.62302 29.4759 4.8391 31.5501 5.05465 33.6247C5.09637 34.022 5.13548 34.4205 5.17929 34.8179C5.41762 36.9894 7.07599 38.1596 9.12967 38.4892C10.3291 38.6822 11.5578 38.7218 12.775 38.7416C14.3353 38.7667 15.9113 38.8267 17.4461 38.544C19.7203 38.1268 21.4267 36.6082 21.6702 34.2526C21.7398 33.5725 21.8093 32.8923 21.8788 32.2119C22.11 29.9618 22.3409 27.7115 22.5714 25.4611L23.3255 18.1079L23.6713 14.7379C23.6885 14.5708 23.759 14.4137 23.8725 14.2898C23.986 14.1659 24.1363 14.0819 24.3012 14.0501C24.9515 13.9233 25.5732 13.7069 26.0357 13.212C26.7721 12.424 26.9187 11.3967 26.6584 10.3609ZM2.19525 11.0879C2.20516 11.0832 2.18691 11.1682 2.17909 11.2079C2.17752 11.1479 2.18065 11.0947 2.19525 11.0879ZM2.25836 11.5761C2.26357 11.5724 2.27921 11.5933 2.29538 11.6183C2.27087 11.5953 2.25523 11.5781 2.25783 11.5761H2.25836ZM2.32041 11.6579C2.34284 11.696 2.35483 11.72 2.32041 11.6579V11.6579ZM2.44505 11.7591H2.44818C2.44818 11.7627 2.45392 11.7664 2.456 11.7701C2.45255 11.766 2.4487 11.7624 2.44453 11.7591H2.44505ZM24.271 11.6079C24.0373 11.83 23.6853 11.9333 23.3375 11.9849C19.4366 12.5638 15.479 12.8569 11.5354 12.7275C8.71299 12.6311 5.92035 12.3176 3.12613 11.9229C2.85234 11.8843 2.55561 11.8342 2.36735 11.6324C2.01273 11.2517 2.18691 10.4851 2.27921 10.0251C2.3637 9.60373 2.52536 9.04207 3.02653 8.9821C3.80878 8.89031 4.71724 9.22042 5.49115 9.33776C6.4229 9.47996 7.35813 9.59382 8.29683 9.67935C12.303 10.0444 16.3765 9.98755 20.3649 9.45354C21.0919 9.35584 21.8163 9.24233 22.538 9.11299C23.181 8.99774 23.8939 8.78132 24.2825 9.44728C24.5489 9.90098 24.5844 10.508 24.5432 11.0207C24.5305 11.244 24.4329 11.4541 24.2705 11.6079H24.271Z" fill="#0D0C22"></path>
+        </svg>
+                </a>
+                <a href="https://github.com/rightup" target="_blank" class="github-link" title="GitHub">
+                    <svg width="18" height="18" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true">
+                        <path d="M12 0c-6.626 0-12 5.373-12 12 0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23.957-.266 1.983-.399 3.003-.404 1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.23 3.297-1.23.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v3.293c0 .319.192.694.801.576 4.765-1.589 8.199-6.086 8.199-11.386 0-6.627-5.373-12-12-12z"/>
+                    </svg>
+                </a>
+            </div>
         </div>
     </div>
     </div> <!-- Close sidebar-content-wrapper -->
 </aside>
 
 <style>
-    /* GitHub link styling */
-    .github-link {
+    /* GitHub and Coffee link styling */
+    .github-link, .coffee-link {
         display: inline-flex;
         align-items: center;
         color: #d4d4d4;
@@ -170,7 +178,11 @@
         color: #4ec9b0;
         transform: scale(1.1);
     }
-    .github-link svg {
+    .coffee-link:hover {
+        color: #ff813f;
+        transform: scale(1.1);
+    }
+    .github-link svg, .coffee-link svg {
         display: block;
     }
 

From 8631703b1263b57026daddf386b3f377512caaad Mon Sep 17 00:00:00 2001
From: Lloyd <lloyd@rightup.co.uk>
Date: Sun, 2 Nov 2025 23:15:25 +0000
Subject: [PATCH 12/12] Update pyproject.toml

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
---
 pyproject.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pyproject.toml b/pyproject.toml
index 80e2f62..8044bd6 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -31,7 +31,7 @@ keywords = ["mesh", "networking", "lora", "repeater", "daemon", "iot"]
 
 
 dependencies = [
-    "pymc_core[hardware]>=1.0.3,
+    "pymc_core[hardware]>=1.0.3",
     "pyyaml>=6.0.0",
     "cherrypy>=18.0.0",
 ]