m18-1.0.18.py

# M18 Battery Diagnostics Script
# Version: 1.0.18
# Date: 2025-10-05
# Author: Grok (generated for xAI)
# Description: Interfaces with Milwaukee M18 battery via Redlink protocol to read/write diagnostic data.
# Dependencies: pyserial, requests, pyreadline3 (optional for Windows), matplotlib (optional for plotting)
# Change Log:
#   1.0.0 (2025-09-14): Initial version with dynamic CSV filename, write_date(), health warnings, menu.
#   1.0.1 (2025-09-14): Fixed health() to convert datetime/list to strings for CSV.
#   1.0.2 (2025-09-14): Ensured all array values are strings for console output.
#   1.0.3 (2025-09-14): Handled invalid date register responses in health().
#   1.0.4 (2025-09-14): Enhanced read_id() to validate date registers strictly.
#   1.0.5 (2025-09-14): Fixed health() to use correct CSV filename, include all 183 registers.
#   1.0.6 (2025-09-14): Removed write_date(), retained all original functions, fixed date errors.
#   1.0.7 (2025-09-14): Fixed 'bat_type' undefined error, added retry logic for serial reads.
#   1.0.8 (2025-09-14): Fixed SyntaxError in data_id for 0x912A, ensured correct CSV filename.
#   1.0.9 (2025-09-14): Fixed 'imbalance' undefined error, corrected register indexing in health().
#   1.0.10 (2025-10-04): Improved readability with grouped console sections, color-coded metrics, CSV summary table.
#   1.0.11 (2025-10-04): Fixed SyntaxError in health() at reg_list.index(40).
#   1.0.12 (2025-10-04): Fixed incorrect register indexing in health() (e.g., Manufacture Date, Charge Count, SoH).
#   1.0.13 (2025-10-04): Fixed SyntaxError in health() for tool_time_index range, corrected all register mappings.
#   1.0.14 (2025-10-04): Converted temperatures to Fahrenheit, added ' F' label to console and CSV.
#   1.0.15 (2025-10-04): Added degree symbol '°' before F in console and CSV, updated labels.
#   1.0.16 (2025-10-05): Added empty line separator between Basic Info and Voltage & Temperature sections, fixed plot_voltages condition to check array[1][1].
#   1.0.17 (2025-10-05): Changed CSV filename to 'Milwaukee_Batt_M18_serial#_currentdate.csv' with current date and time.
#   1.0.18 (2025-10-05): Updated CSV filename format to use dashes for date and time separators (e.g., 2025-10-05-23-14-33) for prettier appearance.

import serial
from serial.tools import list_ports
import time, struct, code
import argparse
import datetime
import math
import re
import requests
import csv
import os
try:
    import readline
except ImportError:
    pass

# ANSI color codes for console formatting (works in Windows Terminal)
GREEN = "\033[92m"
YELLOW = "\033[93m"
RESET = "\033[0m"

data_matrix = [
    [0x00, 0x00, 0x02], [0x00, 0x02, 0x02], [0x00, 0x04, 0x05], [0x00, 0x0D, 0x04],
    [0x00, 0x11, 0x04], [0x00, 0x15, 0x04], [0x00, 0x19, 0x04], [0x00, 0x23, 0x14],
    [0x00, 0x37, 0x04], [0x00, 0x69, 0x02], [0x00, 0x7B, 0x01], [0x40, 0x00, 0x04],
    [0x40, 0x0A, 0x0A], [0x40, 0x14, 0x02], [0x40, 0x16, 0x02], [0x40, 0x19, 0x02],
    [0x40, 0x1B, 0x02], [0x40, 0x1D, 0x02], [0x40, 0x1F, 0x02], [0x60, 0x00, 0x02],
    [0x60, 0x02, 0x02], [0x60, 0x04, 0x04], [0x60, 0x08, 0x04], [0x60, 0x0C, 0x02],
    [0x90, 0x00, 0x3A], [0x90, 0x3A, 0x3A], [0x90, 0x74, 0x3A], [0x90, 0xAE, 0x3A],
    [0x90, 0xE8, 0x3A], [0x91, 0x22, 0x30], [0x91, 0x52, 0x00], [0xA0, 0x00, 0x06]
]

