hitl_tester.test_cases.bms.test_nicd_cell

  1"""
  2Turn on and off relays for charging. 700 mA for 14 hours
  3After charged, turn on relay for discharge resistor
  4Measure how long (time) it takes for the cell to get to 1.21V and 1.2V
  5Stop discharging at 1.2V
  6Cells that last >5 hours before the 1.21V cutoff need to go to the 20S pack
  7Cells that last >5 hours before the 1.2V cutoff can go to 17S or 20S pack
  8Any cells that do not last 5 hours should not be used in a pack
  9
 10We are using this hardware:
 11ADCplate (https://pi-plates.com/adcplate-users-guide/) x3
 12RELAYplate2 (https://pi-plates.com/relayplate2/) x3
 13
 14D0 - D3 = voltages
 153 plates = 12 voltages
 16"""
 17
 18from __future__ import annotations
 19
 20import atexit
 21import datetime
 22import pathlib
 23import platform
 24import signal
 25import sys
 26import time
 27from dataclasses import dataclass
 28from enum import Enum
 29
 30import pytest
 31import yaml
 32from colorama import init, Fore
 33
 34from hitl_tester.modules.bms.bms_hw import BMSHardware
 35from hitl_tester.modules.bms_types import BMSFlags, ResourceNotFoundError
 36from hitl_tester.modules.bms.csv_tables import CSVRecorders
 37from hitl_tester.modules.logger import logger
 38
 39if hasattr(pytest, "flags") and isinstance(pytest.flags, BMSFlags) and pytest.flags.dry_run:
 40    from hitl_tester.modules.bms.pseudo_hardware import ADC
 41    from hitl_tester.modules.bms.pseudo_hardware import RELAY2
 42else:
 43    import piplates.ADCplate as ADC  # type: ignore[no-redef]
 44    import piplates.RELAYplate2 as RELAY2  # type: ignore[no-redef]
 45
 46init(True, strip=True)  # Initialize colorama (autoreset)
 47
 48REPORT_FILE = ""
 49
 50
 51@dataclass
 52class Port:
 53    """The board and channel on a PiPlate."""
 54
 55    board_id: int
 56    channel_id: int
 57
 58
 59class CellState(Enum):
 60    """The current state of the NiCd cell."""
 61
 62    RESTING = Fore.LIGHTBLACK_EX
 63    DISCHARGING = Fore.CYAN
 64    PASSED_20S = Fore.LIGHTGREEN_EX
 65    PASSED_17S_OR_20S = Fore.GREEN
 66    FAILED = Fore.LIGHTRED_EX
 67
 68
 69@dataclass
 70class Cell:
 71    """A NiCd cell attached to the HITL."""
 72
 73    adc_port: Port
 74    relay_port: Port
 75    ident: int
 76    timestamp_start: float = 0.0
 77    timestamp_1210_ma: float = 0.0
 78    timestamp_1200_ma: float = 0.0
 79    _state: CellState = CellState.RESTING
 80    csv: CSVRecorders | None = None
 81
 82    def __post_init__(self):
 83        """Set sample rate for cell voltage."""
 84        ADC.setMODE(self.adc_port.board_id, "ADV")  # Put board_id into advanced
 85        ADC.configINPUT(
 86            self.adc_port.board_id, f"D{self.adc_port.channel_id}", 7, True
 87        )  # 0nly 8 can be enabled at any time
 88
 89        BMSHardware().report_filename = REPORT_FILE
 90        self.csv = CSVRecorders(BMSHardware())
 91
 92        @atexit.register
 93        def __atexit__():
 94            """Configure a safe shut down for when the class instance is destroyed."""
 95            logger.write_info_to_report(f"Disabling cell B{self.relay_port.board_id}:C{self.relay_port.channel_id}")
 96            self.state = CellState.RESTING
 97
 98    @property
 99    def state(self):
