def get_disks():
sensors_space = []
sensor_usage_values = {}
for part in psutil.disk_partitions(all=False):
if os.name == 'nt':
if 'cdrom' in part.opts or part.fstype == '':
continue
usage = psutil.disk_usage(part.mountpoint)
sensor_values = {
const.SENSOR_NAME_DISKS_TOTAL_SPACE: to_mega_byte(usage.total),
const.SENSOR_NAME_DISKS_USED_SPACE: to_mega_byte(usage.used),
const.SENSOR_NAME_DISKS_FREE_SPACE: to_mega_byte(usage.free)
}
sensor_name_space = const.SENSOR_NAME_DISKS_SPACE.format(part.device)
sensors_space.append(get_sensor(sensor_name_space, sensor_values))
sensor_usage_values[part.device] = usage.percent
sensors_space.append(
get_sensor(const.SENSOR_NAME_DISKS_PERCENT_USED, sensor_usage_values))
return sensors_space
def get_networks():
sensors = []
network_total = psutil.net_io_counters()
bandwidth_value = {
const.SENSOR_NAME_NETWORKS_RECV: network_total.bytes_recv,
const.SENSOR_NAME_NETWORKS_SENT: network_total.bytes_sent
}
packet_value = {
const.SENSOR_NAME_NETWORKS_RECV: network_total.packets_recv,
const.SENSOR_NAME_NETWORKS_SENT: network_total.packets_sent
}
sensors.append(
get_sensor(
const.SENSOR_NAME_NETWORKS.format(
const.SENSOR_NAME_NETWORKS_BANDWIDTH), bandwidth_value))
sensors.append(
get_sensor(
const.SENSOR_NAME_NETWORKS.format(
const.SENSOR_NAME_NETWORKS_PACKET), packet_value))
return sensors
def get_sensors_for_memory(nt, prefix):
sensors = []
space_values = {}
for name in nt._fields:
value = getattr(nt, name)
if name != 'percent':
space_values[name.capitalize()] = to_mega_byte(value)
else:
percent_value = value
sensors.append(get_sensor(prefix + const.SENSOR_NAME_MEMORY_SPACE, space_values))
sensors.append(get_sensor(prefix + const.SENSOR_NAME_MEMORY_PERCENT, percent_value))
return sensors
def get_fan_speed(name, value, max_val):
sensor_name = const.SENSOR_NAME_CPU_CLOCK.format(name)
sensor_value = {
const.SENSOR_NAME_CPU_CLOCK_CURRENT: value,
const.SENSOR_NAME_CPU_CLOCK_MAX: max_val
}
return get_sensor(sensor_name, sensor_value)
def get_temperature(name, value, max_val):
sensor_name = const.SENSOR_NAME_TEMPERATURE_NAME.format(name)
sensor_value = {
const.SENSOR_NAME_TEMPERATURE_CURRENT: value,
const.SENSOR_NAME_TEMPERATURE_MAX: max_val
}
return get_sensor(sensor_name, sensor_value)
def get_power(name, value, max_val):
sensor_name = const.SENSOR_NAME_CPU_USAGE_POWER.format(name)
sensor_value = {
const.SENSOR_NAME_CPU_USAGE_POWER_CURRENT: value,
const.SENSOR_NAME_CPU_USAGE_POWER_MAX: max_val
}
return get_sensor(sensor_name, sensor_value)
def get_cpu_usage(name, value, max_val):
sensor_name = const.SENSOR_NAME_CPU_USAGE_NAME.format(name)
sensor_value = {
const.SENSOR_NAME_CPU_USAGE_CURRENT: value,
const.SENSOR_NAME_CPU_USAGE_MAX: max_val
}
return get_sensor(sensor_name, sensor_value)
def get_temperatures():
sensors = []
if not hasattr(psutil, "sensors_temperatures"):
return sensors
temps = psutil.sensors_temperatures()
if not temps:
return sensors
for name, entries in temps.items():
for entry in entries:
temp_high = entry.high
temp_crit = entry.critical
if entry.high == None:
temp_high = -1
if entry.critical == None:
temp_crit = -1
sensor_name = const.SENSOR_NAME_TEMPERATURE_NAME.format(
name, entry.label)
sensor_value = {
const.SENSOR_NAME_TEMPERATURE_CURRENT: entry.current,
const.SENSOR_NAME_TEMPERATURE_HIGH: temp_high,
const.SENSOR_NAME_TEMPERATURE_CRITICAL: temp_crit
}
sensors.append(get_sensor(sensor_name, sensor_value))
return sensors
def get_battery():
if not hasattr(psutil, 'sensors_battery'):
return []
batt = psutil.sensors_battery()
if batt is None:
return []
sensors = []
sensors.append(get_sensor(const.SENSOR_NAME_BATTERY_PERCENT, round(batt.percent, 2)))
if batt.power_plugged:
sensors.append(get_sensor(const.SENSOR_NAME_BATTERY_POWER_PLUGGED, 1))
else:
sensors.append(get_sensor(const.SENSOR_NAME_BATTERY_POWER_PLUGGED, 0))
sensors.append(get_sensor(const.SENSOR_NAME_BATTERY_LEFT, secs2hours(batt.secsleft)))
return sensors
def get_cpu():
import pythoncom
sensors = []
pythoncom.CoInitialize()
w = wmi.WMI(namespace="root\OpenHardwareMonitor")
sensors_infos = w.Sensor()
for sensor in sensors_infos:
if sensor.SensorType == "Temperature":
sensor_name = const.SENSOR_NAME_TEMPERATURE_NAME.format(
sensor.Name)
sensor_value = {
const.SENSOR_NAME_TEMPERATURE_CURRENT: sensor.Value,
const.SENSOR_NAME_TEMPERATURE_MAX: sensor.Max
}
sensors.append(get_sensor(sensor_name, sensor_value))
elif sensor.Name == "CPU Total":
sensor_name = const.SENSOR_NAME_CPU_USAGE_NAME.format(sensor.Name)
sensor_value = {
const.SENSOR_NAME_CPU_USAGE_CURRENT: sensor.Value,
const.SENSOR_NAME_CPU_USAGE_MAX: sensor.Max
}
sensors.append(get_sensor(sensor_name, sensor_value))
elif sensor.SensorType == "Power":
sensor_name = const.SENSOR_NAME_CPU_USAGE_POWER.format(sensor.Name)
sensor_value = {
const.SENSOR_NAME_CPU_USAGE_POWER_CURRENT: sensor.Value,
const.SENSOR_NAME_CPU_USAGE_POWER_MAX: sensor.Max
}
sensors.append(get_sensor(sensor_name, sensor_value))
elif sensor.SensorType == "Clock":
sensor_name = const.SENSOR_NAME_CPU_CLOCK.format(sensor.Name)
sensor_value = {
const.SENSOR_NAME_CPU_CLOCK_CURRENT: sensor.Value,
const.SENSOR_NAME_CPU_CLOCK_MAX: sensor.Max
}
sensors.append(get_sensor(sensor_name, sensor_value))
return sensors
def get_internet_speed():
st = speedtest.Speedtest()
payload = {
const.SENSOR_NAME_INTERNET_SPEED_DOWNLOAD:
round(st.download() / 1000000, 2),
const.SENSOR_NAME_INTERNET_SPEED_UPLOAD:
round(st.upload() / 1000000, 2)
}
internet_speed = [
util.get_sensor(const.SENSOR_NAME_INTERNET_SPEED_NAME, payload)
]
return internet_speed
def get_fans():
sensors = []
if not hasattr(psutil, "sensors_fans"):
return sensors
fans = psutil.sensors_fans()
if not fans:
return sensors
sensor_values = {}
for name, entries in fans.items():
for entry in entries:
sensor_values[const.SENSOR_NAME_FANS_FORMAT.format(
name, entry.label)] = entry.current
sensors.append(get_sensor(const.SENSOR_NAME_FANS, sensor_values))
return sensors
for i in range(stream_length - 1):
audio_add += r.read(framerate)
format_float = '<' + str(nframes) + 'i'
testResult = struct.unpack(format_float, audio_add)
nb = np.array(testResult)
nm = np.max(np.abs(nb))
sigf32 = (nb / nm).astype(np.float32)
scipy.io.wavfile.write(file_location, framerate, sigf32)
rate, data = scipy.io.wavfile.read(file_location)
rms_amp = np.sqrt(np.mean(np.square(data)))
logrms_amp = 20 * math.log10(rms_amp)
Amplitude = get_sensor("Average Amplitude",
{"Amplitude": str(logrms_amp)})
freqs = fftfreq(data.shape[0], 1 / rate)
freqspos = freqs[:int(freqs.size / 2)]
datafft = fft(data)
fftabs = abs(datafft)[:int(freqs.size / 2)]
peakfreq = np.max(fftabs)
locmaxfreq = np.argmax(fftabs)
freqmax = freqspos[locmaxfreq]
Frequency = get_sensor("Frequency", {"Max Frequency": str(freqmax)})
Peak = get_sensor("Max Peak", {"Amplitude": str(locmaxfreq)})
sensors = []
def get_closer():
sensors = []
sensors.append(util.get_sensor("Distance to Sensors", sensor.distance))
return sensors
def get_cpus():
return [get_sensor(const.SENSOR_NAME_CPU_USAGE, psutil.cpu_percent())]