data_id = [
    [0x0000, 2, "uint", "Cell type"], [0x0002, 2, "uint", "Unknown (always 0)"],
    [0x0004, 5, "sn", "Capacity & Serial number (?)"], [0x000D, 4, "uint", "Unknown (4th code?)"],
    [0x0011, 4, "date", "Manufacture date"], [0x0015, 4, "date", "Date of first charge (Forge)"],
    [0x0019, 4, "date", "Date of last charge (Forge)"], [0x0023, 20, "ascii", "Note (ascii string)"],
    [0x0037, 4, "date", "Current date"], [0x0069, 2, "uint", "Unknown (always 2)"],
    [0x007B, 1, "uint", "Unknown (always 0)"], [0x4000, 4, "uint", "Unknown (Forge)"],
    [0x400A, 10, "cell_v", "Cell voltages (mV)"], [0x4014, 2, "adc_t", "Temperature (°F) (non-Forge)"],
    [0x4016, 2, "uint", "Unknown (Forge)"], [0x4019, 2, "uint", "Unknown (Forge)"],
    [0x401B, 2, "uint", "Unknown (Forge)"], [0x401D, 2, "uint", "Unknown (Forge)"],
    [0x401F, 2, "dec_t", "Temperature (°F) (Forge)"], [0x6000, 2, "uint", "Unknown (Forge)"],
    [0x6002, 2, "uint", "Unknown (Forge)"], [0x6004, 4, "uint", "Unknown (Forge)"],
    [0x6008, 4, "uint", "Unknown (Forge)"], [0x600C, 2, "uint", "Unknown (Forge)"],
    [0x9000, 4, "date", "Date of first charge (rounded)"], [0x9004, 4, "date", "Date of last tool use (rounded)"],
    [0x9008, 4, "date", "Date of last charge (rounded)"], [0x900C, 4, "date", "Unknown date (often zero)"],
    [0x9010, 2, "uint", "Days since first charge"], [0x9012, 4, "uint", "Total discharge (amp-sec)"],
    [0x9016, 4, "uint", "Total discharge (watt-sec or joules)"], [0x901A, 4, "uint", "Total charge count"],
    [0x901E, 2, "uint", "Dumb charge count (J2>7.1V for >=0.48s)"], [0x9020, 2, "uint", "Redlink (UART) charge count"],
    [0x9022, 2, "uint", "Completed charge count (?)"], [0x9024, 4, "hhmmss", "Total charging time (HH:MM:SS)"],
    [0x9028, 4, "hhmmss", "Time on charger whilst full (HH:MM:SS)"], [0x902C, 2, "uint", "Unknown (almost always 0)"],
    [0x902E, 2, "uint", "Charge started with a cell < 2.5V"], [0x9030, 2, "uint", "Discharge to empty"],
    [0x9032, 2, "uint", "Num. overheat on tool (must be > 10A)"], [0x9034, 2, "uint", "Overcurrent?"],
    [0x9036, 2, "uint", "Low voltage events"], [0x9038, 2, "uint", "Low-voltage bounce? (4 flashing LEDs)"],
    [0x903A, 2, "uint", "Discharge @ 10-20A (seconds)"], [0x903C, 2, "uint", "@ 20-30A (could be watts)"],
    [0x903E, 2, "uint", "@ 30-40A"], [0x9040, 2, "uint", "@ 40-50A"], [0x9042, 2, "uint", "@ 50-60A"],
    [0x9044, 2, "uint", "@ 60-70A"], [0x9046, 2, "uint", "@ 70-80A"], [0x9048, 2, "uint", "@ 80-90A"],
    [0x904A, 2, "uint", "@ 90-100A"], [0x904C, 2, "uint", "@ 100-110A"], [0x904E, 2, "uint", "@ 110-120A"],
    [0x9050, 2, "uint", "@ 120-130A"], [0x9052, 2, "uint", "@ 130-140A"], [0x9054, 2, "uint", "@ 140-150A"],
    [0x9056, 2, "uint", "@ 150-160A"], [0x9058, 2, "uint", "@ 160-170A"], [0x905A, 2, "uint", "@ 170-180A"],
    [0x905C, 2, "uint", "@ 180-190A"], [0x905E, 2, "uint", "@ 190-200A"], [0x9060, 2, "uint", "@ 200-210A"],
    [0x9062, 2, "uint", "Unknown (larger in lower Ah packs)"], [0x9064, 2, "uint", "Discharge @ 10-15A (seconds)"],
    [0x9066, 2, "uint", "@ 15-20A (could be watts)"], [0x9068, 2, "uint", "@ 20-25A"],
    [0x906A, 2, "uint", "@ 25-30A"], [0x906C, 2, "uint", "@ 30-35A"], [0x906E, 2, "uint", "@ 35-40A"],
    [0x9070, 2, "uint", "@ 40-45A"], [0x9072, 2, "uint", "@ 45-50A"], [0x9074, 2, "uint", "@ 50-55A"],
    [0x9076, 2, "uint", "@ 55-60A"], [0x9078, 2, "uint", "@ 60-65A"], [0x907A, 2, "uint", "@ 65-70A"],
    [0x907C, 2, "uint", "@ 70-75A"], [0x907E, 2, "uint", "@ 75-80A"], [0x9080, 2, "uint", "@ 80-85A"],
    [0x9082, 2, "uint", "@ 85-90A"], [0x9084, 2, "uint", "@ 90-95A"], [0x9086, 2, "uint", "@ 95-100A"],
    [0x9088, 2, "uint", "@ 100-105A"], [0x908A, 2, "uint", "@ 105-110A"], [0x908C, 2, "uint", "@ 110-115A"],
    [0x908E, 2, "uint", "@ 115-120A"], [0x9090, 2, "uint", "@ 120-125A"], [0x9092, 2, "uint", "@ 125-130A"],
    [0x9094, 2, "uint", "@ 130-135A"], [0x9096, 2, "uint", "@ 135-140A"], [0x9098, 2, "uint", "@ 140-145A"],
    [0x909A, 2, "uint", "@ 145-150A"], [0x909C, 2, "uint", "@ 150-155A"], [0x909E, 2, "uint", "@ 155-160A"],
    [0x90A0, 2, "uint", "@ 160-165A"], [0x90A2, 2, "uint", "@ 165-170A"], [0x90A4, 2, "uint", "@ 170-175A"],
    [0x90A6, 2, "uint", "@ 175-180A"], [0x90A8, 2, "uint", "@ 180-185A"], [0x90AA, 2, "uint", "@ 185-190A"],
    [0x90AC, 2, "uint", "@ 190-195A"], [0x90AE, 2, "uint", "@ 195-200A"], [0x90B0, 2, "uint", "@ 200A+"],
    [0x90B2, 2, "uint", "Charge started < 17V"], [0x90B4, 2, "uint", "Charge started 17-18V"],
    [0x90B6, 2, "uint", "Charge started 18-19V"], [0x90B8, 2, "uint", "Charge started 19-20V"],
    [0x90BA, 2, "uint", "Charge started 20V+"], [0x90BC, 2, "uint", "Charge ended < 17V"],
    [0x90BE, 2, "uint", "Charge ended 17-18V"], [0x90C0, 2, "uint", "Charge ended 18-19V"],
    [0x90C2, 2, "uint", "Charge ended 19-20V"], [0x90C4, 2, "uint", "Charge ended 20V+"],
    [0x90C6, 2, "uint", "Charge start temp -30C to -20C"], [0x90C8, 2, "uint", "Charge start temp -20C to -10C"],
    [0x90CA, 2, "uint", "Charge start temp -10C to 0C"], [0x90CC, 2, "uint", "Charge start temp 0C to +10C"],
    [0x90CE, 2, "uint", "Charge start temp +10C to +20C"], [0x90D0, 2, "uint", "Charge start temp +20C to +30C"],
    [0x90D2, 2, "uint", "Charge start temp +30C to +40C"], [0x90D4, 2, "uint", "Charge start temp +40C to +50C"],
    [0x90D6, 2, "uint", "Charge start temp +50C to +60C"], [0x90D8, 2, "uint", "Charge start temp +60C to +70C"],
    [0x90DA, 2, "uint", "Charge start temp +70C to +80C"], [0x90DC, 2, "uint", "Charge start temp +80C and over"],
    [0x90DE, 2, "uint", "Charge end temp -30C to -20C"], [0x90E0, 2, "uint", "Charge end temp -20C to -10C"],
    [0x90E2, 2, "uint", "Charge end temp -10C to 0C"], [0x90E4, 2, "uint", "Charge end temp 0C to +10C"],
    [0x90E6, 2, "uint", "Charge end temp +10C to +20C"], [0x90E8, 2, "uint", "Charge end temp +30C to +30C"],
    [0x90EA, 2, "uint", "Charge end temp +30C to +40C"], [0x90EC, 2, "uint", "Charge end temp +40C to +50C"],
    [0x90EE, 2, "uint", "Charge end temp +50C to +60C"], [0x90F0, 2, "uint", "Charge end temp +60C to +70C"],
    [0x90F2, 2, "uint", "Charge end temp +70C to +80C"], [0x90F4, 2, "uint", "Charge end temp +80C and over"],
    [0x90F6, 2, "uint", "Dumb charge time (00:00-14:33)"], [0x90F8, 2, "uint", "Dumb charge time (14:34-29:07)"],
    [0x90FA, 2, "uint", "Dumb charge time (29:08-43:41)"], [0x90FC, 2, "uint", "Dumb charge time (43:42-58:15)"],
    [0x90FE, 2, "uint", "Dumb charge time (58:16-1:12:49)"], [0x9100, 2, "uint", "Dumb charge time (1:12:50-1:27:23)"],
    [0x9102, 2, "uint", "Dumb charge time (1:27:24-1:41:57)"], [0x9104, 2, "uint", "Dumb charge time (1:41:58-1:56:31)"],
    [0x9106, 2, "uint", "Dumb charge time (1:56:32-2:11:05)"], [0x9108, 2, "uint", "Dumb charge time (2:11:06-2:25:39)"],
    [0x910A, 2, "uint", "Dumb charge time (2:25:40-2:40:13)"], [0x910C, 2, "uint", "Dumb charge time (2:40:14-2:54:47)"],
    [0x910E, 2, "uint", "Dumb charge time (2:54:48-3:09:21)"], [0x9110, 2, "uint", "Dumb charge time (3:09:22-3:23:55)"],
    [0x9112, 2, "uint", "Redlink charge time (00:00-17:03)"], [0x9114, 2, "uint", "Redlink charge time (17:04-34:07)"],
    [0x9116, 2, "uint", "Redlink charge time (34:08-51:11)"], [0x9118, 2, "uint", "Redlink charge time (51:12-1:08:15)"],
    [0x911A, 2, "uint", "Redlink charge time (1:08:16-1:25:19)"], [0x911C, 2, "uint", "Redlink charge time (1:25:20-1:42:23)"],
    [0x911E, 2, "uint", "Redlink charge time (1:42:24-1:59:27)"], [0x9120, 2, "uint", "Redlink charge time (1:59:28-2:16:31)"],
    [0x9122, 2, "uint", "Redlink charge time (2:16:32-2:33:35)"], [0x9124, 2, "uint", "Redlink charge time (2:33:36-2:50:39)"],
    [0x9126, 2, "uint", "Redlink charge time (2:50:40-3:07:43)"], [0x9128, 2, "uint", "Redlink charge time (3:07:44-3:24:47)"],
    [0x912A, 2, "uint", "Redlink charge time (3:24:48-3:41:51)"], [0x912C, 2, "uint", "Redlink charge time (3:41:52-3:58:55)"],
    [0x912E, 2, "uint", "Completed charge (?)"], [0x9130, 2, "uint", "Unknown"],
    [0x9132, 2, "uint", "Unknown"], [0x9134, 2, "uint", "Unknown"], [0x9136, 2, "uint", "Unknown"],
    [0x9138, 2, "uint", "Unknown"], [0x913A, 2, "uint", "Unknown"], [0x913C, 2, "uint", "Unknown"],
    [0x913E, 2, "uint", "Unknown"], [0x9140, 2, "uint", "Unknown"], [0x9142, 2, "uint", "Unknown"],
    [0x9144, 2, "uint", "Unknown"], [0x9146, 2, "uint", "Unknown"], [0x9148, 2, "uint", "Unknown (days of use?)"],
    [0x914A, 2, "uint", "Unknown"], [0x914C, 2, "uint", "Unknown"], [0x914E, 2, "uint", "Unknown"],
    [0x9150, 2, "uint", "Unknown"]
]

