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