tsmppt60-driver 0.2.2__py3-none-any.whl

tsmppt60_driver/__init__.py

@@ -0,0 +1,106 @@
+from tsmppt60_driver.base import ManagementBase
+from tsmppt60_driver.status import (
+    BatteryStatus,
+    CountersStatus,
+    OperatingConditions,
+    SolarArrayStatus,
+    TemperaturesStatus,
+)
+
+
+"""TS-MPPT-60 driver library to get all devices status data."""
+
+
+class SystemStatus(object):
+    """This is class to get the system status of TS-MPPT-60. Use this like below with dict object.
+
+        print(SystemStatus("192.168.1.20").get())
+
+        {'Amp Hours': {'group': 'Counter', 'unit': 'Ah', 'value': 18097.9},
+         'Array Current': {'group': 'Array', 'unit': 'A', 'value': 1.4},
+         'Array Voltage': {'group': 'Array', 'unit': 'V', 'value': 53.41},
+         'Battery Voltage': {'group': 'Battery', 'unit': 'V', 'value': 23.93},
+         'Charge Current': {'group': 'Battery', 'unit': 'A', 'value': 3.2},
+         'Heat Sink Temperature': {'group': 'Temperature', 'unit': 'C', ...},
+         'Kilowatt Hours': {'group': 'Counter', 'unit': 'kWh', 'value': 237.0},
+         'Target Voltage': {'group': 'Battery', 'unit': 'V', 'value': 28.6}}
+
+    The above data is limited information. You can disable the limitter
+    like below.
+
+        print(SystemStatus("192.168.1.20").get(False))
+
+        {'Amp Hours': {'group': 'Counter', 'unit': 'Ah', 'value': 18097.8},
+         'Array Current': {'group': 'Array', 'unit': 'A', 'value': 1.3},
+         'Array Voltage': {'group': 'Array', 'unit': 'V', 'value': 53.41},
+         'Battery Temperature': {'group': 'Temperature', 'unit': 'C', ...},
+         'Battery Voltage': {'group': 'Battery', 'unit': 'V', 'value': 24.01},
+         'Charge Current': {'group': 'Battery', 'unit': 'A', 'value': 3.2},
+         'Heat Sink Temperature': {'group': 'Temperature', 'unit': 'C', ...},
+         'Kilowatt Hours': {'group': 'Counter', 'unit': 'kWh', 'value': 237.0},
+         'Output Power': {'group': 'Battery', 'unit': 'W', 'value': 76.0},
+         'Sweep Pmax': {'group': 'Array', 'unit': 'W', 'value': 73.0},
+         'Sweep Vmp': {'group': 'Array', 'unit': 'V', 'value': 53.41},
+         'Sweep Voc': {'group': 'Array', 'unit': 'V', 'value': 60.05},
+         'Target Voltage': {'group': 'Battery', 'unit': 'V', 'value': 28.6},
+         'LED State': {'group': 'Condition', 'value': 11, 'unit': ''},
+         'Charge State': {'group': 'Condition', 'value': 3, 'unit': ''}}
+    """
+
+    def __init__(self, host):
+        """Initialize class object.
+
+        Keyword arguments:
+        host -- TS-MPPT-60 host address like "192.168.1.20"
+        """
+        _mb = ManagementBase(host)
+
+        self._devices = (
+            BatteryStatus(_mb),
+            SolarArrayStatus(_mb),
+            TemperaturesStatus(_mb),
+            CountersStatus(_mb),
+            OperatingConditions(_mb),
+        )
+
+    def get(self, is_limit=True):
+        """Get and return all status of devices like the below dict.
+
+            {
+                "Battery Voltage":{
+                    "group": "Battery",
+                    "value": 12.1,
+                    "unit": "V"},
+                "Charge Current":{
+                    "group": "Battery",
+                    "value": 8.4,
+                    "unit": "A"}
+            }
+
+        Keyword arguments:
+        is_limit -- limit the number of getting status
+        """
+        status_dict = {}
+
+        for device in self._devices:
+            for status in device.get_status_all(is_limit):
+                label = status.pop("label")
+                status_dict[label] = status
+
+        return status_dict
+
+    def __len__(self):
+        return len(self._devices)
+
+    def __iter__(self):
+        self._index = 0
+        return self
+
+    def __next__(self):
+        if self._index >= len(self._devices):
+            raise StopIteration
+
+        stat_obj = self._devices[self._index]
+        self._index += 1
+
+        return stat_obj