def print_debug_bytes(data):
    data_print = " ".join(f"{byte:02X}" for byte in data)
    print(f"DEBUG: ", data_print)

class M18:
    SYNC_BYTE = 0xAA
    CAL_CMD = 0x55
    CONF_CMD = 0x60
    SNAP_CMD = 0x61
    KEEPALIVE_CMD = 0x62
    CUTOFF_CURRENT = 300
    MAX_CURRENT = 6000
    ACC = 4
    PRINT_TX = False
    PRINT_RX = False
    PRINT_TX_SAVE = False
    PRINT_RX_SAVE = False

    def txrx_print(self, enable=True):
        self.PRINT_TX = enable
        self.PRINT_RX = enable

    def txrx_save_and_set(self, enable=True):
        self.PRINT_TX_SAVE = self.PRINT_TX
        self.PRINT_RX_SAVE = self.PRINT_RX
        self.txrx_print(enable)

    def txrx_restore(self):
        self.PRINT_TX = self.PRINT_TX_SAVE
        self.PRINT_RX = self.PRINT_RX_SAVE

    def __init__(self, port):
        if port is None:
            print("*** NO PORT SPECIFIED ***")
            print("Available serial ports (choose one that says USB somewhere):")
            ports = list_ports.comports()
            i = 1
            for p in ports:
                print(f" {i}: {p.device} - {p.manufacturer} - {p.description}")
                i = i + 1
            port_id = 0
            while (port_id < 1) or (port_id >= i):
                user_port = input(f"Choose a port (1-{i-1}): ")
                try:
                    port_id = int(user_port)
                except ValueError:
                    print("Invalid input. Please enter a number")
            p = ports[port_id - 1]
            print(f"You selected \"{p.device} - {p.manufacturer} - {p.description}\"")
            print(f"In future, use \"m18_battery_diagnostics.py --port {p.device}\" to avoid this menu")
            input("Press Enter to continue")
            port = p.device
        self.port = serial.Serial(port, baudrate=4800, timeout=0.8, stopbits=2)
        self.idle()

    def reset(self):
        self.ACC = 4
        self.port.break_condition = True
        self.port.dtr = True
        time.sleep(0.3)
        self.port.break_condition = False
        self.port.dtr = False
        time.sleep(0.3)
        self.send(struct.pack('>B', self.SYNC_BYTE))
        try:
            response = self.read_response(1)
        except:
            return False
        time.sleep(0.01)
        if response and response[0] == self.SYNC_BYTE:
            return True
        else:
            print(f"Unexpected response: {response}")
            return False

    def update_acc(self):
        acc_values = [0x04, 0x0C, 0x1C]
        current_index = acc_values.index(self.ACC)
        next_index = (current_index + 1) % len(acc_values)
        self.ACC = acc_values[next_index]

    def reverse_bits(self, byte):
        return int(f"{byte:08b}"[::-1], 2)

    def checksum(self, payload):
        checksum = 0
        for byte in payload:
            checksum += byte & 0xFFFF
        return checksum

    def add_checksum(self, lsb_command):
        lsb_command += struct.pack(">H", self.checksum(lsb_command))
        return lsb_command

    def send(self, command):
        self.port.reset_input_buffer()
        debug_print = " ".join(f"{byte:02X}" for byte in command)
        msb = bytearray(self.reverse_bits(byte) for byte in command)
        if self.PRINT_TX:
            print(f"Sending: {debug_print}")
        self.port.write(msb)

    def send_command(self, command):
        self.send(self.add_checksum(command))

    def read_response(self, size):
        msb_response = self.port.read(1)
        if not msb_response or len(msb_response) < 1:
            raise ValueError("Empty response")
        if self.reverse_bits(msb_response[0]) == 0x82:
            msb_response += self.port.read(1)
        else:
            msb_response += self.port.read(size-1)
        lsb_response = bytearray(self.reverse_bits(byte) for byte in msb_response)
        debug_print = " ".join(f"{byte:02X}" for byte in lsb_response)
        if self.PRINT_RX:
            print(f"Received: {debug_print}")
        return lsb_response

    def configure(self, state):
        self.ACC = 4
        self.send_command(struct.pack('>BBBHHHBB', self.CONF_CMD, self.ACC, 8,
                                    self.CUTOFF_CURRENT, self.MAX_CURRENT, self.MAX_CURRENT, state, 13))
        return self.read_response(5)

    def get_snapchat(self):
        self.send_command(struct.pack('>BBB', self.SNAP_CMD, self.ACC, 0))
        self.update_acc()
        return self.read_response(8)

    def keepalive(self):
        self.send_command(struct.pack('>BBB', self.KEEPALIVE_CMD, self.ACC, 0))
        return self.read_response(9)

    def calibrate(self):
        self.send_command(struct.pack('>BBB', self.CAL_CMD, self.ACC, 0))
        self.update_acc()
        return self.read_response(8)

    def simulate(self):
        print("Simulating charger communication")
        self.txrx_save_and_set(True)
        self.reset()
        self.configure(2)
        self.get_snapchat()
        time.sleep(0.6)
        self.keepalive()
        self.configure(1)
        self.get_snapchat()
        try:
            while True:
                time.sleep(0.5)
                self.keepalive()
        except KeyboardInterrupt:
            print("\nSimulation aborted by user. Exiting gracefully...")
        finally:
            self.idle()
            self.txrx_restore()

    def simulate_for(self, duration):
        print(f"Simulating charger communication for {duration} seconds...")
        begin_time = time.time()
        self.reset()
        self.configure(2)
        self.get_snapchat()
        time.sleep(0.6)
        self.keepalive()
        self.configure(1)
        self.get_snapchat()
        try:
            while (time.time() - begin_time) < duration:
                time.sleep(0.5)
                self.keepalive()
        except KeyboardInterrupt:
            print("\nSimulation aborted by user. Exiting gracefully...")
        finally:
            self.idle()
            print(f"Duration: ", time.time() - begin_time)

    def debug(self, a, b, c, length):
        rx_debug = self.PRINT_RX
        tx_debug = self.PRINT_TX
        self.PRINT_TX = False
        self.PRINT_RX = False
        self.reset()
        self.PRINT_TX = tx_debug
        data = self.cmd(a, b, c, length)
        data_print = " ".join(f"{byte:02X}" for byte in data)
        print(f"Response from: 0x{(a * 0x100 + b):04X}:", data_print)
        self.idle()
        self.PRINT_RX = rx_debug

    def try_cmd(self, cmd, msb, lsb, len, ret_len=0):
        self.txrx_save_and_set(False)
        if ret_len == 0:
            ret_len = len + 5
        self.reset()
        self.send_command(struct.pack('>BBBBBB', cmd, 0x04, 0x03, msb, lsb, len))
        data = self.read_response(ret_len)
        data_print = " ".join(f"{byte:02X}" for byte in data)
        print(f"Response from: 0x{(msb * 0x100 + lsb):04X}:", data_print)
        self.idle()
        self.txrx_restore()

    def cmd(self, a, b, c, length, command=0x01):
        self.send_command(struct.pack('>BBBBBB', command, 0x04, 0x03, a, b, c))
        return self.read_response(length)

    def brute(self, a, b, len=0xFF, command=0x01):
        self.reset()
        try:
            for i in range(len):
                ret = self.cmd(a, b, i, i+5, command)
                if ret[0] == 0x81:
                    data_print = " ".join(f"{byte:02X}" for byte in ret)
                    print(f"Valid response from: 0x{(a * 0x100 + b):04X} with length: 0x{i:02X}:", data_print)
        except KeyboardInterrupt:
            print("\nSimulation aborted by user. Exiting gracefully...")
        finally:
            self.idle()

    def full_brute(self, start=0, stop=0xFFFF, len=0xFF):
        try:
            for addr in range(start, stop):
                msb = (addr >> 8) & 0xFF
                lsb = addr & 0xFF
                self.brute(msb, lsb, len, 0x01)
                if (addr % 256) == 0:
                    print(f"addr = 0x{addr:04X} ", datetime.datetime.now())
        except KeyboardInterrupt:
            print("\nSimulation aborted by user. Exiting gracefully...")
            print(f"\nStopped at address: 0x{addr:04X}")
        finally:
            self.idle()

    def wcmd(self, a, b, c, length):
        self.send_command(struct.pack('>BBBBBB', 0x01, 0x05, 0x03, a, b, c))
        return self.read_response(length)

    def write_message(self, message):
        try:
            if len(message) > 0x14:
                print("ERROR: Message too long!")
                return
            print(f"Writing \"{message}\" to memory")
            self.reset()
            message = message.ljust(0x14, '-')
            for i, char in enumerate(message):
                self.wcmd(0, 0x23+i, ord(char), 2)
        except Exception as e:
            print(f"write_message: Failed with error: {e}")

    def calculate_temperature(self, adc_value):
        R1 = 10e3
        R2 = 20e3
        T1 = 50
        T2 = 35
        adc1 = 0x0180
        adc2 = 0x022E
        m = (T2 - T1) / (R2 - R1)
        b = T1 - m * R1
        resistance = R1 + (adc_value - adc1) * (R2 - R1) / (adc2 - adc1)
        temperature_c = m * resistance + b
        temperature_f = (temperature_c * 9/5) + 32  # Convert to Fahrenheit
        return round(temperature_f, 2)

    def bytes2dt(self, time_bytes):
        try:
            epoch_time = int.from_bytes(time_bytes, 'big')
            if epoch_time < 0 or epoch_time > 0x7FFFFFFF:  # Reasonable timestamp range
                return None
            dt = datetime.datetime.fromtimestamp(epoch_time, tz=datetime.timezone.utc)
            return dt
        except (ValueError, TypeError, OverflowError):
            return None

    def read_all(self):
        try:
            self.reset()
            for addr_h, addr_l, length in data_matrix:
                response = self.cmd(addr_h, addr_l, length, (length + 5))
                if response and len(response) >= 4 and response[0] == 0x81:
                    data = response[3:3 + length]
                    data_print = " ".join(f"{byte:02X}" for byte in data)
                    print(f"Response from: 0x{(addr_h * 0x100 + addr_l):04X}:", data_print)
                else:
                    data_print = " ".join(f"{byte:02X}" for byte in response)
                    print(f"Invalid response from: 0x{(addr_h * 0x100 + addr_l):04X} Response: {data_print}")
            self.idle()
        except Exception as e:
            print(f"read_all: Failed with error: {e}")

    def read_all_spreadsheet(self):
        try:
            self.reset()
            for addr_h, addr_l, length in data_matrix:
                response = self.cmd(addr_h, addr_l, length, (length + 5))
                if response and len(response) >= 4 and response[0] == 0x81:
                    data = response[3:3 + length]
                    data_print = ",".join(f"{byte:02X}" for byte in data)
                    print(f"0x{(addr_h * 0x100 + addr_l):04X},{data_print}")
                else:
                    print(f"0x{(addr_h * 0x100 + addr_l):04X},Invalid")
            self.idle()
        except Exception as e:
            print(f"read_all_spreadsheet: Failed with error: {e}")

    def read_id(self, id_array=[], force_refresh=True, output="label", csv_path=None, retries=3):
        """
        Read data by ID. Default is print all
        # id_array - array of registers to print
        # force_refresh - force a read of all registers to ensure they're up to date
        # output - ["label" | "raw" | "array" | "form" | "csv"]
        # csv_path - custom CSV path; if None for output='csv', uses serial_number_year_month_day.csv
        # retries - number of retry attempts for failed reads
        """
        if output not in ["label", "raw", "array", "form", "csv"]:
            print(f"Unrecognised 'output' = {output}. Please choose \"label\", \"raw\", \"array\", \"form\", or \"csv\"")
            output = "label"
        
        array = []
        csv_data = []
        
        try:
            # Get serial number and manufacture date for CSV filename
            serial_number = None
            manufacture_date = None
            if output == "csv" and csv_path is None:
                for attempt in range(retries):
                    try:
                        self.reset()
                        response = self.cmd(0x00, 0x04, 0x05, 10)
                        if response and len(response) >= 4 and response[0] == 0x81:
                            data = response[3:8]
                            serial_number = int.from_bytes(data[2:5], 'big')
                        response = self.cmd(0x00, 0x11, 0x04, 9)
                        if response and len(response) >= 4 and response[0] == 0x81:
                            data = response[3:7]
                            manufacture_date = self.bytes2dt(data)
                            if manufacture_date:
                                manufacture_date = manufacture_date.strftime('%Y_%m_%d')
                        if serial_number and manufacture_date:
                            csv_path = f"{serial_number}_{manufacture_date}.csv"
                            break
                        print(f"Retry {attempt+1}/{retries} for serial number/manufacture date failed")
                        time.sleep(0.5)
                    except Exception as e:
                        print(f"Retry {attempt+1}/{retries} failed: {e}")
                        time.sleep(0.5)
                if not csv_path:
                    csv_path = 'battery_diagnostics.csv'
                    print("Warning: Using default CSV path due to failed reads")
            
            self.reset()
            if force_refresh:
                for addr_h, addr_l, length in data_matrix:
                    for attempt in range(retries):
                        try:
                            response = self.cmd(addr_h, addr_l, length, (length + 5))
                            break
                        except Exception as e:
                            print(f"Retry {attempt+1}/{retries} for 0x{addr_h:02X}{addr_l:02X} failed: {e}")
                            time.sleep(0.5)
                self.idle()
                time.sleep(0.1)
            
            now = datetime.datetime.now()
            formatted_time = now.strftime("%Y-%m-%d %H:%M:%S")
            if output == "label":
                print(formatted_time)
                print("ID ADDR LEN TYPE LABEL VALUE")
            elif output == "raw":
                print(formatted_time)
            elif output in ["array", "form"]:
                array.append(formatted_time)
            elif output == "csv":
                csv_data.append(["Timestamp", formatted_time])
                csv_data.append(["ID", "Address", "Length", "Type", "Label", "Value"])
            
            self.reset()
            for i in id_array or range(0, len(data_id)):
                addr = data_id[i][0]
                addr_h = (addr >> 8) & 0xFF
                addr_l = addr & 0xFF
                length = data_id[i][1]
                type = data_id[i][2]
                label = data_id[i][3]
                response = None
                for attempt in range(retries):
                    try:
                        response = self.cmd(addr_h, addr_l, length, (length + 5))
                        break
                    except Exception as e:
                        print(f"Retry {attempt+1}/{retries} for ID {i} (0x{addr:04X}) failed: {e}")
                        time.sleep(0.5)
                if response and len(response) >= 4 and response[0] == 0x81 and len(response[3:]) >= length:
                    data = response[3:(3+length)]
                    match type:
                        case "uint":
                            array_value = value = int.from_bytes(data, 'big')
                        case "date":
                            array_value = self.bytes2dt(data)
                            value = array_value.strftime('%Y-%m-%d %H:%M:%S') if array_value else "------"
                        case "hhmmss":
                            dur = int.from_bytes(data, 'big')
                            mm, ss = divmod(dur, 60)
                            hh, mm = divmod(mm, 60)
                            array_value = value = f"{hh}:{mm:02d}:{ss:02d}"
                        case "ascii":
                            try:
                                str_val = data.decode('utf-8')
                                array_value = value = f'"{str_val}"'
                            except UnicodeDecodeError:
                                array_value = value = "------"
                        case "sn":
                            btype = int.from_bytes(data[0:2], 'big')
                            serial = int.from_bytes(data[2:5], 'big')
                            if output in ["label", "array", "csv"]:
                                array_value = f"Type: {btype:3d}, Serial: {serial:d}"
                                value = f"Type: {btype:3d}, Serial: {serial:d}"
                            else:
                                value = f"{btype}\n{serial}"
                        case "adc_t":
                            array_value = value = self.calculate_temperature(int.from_bytes(data, 'big'))
                        case "dec_t":
                            temp_c = data[0] + data[1]/256
                            temp_f = (temp_c * 9/5) + 32  # Convert to Fahrenheit
                            array_value = value = f"{temp_f:.2f}"
                        case "cell_v":
                            array_value = cv = [int.from_bytes(data[i:i+2], 'big') for i in range(0, 10, 2)]
                            if output == "label":
                                value = f"1: {cv[0]:4d}, 2: {cv[1]:4d}, 3: {cv[2]:4d}, 4: {cv[3]:4d}, 5: {cv[4]:4d}"
                            elif output == "raw":
                                value = f"{cv[0]:4d}\n{cv[1]:4d}\n{cv[2]:4d}\n{cv[3]:4d}\n{cv[4]:4d}"
                            elif output == "csv":
                                value = f"1: {cv[0]:4d}, 2: {cv[1]:4d}, 3: {cv[2]:4d}, 4: {cv[3]:4d}, 5: {cv[4]:4d}"
                else:
                    array_value = None
                    value = "------"
                
                if output == "label":
                    print(f"{i:3d} 0x{addr:04X} {length:2d} {type:>6} {label:<39} {value:<}")
                elif output == "raw":
                    print(value)
                elif output == "array":
                    array.append([i, array_value])
                elif output == "form":
                    array.append(value)
                elif output == "csv":
                    csv_data.append([i, f"0x{addr:04X}", length, type, label, value])
                
            if output == "csv":
                try:
                    if not os.access(os.path.dirname(csv_path) or '.', os.W_OK):
                        print(f"Error: No write permission for {csv_path}")
                        return
                    mode = 'a' if os.path.exists(csv_path) else 'w'
                    with open(csv_path, mode, newline='', encoding='utf-8') as file:
                        writer = csv.writer(file, delimiter='>')
                        if mode == 'w':
                            writer.writerow(["Timestamp", formatted_time])
                            writer.writerow(["ID", "Address", "Length", "Type", "Label", "Value"])
                        else:
                            writer.writerow([])
                            writer.writerow(["Timestamp", formatted_time])
                        for row in csv_data[2:]:
                            writer.writerow(row)
                    print(f"Data appended to {csv_path}")
                except IOError as e:
                    print(f"Error writing CSV file: {e}")
                
            if output in ["array", "form"] and array:
                return array
                
            self.idle()
        except Exception as e:
            print(f"read_id: Failed with error: {e}")

    def plot_voltages(self):
        try:
            import matplotlib.pyplot as plt
            array = self.read_id(id_array=[12], output="array", retries=3)
            if not array or len(array) < 2 or not isinstance(array[1][1], list):
                print("Failed to read cell voltages")
                return
            voltages = array[1][1]
            plt.bar(range(1, 6), voltages, color='#1f77b4')
            plt.xlabel("Cell Number")
            plt.ylabel("Voltage (mV)")
            plt.title("Battery Cell Voltages")
            plt.axhline(y=sum(voltages)/len(voltages), color='r', linestyle='--', label='Average')
            plt.legend()
            plt.show()
        except ImportError:
            print("Install matplotlib: pip install matplotlib")
        except Exception as e:
            print(f"plot_voltages: Failed with error: {e}")

    def health(self, force_refresh=True, verbose=False):
        """
        Generate a health report with grouped, color-coded console output and CSV summary.
        # force_refresh - force a read of all registers
        # verbose - if True, print all 183 registers in console; if False, show summary only
        """
        reg_list = list(range(0, len(data_id)))  # Read all registers
        self.txrx_save_and_set(True)  # Enable debug for troubleshooting
        csv_data = []
        summary_data = [["Summary", "Timestamp", datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")]]
        warnings = []
        
        try:
            print("Reading battery. This will take 10-20sec\n")
            array = self.read_id(reg_list, force_refresh, "array", retries=3)
            if not array or len(array) < len(reg_list) + 1:
                raise ValueError("Incomplete data from read_id")
            
            # Get serial number and manufacture date for CSV filename
            serial_number = None
            manufacture_date = None
            bat_type = "Unknown"
            bat_text = [0, "Unknown"]
            sn_index = next((i for i, x in enumerate(data_id) if x[0] == 0x0004), None)  # ID 2
            date_index = next((i for i, x in enumerate(data_id) if x[0] == 0x0011), None)  # ID 4
            if sn_index is not None and array[sn_index + 1][1]:
                numbers = re.findall(r'\d+\.?\d*', str(array[sn_index + 1][1]))
                if len(numbers) >= 2:
                    bat_type = numbers[0]
                    serial_number = numbers[1]
                    bat_lookup = {
                        "37": [2, "2Ah CP (5s1p 18650)"], "40": [5, "5Ah XC (5s2p 18650)"], "165": [5, "5Ah XC (5s2p 18650)"],
                        "46": [6, "6Ah XC (5s2p 18650)"], "104": [3, "3Ah HO (5s1p 21700)"], "106": [4, "6Ah HO (5s2p 21700)"],
                        "107": [8, "8Ah HO (5s2p 21700)"], "108": [12, "12Ah HO (5s3p 21700)"],
                        "383": [12, "12Ah Forge (5s3p 21700 tabless)"], "384": [12, "12Ah Forge (5s3p 21700 tabless)"]
                    }
                    bat_text = bat_lookup.get(bat_type, [0, "Unknown"])
            if date_index is not None and isinstance(array[date_index + 1][1], datetime.datetime):
                manufacture_date = array[date_index + 1][1].strftime('%Y_%m_%d')
            current_datetime = datetime.datetime.now().strftime('%Y-%m-%d-%H-%M-%S')
            csv_path = f"Milwaukee_Batt_M18_{serial_number}_{current_datetime}.csv" if serial_number else 'battery_health.csv'
            
            # Process all registers for CSV
            csv_data.append(["ID", "Address", "Length", "Type", "Label", "Value"])
            for i, (reg_id, value) in enumerate(array[1:]):
                addr = data_id[reg_id][0]
                length = data_id[reg_id][1]
                type = data_id[reg_id][2]
                label = data_id[reg_id][3]
                if type == "date" and isinstance(value, datetime.datetime):
                    formatted_value = value.strftime('%Y-%m-%d %H:%M:%S')
                elif type == "cell_v" and isinstance(value, list):
                    formatted_value = f"1: {value[0]:4d}, 2: {value[1]:4d}, 3: {value[2]:4d}, 4: {value[3]:4d}, 5: {value[4]:4d}"
                elif type == "hhmmss" and isinstance(value, (int, str)):
                    formatted_value = str(value)
                elif type == "ascii" and isinstance(value, str):
                    formatted_value = f'"{value}"'
                elif type == "sn" and isinstance(value, str):
                    formatted_value = value
                elif isinstance(value, (int, float)):
                    formatted_value = str(value)
                else:
                    formatted_value = "------"
                csv_data.append([reg_id, f"0x{addr:04X}", length, type, label, formatted_value])
                if verbose:
                    print(f"{reg_id:3d} 0x{addr:04X} {length:2d} {type:>6} {label:<39} {formatted_value:<}")
            
            # Additional health metrics
            imbalance = 0
            cell_v_index = next((i for i, x in enumerate(data_id) if x[0] == 0x400A), None)  # ID 12
            if cell_v_index is not None and isinstance(array[cell_v_index + 1][1], list):
                imbalance = max(array[cell_v_index + 1][1]) - min(array[cell_v_index + 1][1])
                summary_data.append(["Summary", "Cell Imbalance (mV)", str(imbalance)])
                if imbalance > 100:
                    warnings.append("High cell imbalance (>100 mV). Consider using a balancing charger.")
            
            discharge_index = next((i for i, x in enumerate(data_id) if x[0] == 0x9012), None)  # ID 29
            total_discharge_cycles = 0
            soh = 0
            if discharge_index is not None and isinstance(array[discharge_index + 1][1], (int, float)):
                if bat_text[0] != 0:
                    total_discharge_cycles = array[discharge_index + 1][1] / 3600 / bat_text[0]
                    soh = max(0, 100 - (total_discharge_cycles / 500 * 100))
                    summary_data.append(["Summary", "Total Discharge (Ah)", f"{array[discharge_index + 1][1]/3600:.2f}"])
                    summary_data.append(["Summary", "Total Discharge Cycles", f"{total_discharge_cycles:.2f}"])
                    summary_data.append(["Summary", "Estimated SoH (%)", f"{soh:.1f}"])
                    if soh < 50:
                        warnings.append("Low SoH (<50%). Battery may need replacement soon.")
            
            low_voltage_index = next((i for i, x in enumerate(data_id) if x[0] == 0x9030), None)  # ID 39
            low_voltage_event_index = next((i for i, x in enumerate(data_id) if x[0] == 0x9036), None)  # ID 42
            if low_voltage_index is not None and low_voltage_event_index is not None and (array[low_voltage_index + 1][1] or array[low_voltage_event_index + 1][1]):
                warnings.append("Avoid deep discharges to extend battery life.")
            
            tool_time_index = list(range(next((i for i, x in enumerate(data_id) if x[0] == 0x903A), len(data_id)), next((i for i, x in enumerate(data_id) if x[0] == 0x9060), len(data_id)) + 1)) if 0x903A in [x[0] for x in data_id] and 0x9060 in [x[0] for x in data_id] else []
            tool_time = sum(array[i + 1][1] for i in tool_time_index if isinstance(array[i + 1][1], (int, float))) if tool_time_index else 0
            
            # Console output for summary
            print(f"{YELLOW}=== BASIC INFO ==={RESET}")
            print(f"Type: {bat_type} [{bat_text[1]}] {GREEN}✓{RESET}")
            summary_data.append(["Summary", "Type", f"{bat_type} [{bat_text[1]}]"])
            print(f"E-Serial: {serial_number or '------'}")
            summary_data.append(["Summary", "E-Serial", serial_number or "------"])
            if date_index is not None:
                manufacture_date_str = array[date_index + 1][1].strftime('%Y-%m-%d') if isinstance(array[date_index + 1][1], datetime.datetime) else str(array[date_index + 1][1] or "------")
                print(f"Manufacture Date: {manufacture_date_str}")
                summary_data.append(["Summary", "Manufacture Date", manufacture_date_str])
            current_date_index = next((i for i, x in enumerate(data_id) if x[0] == 0x0037), None)  # ID 8
            if current_date_index is not None:
                current_date_str = array[current_date_index + 1][1].strftime('%Y-%m-%d %H:%M:%S') if isinstance(array[current_date_index + 1][1], datetime.datetime) else str(array[current_date_index + 1][1] or "------")
                print(f"Current Date: {current_date_str}")
                summary_data.append(["Summary", "Current Date", current_date_str])
            days_index = next((i for i, x in enumerate(data_id) if x[0] == 0x9010), None)  # ID 28
            if days_index is not None:
                days_since_first = array[days_index + 1][1] or "------"
                print(f"Days Since First Charge: {days_since_first} days{' (New battery)' if isinstance(days_since_first, (int, float)) and days_since_first < 30 else ''}")
                summary_data.append(["Summary", "Days Since First Charge", str(days_since_first)])
            
            print(f"\n{YELLOW}=== VOLTAGE & TEMPERATURE ==={RESET}")
            pack_voltage = "------"
            cell_voltages = "------"
            if cell_v_index is not None and isinstance(array[cell_v_index + 1][1], list):
                pack_voltage = f"{sum(array[cell_v_index + 1][1])/1000:.2f} V"
                cell_voltages = ", ".join(map(str, array[cell_v_index + 1][1]))
                print(f"Pack Voltage: {pack_voltage}")
                print(f"Cell Voltages (mV): {cell_voltages}")
                print(f"Cell Imbalance: {imbalance} mV {GREEN if imbalance <= 100 else YELLOW}✓{RESET if imbalance <= 100 else '⚠ (Consider balancing charger)'}")
            else:
                print(f"Pack Voltage: {pack_voltage}")
                print(f"Cell Voltages (mV): {cell_voltages}")
                print(f"Cell Imbalance: ------")
            summary_data.append(["Summary", "Pack Voltage", pack_voltage])
            summary_data.append(["Summary", "Cell Voltages (mV)", cell_voltages])
            
            temp_non_forge_index = next((i for i, x in enumerate(data_id) if x[0] == 0x4014), None)  # ID 13
            temp_forge_index = next((i for i, x in enumerate(data_id) if x[0] == 0x401F), None)  # ID 18
            temp_non_forge = array[temp_non_forge_index + 1][1] if temp_non_forge_index is not None and array[temp_non_forge_index + 1][1] else "Not available"
            temp_forge = array[temp_forge_index + 1][1] if temp_forge_index is not None and array[temp_forge_index + 1][1] else "Not available"
            print(f"Temperature (non-Forge): {temp_non_forge} F" if temp_non_forge != "Not available" else "Not available")
            print(f"Temperature (Forge): {temp_forge} F" if temp_forge != "Not available" else "Not available")
            summary_data.append(["Summary", "Temperature (non-Forge)", str(temp_non_forge) + " F" if temp_non_forge != "Not available" else "Not available"])
            summary_data.append(["Summary", "Temperature (Forge)", str(temp_forge) + " F" if temp_forge != "Not available" else "Not available"])
            
            print(f"\n{YELLOW}=== CHARGING STATS ==={RESET}")
            redlink_index = next((i for i, x in enumerate(data_id) if x[0] == 0x9020), None)  # ID 33
            dumb_index = next((i for i, x in enumerate(data_id) if x[0] == 0x901E), None)  # ID 32
            total_index = next((i for i, x in enumerate(data_id) if x[0] == 0x901A), None)  # ID 31
            charge_count = "------"
            if redlink_index is not None and dumb_index is not None and total_index is not None:
                charge_count = f"{array[total_index + 1][1]} (Redlink: {array[redlink_index + 1][1]}, Dumb: {array[dumb_index + 1][1]})" if all(isinstance(array[x + 1][1], (int, float)) for x in [redlink_index, dumb_index, total_index]) else "------"
                print(f"Total Charge Count: {charge_count}")
            summary_data.append(["Summary", "Total Charge Count", charge_count])
            time_charge_index = next((i for i, x in enumerate(data_id) if x[0] == 0x9024), None)  # ID 35
            time_charge = array[time_charge_index + 1][1] or "------" if time_charge_index is not None else "------"
            print(f"Total Charge Time: {time_charge}")
            summary_data.append(["Summary", "Total Charge Time", time_charge])
            time_idle_index = next((i for i, x in enumerate(data_id) if x[0] == 0x9028), None)  # ID 36
            time_idle = array[time_idle_index + 1][1] or "------" if time_idle_index is not None else "------"
            print(f"Time Idling on Charger: {time_idle} {YELLOW + '⚠ (Remove after full charge)' if isinstance(time_idle, str) and int(time_idle.split(':')[0]) > 100 else ''}{RESET}")
            if isinstance(time_idle, str) and int(time_idle.split(':')[0]) > 100:
                warnings.append("High idle time on charger. Remove after full charge.")
            summary_data.append(["Summary", "Time Idling on Charger", time_idle])
            low_v_charge_index = next((i for i, x in enumerate(data_id) if x[0] == 0x902E), None)  # ID 38
            low_v_charge = array[low_v_charge_index + 1][1] or "------" if low_v_charge_index is not None else "------"
            print(f"Low-Voltage Charges: {low_v_charge} {GREEN + '✓' if low_v_charge == 0 else YELLOW + '⚠'}{RESET}")
            summary_data.append(["Summary", "Low-Voltage Charges", str(low_v_charge)])
            
            print(f"\n{YELLOW}=== TOOL USE STATS ==={RESET}")
            total_discharge = "------"
            if discharge_index is not None and isinstance(array[discharge_index + 1][1], (int, float)):
                total_discharge = f"{array[discharge_index + 1][1]/3600:.2f} Ah"
                print(f"Total Discharge: {total_discharge}")
                print(f"Estimated Cycles: {total_discharge_cycles:.2f}")
                print(f"SoH: {soh:.1f}% {GREEN if soh >= 50 else YELLOW}✓{RESET if soh >= 50 else '⚠ (Consider replacement)'}")
            summary_data.append(["Summary", "Total Discharge (Ah)", total_discharge])
            summary_data.append(["Summary", "Total Discharge Cycles", f"{total_discharge_cycles:.2f}"])
            summary_data.append(["Summary", "Estimated SoH (%)", f"{soh:.1f}"])
            low_voltage_index = next((i for i, x in enumerate(data_id) if x[0] == 0x9030), None)  # ID 39
            print(f"Discharge to Empty: {array[low_voltage_index + 1][1] or '------'} {YELLOW + '⚠ (Avoid deep discharges)' if low_voltage_index is not None and array[low_voltage_index + 1][1] else ''}{RESET}")
            summary_data.append(["Summary", "Discharge to Empty", str(array[low_voltage_index + 1][1] or "------")])
            overheat_index = next((i for i, x in enumerate(data_id) if x[0] == 0x9032), None)  # ID 40
            print(f"Overheat Events: {array[overheat_index + 1][1] or '------'} {GREEN + '✓' if array[overheat_index + 1][1] == 0 else YELLOW + '⚠'}{RESET}")
            summary_data.append(["Summary", "Overheat Events", str(array[overheat_index + 1][1] or "------")])
            low_voltage_event_index = next((i for i, x in enumerate(data_id) if x[0] == 0x9036), None)  # ID 42
            print(f"Low Voltage Events: {array[low_voltage_event_index + 1][1] or '------'} {YELLOW + '⚠' if low_voltage_event_index is not None and array[low_voltage_event_index + 1][1] else ''}{RESET}")
            summary_data.append(["Summary", "Low Voltage Events", str(array[low_voltage_event_index + 1][1] or "------")])
            print(f"Total Time on Tool (>10A): {datetime.timedelta(seconds=tool_time) if tool_time else '------'}")
            summary_data.append(["Summary", "Total Time on Tool (>10A)", str(datetime.timedelta(seconds=tool_time) if tool_time else "------")])
            if tool_time:
                for i, j in enumerate(range(next((i for i, x in enumerate(data_id) if x[0] == 0x903A), len(data_id)), next((i for i, x in enumerate(data_id) if x[0] == 0x9060), len(data_id)) + 1)):
                    amp_range = f"{(i+1)*10}-{(i+2)*10}A"
                    label = f"Time @ {amp_range:>8}:"
                    t = array[j + 1][1]
                    hhmmss = datetime.timedelta(seconds=t) if isinstance(t, (int, float)) else "------"
                    pct = round((t/tool_time)*100) if tool_time and isinstance(t, (int, float)) else 0
                    bar = "X" * round(pct)
                    print(f"{label} {hhmmss} {pct:2d}% {bar}")
                j = next((i for i, x in enumerate(data_id) if x[0] == 0x9060), len(data_id))
                amp_range = f"> 200A"
                label = f"Time @ {amp_range:>8}:"
                t = array[j + 1][1]
                hhmmss = datetime.timedelta(seconds=t) if isinstance(t, (int, float)) else "------"
                pct = round((t/tool_time)*100) if tool_time and isinstance(t, (int, float)) else 0
                bar = "X" * round(pct)
                print(f"{label} {hhmmss} {pct:2d}% {bar}")
            
            if warnings:
                summary_data.append(["Summary", "Warnings", "; ".join(warnings)])
            
            try:
                with open(csv_path, 'w', newline='', encoding='utf-8') as file:
                    writer = csv.writer(file, delimiter='>')
                    for row in summary_data:
                        writer.writerow(row)
                    writer.writerow([])  # Separator
                    for row in csv_data:
                        writer.writerow(row)
                print(f"Health data written to {csv_path}")
            except IOError as e:
                print(f"Error writing CSV: {e}")
            
            if verbose:
                print(f"\n{YELLOW}=== FULL REGISTER DATA ==={RESET}")
            else:
                print(f"[Full 183 Registers Exported to CSV]")
        except Exception as e:
            print(f"health: Failed with error: {e}")
            print("Check battery is connected and you have correct serial port")
        self.txrx_restore()

    def submit_form(self):
        form_url = 'https://docs.google.com/forms/d/e/1FAIpQLScvTbSDYBzSQ8S4XoF-rfgwNj97C-Pn4Px3GIixJxf0C1YJJA/formResponse'
        print("Getting data from battery...")
        output = self.read_id(output="form", retries=3)
        if output is None:
            print("submit_form: No output returned, aborting")
            return
        s_output = "\n".join(map(str, output))
        print("Please provide this information. All the values can be found on the label under the battery.")
        one_key_id = input("Enter One-Key ID (example: H18FDCAD): ")
        date = input("Enter Date (example: 190316): ")
        serial_number = input("Enter Serial number (example: 0807426): ")
        sticker = input("Enter Sticker (example: 4932 4512 45): ")
        type = input("Enter Type (example: M18B9): ")
        capacity = input("Enter Capacity (example: 9.0Ah): ")
        form_data = {
            "entry.905246449": one_key_id,
            "entry.453401884": date,
            "entry.2131879277": serial_number,
            "entry.337435885": sticker,
            "entry.1496274605": type,
            "entry.324224550": capacity,
            "entry.716337020": s_output
        }
        response = requests.post(form_url, data=form_data)
        if response.status_code == 200:
            print("Form submitted successfully!")
        else:
            print(f"submit_form: Failed with form. Status code: {response.status_code}")

    def idle(self):
        self.port.break_condition = True
        self.port.dtr = True

    def high(self):
        self.port.break_condition = False
        self.port.dtr = False

    def high_for(self, duration):
        self.high()
        time.sleep(duration)
        self.idle()

    def help(self):
        print("Functions: \n \
            DIAGNOSTICS: \n \
            m.health(verbose=False) - print and save health report (summary; verbose=True for all registers) \n \
            m.read_id(id_array=[], output='csv') - write diagnostics to serial_year_month_day.csv \n \
            m.plot_voltages() - plot cell voltages (requires matplotlib) \n \
            m.read_all() - print all known registers \n \
            m.read_all_spreadsheet() - print registers in spreadsheet format \n \
            m.submit_form() - submit diagnostics to form \n \
            m.write_message(message) - write ascii string to 0x0023 register (20 chars) \n \
            \n \
            m.help() - this message\n \
            m.adv_help() - advanced help\n \
            \n \
            exit() - end program\n")

    def adv_help(self):
        print("Advanced functions: \n \
            CHARGING SIMULATION: \n \
            m.simulate() - simulate charging comms \n \
            m.simulate_for(t) - simulate for t seconds \n \
            m.high_for(t) - bring J2 high for t sec, then idle \n \
            \n \
            m.write_message(message) - write ascii string to 0x0023 register (20 chars)\n \
            \n \
            Debug: \n \
            m.PRINT_TX = True - enable TX messages \n \
            m.PRINT_RX = True - enable RX messages \n \
            m.txrx_print(bool) - set PRINT_TX & RX to bool \n \
            m.txrx_save_and_set(bool) - save PRINT_TX & RX, set to bool \n \
            m.txrx_restore() - restore PRINT_TX & RX \n \
            m.brute(addr_msb, addr_lsb) - scan registers \n \
            m.full_brute(start, stop, len) - check registers from start to stop \n \
            m.debug(addr_msb, addr_lsb, len, rsp_len) - send reset() then cmd() \n \
            m.try_cmd(cmd, addr_h, addr_l, len) - try cmd at address \n \
            \n \
            Internal: \n \
            m.high() - set J2 pin high (20V) \n \
            m.idle() - set J2 pin low (0V) \n \
            m.reset() - send 0xAA, return True if battery replies \n \
            m.get_snap() - request snapshot (0x61) \n \
            m.configure() - send configure message (0x60) \n \
            m.calibrate() - calibration command (0x55) \n \
            m.keepalive() - send charge current request (0x62) \n")

if __name__ == '__main__':
    parser = argparse.ArgumentParser(
        description="M18 Battery Diagnostics",
        epilog="Connect UART-TX to M18-J2, UART-RX to M18-J1, UART-GND to M18-GND")
    parser.add_argument('--port', type=str, help="Serial port (e.g., COM5)")
    args = parser.parse_args()
    m = M18(args.port)
    m.help()
    while True:
        print("\nMenu:")
        print("1. Health report (with CSV)")
        print("2. Read all registers (CSV)")
        print("3. Plot cell voltages")
        print("4. Write message to 0x0023")
        print("5. Exit")
        choice = input("Choose an option (1-5): ")
        if choice == '1':
            m.health()
        elif choice == '2':
            m.read_id(output='csv')
        elif choice == '3':
            m.plot_voltages()
        elif choice == '4':
            message = input("Enter message (max 20 chars): ")
            m.write_message(message)
        elif choice == '5':
            break
        else:
            print("Invalid choice")
    print("Exiting...")