Una repositoy che integra un plugin custom su SignalK per ottenere tutti i dati del BMS della batteria
- Introdotta l'implementazione JavaScript per la comunicazione BMS in bmscore.js, inclusi i metodi per il recupero dati e la gestione degli errori. - Creato errors.js per mappare i codici di errore dal formato Python a quello JavaScript.
This commit is contained in:
Giuseppe Raffa
7
python-reference/__init__.py
Normal file
7
python-reference/__init__.py
Normal file
@@ -0,0 +1,7 @@
|
||||
from .daly_bms import DalyBMS
|
||||
from .daly_sinowealth import DalyBMSSinowealth
|
||||
try:
|
||||
from .daly_bms_bluetooth import DalyBMSBluetooth
|
||||
except ImportError:
|
||||
# Bluetooth is optional and requires bleak to be installed
|
||||
pass
|
||||
254
python-reference/daly-bms-cli
Executable file
254
python-reference/daly-bms-cli
Executable file
@@ -0,0 +1,254 @@
|
||||
#!/usr/bin/python3
|
||||
import argparse
|
||||
import json
|
||||
import logging
|
||||
import sys
|
||||
|
||||
from dalybms import DalyBMS
|
||||
from dalybms import DalyBMSSinowealth
|
||||
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("-d", "--device",
|
||||
help="RS485 device, e.g. /dev/ttyUSB0",
|
||||
type=str, required=True)
|
||||
parser.add_argument("--uart", help="UART instead of RS485", action="store_true")
|
||||
parser.add_argument("--sinowealth", help="BMS with Sinowealth chip", action="store_true")
|
||||
parser.add_argument("--status", help="show status", action="store_true")
|
||||
parser.add_argument("--soc", help="show voltage, current, SOC", action="store_true")
|
||||
parser.add_argument("--mosfet", help="show mosfet status", action="store_true")
|
||||
parser.add_argument("--cell-voltages", help="show cell voltages", action="store_true")
|
||||
parser.add_argument("--temperatures", help="show temperature sensor values", action="store_true")
|
||||
parser.add_argument("--balancing", help="show cell balancing status", action="store_true")
|
||||
parser.add_argument("--errors", help="show BMS errors", action="store_true")
|
||||
parser.add_argument("--all", help="show all", action="store_true")
|
||||
parser.add_argument("--check", help="Nagios style check", action="store_true")
|
||||
parser.add_argument("--set-charge-mosfet", help="'on' or 'off'", type=str)
|
||||
parser.add_argument("--set-discharge-mosfet", help="'on' or 'off'", type=str)
|
||||
parser.add_argument("--set-soc", help="'0.0' to '100.0'", type=str)
|
||||
parser.add_argument("--restart", help="restart bms", action="store_true")
|
||||
parser.add_argument("--retry", help="retry X times if the request fails, default 5", type=int, default=5)
|
||||
parser.add_argument("--verbose", help="Verbose output", action="store_true")
|
||||
|
||||
parser.add_argument("--mqtt", help="Write output to MQTT", action="store_true")
|
||||
parser.add_argument("--mqtt-hass", help="MQTT Home Assistant Mode", action="store_true")
|
||||
|
||||
parser.add_argument("--mqtt-topic",
|
||||
help="MQTT topic to write to. default daly_bms",
|
||||
type=str,
|
||||
default="daly_bms")
|
||||
|
||||
parser.add_argument("--mqtt-broker",
|
||||
help="MQTT broker (server). default localhost",
|
||||
type=str,
|
||||
default="localhost")
|
||||
|
||||
parser.add_argument("--mqtt-port",
|
||||
help="MQTT port. default 1883",
|
||||
type=int,
|
||||
default=1883)
|
||||
|
||||
parser.add_argument("--mqtt-user",
|
||||
help="Username to authenticate MQTT with",
|
||||
type=str)
|
||||
|
||||
parser.add_argument("--mqtt-password",
|
||||
help="Password to authenticate MQTT with",
|
||||
type=str)
|
||||
|
||||
args = parser.parse_args()
|
||||
|
||||
log_format = '%(levelname)-8s [%(filename)s:%(lineno)d] %(message)s'
|
||||
if args.verbose:
|
||||
level = logging.DEBUG
|
||||
else:
|
||||
level = logging.WARNING
|
||||
|
||||
logging.basicConfig(level=level, format=log_format, datefmt='%H:%M:%S')
|
||||
|
||||
logger = logging.getLogger()
|
||||
|
||||
if args.uart:
|
||||
address = 8
|
||||
else:
|
||||
address = 4
|
||||
|
||||
if args.sinowealth:
|
||||
bms = DalyBMSSinowealth(request_retries=args.retry, logger=logger)
|
||||
else:
|
||||
bms = DalyBMS(request_retries=args.retry, address=address, logger=logger)
|
||||
bms.connect(device=args.device)
|
||||
|
||||
result = False
|
||||
|
||||
mqtt_client = None
|
||||
if args.mqtt:
|
||||
import paho.mqtt.client as paho
|
||||
|
||||
mqtt_client = paho.Client()
|
||||
mqtt_client.enable_logger(logger)
|
||||
mqtt_client.username_pw_set(args.mqtt_user, args.mqtt_password)
|
||||
mqtt_client.connect(args.mqtt_broker, port=args.mqtt_port)
|
||||
|
||||
|
||||
def build_mqtt_hass_config_discovery(base):
|
||||
# Instead of daly_bms should be here added a proper name (unique), like serial or something
|
||||
# At this point it can be used only one daly_bms system with hass discovery
|
||||
|
||||
hass_config_topic = f'homeassistant/sensor/daly_bms/{base.replace("/", "_")}/config'
|
||||
hass_config_data = {}
|
||||
|
||||
hass_config_data["unique_id"] = f'daly_bms_{base.replace("/", "_")}'
|
||||
hass_config_data["name"] = f'Daly BMS {base.replace("/", " ")}'
|
||||
|
||||
if 'soc_percent' in base:
|
||||
hass_config_data["device_class"] = 'battery'
|
||||
hass_config_data["unit_of_measurement"] = '%'
|
||||
elif 'voltage' in base and not ('lowest_cell' in base or 'highest_cell' in base):
|
||||
hass_config_data["device_class"] = 'voltage'
|
||||
hass_config_data["unit_of_measurement"] = 'V'
|
||||
elif 'current' in base:
|
||||
hass_config_data["device_class"] = 'current'
|
||||
hass_config_data["unit_of_measurement"] = 'A'
|
||||
elif 'temperatures' in base:
|
||||
hass_config_data["device_class"] = 'temperature'
|
||||
hass_config_data["unit_of_measurement"] = '°C'
|
||||
elif 'capacity' in 'base':
|
||||
hass_config_data["device_class"] = 'energy'
|
||||
hass_config_data["unit_of_measurement"] = 'Ah'
|
||||
else:
|
||||
pass
|
||||
|
||||
hass_config_data["json_attributes_topic"] = f'{args.mqtt_topic}{base}'
|
||||
hass_config_data["state_topic"] = f'{args.mqtt_topic}{base}'
|
||||
|
||||
hass_device = {
|
||||
"identifiers": ['daly_bms'],
|
||||
"manufacturer": 'Daly',
|
||||
"model": 'Currently not available',
|
||||
"name": 'Daly BMS',
|
||||
"sw_version": 'Currently not available'
|
||||
}
|
||||
hass_config_data["device"] = hass_device
|
||||
|
||||
return hass_config_topic, json.dumps(hass_config_data)
|
||||
|
||||
|
||||
def mqtt_single_out(topic, data, retain=False):
|
||||
logger.debug(f'Send data: {data} on topic: {topic}, retain flag: {retain}')
|
||||
mqtt_client.publish(topic, data, retain=retain)
|
||||
|
||||
|
||||
def mqtt_iterator(result, base=''):
|
||||
for key in result.keys():
|
||||
if type(result[key]) == dict:
|
||||
mqtt_iterator(result[key], f'{base}/{key}')
|
||||
else:
|
||||
if args.mqtt_hass:
|
||||
logger.debug('Sending out hass discovery message')
|
||||
topic, output = build_mqtt_hass_config_discovery(f'{base}/{key}')
|
||||
mqtt_single_out(topic, output, retain=True)
|
||||
|
||||
if type(result[key]) == list:
|
||||
val = json.dumps(result[key])
|
||||
else:
|
||||
val = result[key]
|
||||
|
||||
mqtt_single_out(f'{args.mqtt_topic}{base}/{key}', val)
|
||||
|
||||
|
||||
def print_result(result):
|
||||
if args.mqtt:
|
||||
mqtt_iterator(result)
|
||||
else:
|
||||
print(json.dumps(result, indent=2))
|
||||
|
||||
|
||||
if args.status:
|
||||
result = bms.get_status()
|
||||
print_result(result)
|
||||
if args.soc:
|
||||
result = bms.get_soc()
|
||||
print_result(result)
|
||||
if args.mosfet:
|
||||
result = bms.get_mosfet_status()
|
||||
print_result(result)
|
||||
if args.cell_voltages:
|
||||
if not args.status:
|
||||
bms.get_status()
|
||||
result = bms.get_cell_voltages()
|
||||
print_result(result)
|
||||
if args.temperatures:
|
||||
result = bms.get_temperatures()
|
||||
print_result(result)
|
||||
if args.balancing:
|
||||
result = bms.get_balancing_status()
|
||||
print_result(result)
|
||||
if args.errors:
|
||||
result = bms.get_errors()
|
||||
print_result(result)
|
||||
if args.all:
|
||||
result = bms.get_all()
|
||||
print_result(result)
|
||||
|
||||
if args.check:
|
||||
status = bms.get_status()
|
||||
status_code = 0 # OK
|
||||
status_codes = ('OK', 'WARNING', 'CRITICAL', 'UNKNOWN')
|
||||
status_line = ''
|
||||
|
||||
data = bms.get_soc()
|
||||
perfdata = []
|
||||
if data:
|
||||
for key, value in data.items():
|
||||
perfdata.append('%s=%s' % (key, value))
|
||||
|
||||
# todo: read errors
|
||||
|
||||
if status_code == 0:
|
||||
status_line = '%0.1f volt, %0.1f amper' % (data['total_voltage'], data['current'])
|
||||
|
||||
print("%s - %s | %s" % (status_codes[status_code], status_line, " ".join(perfdata)))
|
||||
sys.exit(status_code)
|
||||
|
||||
if args.set_charge_mosfet:
|
||||
if args.set_charge_mosfet == 'on':
|
||||
on = True
|
||||
elif args.set_charge_mosfet == 'off':
|
||||
on = False
|
||||
else:
|
||||
print("invalid value '%s', expected 'on' or 'off'" % args.set_charge_mosfet)
|
||||
sys.exit(1)
|
||||
|
||||
result = bms.set_charge_mosfet(on=on)
|
||||
|
||||
if args.set_discharge_mosfet:
|
||||
if args.set_discharge_mosfet == 'on':
|
||||
on = True
|
||||
elif args.set_discharge_mosfet == 'off':
|
||||
on = False
|
||||
else:
|
||||
print("invalid value '%s', expected 'on' or 'off'" % args.set_discharge_mosfet)
|
||||
sys.exit(1)
|
||||
|
||||
result = bms.set_discharge_mosfet(on=on)
|
||||
|
||||
if args.set_soc:
|
||||
try :
|
||||
v = float(args.set_soc)
|
||||
except :
|
||||
print("invalid value '%s', expected float value betwen 0 and 100" % args.set_soc)
|
||||
sys.exit(1)
|
||||
|
||||
result = bms.set_soc(v)
|
||||
|
||||
if args.restart:
|
||||
result = bms.restart()
|
||||
|
||||
|
||||
if mqtt_client:
|
||||
mqtt_client.disconnect()
|
||||
|
||||
bms.disconnect()
|
||||
|
||||
if not result:
|
||||
sys.exit(1)
|
||||
403
python-reference/daly_bms.py
Normal file
403
python-reference/daly_bms.py
Normal file
@@ -0,0 +1,403 @@
|
||||
import serial
|
||||
import struct
|
||||
import time
|
||||
import math
|
||||
import logging
|
||||
|
||||
from .error_codes import ERROR_CODES
|
||||
|
||||
|
||||
class DalyBMS:
|
||||
def __init__(self, request_retries=3, address=4, logger=None):
|
||||
"""
|
||||
|
||||
:param request_retries: How often read requests should get repeated in case that they fail (Default: 3).
|
||||
:param address: Source address for commands sent to the BMS (4 for RS485, 8 for UART/Bluetooth)
|
||||
:param logger: Python Logger object for output (Default: None)
|
||||
"""
|
||||
self.status = None
|
||||
if logger:
|
||||
self.logger = logger
|
||||
else:
|
||||
self.logger = logging.getLogger(__name__)
|
||||
self.request_retries = request_retries
|
||||
self.address = address # 4 = USB, 8 = Bluetooth
|
||||
|
||||
def connect(self, device):
|
||||
"""
|
||||
Connect to a serial device
|
||||
|
||||
:param device: Serial device, e.g. /dev/ttyUSB0
|
||||
"""
|
||||
self.serial = serial.Serial(
|
||||
port=device,
|
||||
baudrate=9600,
|
||||
bytesize=serial.EIGHTBITS,
|
||||
parity=serial.PARITY_NONE,
|
||||
stopbits=serial.STOPBITS_ONE,
|
||||
timeout=0.5,
|
||||
xonxoff=False,
|
||||
writeTimeout=0.5
|
||||
)
|
||||
self.get_status()
|
||||
|
||||
def disconnect(self):
|
||||
if self.serial and self.serial.is_open:
|
||||
self.serial.close()
|
||||
|
||||
@staticmethod
|
||||
def _calc_crc(message_bytes):
|
||||
"""
|
||||
Calculate the checksum of a message
|
||||
|
||||
:param message_bytes: Bytes for which the checksum should get calculated
|
||||
:return: Checksum as bytes
|
||||
"""
|
||||
return bytes([sum(message_bytes) & 0xFF])
|
||||
|
||||
def _format_message(self, command, extra=""):
|
||||
"""
|
||||
Takes the command ID and formats a request message
|
||||
|
||||
:param command: Command ID ("90" - "98")
|
||||
:return: Request message as bytes
|
||||
"""
|
||||
# 95 -> a58095080000000000000000c2
|
||||
message = "a5%i0%s08%s" % (self.address, command, extra)
|
||||
message = message.ljust(24, "0")
|
||||
message_bytes = bytearray.fromhex(message)
|
||||
message_bytes += self._calc_crc(message_bytes)
|
||||
self.logger.debug("w %s" % message_bytes.hex())
|
||||
return message_bytes
|
||||
|
||||
def _read_request(self, command, extra="", max_responses=1, return_list=False):
|
||||
"""
|
||||
Sends a read request to the BMS and reads the response. In case it fails, it retries 'max_responses' times.
|
||||
|
||||
:param command: Command ID ("90" - "98")
|
||||
:param max_responses: For how many response packages it should wait (Default: 1).
|
||||
:return: Request message as bytes or False
|
||||
"""
|
||||
response_data = None
|
||||
x = None
|
||||
for x in range(0, self.request_retries):
|
||||
response_data = self._read(
|
||||
command=command,
|
||||
extra=extra,
|
||||
max_responses=max_responses,
|
||||
return_list=return_list)
|
||||
if not response_data:
|
||||
self.logger.debug("%x. try failed, retrying..." % (x + 1))
|
||||
time.sleep(0.2)
|
||||
else:
|
||||
break
|
||||
if not response_data:
|
||||
self.logger.error('%s failed after %s tries' % (command, x + 1))
|
||||
return False
|
||||
return response_data
|
||||
|
||||
def _read(self, command, extra="", max_responses=1, return_list=False):
|
||||
self.logger.debug("-- %s ------------------------" % command)
|
||||
if not self.serial.is_open:
|
||||
self.serial.open()
|
||||
message_bytes = self._format_message(command, extra=extra)
|
||||
|
||||
# clear all buffers, in case something is left from a previous command that failed
|
||||
self.serial.reset_input_buffer()
|
||||
self.serial.reset_output_buffer()
|
||||
|
||||
if not self.serial.write(message_bytes):
|
||||
self.logger.error("serial write failed for command" % command)
|
||||
return False
|
||||
x = 0
|
||||
response_data = []
|
||||
while True:
|
||||
b = self.serial.read(13)
|
||||
if len(b) == 0:
|
||||
self.logger.debug("%i empty response for command %s" % (x, command))
|
||||
break
|
||||
self.logger.debug("%i %s %s" % (x, b.hex(), len(b)))
|
||||
x += 1
|
||||
response_crc = self._calc_crc(b[:-1])
|
||||
if response_crc != b[-1:]:
|
||||
self.logger.debug("response crc mismatch: %s != %s" % (response_crc.hex(), b[-1:].hex()))
|
||||
header = b[0:4].hex()
|
||||
# todo: verify more header fields
|
||||
if header[4:6] != command:
|
||||
self.logger.debug("invalid header %s: wrong command (%s != %s)" % (header, header[4:6], command))
|
||||
continue
|
||||
data = b[4:-1]
|
||||
response_data.append(data)
|
||||
if x == max_responses:
|
||||
break
|
||||
|
||||
if return_list or len(response_data) > 1:
|
||||
return response_data
|
||||
elif len(response_data) == 1:
|
||||
return response_data[0]
|
||||
else:
|
||||
return False
|
||||
|
||||
def get_soc(self, response_data=None):
|
||||
# SOC of Total Voltage Current
|
||||
if not response_data:
|
||||
response_data = self._read_request("90")
|
||||
if not response_data:
|
||||
return False
|
||||
|
||||
parts = struct.unpack('>h h h h', response_data)
|
||||
data = {
|
||||
"total_voltage": parts[0] / 10,
|
||||
# "x_voltage": parts[1] / 10, # always 0
|
||||
"current": (parts[2] - 30000) / 10, # negative=charging, positive=discharging
|
||||
"soc_percent": parts[3] / 10
|
||||
}
|
||||
return data
|
||||
|
||||
def get_cell_voltage_range(self, response_data=None):
|
||||
# Cells with the maximum and minimum voltage
|
||||
if not response_data:
|
||||
response_data = self._read_request("91")
|
||||
if not response_data:
|
||||
return False
|
||||
|
||||
parts = struct.unpack('>h b h b 2x', response_data)
|
||||
data = {
|
||||
"highest_voltage": parts[0] / 1000,
|
||||
"highest_cell": parts[1],
|
||||
"lowest_voltage": parts[2] / 1000,
|
||||
"lowest_cell": parts[3],
|
||||
}
|
||||
return data
|
||||
|
||||
def get_temperature_range(self, response_data=None):
|
||||
# Temperature in degrees celsius
|
||||
if not response_data:
|
||||
response_data = self._read_request("92")
|
||||
if not response_data:
|
||||
return False
|
||||
parts = struct.unpack('>b b b b 4x', response_data)
|
||||
data = {
|
||||
"highest_temperature": parts[0] - 40,
|
||||
"highest_sensor": parts[1],
|
||||
"lowest_temperature": parts[2] - 40,
|
||||
"lowest_sensor": parts[3],
|
||||
}
|
||||
return data
|
||||
|
||||
def get_mosfet_status(self, response_data=None):
|
||||
# Charge/discharge, MOS status
|
||||
if not response_data:
|
||||
response_data = self._read_request("93")
|
||||
if not response_data:
|
||||
return False
|
||||
# todo: implement
|
||||
self.logger.debug(response_data.hex())
|
||||
|
||||
parts = struct.unpack('>b ? ? B l', response_data)
|
||||
|
||||
if parts[0] == 0:
|
||||
mode = "stationary"
|
||||
elif parts[0] == 1:
|
||||
mode = "charging"
|
||||
else:
|
||||
mode = "discharging"
|
||||
|
||||
data = {
|
||||
"mode": mode,
|
||||
"charging_mosfet": parts[1],
|
||||
"discharging_mosfet": parts[2],
|
||||
# "bms_cycles": parts[3], unstable result
|
||||
"capacity_ah": parts[4] / 1000,
|
||||
}
|
||||
|
||||
return data
|
||||
|
||||
def get_status(self, response_data=None):
|
||||
if not response_data:
|
||||
response_data = self._read_request("94")
|
||||
if not response_data:
|
||||
return False
|
||||
|
||||
parts = struct.unpack('>b b ? ? b h x', response_data)
|
||||
state_bits = bin(parts[4])[2:]
|
||||
state_names = ["DI1", "DI2", "DI3", "DI4", "DO1", "DO2", "DO3", "DO4"]
|
||||
states = {}
|
||||
state_index = 0
|
||||
for bit in reversed(state_bits):
|
||||
if len(state_bits) == state_index:
|
||||
break
|
||||
states[state_names[state_index]] = bool(int(bit))
|
||||
state_index += 1
|
||||
data = {
|
||||
"cells": parts[0], # number of cells
|
||||
"temperature_sensors": parts[1], # number of sensors
|
||||
"charger_running": parts[2],
|
||||
"load_running": parts[3],
|
||||
# "state_bits": state_bits,
|
||||
"states": states,
|
||||
"cycles": parts[5], # number of charge/discharge cycles
|
||||
}
|
||||
self.status = data
|
||||
return data
|
||||
|
||||
def _calc_num_responses(self, status_field, num_per_frame):
|
||||
if not self.status:
|
||||
self.logger.error("get_status has to be called at least once before calling get_cell_voltages")
|
||||
return False
|
||||
|
||||
# each response message includes 3 cell voltages
|
||||
if self.address == 8:
|
||||
# via Bluetooth the BMS returns all frames, even when they don't have data
|
||||
if status_field == 'cell_voltages':
|
||||
max_responses = 16
|
||||
elif status_field == 'temperatures':
|
||||
max_responses = 3
|
||||
else:
|
||||
self.logger.error("unkonwn status_field %s" % status_field)
|
||||
return False
|
||||
else:
|
||||
# via UART/USB the BMS returns only frames that have data
|
||||
max_responses = math.ceil(self.status[status_field] / num_per_frame)
|
||||
return max_responses
|
||||
|
||||
def _split_frames(self, response_data, status_field, structure):
|
||||
values = {}
|
||||
x = 1
|
||||
for response_bytes in response_data:
|
||||
parts = struct.unpack(structure, response_bytes)
|
||||
if parts[0] != x:
|
||||
self.logger.warning("frame out of order, expected %i, got %i" % (x, response_bytes[0]))
|
||||
continue
|
||||
for value in parts[1:]:
|
||||
values[len(values) + 1] = value
|
||||
if len(values) == self.status[status_field]:
|
||||
return values
|
||||
x += 1
|
||||
|
||||
def get_cell_voltages(self, response_data=None):
|
||||
if not response_data:
|
||||
max_responses = self._calc_num_responses(status_field="cells", num_per_frame=3)
|
||||
if not max_responses:
|
||||
return
|
||||
response_data = self._read_request("95", max_responses=max_responses, return_list=True)
|
||||
if not response_data:
|
||||
return False
|
||||
|
||||
cell_voltages = self._split_frames(response_data=response_data, status_field="cells", structure=">b 3h x")
|
||||
for id in cell_voltages:
|
||||
cell_voltages[id] = cell_voltages[id] / 1000
|
||||
return cell_voltages
|
||||
|
||||
def get_temperatures(self, response_data=None):
|
||||
# Sensor temperatures
|
||||
if not response_data:
|
||||
max_responses = self._calc_num_responses(status_field="temperature_sensors", num_per_frame=7)
|
||||
if not max_responses:
|
||||
return
|
||||
response_data = self._read_request("96", max_responses=max_responses, return_list=True)
|
||||
if not response_data:
|
||||
return False
|
||||
|
||||
temperatures = self._split_frames(response_data=response_data, status_field="temperature_sensors",
|
||||
structure=">b 7b")
|
||||
for id in temperatures:
|
||||
temperatures[id] = temperatures[id] - 40
|
||||
return temperatures
|
||||
|
||||
def get_balancing_status(self, response_data=None):
|
||||
# Cell balancing status
|
||||
if not response_data:
|
||||
response_data = self._read_request("97")
|
||||
if not response_data:
|
||||
return False
|
||||
self.logger.info(response_data.hex())
|
||||
bits = bin(int(response_data.hex(), base=16))[2:].zfill(48)
|
||||
self.logger.info(bits)
|
||||
cells = {}
|
||||
for cell in range(1, self.status["cells"] + 1):
|
||||
cells[cell] = bool(int(bits[cell * -1]))
|
||||
self.logger.info(cells)
|
||||
# todo: get sample data and verify result
|
||||
return {"error": "not implemented"}
|
||||
|
||||
def get_errors(self, response_data=None):
|
||||
# Battery failure status
|
||||
if not response_data:
|
||||
response_data = self._read_request("98")
|
||||
if int.from_bytes(response_data, byteorder='big') == 0:
|
||||
return []
|
||||
|
||||
byte_index = 0
|
||||
errors = []
|
||||
for b in response_data:
|
||||
if b == 0:
|
||||
byte_index += 1
|
||||
continue
|
||||
bits = bin(b)[2:]
|
||||
bit_index = 0
|
||||
for bit in reversed(bits):
|
||||
if bit == "1":
|
||||
errors.append(ERROR_CODES[byte_index][bit_index])
|
||||
|
||||
bit_index += 1
|
||||
|
||||
self.logger.debug("%s %s %s" % (byte_index, b, bits))
|
||||
byte_index += 1
|
||||
return errors
|
||||
|
||||
def get_all(self):
|
||||
return {
|
||||
"soc": self.get_soc(),
|
||||
"cell_voltage_range": self.get_cell_voltage_range(),
|
||||
"temperature_range": self.get_temperature_range(),
|
||||
"mosfet_status": self.get_mosfet_status(),
|
||||
"status": self.get_status(),
|
||||
"cell_voltages": self.get_cell_voltages(),
|
||||
"temperatures": self.get_temperatures(),
|
||||
"balancing_status": self.get_balancing_status(),
|
||||
"errors": self.get_errors()
|
||||
}
|
||||
|
||||
def set_charge_mosfet(self, on=True, response_data=None):
|
||||
if on:
|
||||
extra = "01"
|
||||
else:
|
||||
extra = "00"
|
||||
if not response_data:
|
||||
response_data = self._read_request("da", extra=extra)
|
||||
if not response_data:
|
||||
return False
|
||||
self.logger.info(response_data.hex())
|
||||
# on response
|
||||
# 0101000002006cbe
|
||||
# off response
|
||||
# 0001000002006c44
|
||||
|
||||
def set_discharge_mosfet(self, on=True, response_data=None):
|
||||
if on:
|
||||
extra = "01"
|
||||
else:
|
||||
extra = "00"
|
||||
if not response_data:
|
||||
response_data = self._read_request("d9", extra=extra)
|
||||
if not response_data:
|
||||
return False
|
||||
self.logger.info(response_data.hex())
|
||||
# on response
|
||||
# 0101000002006cbe
|
||||
# off response
|
||||
# 0001000002006c44
|
||||
|
||||
|
||||
# Set SoC. Value is float from 0.0 to 100.0
|
||||
def set_soc(self, value):
|
||||
v = round(value*10.0)
|
||||
if v > 1000 : v = 1000
|
||||
if v < 0 : v = 0
|
||||
extra='000000000000%0.4X' % v
|
||||
response_data = self._read_request("21", extra=extra)
|
||||
self.logger.info(response_data.hex())
|
||||
|
||||
def restart(self, response_data=None):
|
||||
response_data = self._read("00","",1,False)
|
||||
180
python-reference/daly_bms_bluetooth.py
Normal file
180
python-reference/daly_bms_bluetooth.py
Normal file
@@ -0,0 +1,180 @@
|
||||
import asyncio
|
||||
import subprocess
|
||||
import logging
|
||||
from bleak import BleakClient
|
||||
|
||||
from .daly_bms import DalyBMS
|
||||
|
||||
|
||||
class DalyBMSBluetooth(DalyBMS):
|
||||
def __init__(self, request_retries=3, logger=None):
|
||||
"""
|
||||
|
||||
:param request_retries: How often read requests should get repeated in case that they fail (Default: 3).
|
||||
:param logger: Python Logger object for output (Default: None)
|
||||
"""
|
||||
if logger:
|
||||
self.logger = logger
|
||||
else:
|
||||
self.logger = logging.getLogger(__name__)
|
||||
DalyBMS.__init__(self, request_retries=request_retries, address=8, logger=logger)
|
||||
self.client = None
|
||||
self.response_cache = {}
|
||||
|
||||
async def connect(self, mac_address):
|
||||
"""
|
||||
Open the connection to the Bluetooth device.
|
||||
|
||||
:param mac_address: MAC address of the Bluetooth device
|
||||
"""
|
||||
try:
|
||||
"""
|
||||
When an earlier execution of the script crashed, the connection to the devices stays open and future
|
||||
connection attempts would fail with this error:
|
||||
bleak.exc.BleakError: Device with address AA:BB:CC:DD:EE:FF was not found.
|
||||
see https://github.com/hbldh/bleak/issues/367
|
||||
"""
|
||||
open_blue = subprocess.Popen(["bluetoothctl"], shell=True, stdout=subprocess.PIPE,
|
||||
stderr=subprocess.STDOUT, stdin=subprocess.PIPE)
|
||||
open_blue.communicate(b"disconnect %s\n" % mac_address.encode('utf-8'))
|
||||
open_blue.kill()
|
||||
except:
|
||||
pass
|
||||
self.client = BleakClient(mac_address)
|
||||
await self.client.connect()
|
||||
await self.client.start_notify(17, self._notification_callback)
|
||||
await self.client.write_gatt_char(48, bytearray(b""))
|
||||
|
||||
async def disconnect(self):
|
||||
"""
|
||||
Disconnect from the Bluetooth device
|
||||
"""
|
||||
self.logger.info("Bluetooth Disconnecting")
|
||||
await self.client.disconnect()
|
||||
self.logger.info("Bluetooth Disconnected")
|
||||
|
||||
async def _read_request(self, command, max_responses=1):
|
||||
response_data = None
|
||||
x = None
|
||||
for x in range(0, self.request_retries):
|
||||
response_data = await self._read(
|
||||
command=command,
|
||||
max_responses=max_responses)
|
||||
if not response_data:
|
||||
self.logger.debug("%x. try failed, retrying..." % (x + 1))
|
||||
await asyncio.sleep(0.2)
|
||||
else:
|
||||
break
|
||||
if not response_data:
|
||||
self.logger.error('%s failed after %s tries' % (command, x + 1))
|
||||
return False
|
||||
return response_data
|
||||
|
||||
async def _read(self, command, max_responses=1):
|
||||
self.logger.debug("-- %s ------------------------" % command)
|
||||
self.response_cache[command] = {"queue": [],
|
||||
"future": asyncio.Future(),
|
||||
"max_responses": max_responses,
|
||||
"done": False}
|
||||
|
||||
message_bytes = self._format_message(command)
|
||||
result = await self._async_char_write(command, message_bytes)
|
||||
self.logger.debug("got %s" % result)
|
||||
if not result:
|
||||
return False
|
||||
if max_responses == 1:
|
||||
return result[0]
|
||||
else:
|
||||
return result
|
||||
|
||||
def _notification_callback(self, handle, data):
|
||||
self.logger.debug("%s %s %s" % (handle, repr(data), len(data)))
|
||||
responses = []
|
||||
if len(data) == 13:
|
||||
responses.append(data)
|
||||
elif len(data) == 26:
|
||||
responses.append(data[0:13])
|
||||
responses.append(data[13:])
|
||||
else:
|
||||
self.logger.error(len(data), "bytes received, not 13 or 26, not implemented")
|
||||
|
||||
for response_bytes in responses:
|
||||
command = response_bytes[2:3].hex()
|
||||
if self.response_cache[command]["done"] is True:
|
||||
self.logger.debug("skipping response for %s, done" % command)
|
||||
return
|
||||
self.response_cache[command]["queue"].append(response_bytes[4:-1])
|
||||
if len(self.response_cache[command]["queue"]) == self.response_cache[command]["max_responses"]:
|
||||
self.response_cache[command]["done"] = True
|
||||
self.response_cache[command]["future"].set_result(self.response_cache[command]["queue"])
|
||||
|
||||
async def _async_char_write(self, command, value):
|
||||
if not self.client.is_connected:
|
||||
self.logger.info("Connecting...")
|
||||
await self.client.connect()
|
||||
|
||||
await self.client.write_gatt_char(15, value)
|
||||
self.logger.debug("Waiting...")
|
||||
try:
|
||||
result = await asyncio.wait_for(self.response_cache[command]["future"], 5)
|
||||
except asyncio.TimeoutError:
|
||||
self.logger.warning("Timeout while waiting for %s response" % command)
|
||||
return False
|
||||
self.logger.debug("got %s" % result)
|
||||
return result
|
||||
|
||||
# wrap all sync functions so that they can be awaited
|
||||
async def get_soc(self, response_data=None):
|
||||
response_data = await self._read_request("90")
|
||||
return super().get_soc(response_data=response_data)
|
||||
|
||||
async def get_cell_voltage_range(self, response_data=None):
|
||||
response_data = await self._read_request("91")
|
||||
return super().get_cell_voltage_range(response_data=response_data)
|
||||
|
||||
async def get_max_min_temperature(self, response_data=None):
|
||||
response_data = await self._read_request("92")
|
||||
return super().get_max_min_temperature(response_data=response_data)
|
||||
|
||||
async def get_mosfet_status(self, response_data=None):
|
||||
response_data = await self._read_request("93")
|
||||
return super().get_mosfet_status(response_data=response_data)
|
||||
|
||||
async def get_status(self, response_data=None):
|
||||
response_data = await self._read_request("94")
|
||||
return super().get_status(response_data=response_data)
|
||||
|
||||
async def get_cell_voltages(self, response_data=None):
|
||||
if not self.status:
|
||||
await self.get_status()
|
||||
max_responses = self._calc_cell_voltage_responses()
|
||||
if not max_responses:
|
||||
return
|
||||
response_data = await self._read_request("95", max_responses=max_responses)
|
||||
|
||||
return super().get_cell_voltages(response_data=response_data)
|
||||
|
||||
async def get_temperatures(self, response_data=None):
|
||||
response_data = await self._read_request("95")
|
||||
return super().get_temperatures(response_data=response_data)
|
||||
|
||||
async def get_balancing_status(self, response_data=None):
|
||||
response_data = await self._read_request("96")
|
||||
return super().get_balancing_status(response_data=response_data)
|
||||
|
||||
async def get_errors(self, response_data=None):
|
||||
response_data = await self._read_request("97")
|
||||
return super().get_errors(response_data=response_data)
|
||||
|
||||
async def get_all(self):
|
||||
return {
|
||||
"soc": await self.get_soc(),
|
||||
"cell_voltage_range": await self.get_cell_voltage_range(),
|
||||
"temperature_range": await self.get_temperature_range(),
|
||||
"mosfet_status": await self.get_mosfet_status(),
|
||||
"status": await self.get_status(),
|
||||
"cell_voltages": await self.get_cell_voltages(),
|
||||
"temperatures": await self.get_temperatures(),
|
||||
"balancing_status": await self.get_balancing_status(),
|
||||
"errors": await self.get_errors()
|
||||
}
|
||||
241
python-reference/daly_sinowealth.py
Normal file
241
python-reference/daly_sinowealth.py
Normal file
@@ -0,0 +1,241 @@
|
||||
import serial
|
||||
import struct
|
||||
import logging
|
||||
|
||||
"""
|
||||
List from BMStool PC / Sinowealth
|
||||
1 = Cell 1 Voltage
|
||||
...
|
||||
09 = Cell 9 Voltage
|
||||
0A = Cell 10 Voltage
|
||||
0B = Total Voltage
|
||||
0C = External Temperature 1
|
||||
0D = External Temperature 2
|
||||
0E = IC Temperature 1
|
||||
0F = IC Temperature 2
|
||||
10 = CADC Current (4 byte)
|
||||
11 = Full Charge Capacity (4 byte)
|
||||
12 = Remaining Capacity (4 byte)
|
||||
13 = RSOC
|
||||
14 = Cycle Count
|
||||
15 = Pack Status
|
||||
16 = Battery Status
|
||||
17 = Pack Config
|
||||
18 = Manufacture Access
|
||||
"""
|
||||
|
||||
|
||||
class DalyBMSSinowealth:
|
||||
PACK_STATUS = {
|
||||
0: 'CAL: ',
|
||||
5: 'VDQ: Valid Discharge Qualified',
|
||||
6: 'FD: Fully Discharged',
|
||||
7: 'FC: Fully Charged',
|
||||
9: 'FAST_DSG: Fast Discharging',
|
||||
10: 'MID_DSG: Medium Discharging',
|
||||
11: 'SLOW_DSG: Slow Discharging',
|
||||
12: 'DSGING: Discharging',
|
||||
13: 'CHGING: Charging',
|
||||
14: 'DSGMOS: Discharging enabled',
|
||||
15: 'CHGMOS: Charging enabled',
|
||||
}
|
||||
|
||||
BATTERY_STATUS = {
|
||||
1: 'CTO: Disconnection protection occurs',
|
||||
2: 'AFE_SC: Hardware short circuit protection occurs',
|
||||
3: 'AFE_OV: Hardware overvoltage protection occurs',
|
||||
4: 'UTD: Discharge low temperature protection',
|
||||
5: 'UTC: Charge low temperature protection occurs',
|
||||
6: 'OTD: Discharge high temperature protection',
|
||||
7: 'OTC: Charge high temperature protection occurs',
|
||||
12: 'OCD: Discharge overcurrent protection occurs',
|
||||
13: 'OCC: Charge overcurrent protection occurs',
|
||||
14: 'UV: Undervoltage protection occurs',
|
||||
15: 'OV: Overvoltage protection occurs',
|
||||
}
|
||||
|
||||
def __init__(self, request_retries=3, logger=None):
|
||||
"""
|
||||
|
||||
:param request_retries: How often read requests should get repeated in case that they fail (Default: 3).
|
||||
:param logger: Python Logger object for output (Default: None)
|
||||
"""
|
||||
if logger:
|
||||
self.logger = logger
|
||||
else:
|
||||
self.logger = logging.getLogger(__name__)
|
||||
self.request_retries = request_retries
|
||||
|
||||
def connect(self, device):
|
||||
"""
|
||||
Connect to a serial device
|
||||
|
||||
:param device: Serial device, e.g. /dev/ttyUSB0
|
||||
"""
|
||||
self.serial = serial.Serial(
|
||||
port=device,
|
||||
baudrate=9600,
|
||||
bytesize=serial.EIGHTBITS,
|
||||
parity=serial.PARITY_NONE,
|
||||
stopbits=serial.STOPBITS_ONE,
|
||||
timeout=0.5,
|
||||
xonxoff=False,
|
||||
writeTimeout=0.5
|
||||
)
|
||||
|
||||
def disconnect(self):
|
||||
if self.serial and self.serial.is_open:
|
||||
self.serial.close()
|
||||
|
||||
def _format_message(self, command, length):
|
||||
message = "0a%s0%s" % (command.zfill(2), length)
|
||||
message_bytes = bytearray.fromhex(message)
|
||||
self.logger.debug("message: %s, %s" % (message_bytes, message_bytes.hex()))
|
||||
return message_bytes
|
||||
|
||||
def _read(self, command):
|
||||
if not self.serial.is_open:
|
||||
self.serial.open()
|
||||
if command in ("10", "11", "12"):
|
||||
length = 4
|
||||
else:
|
||||
length = 2
|
||||
message_bytes = self._format_message(command, length)
|
||||
|
||||
# clear all buffers, in case something is left from a previous command that failed
|
||||
self.serial.reset_input_buffer()
|
||||
self.serial.reset_output_buffer()
|
||||
|
||||
if not self.serial.write(message_bytes):
|
||||
self.logger.error("serial write failed for command" % command)
|
||||
return False
|
||||
|
||||
response_data = self.serial.read(length + 1)
|
||||
if len(response_data) == 0:
|
||||
self.logger.debug("empty response for command %s" % (command))
|
||||
return False
|
||||
|
||||
self.logger.debug("%s (%i)" % (response_data.hex(), len(response_data)))
|
||||
if command in ("10", "11", "12"):
|
||||
return struct.unpack('>i x', response_data)[0]
|
||||
elif command in ("15", "16", "17", "18"):
|
||||
return bin(int.from_bytes(response_data[:-1], byteorder='big'))[2:].zfill(16)
|
||||
else:
|
||||
return struct.unpack('>h x', response_data)[0]
|
||||
|
||||
def get_cell_voltages(self):
|
||||
max_cells = 10
|
||||
x = 1
|
||||
cell_voltages = {}
|
||||
while x <= max_cells:
|
||||
response_data = self._read("%02x" % x)
|
||||
if not response_data:
|
||||
break
|
||||
if response_data == 0:
|
||||
# last cell
|
||||
break
|
||||
|
||||
cell_voltages[x] = response_data / 1000
|
||||
x += 1
|
||||
|
||||
return cell_voltages
|
||||
|
||||
def _read_bulk(self, requests):
|
||||
data = {}
|
||||
for key, command in requests.items():
|
||||
response_data = self._read(command[0])
|
||||
if response_data is False:
|
||||
continue
|
||||
data[key] = response_data / command[1]
|
||||
|
||||
return data
|
||||
|
||||
def get_soc(self):
|
||||
requests = {
|
||||
"total_voltage": ("b", 1000),
|
||||
"current": ("10", 1000),
|
||||
"soc_percent": ("13", 1)
|
||||
}
|
||||
return self._read_bulk(requests)
|
||||
|
||||
def get_temperatures(self):
|
||||
# The BMS returns temperatures in Kelvin
|
||||
# 2731 / 10 = 273,1 K = 0°C
|
||||
requests = {
|
||||
"external1": ("c", 10),
|
||||
"external2": ("d", 10),
|
||||
# "ic1": ("e", 10),
|
||||
# "ic2": ("f", 100), # always 71
|
||||
}
|
||||
responses = self._read_bulk(requests)
|
||||
|
||||
for key, value in responses.items():
|
||||
# change temperatures from Kelvin to °C
|
||||
responses[key] = round(value - 273, 2)
|
||||
return responses
|
||||
|
||||
def get_status(self):
|
||||
requests = {
|
||||
"cycles": ("14", 1),
|
||||
}
|
||||
responses = self._read_bulk(requests)
|
||||
|
||||
for key, value in responses.items():
|
||||
if type(responses[key]) is float:
|
||||
responses[key] = int(value)
|
||||
return responses
|
||||
|
||||
def get_mosfet_status(self):
|
||||
requests = {
|
||||
"full_capacity_ah": ("11", 1000),
|
||||
"remaining_capacity_ah": ("12", 1000),
|
||||
}
|
||||
responses = self._read_bulk(requests)
|
||||
|
||||
for key, value in responses.items():
|
||||
if type(responses[key]) is float:
|
||||
responses[key] = round(value, 2)
|
||||
|
||||
pack_response = self._read("15")
|
||||
if pack_response is False:
|
||||
return responses
|
||||
|
||||
pack_state = []
|
||||
for key, value in self.PACK_STATUS.items():
|
||||
if pack_response[key] == "1":
|
||||
pack_state.append(value)
|
||||
|
||||
responses['pack_state'] = pack_state
|
||||
return responses
|
||||
|
||||
def get_errors(self):
|
||||
response = self._read("16")
|
||||
pack_state = []
|
||||
for key, value in self.BATTERY_STATUS.items():
|
||||
if response[key] == "1":
|
||||
pack_state.append(value)
|
||||
|
||||
return pack_state
|
||||
|
||||
# dummy functions for everything that is not supported by the Sinowealth BMS
|
||||
def get_cell_voltage_range(self):
|
||||
return {}
|
||||
|
||||
def get_temperature_range(self):
|
||||
return {}
|
||||
|
||||
def get_balancing_status(self):
|
||||
return {}
|
||||
|
||||
def get_all(self):
|
||||
return {
|
||||
"soc": self.get_soc(),
|
||||
# "cell_voltage_range": self.get_cell_voltage_range(),
|
||||
# "temperature_range": self.get_temperature_range(),
|
||||
"mosfet_status": self.get_mosfet_status(),
|
||||
"status": self.get_status(),
|
||||
"cell_voltages": self.get_cell_voltages(),
|
||||
"temperatures": self.get_temperatures(),
|
||||
# "balancing_status": self.get_balancing_status(),
|
||||
"errors": self.get_errors()
|
||||
}
|
||||
67
python-reference/error_codes.py
Normal file
67
python-reference/error_codes.py
Normal file
@@ -0,0 +1,67 @@
|
||||
"""
|
||||
The error messages are taken from the "Part 4_ Daly RS485+UART Protocol.pdf",
|
||||
so the translation quality isn't that great yet.
|
||||
"""
|
||||
|
||||
ERROR_CODES = {
|
||||
0: [
|
||||
"one stage warning of unit over voltage",
|
||||
"one stage warning of unit over voltage",
|
||||
"one stage warning of unit over voltage",
|
||||
"two stage warning of unit over voltage",
|
||||
"Total voltage is too high One alarm",
|
||||
"Total voltage is too high Level two alarm",
|
||||
"Total voltage is too low One alarm",
|
||||
"Total voltage is too low Level two alarm"
|
||||
],
|
||||
1: ["Charging temperature too high. One alarm",
|
||||
"Charging temperature too high. Level two alarm",
|
||||
"Charging temperature too low. One alarm",
|
||||
"Charging temperature's too low. Level two alarm",
|
||||
"Discharge temperature is too high. One alarm",
|
||||
"Discharge temperature is too high. Level two alarm",
|
||||
"Discharge temperature is too low. One alarm",
|
||||
"Discharge temperature is too low. Level two alarm",
|
||||
],
|
||||
2: ["Charge over current. Level one alarm",
|
||||
"Charge over current, level two alarm",
|
||||
"Discharge over current. Level one alarm",
|
||||
"Discharge overcurrent, level two alarm",
|
||||
"SOC is too high an alarm",
|
||||
"SOC is too high. Alarm Two",
|
||||
"SOC is too low. level one alarm",
|
||||
"SOC is too low. level two alarm",
|
||||
],
|
||||
3: ["Excessive differential pressure level one alarm",
|
||||
"Excessive differential pressure level two alarm",
|
||||
"Excessive temperature difference level one alarm",
|
||||
"Excessive temperature difference level two alarm",
|
||||
],
|
||||
4: ["charging MOS overtemperature warning",
|
||||
"discharge MOS overtemperature warning",
|
||||
"charging MOS temperature detection sensor failure",
|
||||
"discharge MOS temperature detection sensor failure",
|
||||
"charging MOS adhesion failure",
|
||||
"discharge MOS adhesion failure",
|
||||
"charging MOS breaker failure",
|
||||
"discharge MOS breaker failure",
|
||||
],
|
||||
5: ["AFE acquisition chip malfunction",
|
||||
"monomer collect drop off",
|
||||
"Single Temperature Sensor Fault",
|
||||
"EEPROM storage failures",
|
||||
"RTC clock malfunction",
|
||||
"Precharge Failure",
|
||||
"vehicle communications malfunction",
|
||||
"intranet communication module malfunction",
|
||||
],
|
||||
6: ["Current Module Failure",
|
||||
"main pressure detection module",
|
||||
"Short circuit protection failure",
|
||||
"Low Voltage No Charging",
|
||||
"RESERVED",
|
||||
"RESERVED",
|
||||
"RESERVED",
|
||||
"RESERVED",
|
||||
],
|
||||
}
|
||||
Reference in New Issue
Block a user