def __init__(self): self.log = logging.getLogger("fanfare") self.log.setLevel(logging.INFO) formatter = logging.Formatter(fmt='[%(name)s] %(message)s') handler = logging.handlers.SysLogHandler( facility=logging.handlers.SysLogHandler.LOG_DAEMON, address="/dev/log") handler.setFormatter(formatter) handler.setLevel(logging.INFO) self.log.addHandler(handler) self.temp_treshold = 75 self.poll_time = 30 self.fan_control_device = '/proc/acpi/ibm/fan' if os.getuid() != 0: self.log.error( 'This program must run as root, as it needs access ' 'to the fan control device %s. Exiting...', self.fan_control_device) sys.exit(2) self.target_label = 'Physical id 0' self.full_speed_on = False self.log.info("Starting fanfare daemon") sensors.init()
def _get_detected_chips(): # pragma: no cover sensors.cleanup() sensors.init() chips_detected = list(sensors.iter_detected_chips()) return chips_detected
def enable(self): try: sensors.init() super(Plugin, self).enable() except Exception: log.warning("Plex server not available.") return self.disable()
def get_lmsensor(self): """ """ if self._lmsensor_next_run < datetime.now(): locked = self._lock.acquire(False) if locked == True: try: _lmsensor = {} pysensors.init(config_filename=self.values["config_filename"].data) try: for chip in pysensors.iter_detected_chips(): _lmsensor['%s'%chip] = {} for feature in chip: _lmsensor['%s'%chip][feature.label] = feature.get_value() except Exception: logger.exception("[%s] - Exception in get_lmsensor", self.__class__.__name__) finally: pysensors.cleanup() for val_id in ['temperature', 'voltage']: for config in self.values[val_id].get_index_configs(): for chip in _lmsensor: if config in _lmsensor[chip] : self.values[val_id].set_data_index(config=config, data=_lmsensor[chip][config]) self._lmsensor_last = True except Exception: logger.exception("[%s] - Exception in get_lmsensor", self.__class__.__name__) self._lmsensor_last = False finally: self._lock.release() min_poll=99999 for val_id in ['temperature_poll', 'voltage_poll']: if self.values[val_id].data > 0: min_poll=min(min_poll, self.values[val_id].data) self._lmsensor_next_run = datetime.now() + timedelta(seconds=min_poll)
def __init__(self): self.netCounters = psutil.net_io_counters(pernic=True) sensors.init() while True: self.updateInfoPerSecond() self.updateInfoPerMinute() self.display()
def __init__(self, serial_instance, eol='crlf'): self.serial = serial_instance self.eol = eol self.alive = None self._reader_alive = None self.receiver_thread = None sensors.init()
def main(): node = Node('temperaturemonitor.py') parser = argparse.ArgumentParser( description="Get temperature of CPU cores.") parser.add_argument( "--interval", type=int, default=2, help='Sets time interval between each update on CPU temperature') parser.add_argument("--source", choices=["pysensors", "sysfs"], default="sysfs") args = parser.parse_args() if args.source == "sysfs": while True: with open('/sys/class/thermal/thermal_zone0/temp') as temp_file: temp = int(temp_file.read().strip()) / 1000.0 node.send(messaging.CPUTemperatureMessage(temp, -1)) time.sleep(args.interval) else: import sensors sensors.init() while True: for chip in sensors.iter_detected_chips(): ##print '%s at %s:' % (chip, chip.adapter_name) temperatures = [] for feature in chip: temperatures.append(feature.get_value()) node.send( messaging.CPUTemperatureMessage(temperatures[0], temperatures[1])) time.sleep(args.interval) node.stop() sensors.cleanup()
def get_sensors(self): """ collects the current temperature of CPU and each core """ sensors.init() added = [] cpu_temp_c = [] try: for chip in sensors.iter_detected_chips(): for feature in chip: if feature.name.startswith('temp'): if ((feature.label.startswith('Physical') or feature.label.startswith('CPU')) and feature.label not in added): self._status.add_cpu_temp(feature.get_value()) elif (feature.label.startswith('Core') and feature.label not in added): cpu_temp_c.append(feature.get_value()) added.append(feature.label) except sensors.SensorsError: pass if cpu_temp_c: try: self._status.add_cpu_temp_core(cpu_temp_c) except IndexError: pass sensors.cleanup()
def parse_sensors(cmd): if cmd[1] == "init": sensors.init() elif cmd[1] == "loop": set_loop_cb("sensors", sensors.loop, int(cmd[2])) else: print("[CLI]: \"%s\" not implemented" % (" ".join(cmd)))
def enable(self): try: sensors.init() super(Plugin, self).enable() except Exception: log.warning('Plex server not available.') return self.disable()
def __init__(self): self.log = logging.getLogger("fanfare") self.log.setLevel(logging.INFO) formatter = logging.Formatter(fmt='[%(name)s] %(message)s') handler = logging.handlers.SysLogHandler( facility=logging.handlers.SysLogHandler.LOG_DAEMON, address="/dev/log") handler.setFormatter(formatter) handler.setLevel(logging.INFO) self.log.addHandler(handler) self.temp_treshold = 75 self.poll_time = 30 self.fan_control_device = '/proc/acpi/ibm/fan' if os.getuid() != 0: self.log.error('This program must run as root, as it needs access ' 'to the fan control device %s. Exiting...', self.fan_control_device) sys.exit(2) self.target_label = 'Physical id 0' self.full_speed_on = False self.log.info("Starting fanfare daemon") sensors.init()
def check(self, instance): ## Capture CPU temperature stats dimensions = self._set_dimensions(None, instance) sensors.init() stats ={} try: for chip in sensors.iter_detected_chips(): # Only temps from ISA adpters that are deteced by lm_sensors if (chip.adapter_name == "ISA adapter"): for feature in chip: if "Core" in feature.label: name = feature.label.replace(" ", "_") name = name.lower() stats["cpu."+str(chip)+"."+str(name)+"_temperature"] = feature.get_value() elif "Physical id" in feature.label: name = feature.label.replace(" ", "_") name = name.lower() stats["cpu."+str(chip)+".max_temperature"] = feature.get_value() finally: sensors.cleanup() for key, value in stats.iteritems(): # Writes data to monasca that will go to InfluxDB self.gauge(key, value, dimensions) log.debug('Collected {0} cpu temp metrics'.format(len(stats))) 1,1 Top
def __init__(self): """Initialize""" print("Initialize") if os.name == "posix": sensors.init() self.ser = serial.Serial() self.ser.baudrate = 9600 self.ser.port = PORT try: self.ser.open() except: print("no serial port") if os.name == "posix": self.chips = [[0 for feature in chip] for chip in sensors.iter_detected_chips()] self.cores = psutil.cpu_count() self.cpuTotal = psutil.cpu_percent() self.cpu = [0 for cores in range(self.cores)] self.mem = psutil.virtual_memory() self.disk = psutil.disk_usage('/') self.netio = psutil.net_io_counters() self.netup = 0 self.netdw = 0 self.lastnetup = 0 self.lastnetdw = 0 self.interval = 1
def __init__(self): print("Getting sensors ready") sensors.init() self.data = {} self.cpus = available_cpu_count() self.update()
def process_temp(): print("-" * 50) sensors.init() critical = False try: for chip in sensors.ChipIterator(): for feature in sensors.FeatureIterator(chip): subs = list(sensors.SubFeatureIterator(chip, feature)) critical = None current = None for sub in subs: value = sensors.get_value(chip, sub.number) if sub.name.endswith(b"input"): current = value if sub.name.endswith(b"crit"): critical_value = value name = sensors.get_label(chip, feature) print("Current temp for {}: {} / {}".format(name, current, critical_value)) if current >= critical_value: critical = True if critical: play_critical() finally: sensors.cleanup()
def getY(): sensors.init() # Inicializamos sensores temperaturas = [] # Guarda todas las tempereturas #detectadas suma_total = 0 # Variable de apoyo try: # Recorremos todos los sensores detectados for chip in sensors.iter_detected_chips(): a = chip b = chip.adapter_name if b == "PCI adapter": print "Procesador >", a, for core in chip: print "",core.get_value(), "C" # Agregamos a la lista temperaturas.append(core.get_value()) total_tempe = len(temperaturas) suma_total = sum(suma for suma in temperaturas) prom = int(suma_total) / total_tempe finally: sensors.cleanup() # Cerramos los sensores print "prom =>", prom print "--------------------------------------" if SERIAL: ser.write(str(prom)) # Enviamos el prom al arduino return prom
def fetch_sensor_data(): try: sensors.init() data = {} for chip in sensors.iter_detected_chips(): for feature in chip: # log stuff we care about if feature.label not in IGNORE_READINGS: data[feature.label] = round(feature.get_value(), 3) sorted_data = collections.OrderedDict(sorted(data.items())) write_data_file(sorted_data) if USE_REDIS: import redis REDIS_CONNECTION = redis.StrictRedis(host='localhost', port=6379, db=0) write_data_redis(sorted_data) if USE_INFLUX: from influxdb import InfluxDBClient INFLUX_CLIENT = InfluxDBClient('localhost', 8086, 'root', 'root', 'jarvis') write_data_influx(sorted_data, INFLUX_CLIENT) for name, reading in sorted_data.iteritems(): print "{0}: {1}".format(name, reading) except Exception as exception: print_exc() print "Failed to get sensor data: {0}".format(exception.message)
def metric_init(params): global descriptors sensors.init() corelist = [] try: for chip in sensors.iter_detected_chips(): if chip.prefix == CORETEMP: for feature in chip: if feature.label.startswith('Core'): corelist.append("%s Temperature" % feature.label) except: raise finally: sensors.cleanup() for core in corelist: print 'name: %s' % core descriptors.append({'name': core, 'call_back': temp_handler, 'time_max': 90, 'value_type': 'float', 'units': 'Celsius', 'slope': 'both', 'format': '%.2f', 'description': 'Temperature of %s' % core, 'groups': 'Node Health'}) return descriptors
def __init__(self,inits=('$','%'),aliases=None,order=None): self.inits = inits sensors.init() self.readings = {} self.prev_readings = {} if aliases is not None: self.aliases = aliases self.update()
def __init__(self, inits=('$', '%'), aliases=None, order=None): self.inits = inits sensors.init() self.readings = {} self.prev_readings = {} if aliases is not None: self.aliases = aliases self.update()
def serve(port): sensors.init() server = Server("localhost", port) try: server.serve_forever() except KeyboardInterrupt: server.server_close() finally: sensors.cleanup()
def check(self, instance): sensors.init() try: for chip in sensors.iter_detected_chips(): for feature in chip: self.gauge("sensors." + feature.label, feature.get_value(), device_name=('%s' % (chip))) finally: sensors.cleanup()
def getDictTemp(): result = dict() sensors.init() try: for chip in sensors.iter_detected_chips(): for feature in chip: result[str(feature.label)] = str(feature.get_value()) finally: sensors.cleanup() return result
def init(): print("[RUNNER]: init") buttons.init() buttons.action() leds.init() phy_interface.init() sensors.init() power_counter.init() mqtt.init() cli.init() things.init()
def __init__(self): """ Init sensors stats """ try: sensors.init() except: self.initok = False else: self.initok = True
def __init__(self): """Init sensors stats.""" try: sensors.init() except Exception: self.initok = False else: self.initok = True # Init the stats self.reset()
def __init__(self, influxdb_client, exit_flag_event): """ Initialize PySensors(lm-sensors) """ super(LmSensorsMetrics, self).__init__(influxdb_client=influxdb_client, watchdog=LmSensorsWatchdog(exit_flag_event), exit_flag_event=exit_flag_event) LOG.info('Initializing Lm-sensors...') sensors.init()
def _get_temp(self): import sensors sensors.init() for chip in sensors.iter_detected_chips(): if not 'temp' in str(chip): continue tot = 0 for i, feature in enumerate(chip): tot += feature.get_value() return float(tot) / (i + 1) return None
def main(): try: sensors.init() log_thread = threading.Thread(target=lambda: run_log(60.0)) log_thread.daemon = True log_thread.start() http_viewer.run() finally: sensors.cleanup()
def temp_handler(name): sensors.init() temp = 0.0 try: for chip in sensors.iter_detected_chips(): if chip.prefix == CORETEMP: for feature in chip: if '%s Temperature' % feature.label == name: temp = feature.get_value() finally: sensors.cleanup() return temp
def collect(self): if sensors is None: self.log.error('Unable to import module sensors') return {} sensors.init() try: for chip in sensors.iter_detected_chips(): for feature in chip: self.publish(".".join([str(chip), feature.label]), feature.get_value()) finally: sensors.cleanup()
def get_temp(): sensors.init() temp = 0 try: for chip in sensors.iter_detected_chips(): for feature in chip: sensor_temp = feature.get_value() if sensor_temp > temp: temp = sensor_temp finally: sensors.cleanup() return temp
def getTemp(name): result = dict() sensors.init() try: for chip in sensors.iter_detected_chips(): for feature in chip: try: if feature.label == name: return feature.get_value() except: pass finally: sensors.cleanup()
def __enter__(self): super().__enter__() if not self._initAttempted: self._initAttempted = True try: sensors.init() self._initSuccess = True except: self._initSuccess = False if self._initSuccess: self._initCount += 1 return self
def pysensors(): """use python sensors package to collect sensor data""" #print(f"Using sensors library {sensors.VERSION} ({sensors.LIB_FILENAME})") #print() html = '<pre>' #print(dir(sensors)) sensors.init() try: #print(config) for chip in sensors.iter_detected_chips(): if str(chip) in pysensorconfig: #print(chip) html += str(chip) + '<br>' #print('Adapter:', chip.adapter_name) #print(repr(config[str(chip)])) for feature in chip: #print(config[chip]) if feature.name in pysensorconfig[str(chip)]: if 'label' in pysensorconfig[str(chip)]: label = pysensorconfig[str(chip)]['label'] else: label = feature.label #print(feature.name) if feature.name.startswith('fan'): #print("%-25s %4d RPM" % (label+':', feature.get_value())) html += "%-25s %4d RPM " % (label + ':', feature.get_value()) html += "<meter max=2000 min=0 value=%d high=1250 low=750 optimum=100></meter> <br>" % feature.get_value( ) if feature.name.startswith('temp'): #print("%-27s %4.1f C" % (label+':', feature.get_value())) html += "%-27s %4.1f°C " % ( label + ':', feature.get_value()) html += "<meter max=110.0 min=0.0 value=%f high=70.0 low=40.0 optimum=10.0></meter> </br>" % feature.get_value( ) #f"{label!r}:" #f" {feature.get_value():.1f}" #) for subfeature in feature: if str(subfeature.name) in pysensorconfig[str( chip)][feature.name]: #print(f" {subfeature.name}: {subfeature.get_value():.1f}") #print(" (%s: %4.1f C)" % (subfeature.name, subfeature.get_value())) html += " (%s: %4.1f°C) <br>" % ( subfeature.name, subfeature.get_value()) #print() html += '<br>' finally: sensors.cleanup() return html
def main(): sensors.init() try: for chip in sensors.iter_detected_chips(): print(chip) print('Adapter:', chip.adapter_name) for feature in chip: print('%s (%r): %.1f' % (feature.name, feature.label, feature.get_value())) for subfeature in feature: print(' %s: %.1f' % (subfeature.name, subfeature.get_value())) print() finally: sensors.cleanup()
def create_models(): sensors.init() S = sqla.session() try: for chip_struct in sensors.iter_detected_chips(): chip = sqla.create(S, models.Chip, ['addr', 'bus', 'path', 'prefix'], chip_struct) S.add(chip) S.flush() for sensor_struct in chip_struct: sensor = sqla.create(S, models.Sensor, ['chip', 'label'], sensor_struct) sensor.chip_id = chip.id S.add(sensor) S.flush() S.commit() finally: sensors.cleanup()
def main(): print(f"Using sensors library {sensors.VERSION} ({sensors.LIB_FILENAME})") print() sensors.init() try: for chip in sensors.iter_detected_chips(): print(chip) print('Adapter:', chip.adapter_name) for feature in chip: print(f"{feature.name} ({feature.label!r}):" f" {feature.get_value():.1f}") for subfeature in feature: print(f" {subfeature.name}: {subfeature.get_value():.1f}") print() finally: sensors.cleanup()
def coretemp_handler(name): sensors.init() value = 0 try: for chip in sensors.iter_detected_chips(): if chip.prefix.startswith('coretemp'): for feature in chip: if feature.label == name: value = feature.get_value() break except: print "WTF?!?" finally: sensors.cleanup() return value
def __set_chip_read(self): """ Queries the chip applies result to the 'read' dict. Then, collects the recommended threshold values """ r.init() try: for x in r.iter_detected_chips(CHIP): for f in x: if "Core" in f.label: self.read[f.label] = f.get_value() for sub in f: self.__collect_recommended(sub) finally: r.cleanup()
def __init__(self): rospy.init_node('sysinfo') pub = rospy.Publisher('sysinfo', SysInfo, queue_size=1) pub_diagnostics = rospy.Publisher('/diagnostics', DiagnosticArray, queue_size=1) rospy.Subscriber('roboclaw_state', RoboClawState, self.cb_bat_volt) self._wifi_name = 'wlan0' if rospy.has_param('~wifi_name'): self._wifi_name = rospy.get_param('~wifi_name') self._eth_name = 'eth0' if rospy.has_param('~eth_name'): self._eth_name = rospy.get_param('~eth_name') self._base_bat_voltage = -1 self._last_bat_base = rospy.Time.now() self._stat_bat_base = [] self._stat_bat_pc = [] self._stat_network = [] self._stat_system = [] info_msg = SysInfo() info_msg.hostname = socket.gethostname() sensors.init() diag_msg = DiagnosticArray() r = rospy.Rate(1) while not rospy.is_shutdown(): info_msg.header.stamp = rospy.Time.now() info_msg.system = self.system_status() info_msg.network = self.network_status() info_msg.battery_base = self.battery_base_status() info_msg.battery_pc = self.battery_pc_status() pub.publish(info_msg) diag_msg.header.stamp = rospy.Time.now() diag_msg.status.append(self.stat_bat_base) diag_msg.status.append(self.stat_bat_pc) diag_msg.status.append(self.stat_network) diag_msg.status.append(self.stat_system) pub_diagnostics.publish(diag_msg) r.sleep()
def main(): sensors.init() try: for chip in sensors.iter_detected_chips(): print(chip) print('Adapter:', chip.adapter_name) for feature in chip: print('%s (%r): %.1f' % ( feature.name, feature.label, feature.get_value() )) for subfeature in feature: print(' %s: %.1f' % ( subfeature.name, subfeature.get_value() )) print() finally: sensors.cleanup()
def __init__(self): if not 'FONT' in globals(): raise Exception('Config not loaded, missing \'from config import *\'?') sensors.init() for chip in sensors.iter_detected_chips(): for feature in chip: self.cpusensor = feature break self.lastsent = 0 self.lastrecv = 0 self.lasttimestamp = None self.blink_batt = True self.refresh_batt_left_in = 0 self.time_batt_remaining = 0 self.re_cpufreq = re.compile('^cpu .*(?P<tst> \d+\.\d*)$', re.M|re.I)
def __init__(self, serial_instance, echo=False, eol='crlf', filters=()): self.console = Console() self.serial = serial_instance self.echo = echo self.raw = False self.input_encoding = 'UTF-8' self.output_encoding = 'UTF-8' self.eol = eol self.filters = filters self.update_transformations() self.exit_character = unichr(0x1d) # GS/CTRL+] self.menu_character = unichr(0x14) # Menu: CTRL+T self.alive = None self._reader_alive = None self.receiver_thread = None self.rx_decoder = None self.tx_decoder = None sensors.init()
def load_sensors(self): # build a temp hashmap to collect sensors id & address sensors.init() for chip in sensors.iter_detected_chips(): for feature in chip: if feature.label in self.cfg['sensors'].keys(): dev = xaal.lib.Device("thermometer.basic") dev.address = self.cfg['sensors'][feature.label]['addr'] dev.vendor_id = "IHSEV" dev.product_id = "LM_SENSOR" dev.url = "https://wiki.archlinux.org/index.php/Lm_sensors" dev.info = "%s/%s/%s" % (platform.node(),chip.adapter_name,feature.label) dev.version = 0.2 temp = dev.new_attribute("temperature") name = "%s:%s" % (chip,feature.label) self.data.update({name:temp}) self.engine.add_device(dev) dev.dump()
def getTemp(): sensors.init() avg = 0 try: for chip in sensors.iter_detected_chips(): print HEADER + '%s at %s' % (chip, chip.adapter_name) + ENDC for feature in chip: _system = feature.label _system_temp = feature.get_value() print BLUE + '\tSystem: %s ' % (_system) + ENDC print WARNING + '\tTemp: %.2f°C ' % (_system_temp) + ENDC if _system_temp > 60: print FAIL + '\tSystem Overheating' + ENDC else: print GREEN + BOLD + '\tSystem OK' + ENDC print '\n' finally: sensors.cleanup()
def init(): syscmd("jack_control start") # GPIO setup GPIO.setmode(GPIO.BCM) GPIO.setwarnings(False) sensors.init() devices.init() #controls init must be after devices and sensors, because it using them controls.init() controls.set_telegram_warning_handle(send_warning_telegram) sound.init() # must be after controls # arguments parser = argparse.ArgumentParser() parser.add_argument("--time") parser.add_argument("--check_water_level", action='store_true') args = parser.parse_args() if args.time: config.DEF_TIME_WATER_S = int(args.time) #just check water level if args.check_water_level: my_logging.logger.info( "water level: " + ("ok" if check_water_level() else "low")) exit() my_logging.logger.info("this is "+socket.gethostname()+" and we will run server and telegram bot") web_server.run(__name__) start_bot() status=devices.get_status_str()+sensors.get_status_str()+controls.get_status_str() my_logging.logger.info(status) TTS.init() # this must be before STT # sopare_plugin.init() STT.init() # this must be at the end watch_thread.init() my_logging.logger.info("end init")
def __init__(self): if not 'FONT' in globals(): raise Exception( 'Config not loaded, missing \'from config import *\'?') sensors.init() for chip in sensors.iter_detected_chips(): for feature in chip: self.cpusensor = feature break self.lastsent = 0 self.lastrecv = 0 self.lasttimestamp = None self.blink_batt = True self.refresh_batt_left_in = 0 self.time_batt_remaining = 0 self.re_cpufreq = re.compile('^cpu .*(?P<tst> \d+\.\d*)$', re.M | re.I)
def init_sensors(): try: import sensors except (ImportError, ValueError): return lambda: {} def collect_sensor_data(): data = {} for chip in sensors.iter_detected_chips(): for feature in chip: try: data[f'{chip}.{feature.label}'] = feature.get_value() except: # noqa: E722 pass return data sensors.init() return collect_sensor_data
def collect(self): if sensors is None: self.log.error('Unable to import module sensors') return {} sensors.init() try: for chip in sensors.iter_detected_chips(): for feature in chip: label = feature.label.replace(' ', '-') value = None try: value = feature.get_value() except Exception: if str_to_bool(self.config['send_zero']): value = 0 if value is not None: self.publish(".".join([str(chip), label]), value) finally: sensors.cleanup()
def metric_init(params): global descriptors metric_group = params.get('metric_group', 'coretemp') sensors.init() for chip in sensors.iter_detected_chips(): for feature in chip: if chip.prefix.startswith('coretemp'): descriptors.append({ 'name': feature.label, 'call_back' : coretemp_handler, 'time_max' : 60, 'units': 'C', 'format' : '%.2f', 'slope' : 'both', 'description' : 'CPU Core Temperature', 'groups' : metric_group, }) sensors.cleanup() return descriptors
def collectTemperatureMetrics(self): gmetric_obj = gmetric.Gmetric(self.gconf.host, self.gconf.port, self.gconf.protocol) while not self._stopevent.isSet(): try: sensors.init() list_metrics = {} for chip in sensors.iter_detected_chips(): for feature in chip: fname = str(chip) + "-" + feature.label feature_id = fname.replace(" ", "_") # print '%s: %.2f' % (feature_id, feature.get_value()) list_metrics[feature_id] = feature.get_value() # send metrics # IPMI TOOL FOR mb TEMPERATURE # get system wide counters metrics p = subprocess.Popen( "sudo ipmitool sdr | grep \"MB Temperature\" | awk '{print $4}'", shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, ) try: ipmi_value = float(p.stdout.readline().strip()) list_metrics["MB_Temperature"] = ipmi_value except ValueError: pass self.sendTemperatureMetrics(list_metrics, gmetric_obj) # print list_metrics finally: sensors.cleanup() sleep(self.temperature_interval) logger.info("Terminating %s", threading.currentThread().name)