tsmppt60_driver/base.py

@@ -0,0 +1,266 @@
+import logging
+
+import requests
+
+
+"""TS-MPPT-60 driver's base modules."""
+
+
+class Logger(object):
+    """Logger base class for this module."""
+
+    _FORMAT_LOG_MSG = "%(asctime)s %(name)s %(levelname)s: %(message)s"
+    _FORMAT_LOG_DATE = "%Y/%m/%d %p %l:%M:%S"
+
+    def __init__(self, log_file_path=None, debug=False):
+        """Initialize Logger class object.
+
+        Keyword arguments:
+        log_file_path -- Path to record log file.
+        debug -- If True, logging is enabled.
+        """
+        self.logger = logging.getLogger(type(self).__name__)
+
+        handler = logging.StreamHandler()
+        formatter = logging.Formatter(fmt=self._FORMAT_LOG_MSG, datefmt=self._FORMAT_LOG_DATE)
+        handler.setFormatter(formatter)
+        self.logger.addHandler(handler)
+
+        if log_file_path:
+            handler = logging.FileHandler(log_file_path, mode="a")
+            handler.setFormatter(formatter)
+            self.logger.addHandler(handler)
+
+        if debug:
+            self.logger.setLevel(logging.DEBUG)
+        else:
+            self.logger.setLevel(logging.INFO)
+
+
+class ModbusRegisterTable(object):
+    """MODBUS register settings table."""
+
+    VOLTAGE_SCALING_HIGH = (0x0000, "", "Voltage Scaling High", 1)
+    VOLTAGE_SCALING_LOW = (0x0001, "", "Voltage Scaling Low", 1)
+    CURRENT_SCALING_HIGH = (0x0002, "", "Current Scaling High", 1)
+    CURRENT_SCALING_LOW = (0x0003, "", "Current Scaling Low", 1)
+    VOLTAGE_SCALING = (0x0000, "", "Voltage Scaling", 2)
+    CURRENT_SCALING = (0x0002, "", "Current Scaling", 2)
+    SOFTWARE_VERSION = (0x0004, "Numbers", "Software Version", 1)
+
+    BATTERY_VOLTAGE = (0x0026, "V", "Battery Voltage", 1)
+    CHARGING_CURRENT = (0x0027, "A", "Charge Current", 1)
+    TARGET_REGULATION_VOLTAGE = (0x0033, "V", "Target Voltage", 1)
+    OUTPUT_POWER = (0x003A, "W", "Output Power", 1)
+    ARRAY_VOLTAGE = (0x001B, "V", "Array Voltage", 1)
+    ARRAY_CURRENT = (0x001D, "A", "Array Current", 1)
+    VMP_LAST_SWEEP = (0x003D, "V", "Sweep Vmp", 1)
+    VOC_LAST_SWEEP = (0x003E, "V", "Sweep Voc", 1)
+    POWER_LAST_SWEEP = (0x003C, "W", "Sweep Pmax", 1)
+    HEATSINK_TEMP = (0x0023, "C", "Heat Sink Temperature", 1)
+    BATTERY_TEMP = (0x0025, "C", "Battery Temperature", 1)
+    AH_CHARGE_RESETABLE = (0x0034, "Ah", "Amp Hours", 2)
+    KWH_CHARGE_RESETABLE = (0x0038, "kWh", "Kilowatt Hours", 1)
+
+    LED_STATE = (0x0031, "Numbers", "LED State", 1)
+    CHARGE_STATE = (0x0032, "Numbers", "Charge State", 1)
+
+
+class ManagementBase(object):
+    """Class to get raw data from TS-MPPT-60. MODBUS ID is fixed to 1 as written on data sheet TSMPPT.APP_.Modbus.EN_.10.2.pdf.
+
+    Keyword arguments:
+    host -- host name like dummy.co.jp
+    cgi -- cgi script file name
+    debug -- debug message output is enabled if True
+    """
+
+    _ID_MODBUS = 0x01
+
+    def __init__(self, host, cgi="MBCSV.cgi", debug=False):
+        """Initialize class object.
+
+        Keyword arguments:
+        host -- Host address like "192.168.1.20" of TS-MPPT-60 live view
+        cgi -- CGI file name to get the information
+        debug -- If True, logging is enabled.
+        """
+        self._logger = logging.getLogger(type(self).__name__)
+        self._logger.addHandler(logging.StreamHandler())
+
+        if debug:
+            self._logger.setLevel(logging.DEBUG)
+
+        self._url = "http://" + host + "/" + cgi
+        self._vscale = self._compute_scaler(ModbusRegisterTable.VOLTAGE_SCALING)
+        self._iscale = self._compute_scaler(ModbusRegisterTable.CURRENT_SCALING)
+
+    def _get(self, addr, reg, mbid=_ID_MODBUS, field=4):
+        """Get and return raw data string like "1,4,1,1,1" against MBID, Address, Register, and Field.
+
+        Keyword arguments:
+        addr -- Address to get information
+        reg -- Register to get information
+        mbid -- MBID
+        field -- Field to get information
+
+        >>> mb._get(addr=0x0000, reg=1)
+        '1,4,2,0,0'
+        >>> mb._get(addr=0x0001, reg=1)
+        '1,4,2,0,0'
+        """
+        params = []
+        params.append("ID=" + str(mbid))
+        params.append("F=" + str(field))
+        params.append("AHI=" + str(addr >> 8))
+        params.append("ALO=" + str(addr & 255))
+        params.append("RHI=" + str(reg >> 8))
+        params.append("RLO=" + str(reg & 255))
+
+        res = requests.get("{0}?{1}".format(self._url, "&".join(params)), timeout=(5, 15))
+
+        return res.text
+
+    def _read_modbus(self, address, register, mbid=_ID_MODBUS):
+        """Read and return the value string with short integer (ex. 16bit value) against MBID, Address, and Register.
+
+        Keyword arguments:
+        address -- Address to get information
+        register -- Register to get information
+        mbid -- MBID
+
+        >>> mb._read_modbus(0x0000, 1)
+        [0]
+        >>> mb._read_modbus(0x0001, 1)
+        [0]
+        """
+        raw_value_str = self._get(address, register, mbid)
+        raw_values = [int(v) for v in raw_value_str.split(",")]
+        idx_max = raw_values[2]
+        raw_values = raw_values[3:]
+        idx = 0
+        ret = []
+
+        while idx < idx_max:
+            ret_short = raw_values[idx] << 8
+            idx += 1
+            ret_short += raw_values[idx]
+            idx += 1
+            ret.append(ret_short)
+
+        return ret
+
+    def _compute_scaler(self, param):
+        """Compute and return the voltage/current scaler as written on data sheet page 8 or 25.
+        This will be called only once when initializing this object.
+
+        Vscaling = whole.fraction = [V_PU hi].[V_PU lo]
+
+        Example:
+        Address:Value(hex):Variable Name
+        V_PU HI byte:0x004E = 78
+        V_PU LO byte:0x03A6 = 934
+
+        V_PU lo must be shifted by 16 (divided by 2^16)
+        and then added to V_PU hi Vscaling = 78 + 934/65536 = 78.01425
+
+        Keyword arguments:
+        param -- register to get a value
+        >>> mb._compute_scaler(ModbusRegisterTable.VOLTAGE_SCALING)
+        0.0
+        >>> mb._compute_scaler(ModbusRegisterTable.CURRENT_SCALING)
+        0.0
+        """
+        values = self._read_modbus(param[0], param[3])
+        return float(values[0]) + (float(values[1]) / pow(2, 16))
+
+    def get_raw_value(self, address, register):
+        """Return a raw value against address got from TS-MPPT-60.
+
+        Keyword arguments:
+        address -- address to get a value
+        register -- register to get a value
+
+        Returns:
+            Raw value as integer type.
+
+        >>> mb.get_raw_value(0x0026, 1)
+        0
+        >>> mb.get_raw_value(0x0027, 1)
+        0
+        """
+        values = self._read_modbus(address, register)
+
+        if register > 1:
+            raw_value = (values[0] << 16) | (values[1] & 0xFFFF)
+        else:
+            raw_value = values[0]
+            raw_value &= 0xFFFF
+            if raw_value & 0x8000:
+                raw_value ^= 0xFFFF
+                raw_value = -1 * (raw_value + 1)
+
+        return raw_value
+
+    def get_scaled_value(self, address, scale_factor, register):
+        """Calculate and return a scaled status value against address got from TS-MPPT-60.
+
+        Keyword arguments:
+        address -- address to get a value
+        scale_factor -- unit string
+        register -- register to get a value
+
+        Returns:
+            Scaled value like 12.4 against your expecting.
+
+        >>> mb.get_scaled_value(0x0026, "V", 1)
+        0.0
+        >>> mb.get_scaled_value(0x0027, "A", 1)
+        0.0
+        """
+        raw_value = self.get_raw_value(address, register)
+
+        if scale_factor == "V":
+            scaled_value = raw_value * self._vscale / pow(2, 15)
+        elif scale_factor == "A":
+            scaled_value = raw_value * self._iscale / pow(2, 15)
+        elif scale_factor == "W":
+            wscale = self._iscale * self._vscale
+            scaled_value = raw_value * wscale / pow(2, 17)
+        elif scale_factor == "Ah":
+            scaled_value = raw_value / 10.0
+        else:
+            scaled_value = raw_value
+
+        return round(scaled_value, 2)
+
+
+if __name__ == "__main__":
+    import doctest
+
+    try:
+        from unittest.mock import patch
+    except ImportError:
+        from mock import patch
+
+    class DummyRequest(object):
+        """Dummy response class against requests.Response."""
+
+        pass
+
+    class DummyResponse(object):
+        """Dummy response class against requests.Response."""
+
+        pass
+
+    dummy_host = "dummy.co.jp"
+
+    req = DummyRequest()
+    req.url = "http://" + dummy_host + "/dummy.cgi"
+    res = DummyResponse()
+    res.request = req
+    res.text = "1,4,2,0,0"
+
+    with patch("requests.get", returns=res) as _m:
+        _m.return_value = res
+        doctest.testmod(verbose=True, extraglobs={"mb": ManagementBase(host=dummy_host)})

