def get_data():
chainsaw = INA219(SHUNT_OHMS, busnum=5, address=0x40)
trimmer = INA219(SHUNT_OHMS, busnum=5, address=0x41)
for device in [chainsaw, trimmer]:
device.configure()
try:
data = np.array([[
chainsaw.voltage() * 10,
chainsaw.current(),
chainsaw.power(),
chainsaw.shunt_voltage(),
get_rpm(chainsaw.voltage(), chainsaw.current(), 0.8)
],
[
trimmer.voltage() * 10,
trimmer.current(),
trimmer.power(),
trimmer.shunt_voltage(),
get_rpm(trimmer.voltage(), trimmer.current(),
0.55)
]])
#print data
except DeviceRangeError as e:
print e
return data
def average():
ina1 = INA219(SHUNT_OHMS, MAX_EXPECTED_AMPS, address=0x40)
ina1.configure(ina1.RANGE_16V, ina1.GAIN_AUTO)
ina2 = INA219(SHUNT_OHMS, MAX_EXPECTED_AMPS, address=0x45)
ina2.configure(ina2.RANGE_16V, ina2.GAIN_AUTO)
averageCurrent = 0
averageTension = 0
averagePower = 0
begin = time.time()
for i in range(0, 90):
averageCurrent += ina1.current()
averageTension += ina2.voltage()
averagePower += ina1.power()
averageCurrent = averageCurrent / 90
averageTension = averageTension / 90
averagePower = averagePower / 90
end = time.time()
print("")
print("Average Current ======= ")
print(str(averageCurrent) + "mA")
print("Average Tension ======= ")
print(str(averageTension) + "V")
print("Average Power ======= ")
print(str(averagePower) + "mW")
print("")
print("Time used =======")
print(end - begin)
return 3
def create_ina():
ina0 = INA219(SHUNT_OHMS, address=0x40)
ina0.configure(ina0.RANGE_16V)
ina1 = INA219(SHUNT_OHMS, address=0x41)
ina1.configure(ina1.RANGE_16V)
return [ina0, ina1]
def __init__(self, readFrequencyPerMesureTime, mesureTime):
self.numberOfRead = readFrequencyPerMesureTime
self.interval = mesureTime / readFrequencyPerMesureTime
self.mesureTime = mesureTime
self.inaMain = INA219(self.SHUNT_OHMS,
self.MAX_EXPECTED_AMPS_MAIN,
address=0x40)
self.inaM1 = INA219(self.SHUNT_OHMS,
self.MAX_EXPECTED_AMPS_MOTOR,
address=0x41)
self.inaM2 = INA219(self.SHUNT_OHMS,
self.MAX_EXPECTED_AMPS_MOTOR,
address=0x42)
self.inaM3 = INA219(self.SHUNT_OHMS,
self.MAX_EXPECTED_AMPS_MOTOR,
address=0x43)
self.inaM4 = INA219(self.SHUNT_OHMS,
self.MAX_EXPECTED_AMPS_MOTOR,
address=0x44)
self.inaMain.configure(self.inaMain.RANGE_16V, self.inaMain.GAIN_AUTO)
self.inaM1.configure(self.inaM1.RANGE_16V, self.inaM1.GAIN_AUTO)
self.inaM2.configure(self.inaM2.RANGE_16V, self.inaM2.GAIN_AUTO)
self.inaM3.configure(self.inaM3.RANGE_16V, self.inaM3.GAIN_AUTO)
self.inaM4.configure(self.inaM4.RANGE_16V, self.inaM4.GAIN_AUTO)
self.index = 0
self.powerMain = 0
self.voltageMain = 0
self.currentMain = 0
self.powerM1 = 0
self.powerM2 = 0
self.powerM3 = 0
self.powerM4 = 0
self.powerCalculatorMain = 0
self.voltageCalculatorMain = 0
self.currentCalculatorMain = 0
self.currentCalculatorM1 = 0
self.currentCalculatorM2 = 0
self.currentCalculatorM3 = 0
self.currentCalculatorM4 = 0
#Calcul de la charge restante. (Ah)
self.startCharge = self.estimateChargeRemaining(
self.mesureInitVoltage())
self.secondElapsed = 0
self.remainingTime = 0
self.totalCurrentUsed = 0
self.m1Voltage = 0
self.m2Voltage = 0
self.m3Voltage = 0
self.m4Voltage = 0
def __init__(self, thread_id, name, event, consumer_id, consLock):
threading.Thread.__init__(self)
self.thread_id = thread_id
self.name = name
self.event = event
self.consumer_id = consumer_id
self.cLock = consLock
self.local_energy_consumed = 0.0
self.mmaPowerSum = 0.0
self.mmaPower = 0.0
if (consumer_id == 1):
self.led = LED(16)
else:
self.led = LED(26)
self.ina = INA219(SHUNT_OHMS, MAX_EXPECTED_AMPS, address=INA_ADDRESS)
self.ina.configure(voltage_range=self.ina.RANGE_32V,
gain=self.ina.GAIN_AUTO,
bus_adc=self.ina.ADC_128SAMP,
shunt_adc=self.ina.ADC_128SAMP)
self.contract_instance = None
self.setup_web3()
def __init__(self):
# Initialise
# Set these to smooth out readings due to current spikes
# Note readings will vary based on instantaneous load
self.coefficients = (0.05, 0.15, 0.3, 0.5)
# During start-up, exit immediately if first reading below BATTERY_VMIN
# During operation, exit if average readings below BATTERY_VMIN
self.shutdown = False
# Set measurement config, ina class will optimise readings for resolution
# Added busnum to ensure correct I2C bus used
self.ina = INA219(SHUNT_OHMS, MAX_EXPECTED_AMPS, busnum=1)
self.ina.configure(self.ina.RANGE_16V)
# Initialise readings
self.voltage = self.ina.voltage()
self.current = 0
self.battery_charge = 100
# [FULL, CHARGING, DISCHARGING, FAULT]
self.battery_status = "FULL"
# Initialise history of 4 readings, last element is most recent
self.history = [self.voltage, self.voltage, self.voltage, self.voltage]
# Get actual readings
self.get_battery()
# Shutdown immediately if below VMIN without charger attached
if self.voltage < BATTERY_VMIN and battery.battery_status != "CHARGING":
self.shutdown = True
def read(self, device):
address = device[0]
monitoredDevice = device[1]
print "**********%s*********" % monitoredDevice
print "Device Addres: %x" % address
ina = INA219(SHUNT_OHMS, MAX_EXPECTED_AMPS, address)
ina.configure()
print "Bus Voltage: %.3f V" % ina.voltage()
try:
current = ina.current()
print "Bus Current: %.3f mA" % current
print "Power: %.3f mW" % ina.power()
if current < 0:
print "State: Charging\n"
elif current > 0:
if address == 0x44:
print "Power Supplied to GBC via PoE"
elif address == 0x45:
print "Power delivered to Load via PoE"
else:
print "State: Discharging\n"
except DeviceRangeError as e:
# Current out of device range with specified shunt resister
print e
def read():
SHUNT_OHMS = 0.1
ina = INA219(SHUNT_OHMS)
ina.configure()
power_info = {}
try:
power_info["ts"] = dt.now()
power_info["bus_voltage"] = ina.voltage()
power_info["bus_current"] = ina.current()
power_info["sys_power"] = ina.power()
print "Info for %s" % power_info["ts"].strftime("%Y-%m-%d %H:%M:%S")
print "Bus Voltage: %.3f V" % power_info["bus_voltage"]
print "Bus Current: %.3f mA" % power_info["bus_current"]
print "Power: %.3f mW" % power_info["sys_power"]
return power_info
except DeviceRangeError as e:
# Current out of device range with specified shunt resister
print e
return None
def read(i2c_adress):
"""
:param i2c_adress: i2c adress for ina219
:return:
volt in V
amp in A
watt in W
"""
ina = INA219(SHUNT_OHMS, MAX_EXPECTED_AMPS, address=i2c_adress)
ina.configure(ina.RANGE_16V)
ina.wake() # awake ina219
volt = 0
amp = 0
watt = 0
print("Bus Voltage: %.3f V" % ina.voltage())
try:
volt = ina.voltage()
amp = ina.current()
watt = ina.power()
except DeviceRangeError as e:
# Current out of device range with specified shunt resistor
print(e)
ina.sleep() # enter in low power mode
return volt, amp / 1000, watt / 1000
def __init__(self, threadID, name, threadLock, event):
threading.Thread.__init__(self)
self.threadID = threadID
self.name = name
self.tLock = threadLock
self.event = event
self.data = {
"voltage": 0.0,
"current": 0.0,
"power": 0.0,
"time": time.time()
}
self.local_energy_stored = 0.0
self.mmaCurrentSum = 0.0
self.mmaCurrent = 0.0
self.mmaVoltageSum = 0.0
self.mmaVoltage = 0.0
self.mmaPowerSum = 0.0
self.mmaPower = 0.0
self.ina = INA219(SHUNT_OHMS, MAX_EXPECTED_AMPS, address=INA_ADDRESS)
self.ina.configure(voltage_range=self.ina.RANGE_32V,
gain=self.ina.GAIN_AUTO,
bus_adc=self.ina.ADC_128SAMP,
shunt_adc=self.ina.ADC_128SAMP)
self.contract_instance = None
self.setup_web3()
def setup_ina219(self, adress):
try:
ina = INA219(self.SHUNT_OHMS, address=adress)
ina.configure()
except Exception:
ina = None
return ina
def read():
"""
INA219(shunt_ohms, max_expected_amps=None,
busnum=None, address=__ADDRESS,
log_level=logging.ERROR)
"""
ina = INA219(SHUNT_OHMS, busnum=1, address=0x41)
ina.configure()
try:
while True:
try:
V_BUS = ina.voltage()
I_BUS = ina.current()
P_BUS = ina.power()
V_SHUNT = ina.shunt_voltage()
print(
'Voltage: {:.3f} V | Current: {:.3f} mA | Power: {:.3f} mW | V Shunt: {:.3f} mV'
.format(V_BUS, I_BUS, P_BUS, V_SHUNT))
except DeviceRangeError as e:
# Current out of device range with specified shunt resistor
print(e)
time.sleep(1)
except KeyboardInterrupt:
print("\nBye!")
def _read_battery_power():
global _import_ina_failed
if not _import_ina_failed:
for addr in P.power_monitor_ina_addr:
try:
ina = INA219(shunt_ohms=0.1, address=addr[1])
ina.configure(voltage_range=ina.RANGE_16V, gain=ina.GAIN_AUTO, bus_adc=ina.ADC_4SAMP) #, bus_adc=ina.ADC_4SAMP, shunt_adc=ina.ADC_4SAMP)
voltage = ina.voltage()
current = round(ina.current(), 0)
power = round(ina.power(), 0)
dispatcher.send(signal=Constant.SIGNAL_BATTERY_STAT, battery_name=addr[0],
voltage=voltage, current=current, power=power)
power_rec = m.PowerMonitor.find_one({m.PowerMonitor.name: addr[0]})
if power_rec is not None:
power_rec.raw_voltage = voltage
total_subtracted_voltage = _get_total_subtracted_voltage(power_rec.subtracted_sensor_id_list)
if power_rec.voltage_divider_ratio is not None:
power_rec.voltage = (voltage / power_rec.voltage_divider_ratio) - total_subtracted_voltage
else:
power_rec.voltage = voltage - total_subtracted_voltage
power_rec.current = current
power_rec.power = power
power_rec.save_changed_fields(broadcast=True, persist=True)
except ImportError as imp:
L.l.info("INA module not available on this system, ex={}".format(imp))
_import_ina_failed = True
except DeviceRangeError as ex:
L.l.error("Current out of device range with specified shunt resister, ex={}".format(ex))
except Exception as ex:
L.l.error("INA board not initialised, ex={}".format(ex), exc_info=True)
_import_ina_failed = True
def setup_ina219():
try:
ina = INA219(SHUNT_OHMS)
ina.configure()
except Exception:
ina = None
return ina
def setup_device(self):
"""
:return:
"""
self._panel_addr = INA219(
self._sensor_info['shunt_ohms'],
self._sensor_info['max_expected_amps'],
address=self._sensor_info['addr']
)
# TODO: hardcoded: this should be ok, i guess?
self._panel_addr.configure(
voltage_range=self._panel_addr.RANGE_16V,
gain=self._panel_addr.GAIN_AUTO,
bus_adc=self._panel_addr.ADC_128SAMP,
shunt_adc=self._panel_addr.ADC_128SAMP
)
self.current_state = {
'voltage': self._panel_addr.voltage(),
'current': self._panel_addr.current()
}
return {
'sensor_name': self.sensor_name,
'sensor_type': self.sensor_type,
'sensor_id': self.sensor_id,
'current_state': self.current_state
}
def read():
db = MySQLdb.connect("localhost", "ina_user", "Your_password", "ina_data")
cursor = db.cursor()
ina = INA219(SHUNT_OHMS, MAX_EXPECTED_AMPS)
ina.configure(ina.RANGE_16V, ina.GAIN_1_40MV)
#print "Bus Voltage: %.3f V" % ina.voltage()
#try:
#print "Bus Current: %.3f mA" % ina.current()
#print "Power: %.3f mW" % ina.power()
#print "Shunt voltage: %.3f mV" % ina.shunt_voltage()
#except DeviceRangeError as e:
#print "Current overflow"
millisec = int(round(time.time() * 1000))
sql = "INSERT INTO ina_values(bus_voltage, load_voltage, current, millisec) VALUES('" + str(ina.voltage()) +"', '" + str(ina.shunt_voltage()) + "', '" + str(ina.current()) + "', '" + str(millisec) + "');"
#print(sql)
try:
cursor.execute(sql)
db.commit()
except:
db.rollback()
db.close
def init_i2c():
global Oled
global Ina
global Io
global Firmware_found
global Tim
#reset_board()
#boot_loader=I2c.is_ready(0x22)
devs = I2c.scan()
if 0x3C in devs:
print("Oled screen detected")
Oled = ssd1306.SSD1306_I2C(128, 64, I2c)
Oled.poweron()
Oled.fill(0)
Oled.contrast(255)
inf("Init!", 1000)
Oled.show()
if 0x40 in devs:
print("INA219 detected")
Ina = INA219(0.1, I2c, max_expected_amps=2.5)
Ina.configure(voltage_range=INA219.RANGE_16V)
if 0x20 in devs:
print("PCF8574 io expander detected ", end='')
Io = PCF8574(I2c)
time.sleep_ms(500)
print("IO:{:02X}h".format(Io.port))
set_current(0)
Tmc = 0
if 0x22 in devs:
print("Bootloader found")
if 0x33 in devs:
print("Vpi Board found")
Firmware_found = True
return (Ina is not None) and (Io is not None)
def measure():
global SERIES
oled.text("Measuring P\nVary RL\nPress A to exit")
if mp:
mp.new_series(SERIES, 'Resistance [Ohm]', 'Current [mA]',
'Voltage [V*100]', 'Power [mW]')
SHUNT_OHMS = 1
ina = INA219(SHUNT_OHMS, i2c)
ina.configure()
# any button press returns to menu
last_i = 0
while True:
if butA.pressed() or butB.pressed() or butC.pressed(): return
v = ina.voltage() # [V]
i = ina.current() # [mA]
# avoid division by zero and report only changes
r = -1 if i < 0.1 else 1000 * v / i
p = v * i
if r > 0 and mp:
mp.data(SERIES, r, i, 100 * v, p)
oled.text("R={:5.0f} Ohm\nP={:5.0f} mW\n{:5.1f}V {:5.1f}mA".format(
r, p, v, i))
print("R={:5.0f} Ohm, P={:5.0f} mW, V={:5.1f}V, I={:5.1f}mA".format(
r, p, v, i))
last_i = i
# limit the measurement rate
time.sleep(0.2)
def read(*addrs):
inas = [
(INA219(SHUNT_OHMS, address=addr), addr)
for addr in addrs
]
for ina, _ in inas:
ina.configure()
for ina, addr in inas:
voltage = ina.voltage()
current = ina.current()
power = ina.power()
data = dict(
voltage=voltage,
current=current,
power=power,
shunt_voltage=ina.shunt_voltage(),
t=time.time(),
addr=hex(addr),
)
VOLTAGE.labels(address=hex(addr)).set(voltage)
POWER.labels(address=hex(addr)).set(power)
CURRENT.labels(address=hex(addr)).set(current)
print(json.dumps(data))
def _read_battery_power():
global _import_ina_failed
if not _import_ina_failed:
for addr in P.power_monitor_ina_addr:
try:
ina = INA219(shunt_ohms=0.1, address=addr[1])
ina.configure(
voltage_range=ina.RANGE_16V, gain=ina.GAIN_AUTO
) #, bus_adc=ina.ADC_4SAMP, shunt_adc=ina.ADC_4SAMP)
voltage = ina.voltage()
current = round(ina.current(), 0)
power = round(ina.power(), 0)
dispatcher.send(signal=Constant.SIGNAL_BATTERY_STAT,
battery_name=addr[0],
voltage=voltage,
current=current,
power=power)
except ImportError as imp:
L.l.info(
"INA module not available on this system, ex={}".format(
imp))
_import_ina_failed = True
except DeviceRangeError as ex:
L.l.error(
"Current out of device range with specified shunt resister, ex={}"
.format(ex))
except Exception as ex:
L.l.info(
"INA board not available on this system, ex={}".format(ex))
_import_ina_failed = True
def read():
ina = INA219(SHUNT_OHMS, MAX_EXPECTED_AMPS)
ina.configure(ina.RANGE_16V)
keepPrinting = True
oneLineOutput = "Bus {busVolts:5.2f} V, {busCurrent:6.2f} mA. Power {Power:6.2f} mW. Shunt {ShuntVolts:7.0f} mV"
while keepPrinting :
try:
print ( oneLineOutput.format \
(busVolts = ina.voltage(), \
busCurrent = ina.current(), \
Power = ina.power(), \
ShuntVolts = ina.shunt_voltage() \
), \
end='\r' )
except DeviceRangeError as e:
# Current out of device range with specified shunt resistor
print (e)
except KeyboardInterrupt:
print ()
print ("Quitting")
keepPrinting = False
print()
def UpsPresent():
# check if i2c bus is usable. check if we can read UPS registers.
# initialize i2c bus and both INA sensors
# returns False if we get an exception in any of these operations
global i2c_bus
global inaRPi
global inaBattery
# init i2c protocol
fUpsPresent = True
try:
i2c_bus = smbus2.SMBus(DEVICE_BUS)
except Exception as e:
errMsg = 'i2c bus for communication with UPS could not be initialized. Error message: ' + str(
e)
syslog.syslog(errMsg)
print(errMsg)
return False
# check UPS replies on i2c bus
try:
void = i2c_bus.read_byte_data(DEVICE_ADDR, 0x12)
except OSError as e:
errMsg = 'No reply from UPS on i2c bus. Error message: ' + str(e)
syslog.syslog(errMsg)
print(errMsg)
return False
# Raspberry Pi output current and voltage
try:
inaRPi = INA219(0.00725, address=0x40)
inaRPi.configure()
except Exception as exc:
errMsg = 'Cannot initialize communication with INA219 (output). Error message: ' + str(
exc)
syslog.syslog(errMsg)
print(errMsg)
return False
# Battery current and voltage
try:
inaBattery = INA219(0.005, address=0x45)
inaBattery.configure()
except Exception as exc:
errMsg = 'Cannot initialize communication with INA219 (battery). Error message: ' + str(
exc)
syslog.syslog(errMsg)
print(errMsg)
return False
return True
def sensor():
global heading_angle
global rudder
global sail
Shunt_OHMS = 0.1 # For this sensor it is 0.1 ohm
try:
print('Starting Current Sensor')
print('Collecting Sensor Values...')
start = time.time() # Start Time
#global DataPoints
DataPoints = deque(maxlen=None) # Creating Array of datatype Deque to store values
a = 0.9664 # Regression Fitting Parameter
b = 0.0285 # Regression Fitting Parameter
ina = INA219(Shunt_OHMS) # Auto Gain
ina.configure()
print('Current Sensor Configured Successfully')
sensor_times=0
while True:
sensor_times=(sensor_times+1)%15
frequency=gl.get_value('frequency')
if gl.get_value('flag'):
break
try:
ruddervalue= float('{0:.2f}'.format(gl.get_value('rudder')))
sailvalue= float('{0:.2f}'.format(gl.get_value('sail')))
currentvalue = round((a*ina.current())+b) # Rounding off values to nearest integer
voltagevalue = float('{0:.1f}'.format(ina.voltage())) # Floating point up to one decimal point
powervalue = round(currentvalue*voltagevalue)
timevalue = float('{0:.1f}'.format(time.time()-start)) # Elapsed time in Seconds with 1 decimal point floating number
headingvalue = float('{0:.2f}'.format(gl.get_value('heading_angle')))
DataPoints.append([timevalue, ruddervalue, sailvalue, gl.get_value('x'),gl.get_value('y'),gl.get_value('desired_angle'), headingvalue,currentvalue, voltagevalue, powervalue,gl.get_value('v'),gl.get_value('u'),gl.get_value('w'),gl.get_value('keeping_state'),gl.get_value('tacking_state')]) # Updating DataPoints Array
if sensor_times==0:
print('current:',currentvalue,'voltage',voltagevalue)
except DeviceRangeError:
print('Device Range Error')
time.sleep(1/frequency) # Reading value after 0.5 second
except:
print('Exception Occurred, Current Sensor Stopped \n')
# Wt = input('Do you want to store the sensor values Y/N? ')
# if Wt == 'Y':
writing(DataPoints)
# else:
# print('Ending without saving sensor data \n')
print('Sensor Stopped!\n')
def run(self):
ina = INA219()
failure = False
lastNotify = datetime.datetime.now() - datetime.timedelta(days=1)
eventTimestamp = None
logger = logging.getLogger('powerpi')
handler = logging.FileHandler('/srv/powerpi/powerpi.log')
formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)
logger.setLevel(logging.DEBUG)
while True:
load = ina.getCurrent_mA()
if load < 10:
logger.debug(str(load))
if not failure:
logger.error('power outage has occurred')
failure = True
eventTimestamp = datetime.datetime.now()
if (datetime.datetime.now() -
lastNotify).total_seconds() > self.kFrequency:
notifyThread1 = threading.Thread(target=self.notifyEmail,
args=('lost',
eventTimestamp))
notifyThread1.start()
notifyThread2 = threading.Thread(target=self.notifySms,
args=('lost',
eventTimestamp))
notifyThread2.start()
lastNotify = datetime.datetime.now()
elif failure:
logger.info('power has been restored')
notifyThread1 = threading.Thread(target=self.notifyEmail,
args=('restored',
eventTimestamp))
notifyThread1.start()
notifyThread2 = threading.Thread(target=self.notifySms,
args=('restored',
eventTimestamp))
notifyThread2.start()
failure = False
eventTimestamp = None
lastNotify = datetime.datetime.now() - datetime.timedelta(
days=1)
time.sleep(1)
def test_default(self, device):
device.return_value = Mock()
self.ina = INA219(0.1)
self.assertEqual(self.ina._shunt_ohms, 0.1)
self.assertIsNone(self.ina._max_expected_amps)
self.assertIsNone(self.ina._gain)
self.assertFalse(self.ina._auto_gain_enabled)
self.assertAlmostEqual(self.ina._min_device_current_lsb, 6.25e-6, 2)
def test_default(self):
self.ina = INA219(0.1, I2C(2))
self.assertEqual(self.ina._shunt_ohms, 0.1)
self.assertIsNotNone(self.ina._i2c)
self.assertIsNone(self.ina._max_expected_amps)
self.assertIsNone(self.ina._gain)
self.assertFalse(self.ina._auto_gain_enabled)
self.assertAlmostEqual(self.ina._min_device_current_lsb, 6.25e-6, 2)
def __init__(
self,
address,
shunt_ohms=SHUNT_OHMS,
max_expected_amps=MAX_EXPECTED_AMPS,
):
self.ina = INA219(shunt_ohms, max_expected_amps, address=address)
self.ina.configure(self.ina.RANGE_16V)
def __init__(self, bat_addr=0x40, sol_addr=0x41, bmu_addr=0x44):
SHUNT_OHMS = 0.1
MAX_AMP = 2.0
self.temperature = 20
self.speedSound = 17150
self.__bat_addr = bat_addr
self.__sol_addr = sol_addr
self.__bmu_addr = bmu_addr
self.__SANE_MAX_VOLT = 20.00
self.__SANE_MIN_VOLT = 10.00
self.__SANE_MAX_CURRENT = 1000.00
self.__SANE_MIN_CURRENT = -2000.00
self.READINGS = 5
self.__water = serial.Serial('/dev/ttyS0', 115200)
self.__bat = INA219(SHUNT_OHMS, MAX_AMP, address=bat_addr)
self.__solar = INA219(SHUNT_OHMS, MAX_AMP, address=sol_addr)
self.__bmu = INA219(SHUNT_OHMS, MAX_AMP, address=bmu_addr)
def read():
ina = INA219(SHUNT_OHMS)
ina.configure(ina.RANGE_16V, ina.GAIN_AUTO)
values = []
for i in range(1, 16):
values.append(int(ina.voltage() * 100))
ina.sleep()
return float(sum(values)) / max(len(values), 1)
exit()
def __init__(self, address=ADDRESS, shunt_ohms=SHUNT_OHMS,
max_expected_amps=MAX_EXPECTED_AMPS, filename=None):
self.ina = INA219(shunt_ohms, max_expected_amps, address=address)
self.ina.configure(self.ina.RANGE_16V)
self.filename = filename
self.f = None
self.loop_thread = None
self.interval = 0.0 # ms
self.callback = None