100        """Get current cell state."""
101        return self._state
102
103    @state.setter
104    def state(self, new_state: CellState):
105        """Set current cell state."""
106        if new_state == CellState.DISCHARGING:
107            RELAY2.relayON(self.relay_port.board_id, self.relay_port.channel_id)
108        else:
109            RELAY2.relayOFF(self.relay_port.board_id, self.relay_port.channel_id)
110        self._state = new_state
111
112    @property
113    def voltage(self) -> float:
114        """Measure a voltage using the ADC plates."""
115        return float(ADC.readSINGLE(self.adc_port.board_id, f"D{self.adc_port.channel_id}") or 0.0)
116
117    def __str__(self) -> str:
118        """Formatted string representation."""
119        return (
120            f"{self.state.value}{self.state.name}{Fore.RESET}"
121            f"[B{self.relay_port.board_id}:C{self.relay_port.channel_id}, {self.voltage}V]"
122        )
123
124
125def safe_shutdown_handler(_signo, _stack_frame):
126    """
127    This handler will be called when a HANGUP signal is received.
128    i.e. ssh connection drops out. In this event, we're going to
129    ensure that the test setup is transitioned to a safe state.
130    """
131    signal.signal(_signo, signal.SIG_IGN)  # Ignore additional signals
132    logger.write_critical_to_report(f"Caught {signal.Signals(_signo).name}, Powering OFF HITL!!!")
133    sys.exit(0)  # exit gracefully (Calls bms_teardown)
134
135
136def test_safe_shutdown():
137    """Initialize safe shutdown handler."""
138    for signal_flag in (signal.SIGABRT, signal.SIGHUP, signal.SIGINT, signal.SIGTERM, signal.SIGCHLD):
139        signal.signal(signal_flag, safe_shutdown_handler)
140
141
142def test_logger():
143    """Initialize the log file."""
144    global REPORT_FILE
145
146    hitl_config = pathlib.Path(__file__).parent.resolve() / ".." / "hitl_config.yml"
147    with open(hitl_config, "r", encoding="utf-8") as config_file:
148        for config in yaml.safe_load_all(config_file):
149            if config["plate_set_id"] == pytest.flags.plateset_id:
150                # Record the report filename
151                REPORT_FILE = pytest.flags.report_filename
152
153                # initialize the logger
154                logger.use_file_mode(REPORT_FILE, config["log_level"])
155                logger.write_info_to_report("Found plateset")
156                break
157        else:
158            raise ResourceNotFoundError(f'Plateset "{pytest.flags.plateset_id}" does not exist in "{hitl_config.name}"')
159
160
161def formatted_time(seconds: float) -> str:
162    """Return time formatted as hh:mm:ss."""
163    return str(datetime.timedelta(seconds=seconds)).partition(".")[0]
164
165
166def test_discharge():
167    """Charge at 700 mA for 14 hours."""
168    logger.write_info_to_report("Beginning discharge test")
169    cell_holder = "A" if platform.node() == "HITL-4-1" else "B" if platform.node() == "HITL-4-2" else "?"
170    all_cells = [
171        Cell(adc_port=Port(0, 0), relay_port=Port(3, 8), ident=1),
172        Cell(adc_port=Port(0, 1), relay_port=Port(3, 1), ident=2),
173        Cell(adc_port=Port(0, 2), relay_port=Port(3, 2), ident=3),
174        Cell(adc_port=Port(0, 3), relay_port=Port(3, 3), ident=4),
175        Cell(adc_port=Port(1, 0), relay_port=Port(3, 4), ident=5),
176        Cell(adc_port=Port(1, 1), relay_port=Port(3, 5), ident=6),
177        Cell(adc_port=Port(1, 2), relay_port=Port(3, 6), ident=7),
178        Cell(adc_port=Port(1, 3), relay_port=Port(3, 7), ident=8),
179        Cell(adc_port=Port(2, 0), relay_port=Port(4, 8), ident=9),
180        Cell(adc_port=Port(2, 1), relay_port=Port(4, 1), ident=10),
181        Cell(adc_port=Port(2, 2), relay_port=Port(4, 2), ident=11),
182        Cell(adc_port=Port(2, 3), relay_port=Port(4, 3), ident=12),
183    ]
184    logger.write_info_to_report(", ".join(map(str, all_cells)))
185    test_start = time.perf_counter()
186
187    # Initialize cells
188    for cell in all_cells:
189        cell.timestamp_start = time.perf_counter()
190        cell.state = CellState.DISCHARGING
191        cell.csv.nicd.create_file("0000_", f"_{cell_holder}{cell.ident:02}")
192
193    # Discharge cells to 1.2V
194    while CellState.DISCHARGING in [cell.state for cell in all_cells]:
195        time_remaining_seconds = max(0.0, (5 * 3600) - (time.perf_counter() - test_start))
196        time_remaining_string = formatted_time(time_remaining_seconds)
197        logger.write_info_to_report(f"Time remaining (H:M:S): {time_remaining_string}")
198        logger.write_info_to_report(", ".join(map(str, all_cells)))
199        for cell in all_cells:
200            old_cell_state = cell.state
201            volts = cell.voltage
202            if not cell.timestamp_1210_ma and volts <= 1.21:
203                cell.timestamp_1210_ma = time.perf_counter()
204            elif not cell.timestamp_1200_ma and volts <= 1.20:
205                cell.timestamp_1200_ma = time.perf_counter()
206
207                if cell.timestamp_1210_ma - cell.timestamp_start >= 5 * 3600:  # >5 hours before 1.21V = 20S
208                    cell.state = CellState.PASSED_20S
209                elif cell.timestamp_1200_ma - cell.timestamp_start >= 5 * 3600:  # >5 hours before 1.2V = 17S/20S
210                    cell.state = CellState.PASSED_17S_OR_20S
211                else:
212                    cell.state = CellState.FAILED
213
214            # Record CSV
215            if cell.state == CellState.DISCHARGING or cell.state != old_cell_state:
216                cell.csv.nicd.record(
217                    time.perf_counter() - test_start,
218                    cell.relay_port.board_id,
219                    cell.relay_port.channel_id,
220                    volts,
221                    cell.state.name.title(),
222                    int(cell.timestamp_1210_ma - cell.timestamp_start) if cell.timestamp_1210_ma else None,
223                    int(cell.timestamp_1200_ma - cell.timestamp_start) if cell.timestamp_1200_ma else None,
224                )
225        time.sleep(10)
226
227    # Log results
228    logger.write_info_to_report("Completed discharge test")
229    for cell in all_cells:
230        logger.write_info_to_report(
231            f"Relay board: {cell.relay_port.board_id}, "
232            f"Relay channel: {cell.relay_port.channel_id}, "
233            f"Time to 1.21V (H:M:S): {formatted_time(cell.timestamp_1210_ma - cell.timestamp_start)}, "
234            f"Time to 1.20V (H:M:S): {formatted_time(cell.timestamp_1200_ma - cell.timestamp_start)}, "
235            f"Result: {cell.state.value}{cell.state.name}{Fore.RESET}"
236        )