question

Oops, replied above.

Yep that was it. Now it's plotting!

@madsci1016

Hey if it works use it. There are only a few things I would tidy up, mainly because I am used to writing for real time programming and try not to cause too much code to be required, loaded or executed if it can be helped. But all of these are stylistic, I would say you have the hang of python and go with what you know. Also you have taught me a thing or two about defining and re-using classes properly.

Having said that

The loading of all of dbusmonitor seems a bit heavyweight unless you are going to use more of it's facilities later, i'm not sure what it is doing for you.

You could use something like:

service = 'com.victronenergy.system'
path = '/'
systemObject = VeDbusItemImport(dbusConn, service, path)
Then when you need it :
values = systemObject._refreshcachedvalue()
values = systemObject.get_value()
soc = values['/Dc/Battery/Soc']

NB if you are only going to use parts of the data from the system service you can set the path to only load part of the data. So.....

path = '/Dc/Battery'
systemObject = VeDbusItemImport(dbusConn, service, path)

Then when you need it
values = systemObject._refreshcachedvalue()
values = systemObject.get_value
soc = values['/Soc']

If you are going to have objects open on multiple services stick them in a data structure.

Then I would look at ways of only updating the bits that have changed in _updatedbus and flattening the if, elif structure of _parse_can_data

So as functions are objects and can be stored in data structures _parse_can_data could rely on a data structure of a dictionary of the can arbitration ids with lambda functions to call for each one.

So if 'canFunctions' is the data structure of ids and functions

then _parse_can_data becomes something like

if msg is not None:
     dummy = canFunctions['msg.arbitration_id'](msg.data)

Each function is customised to do the necessary data transform and write to the dbus so the first one might look like.

lamda(data):
    self._dbusservice["/Ac/ActiveIn/L1/P"] = (getSignedNumber(data[0] + data[1]*256, 16)*100)
    self._dbusservice["/Ac/ActiveIn/L2/P"] = (getSignedNumber(data[2] + data[3]*256, 16)*100)

I have not tested that code but it give an idea of how much the code could be shortened (both in number of lines and how much gets executed each time.)

ditto _handlecantx

You have 6 separate message which are re-defined (mostly unchanged) every 2 seconds.

Then execute the same code repeated inline 6 times.

So you could put the messages into a data structure (defined only once at start up). Update the SOC value in the data structure when it changes, and then loop through the structure sending each message in turn with the same three lines of code, which are not duplicated inline in your programme. In fact is it necessary to send all 6 or could you just send the changed SOC ?