async def pi(ctx, *, args):
member = ctx.message.author
channel = bot.get_channel(IDs.get("bot-testing"))
if (isAdmin(member)):
await ctx.channel.send("Informationen skickas i #bot-testing")
if args == "temp":
cpu = CPUTemperature()
cpu_temp = round(cpu.temperature)
await channel.send(f"Temp: {cpu_temp}°C")
elif args == "load":
load = LoadAverage()
load_avg = round(load.load_average * 100)
await channel.send(f"Load: {load_avg}%")
elif args == "disk":
disk = DiskUsage()
disk_usage = round(disk.usage)
await channel.send(f"Disk: {disk_usage}%")
elif args == "all":
cpu = CPUTemperature()
cpu_temp = round(cpu.temperature)
load = LoadAverage()
load_avg = round(load.load_average * 100)
disk = DiskUsage()
disk_usage = round(disk.usage)
await channel.send(
f"Temp: {cpu_temp}°C \nLoad: {load_avg}% \nDisk: {disk_usage}%"
)
else:
await channel.send(
f"Jag förstår inte argumentet: {args} \n Jag kan följande: [temp, load, disk, all]"
)
else:
await ctx.channel.send(
"Endast individer av exceptionell rank har tillgång till denna funktion!"
)
def logsystemstatus():
# Log Temperature
#logging.debug("========================================================================================")
if (CPUTemperature().temperature) > 75:
logging.warning(
f"***TEMPERATURE {(CPUTemperature().temperature):.1f}°C")
elif (CPUTemperature().temperature) > 65:
logging.debug(
f"#**TEMPERATURE {(CPUTemperature().temperature):.1f}°C")
elif (CPUTemperature().temperature) > 55:
logging.debug(
f"# *TEMPERATURE {(CPUTemperature().temperature):.1f}°C")
else:
logging.info(
f"# TEMPERATURE {(CPUTemperature().temperature):.1f}°C")
# Log disk capacity usage
vp_usage = shutil.disk_usage(VIDEOPATH)
ip_usage = shutil.disk_usage(IMAGEPATH)
ap_usage = shutil.disk_usage(IMAGEARCHIVEPATH)
rp_usage = shutil.disk_usage(RUNNINGPATH)
vp_size = get_foldersize(VIDEOPATH)
ip_size = get_foldersize(IMAGEPATH)
ap_size = get_foldersize(IMAGEARCHIVEPATH)
vp_left = (vp_usage.free - (VIDEOPATHFSLIMIT * 1048576))
ip_left = ((IMAGEPATHLIMIT * 1048576) - ip_size)
ap_left = ((IMAGEARCHIVEPATHLIMIT * 1048576) - ap_size)
vp_count = len(os.listdir(VIDEOPATH))
ip_count = len(os.listdir(IMAGEPATH))
ap_count = len(os.listdir(IMAGEARCHIVEPATH))
logging.debug(
f"# VIDEOPATH VolS: {((vp_usage.total) / 1048576):,.0f}MB, VolF: {((vp_usage.free) / 1048576):,.0f}MB, VolU: {((vp_usage.used / vp_usage.total) * 100):.1f}%, FolU: {((vp_size) / 1048576):,.0f}MB ({vp_count}), FolF: {((vp_left) / 1048576):,.0f}MB"
)
logging.debug(
f"# IMAGEPATH VolS: {((ip_usage.total) / 1048576):,.0f}MB, VolF: {((ip_usage.free) / 1048576):,.0f}MB, VolU: {((ip_usage.used / ip_usage.total) * 100):.1f}%, FolU: {((ip_size) / 1048576):,.0f}MB ({ip_count}), FolF: {((ip_left) / 1048576):,.0f}MB"
)
logging.debug(
f"# IMAGEARCHIVEPATH VolS: {((ap_usage.total) / 1048576):,.0f}MB, VolF: {((ap_usage.free) / 1048576):,.0f}MB, VolU: {((ap_usage.used / ap_usage.total) * 100):.1f}%, FolU: {((ap_size) / 1048576):,.0f}MB ({ap_count}), FolF: {((ap_left) / 1048576):,.0f}MB"
)
logging.debug(
f"# RUNNINGPATH VolS: {((rp_usage.total) / 1048576):,.0f}MB, VolF: {((rp_usage.free) / 1048576):,.0f}MB, VolU: {((rp_usage.used / rp_usage.total) * 100):.1f}%"
)
logging.debug(
f"# FLAGS TRIGGERFLAG: {trigger_flag:010b}, PROCESSFLAG: {process_flag:010b}"
)
logging.debug(f"# RECORDTHREAD {record_thread}")
logging.debug(f"# STREAMTHREAD {stream_thread}")
logging.debug(f"# TLAPSETHREAD {tlapse_thread}")
logging.debug(
f"# IDLE TIME {(int(time.time()) - EVENTTIME)} seconds")
logging.debug(f"# UPTIME {(int(time.time()) - UPTIME)} seconds")
def main(argv): #import getopt # going to add arguments later for daemonization, logging, etc... # init the cputemperature class cpu = CPUTemperature( threshold=50.0, event_delay=1.0 ) # set the callbacks cpu.when_activated = activated_callback cpu.when_deactivated = activated_callback # wait for events to happen pause()
def main():
cpu = CPUTemperature()
while True:
temp = cpu.temperature
write_temp(temp)
# graph(temp)
sleep(60)
def Time_test():
fred = datetime.datetime.now()
time = fred.strftime("%H:%M:%S")
cpuData = CPUTemperature()
print("{0:.1f}".format(cpuData.temperature))
temperature = "{0:.1f}".format(cpuData.temperature)
room_temp = roomtemperature()
print("Time_test received ", room_temp)
image = Image.new("RGB", (OLED.SSD1351_WIDTH, OLED.SSD1351_HEIGHT), "BLACK")
draw = ImageDraw.Draw(image)
font_saxmono = ImageFont.truetype(os.path.join(app_dir,'saxmono.ttf'), 16)
font_clock = font_saxmono
font_temperature = font_saxmono
draw.text((0, 12), 'Mikes Clock', fill="BLUE", font=font_saxmono)
draw.text((0, 30), time, fill="YELLOW", font=font_clock)
draw.text((0, 100), temperature, fill="RED", font=font_temperature)
if room_temp is not None:
draw.text((0, 65), room_temp, fill="ORANGE", font=font_temperature)
print (time)
OLED.Display_Image(image)
def __stabilize_temperature(self, stop_thread):
"""Method to provide asynchronous temperature control point for running fans by the temperature.
Args:
stop_thread: Stop flag of the tread about terminating it outside of the function's loop.
"""
from gpiozero import CPUTemperature
cpu = CPUTemperature()
while True:
temperature = float(cpu.temperature)
for fan in self.fans:
if temperature <= 45:
fan.change_speed(0)
elif temperature <= 75:
fan.change_speed(100)
else:
fan.change_speed(
self.__temperature_to_percent(temperature))
if stop_thread():
break
time.sleep(1.5)
def get_system_info():
cpu = CPUTemperature()
frame_black = [0] * int((epd.width * epd.height / 8))
frame_red = [0] * int((epd.width * epd.height / 8))
try:
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(("8.8.8.8", 80))
testIP = (s.getsockname()[0])
s.close()
except BaseException:
testIP = "0.0.0.0"
with open('/proc/uptime', 'r') as f:
uptime_seconds = float(f.readline().split()[0])
uptime_string = round(uptime_seconds / 60,0)
localfile = open('/home/pi/config/LastUpdated.txt','r')
lastUpgrade = localfile.read()
localfile.close()
epd.draw_string_at(frame_black,1,1, str(socket.gethostname()), font1, 1)
epd.draw_string_at(frame_red,1,20, str(testIP), font1, 1)
epd.draw_string_at(frame_black,1,40, "CPU Temp:" + str(round(cpu.temperature, 1)) + "c", font1, 1)
epd.draw_string_at(frame_black,1,60, "UpTime:" + str(int(uptime_string)) + " Min", font1, 1)
epd.draw_string_at(frame_black,1,100, "UpGrade Files:", font1, 1)
epd.draw_string_at(frame_black,1,120, str(lastUpgrade[4:10]) + " " + str(lastUpgrade[11:16]), font1, 1)
epd.draw_string_at(frame_black,1,180, "Screen Updated", font1, 1)
epd.draw_string_at(frame_black,1,240, str(strftime("%b-%d %H:%M")), font1, 1)
epd.display_frame(frame_black, frame_red)
def getCPUtemperature():
cpu = CPUTemperature()
temp_C = int(float(cpu.temperature))
temp_F = round(9.0 / 5.0 * temp_C + 32)
temp_C = round(temp_C)
return temp_C, temp_F
def getSensorData(name, sensor):
"""
Read the information in GPIO port of raspberry.
All sensortypes need have type unit and the result of meassurement
"""
data = {
'name': name,
}
sensorType = sensor.get('type', '')
if (sensorType == 'cpuTemperatura'):
cpu = CPUTemperature()
data['meassurement'] = cpu.temperature
data['meassurementType'] = 'temperatura'
data['meassurementUnit'] = 'Celsius'
elif (sensorType == 'dht22Temperatura'):
humidity, temperature = Adafruit_DHT.read_retry(
Adafruit_DHT.DHT22, int(sensor.get('gpio')))
data['meassurement'] = temperature
data['meassurementType'] = 'temperatura'
data['meassurementUnit'] = 'Celsius'
elif (sensorType == 'dht22Umidade'):
humidity, temperature = Adafruit_DHT.read_retry(
Adafruit_DHT.DHT22, int(sensor.get('gpio')))
data['meassurement'] = humidity
data['meassurementType'] = 'umidade'
data['meassurementUnit'] = 'Porcentagem'
return data
def home():
def getRAMinfo():
p = os.popen('free')
i = 0
while 1:
i = i + 1
line = p.readline()
if i == 2:
return (line.split()[1:4])
res = requests.get(url)
data = res.json()
temp_city = data['main']['temp']
RAM_stats = getRAMinfo()
RAM_used = round(int(RAM_stats[1]) / 1000, 1)
cpu = CPUTemperature()
cpu_temp1 = cpu.temperature
cpu_temp = cpu_temp1
ser = serial.Serial('/dev/ttyACM0', 9600)
rawserial = ser.readline()
cookedserial = rawserial.decode('utf-8').strip('\r\n')
datasplit = cookedserial.split('-')
temperature_dht = datasplit[0].strip("b'")
humidity_dht = datasplit[-1]
if (temperature_dht != ""):
text_temp = temperature_dht
return render_template("index.html",
RAM_used=RAM_used,
cpu_temp=cpu_temp,
temp=text_temp,
temp_city=temp_city)
def run(self):
while True:
temperature = CPUTemperature().temperature
print(f"{COLOR_TERM_BLUE_BACKGR}CPU temperature: {temperature}{COLOR_TERM_END}")
color = self.GetColorForCpuTemp(temperature)
self.led.On(self.index_led, color)
time.sleep(self.polling_interval)
def __init__(self):
# Pygame library for load and play MP3 file
pygame.mixer.init()
pygame.mixer.music.load("beep-02.mp3")
pygame.mixer.music.set_volume(1.0)
self.cpu = CPUTemperature()
def __init__(self, cfg=None):
self._cfg = cfg
self._dc = 0
self._cpu = CPUTemperature()
# This attribute is initialized
# in a dedicated method (see below)
self._pi = None
def index():
if request.method == 'POST':
for key in request.form.keys():
if key == 'waterAll':
waterAll()
elif key.startswith('waterNow_'):
sectID = key.split('_')[1]
waterNow(int(sectID))
return redirect(url_for('.index'))
else:
navURL = getNavURL()
styles = getStyles()
now = datetime.now()
cpu = CPUTemperature()
data = {'sectData': None,
'weather': None,
'sysData': None,
'cpuTemp': {
'time': f'{now.strftime("%H:%M")}',
'temp': f'{round(cpu.temperature, 1)} C'
}
}
data['sectData'] = getJsonData('watering-sectors')
data['weather'] = getForecast(getJsonData('forecast'))
data['sysData'] = getJsonData('system-data')
return render_template('index.html', navurl=navURL, styles=styles, data=data)
def start():
global data
cput = CPUTemperature()
cpt = str(cput)
cpus = cpt[44:46]
ServerTemp = int(cpus)
hostname = socket.gethostname()
ip_address = socket.gethostbyname(hostname)
IPaddress = f"{ip_address}"
Humidity, Temp = Adafruit_DHT.read_retry(sensor, pin)
if (B.is_pressed):
IRs = "YES!"
else:
IRs = "NO!"
data = {
'RT': Temp,
'RH': Humidity,
'IR': IRs,
'IP': IPaddress,
'ST': ServerTemp
}
return render_template('MainPG.html', **data)
def Time_test():
fred = datetime.datetime.now()
# fred =time.time()
# hms = time.strftime('%H:%M:%S', fred)
time = fred.strftime("%H:%M:%S")
cpuData = CPUTemperature()
print("{0:.1f}".format(cpuData.temperature))
temperature = "{0:.1f}".format(cpuData.temperature)
# temperature = str(cpuData.temperature)
# print(temperature)
room_temp = roomtemperature()
print("Time_test received ", room_temp)
image = Image.new("RGB", (OLED.SSD1351_WIDTH, OLED.SSD1351_HEIGHT),
"BLACK")
draw = ImageDraw.Draw(image)
# font = ImageFont.truetype('cambriab.ttf',24)
# font_12 = ImageFont.truetype('cambriab.ttf', 12)
# font_acme = ImageFont.truetype('Baloo-Regular.ttf', 36)
# font_jetbrains = ImageFont.truetype('JetBrainsMono-Regular.ttf', 24)
font_saxmono = ImageFont.truetype('fonts/saxmono.ttf', 16)
font_clock = ImageFont.truetype('fonts/saxmono.ttf', 24)
font_temperature = ImageFont.truetype('fonts/saxmono.ttf', 24)
draw.text((0, 12), 'Mikes Clock', fill="BLUE", font=font_saxmono)
draw.text((0, 30), time, fill="YELLOW", font=font_clock)
draw.text((0, 100), temperature, fill="RED", font=font_temperature)
if room_temp is not None:
draw.text((0, 65), room_temp, fill="ORANGE", font=font_temperature)
print(time)
pilogo = Image.open('icons/raspberry_1.bmp')
draw.bitmap([0, 0, 60, 60], pilogo)
OLED.Display_Image(image)
def __init__(self):
self.humidify_water_level_sensor = Button(
self.HUMIDIFY_WATER_LEVEL_PIN)
self.distance_sensor = DistanceSensor(
trigger=self.RANGING_MODULE_TRIGGER_PIN,
echo=self.RANGING_MODULE_ECHO_PIN)
self.cpu_temperature_sensor = CPUTemperature()
def toGraphite(Distance, CpuUtil):
cpu = CPUTemperature()
FishDist = ((Distance * 0.0393701) / 12)
CpuTemp = (cpu.temperature * (9 / 5)) + 32
#print("FishDist=",FishDist)
#print("----------sender 1---------------------")
sender1.send('FishDist', FishDist)
sender1.send('CpuTemp', CpuTemp)
sender1.send('CpuUtil', CpuUtil)
#print("----------sender 2---------------------")
#sender2.send('WaterLevelHigh', WaterLevelHigh)
#sender2.send('WaterLevelLow', WaterLevelLow)
#sender2.send('WaterLevelAvg', WaterLevelAvg)
#sender2.send('WaterLevelMedian', WaterLevelMedian)
#sender2.send('WaveHeight', WaveHeight)
#sender2.send('CpuTemp',CpuTemp)
#sender2.send('CpuUtil',CpuUtil)
return
def do_temp(field=0):
try:
cpu = CPUTemperature()
t = cpu.temperature
except OSError as err:
t = 0
print('temperature = %.2f' % t)
global THINGSPEAK_WRITE_KEY
if not THINGSPEAK_WRITE_KEY:
print('not ThingSpeak key specified, skip sending data')
return
print('send data to ThingSpeak')
data = '{"field%s":"%.2f"}' % (field, t)
headers = {'X-THINGSPEAKAPIKEY': THINGSPEAK_WRITE_KEY,
'Content-type': 'application/json'}
r = requests.post(API_THINGSPEAK_HOST, data=data, headers=headers)
results = r.json()
print(results)
def send_msg(domains_being_blocked, dns_queries_today, ads_percentage_today, ads_blocked_today):
json_body = [
{
"measurement": "pihole." + HOSTNAME.replace(".", "_"),
"tags": {
"host": HOSTNAME
},
"fields": {
"domains_being_blocked": int(domains_being_blocked),
"dns_queries_today": int(dns_queries_today),
"ads_percentage_today": float(ads_percentage_today),
"ads_blocked_today": int(ads_blocked_today),
"uptime": int(uptime.uptime()),
"temp": float(CPUTemperature().temperature),
"load_average": float(LoadAverage().load_average),
"disk_usage": float(DiskUsage().usage)
}
}
]
# InfluxDB host, InfluxDB port, Username, Password, database
client = InfluxDBClient(INFLUXDB_SERVER, INFLUXDB_PORT, INFLUXDB_USERNAME, INFLUXDB_PASSWORD, INFLUXDB_DATABASE)
# Uncomment to create the database (expected to exist prior to feeding it data)
# client.create_database(INFLUXDB_DATABASE)
client.write_points(json_body)
print(json_body)
def start(self):
"""Getting the bus"""
log.info('Initializing sensor GPIOZero')
# Initialize the hardware driver.
try:
# Vanilla MicroPython 1.11 and Pycom MicroPython 1.9.4
if platform_info.vendor in [
platform_info.MICROPYTHON.Vanilla,
platform_info.MICROPYTHON.Pycom
]:
raise NotImplementedError('No GPIOZero on MicroPython')
# CPython SerialBus EPSolar
elif platform_info.vendor == platform_info.MICROPYTHON.RaspberryPi:
from gpiozero import CPUTemperature, LoadAverage, DiskUsage
self.cputemp = CPUTemperature(min_temp=50, max_temp=90)
self.loadaverage = LoadAverage(min_load_average=0,
max_load_average=2)
self.diskusage = DiskUsage()
else:
raise NotImplementedError(
'GPIOZero driver not implemented on this platform')
return True
except Exception as ex:
log.exc(ex, 'GPIOZero hardware driver failed')
def get_battery():
try:
from gpiozero import CPUTemperature
cpu = CPUTemperature()
return int(cpu.temperature)
except ImportError:
pass
def writeOnScreen(sc):
global counter
disp.fill(0)
# Draw a black filled box to clear the image.
draw.rectangle((0, 0, width, height), outline=0, fill=0)
if counter > counterThreshold:
# Write four lines of text.
draw.text((x, top + 0),
datetime.now().strftime('%H:%M:%S'),
font=font,
fill=255)
else:
cpuTemp = CPUTemperature()
draw.text((x, -15), "CPU TEMP: ", font=font2, fill=255)
draw.text((x, 2),
"%.1f" % cpuTemp.temperature + "°C",
font=font2,
fill=255)
# Display image.
disp.image(image)
disp.show()
counter += 1
if counter == 2 * counterThreshold:
counter = 0
s.enter(0.2, 1, writeOnScreen, (sc, ))
def __init__(self, settings):
self.NETWORK_HEIGHT = settings["height"]
self.NETWORK_WIDTH = settings["width"]
self.CONFIG_PATH = settings["cfg"]
self.WEIGHTS_PATH = settings["weights"]
self.MIN_CONFIDENCE = settings["min_confidence"]
self.THRESHOLD = settings["threshold"]
self.buffer = queue.Queue()
print('loading network')
self.net = cv2.dnn.readNetFromDarknet(self.CONFIG_PATH, self.WEIGHTS_PATH)
self.layer_names = self.net.getLayerNames()
self.layer_names = [self.layer_names[i[0] - 1] for i in self.net.getUnconnectedOutLayers()]
print('init video stream')
self.stream = cv2.VideoCapture(0) # cam id is 0
self.stream.set(cv2.CAP_PROP_BUFFERSIZE, 1)
self.stream.set(cv2.CAP_PROP_FRAME_WIDTH, self.NETWORK_WIDTH)
self.stream.set(cv2.CAP_PROP_FRAME_HEIGHT, self.NETWORK_HEIGHT)
print('init frame graber')
frame_graber_thread = threading.Thread(target=self._frame_reader)
frame_graber_thread.daemon = True
frame_graber_thread.start()
print('init cpu monitor')
self.cpu = CPUTemperature()
def __init__(self, config, clock, fan, level):
self._log = Logger('cpu-temp', level)
if config is None:
raise ValueError('null configuration argument.')
_config = config['ros'].get('temperature')
self._warning_threshold = _config.get('warning_threshold')
self._max_threshold = _config.get('max_threshold')
self._log.info(
'warning threshold: {:5.2f}°C; maximum threshold: {:5.2f}°C'.
format(self._warning_threshold, self._max_threshold))
self._sample_time_sec = _config.get(
'sample_time_sec') # how often to divide the 1s TOCK messages
self._log.info('sampling time: {:d}s'.format(self._sample_time_sec))
self._clock = clock # optional
self._fan = fan # optional
self._log.info('starting CPU temperature module.')
self._cpu = None
self._borkd = False
self._enabled = False
self._closed = False
self._counter = itertools.count()
try:
self._cpu = CPUTemperature(
min_temp=0.0, max_temp=100.0,
threshold=self._max_threshold) # min/max are defaults
self._log.info('ready.')
except BadPinFactory as e:
# except Exception as e:
self._borkd = True
self._log.error(
'error loading CPU temperature module: {}'.format(e))
def _get(json):
print("[SOCKET] get:", json)
try:
name = json["name"]
except:
emit_with_log(
"get",
{
"name": None,
"payload": {"error": "Invalid json (the name is missing)"},
},
)
return
if name == "GAPI":
emit_with_log(
"get",
{"name": name, "payload": {"data": {"temp": CPUTemperature().temperature}}},
)
return
if not Server.getInstance().isName(name):
emit_with_log("get", {"name": name, "payload": {"error": "Invalid name"}})
return
data = Server.getInstance().send_get(name)
if data["error"]:
emit_with_log("get", {"name": name, "payload": {"error": data["info"]}})
return
emit_with_log("get", {"name": name, "payload": {"data": data["info"]}})
def update_data(self):
while True:
cpu_temp = CPUTemperature()
sys_uptime=int(uptime())
up_time=datetime.timedelta(seconds=sys_uptime)
self.m_win.bot_uptim_val.setText(str(up_time))
self.m_win.cpu_temp_val.setText(str(cpu_temp.temperature))
time.sleep(1)
def Get_Tamp():
cpu = CPUTemperature()
#logging.info(cpu)
m = re.search('(?<==)\w+', format(cpu))
logging.info(m.group(0))
tamp = m.group(0)
return int(tamp)
def CPUTooHot():
cpu = CPUTemperature()
if cpu.temperature > 75:
return True
else:
return False
def __init__(self, mqtt):
self.mqtt = mqtt
self.cpu = CPUTemperature()
self.disk = DiskUsage()
self.load = LoadAverage()
self.cpuTemperature = self.cpu.temperature
self.diskUsage = self.disk.usage