tsmppt60_driver/status.py

@@ -0,0 +1,319 @@
+import logging
+
+from tsmppt60_driver.base import ModbusRegisterTable
+
+
+"""TS-MPPT-60 driver's internal modules inherites base modules."""
+
+
+class ChargeControllerStatus(object):
+    """Abstract class to get data about charge controller status."""
+
+    def __init__(self, mb, group, debug=False):
+        """Initialize class object.
+
+        Keyword arguments:
+        mb -- instance of ManagementBase class.
+        group -- string to indicate this instance name.
+        debug -- If True, logging is enabled.
+        """
+        self._mb = mb
+        self._group = group
+
+        handler = logging.StreamHandler()
+        handler.setFormatter(
+            logging.Formatter("%(asctime)s %(name)s %(levelname)s: %(message)s", "%Y/%m/%d %p %l:%M:%S")
+        )
+
+        self._logger = logging.getLogger(type(self).__name__)
+        self._logger.addHandler(handler)
+
+        if debug:
+            self._logger.setLevel(logging.DEBUG)
+
+    def __repr__(self):
+        return self._group
+
+    def __str__(self):
+        return self._group
+
+    def get_status(self, address, scale_factor, label, register):
+        """
+        Get and return a data against the specified address, register, etc. like below.
+
+            {
+                "group": "battery",
+                "label": "Battery Voltage",
+                "value": 12.1,
+                "unit": "V"
+            }
+
+        Keyword arguments:
+        address -- address to get a value
+        scale_factor -- unit string
+        label -- label string of got value
+        register -- register to get a value
+        """
+        ret_values = {}
+        ret_values["group"] = self._group
+        ret_values["label"] = label
+        ret_values["value"] = self._mb.get_scaled_value(address, scale_factor, register)
+        ret_values["unit"] = scale_factor
+
+        return ret_values
+
+    def get_status_all(self, is_limit=True):
+        """
+        Get and return all data against the inherited class's paramter list.
+
+            { "group": "Battery",
+                "label": "Battery Voltage",
+                "value": 12.1,
+                "unit": "V"
+            },
+            {
+                "group": "Battery",
+                "label": "Charge Current",
+                "value": 8.4,
+                "unit": "A"
+            }
+
+        Keyword arguments:
+        is_limit -- limit the number of getting status
+        """
+        return [self.get_status(*param) for param in self.get_params(is_limit)]
+
+    def get_params(self, is_limit=True):
+        """Get and return a list of all params of the inherited class's group.
+
+        Keyword arguments:
+        is_limit -- limit the number of getting status
+            ((61, "V", "Sweep Vmp", 1),
+             (62, "V", "Sweep Voc", 1),
+             (60, "W", "Sweep Pmax", 1))
+        """
+        raise NotImplementedError
+
+
+class BatteryStatus(ChargeControllerStatus):
+    """
+    This class gives the following battery status.
+
+    * battery voltage
+    * target voltage
+    * charge current
+    * output power
+    """
+
+    def __init__(self, mb):
+        """Initialize BatteryStatus class object.
+
+        Keyword arguments:
+        mb -- instance of ManagementBase class
+        """
+        ChargeControllerStatus.__init__(self, mb, "Battery")
+
+    def get_params(self, is_limit=True):
+        """Get and return a list of all params to get the battery status. The param is consisted by (address, scale_factor, label, register).
+
+        Keyword arguments:
+        is_limit -- limit the number of getting status
+
+        >>> bat.get_params() == [
+        ...     (38, "V", "Battery Voltage", 1),
+        ...     (51, "V", "Target Voltage", 1),
+        ...     (39, "A", "Charge Current", 1),
+        ... ]
+        True
+        >>> bat.get_params(True) == [
+        ...     (38, "V", "Battery Voltage", 1),
+        ...     (51, "V", "Target Voltage", 1),
+        ...     (39, "A", "Charge Current", 1),
+        ... ]
+        True
+        >>> bat.get_params(False) == [
+        ...     (38, "V", "Battery Voltage", 1),
+        ...     (51, "V", "Target Voltage", 1),
+        ...     (39, "A", "Charge Current", 1),
+        ...     (58, "W", "Output Power", 1),
+        ... ]
+        True
+        """
+        params = [
+            ModbusRegisterTable.BATTERY_VOLTAGE,
+            ModbusRegisterTable.TARGET_REGULATION_VOLTAGE,
+            ModbusRegisterTable.CHARGING_CURRENT,
+        ]
+
+        if not is_limit:
+            params.append(ModbusRegisterTable.OUTPUT_POWER)
+
+        return params
+
+
+class SolarArrayStatus(ChargeControllerStatus):
+    """Class to get data about solar array.
+
+    * array voltage
+    * array current
+    * sweep vmp
+    * sweep voc
+    * sweep pmax
+    """
+
+    def __init__(self, mb):
+        """Initialize SolarArrayStatus class object.
+
+        Keyword arguments:
+        mb -- instance of ManagementBase class
+        """
+        ChargeControllerStatus.__init__(self, mb, "Array")
+
+    def get_params(self, is_limit=True):
+        """Get and return a list of all params to get the solar array status. The param is consisted by (address, scale_factor, label, register).
+
+        Keyword arguments:
+        is_limit -- limit the number of getting status
+
+        >>> array.get_params() == [(27, "V", "Array Voltage", 1), (29, "A", "Array Current", 1)]
+        True
+        >>> array.get_params(True) == [(27, "V", "Array Voltage", 1), (29, "A", "Array Current", 1)]
+        True
+        >>> array.get_params(False) == [
+        ...     (27, "V", "Array Voltage", 1),
+        ...     (29, "A", "Array Current", 1),
+        ...     (61, "V", "Sweep Vmp", 1),
+        ...     (62, "V", "Sweep Voc", 1),
+        ...     (60, "W", "Sweep Pmax", 1),
+        ... ]
+        True
+        """
+        params = [ModbusRegisterTable.ARRAY_VOLTAGE, ModbusRegisterTable.ARRAY_CURRENT]
+
+        if not is_limit:
+            params.extend(
+                [
+                    ModbusRegisterTable.VMP_LAST_SWEEP,
+                    ModbusRegisterTable.VOC_LAST_SWEEP,
+                    ModbusRegisterTable.POWER_LAST_SWEEP,
+                ]
+            )
+
+        return params
+
+
+class TemperaturesStatus(ChargeControllerStatus):
+    """Class to get data about temperatures sensors.
+
+    * heat sink temperature
+    * battery temperature
+    """
+
+    def __init__(self, mb):
+        """Initialize SolarArrayStatus class object.
+
+        Keyword arguments:
+        mb -- instance of ManagementBase class
+        """
+        ChargeControllerStatus.__init__(self, mb, "Temperature")
+
+    def get_params(self, is_limit=True):
+        """Get and return a list of all params to get the temperatures. The param is consisted by (address, scale_factor, label, register).
+
+        Keyword arguments:
+        is_limit -- limit the number of getting status
+
+        >>> temp.get_params() == [(35, "C", "Heat Sink Temperature", 1)]
+        True
+        >>> temp.get_params(True) == [(35, "C", "Heat Sink Temperature", 1)]
+        True
+        >>> temp.get_params(False) == [(35, "C", "Heat Sink Temperature", 1), (37, "C", "Battery Temperature", 1)]
+        True
+        """
+        params = [ModbusRegisterTable.HEATSINK_TEMP]
+
+        if not is_limit:
+            params.append(ModbusRegisterTable.BATTERY_TEMP)
+
+        return params
+
+
+class CountersStatus(ChargeControllerStatus):
+    """
+    Class to get data about resettable counters.
+
+    * amp hours
+    * kilowatt hours
+    """
+
+    def __init__(self, mb):
+        """
+        Initialize CountersStaus class object.
+
+        Keyword arguments:
+        mb -- instance of ManagementBase class
+        """
+        ChargeControllerStatus.__init__(self, mb, "Counter")
+
+    def get_params(self, is_limit=True):
+        """Get and return a list of all params to get the counters. The param is consisted by (address, scale_factor, label, register).
+
+        Keyword arguments:
+        is_limit -- limit the number of getting status
+
+        >>> count.get_params() == ((52, "Ah", "Amp Hours", 2), (56, "kWh", "Kilowatt Hours", 1))
+        True
+        >>> count.get_params(True) == ((52, "Ah", "Amp Hours", 2), (56, "kWh", "Kilowatt Hours", 1))
+        True
+        >>> count.get_params(False) == ((52, "Ah", "Amp Hours", 2), (56, "kWh", "Kilowatt Hours", 1))
+        True
+        """
+        return (ModbusRegisterTable.AH_CHARGE_RESETABLE, ModbusRegisterTable.KWH_CHARGE_RESETABLE)
+
+
+class OperatingConditions(ChargeControllerStatus):
+    """
+    Class to get data about controller's operating conditions.
+
+    * LED state
+    * Charge state
+    """
+
+    def __init__(self, mb):
+        """
+        Initialize OperatingConditions class object.
+
+        Keyword arguments:
+        mb -- instance of ManagementBase class
+        """
+        ChargeControllerStatus.__init__(self, mb, "Condition")
+
+    def get_params(self, is_limit=True):
+        """Get and return a list of all params to get the conditions. The param is consisted by (address, scale_factor, label, register).
+
+        Keyword arguments:
+        is_limit -- limit the number of getting status
+
+        >>> condition.get_params() == ((49, "Numbers", "LED State", 1), (50, "Numbers", "Charge State", 1))
+        True
+        >>> condition.get_params(True) == ((49, "Numbers", "LED State", 1), (50, "Numbers", "Charge State", 1))
+        True
+        >>> condition.get_params(False) == ((49, "Numbers", "LED State", 1), (50, "Numbers", "Charge State", 1))
+        True
+        """
+        return (ModbusRegisterTable.LED_STATE, ModbusRegisterTable.CHARGE_STATE)
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod(
+        verbose=True,
+        extraglobs={
+            "bat": BatteryStatus(None),
+            "array": SolarArrayStatus(None),
+            "temp": TemperaturesStatus(None),
+            "count": CountersStatus(None),
+            "condition": OperatingConditions(None),
+        },
+    )

tsmppt60_driver-0.2.2.dist-info/METADATA

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: tsmppt60-driver
+Version: 0.2.2
+Summary: Python module to get status of your solar charge controller TS-MPPT-60.
+License: GPLv2
+Author: Takashi Ando
+Author-email: odo5522@gmail.com
+Requires-Python: >=3.11,<3.15
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: License :: OSI Approved :: GNU General Public License v2 (GPLv2)
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: System :: Hardware :: Hardware Drivers
+Requires-Dist: requests (>=2.32,<3.0)
+Description-Content-Type: text/markdown
+
+# TS-MPPT-60 driver module
+
+This is python driver module to get the following status of TS-MPPT-60.
+
+* Amp Hours
+* Array Current
+* Array Voltage
+* Battery Temperature
+* Battery Voltage
+* Charge Current
+* Heat Sink Temperature
+* Kilowatt Hours
+* Output Power
+* Sweep Pmax
+* Sweep Vmp
+* Sweep Voc
+* Target Voltage
+
+# Requirement
+
+* requests
+
+# How to install
+
+```bash
+pip install tsmppt60-driver
+```
+
+# How to use
+
+SystemStatus class object is iterator containing all live status data of TS-MPPT-60. Try the following line.
+
+```python
+print(SystemStatus("192.168.1.20").get())
+```
+
+The result is like following.
+
+```
+{'Amp Hours': {'group': 'Counter', 'unit': 'Ah', 'value': 18097.9},
+ 'Array Current': {'group': 'Array', 'unit': 'A', 'value': 1.4},
+ 'Array Voltage': {'group': 'Array', 'unit': 'V', 'value': 53.41},
+ 'Battery Voltage': {'group': 'Battery', 'unit': 'V', 'value': 23.93},
+ 'Charge Current': {'group': 'Battery', 'unit': 'A', 'value': 3.2},
+ 'Heat Sink Temperature': {'group': 'Temperature', 'unit': 'C', ...},
+ 'Kilowatt Hours': {'group': 'Counter', 'unit': 'kWh', 'value': 237.0},
+ 'Target Voltage': {'group': 'Battery', 'unit': 'V', 'value': 28.6}}
+```
+
+The above data is limited information. You can disable the limitter by setting False to the second argument as SystemStatus() class.
+
+```python
+print(SystemStatus("192.168.1.20").get(False))
+```
+
+The result is like following.
+
+```
+{'Amp Hours': {'group': 'Counter', 'unit': 'Ah', 'value': 18097.8},
+ 'Array Current': {'group': 'Array', 'unit': 'A', 'value': 1.3},
+ 'Array Voltage': {'group': 'Array', 'unit': 'V', 'value': 53.41},
+ 'Battery Temperature': {'group': 'Temperature', 'unit': 'C', ...},
+ 'Battery Voltage': {'group': 'Battery', 'unit': 'V', 'value': 24.01},
+ 'Charge Current': {'group': 'Battery', 'unit': 'A', 'value': 3.2},
+ 'Heat Sink Temperature': {'group': 'Temperature', 'unit': 'C', ...},
+ 'Kilowatt Hours': {'group': 'Counter', 'unit': 'kWh', 'value': 237.0},
+ 'Output Power': {'group': 'Battery', 'unit': 'W', 'value': 76.0},
+ 'Sweep Pmax': {'group': 'Array', 'unit': 'W', 'value': 73.0},
+ 'Sweep Vmp': {'group': 'Array', 'unit': 'V', 'value': 53.41},
+ 'Sweep Voc': {'group': 'Array', 'unit': 'V', 'value': 60.05},
+ 'Target Voltage': {'group': 'Battery', 'unit': 'V', 'value': 28.6}}
+```
+
+JSON string can be got with following code.
+
+```bash
+$ python -c "from tsmppt60_driver import *; import json; print(json.dumps(SystemStatus('192.168.1.20').get()))" | jq '."Battery Voltage"'
+
+{
+  "group": "Battery",
+  "value": 28.6,
+  "unit": "V"
+}
+```
+

tsmppt60_driver-0.2.2.dist-info/RECORD

@@ -0,0 +1,6 @@
+tsmppt60_driver/__init__.py,sha256=rQVEYSNs57k8gBg6_X9WLkQ9aNc3-Kx_37G0xy4eiYM,3828
+tsmppt60_driver/base.py,sha256=IHQ6syynGfhlVV_bHfTYKUW0CKv1r4bYfB9T5IRu2pE,8726
+tsmppt60_driver/status.py,sha256=nrz7gb0KaD0bLZ5g6mjOxOgkMYPq6vCr2jeoZjZdVTc,9854
+tsmppt60_driver-0.2.2.dist-info/METADATA,sha256=arGVJKWP5Jvgfa_2VyK1bvsO3NF5qHKMOo3S3GOm2VU,3310
+tsmppt60_driver-0.2.2.dist-info/WHEEL,sha256=EGEvSphFYqXKs23-kQBeyNoJP1nrT8ZJKQoi5p5DYL8,88
+tsmppt60_driver-0.2.2.dist-info/RECORD,,

tsmppt60_driver-0.2.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.4.0
+Root-Is-Purelib: true
+Tag: py3-none-any