Gateway into the Machine

This follows a similar idea to my second project, but takes it in a somewhat different direction, fully integrating it into my home network using the MQTT protocol. For those interested in what MQTT is, have a look here.

Images

Here are the three PC nodes in the network…

Jarvis (Iron Man reference), which is the system I usually work at…

Phoenix, which was the codename for this laptop when it was being developed. It sits in the same room as Jarvis, so their temps have effects on each other…

… and Tars (Interstellar reference). This hosts a Minecraft server and resides in my basement… quite dusty at the moment thanks to the kitchen renovation taking place directly above…

Here’s the the Arduino-powered gateway, which can be connected to any PC to interface with the Arduino MQTT bridge. It has been repurposed from the previous project.

The front of the device…

The rear of the device…

And here are a shot of the network in action…

Here’s a shot of the 3 PC nodes interacting with each other. Right now, they’re all running great, sending each other encouraging messages.

And here’s a shot of what might happen if you neglect your own personal health too much, leading the PCs to go on-strike…

While this is just “Wizard of Ozzed” for the sake of having a quick and dirty example (as well as some humor in my choice of commands…), this is something that can happen if you don’t take care of yourself.

Description

There’s quite a bit to cover here, so bear with me.

As I had stated in the briefing for my previous project, I tend to take much better care of my computers than I do myself (especially when it comes to sleep schedule). The previous idea was one way of attempting to remedy this, but it had some shortcomings. Namely, it was far too easy to game the system with regard to reporting temperatures of the systems, and it had no connection to the systems in order to assist in dealing with certain situations (i.e., when a system is running too hot, what do you do?).

The goal is to allow any and all nodes in the network to communicate their vitals to each other. There are 3 PC nodes (all running Manjaro Linux), as well as a human node. This human node consists of an Arduino (for capturing my vitals at any given moment using the same sensors as in the last project), as well as a PC for reading the output of the Arduino and sending it to the other nodes in the network via the MQTT protocol.

Most of the time, the systems simply communicate their vitals with each other and send each other little messages based on what may be happening at that moment. For instance, one PC may be under heavy load, but its temperatures are in-check. The other PCs will see that and send a message to spur it on further–something along the lines of, “Hey, you’re doing great!” (because especially in times like these, we can all use a little bit of affirmation).

In another instance, a PC may be under very little load, but the temps could still be high. This would indicate a serious problem with that machine (perhaps a fan failure or serious heat in the room). This would cause the other PCs in the network to “sound the alarm” and notify me that something is seriously wrong.

Certain audible responses are triggered based on what the situation is. For instance, if a PC is “sounding the alarm,” it will ring the terminal bell and say something along the lines of “HELP! I need somebody! Not just anybody!” (in a text-to-speech voice for added comedic effect).

Now, that only covers PC-to-PC interaction. At any given point, I can enter the network and report my own vitals via the Arduino connected to a PC. Like with the last project, these are Galvanic Skin Response/Resistance (GSR), heart rate, when I went to sleep the previous night, and for how long I slept. If my GSR is too low or heart rate is too high (indicating that I am stressed), then the PCs will see this and offer words of encouragement.

On the other hand, if I went to sleep at an unreasonable hour the previous night, then that will count as a strike. Strikes last until the end of the week. If I accumulate three strikes, then the computers go on-strike and refuse to perform certain actions. Pulling an all-nighter results in an automatic three strikes.

Progress

One of the things that required quite a bit of trial and error was pulling the necessary data from terminal output. I was simply capturing the output of the sensors command (to get the CPU temperature) and nvidia-smi (to get GPU temperature and utilization, since I have Nvidia GPUs in my systems.

Initially, when the GPU was under 100% load, it would read as 00. This was an indexing issue and was easy to fix.

This happened for no apparent reason. It’s possible that the program just received garbage data from nvidia-smi…

This didn’t go over well with my parents… more on that later…

Since there wasn’t a bunch to do on the Arduino side of things and most of my issues were in Python, that’s all I have for in-progress photo documentation, sadly.

Process Reflection

As with everything I’ve done thus far, time management was a major issue. I’m going to save the details on that, though, as I’ve gone into it already in documentation for my previous works.

Getting the PCs to talk to each other over MQTT was far easier than I had anticipated thanks to Garth Zeglin’s work on the MQTT bridge and server for IDeATe. He did the majority of the dirty work, and there was no need to reinvent the wheel, so I borrowed liberally from his original code.

Something much more difficult was getting the system to consistently read the same sensor data. I’m not sure why, but occasionally, nvidia-smi will output garbage for the GPU utilization. This led to crashes that were initially very hard to track down, but after a while, I simply added an empty string check where necessary–the crashes are gone now.

Another difficult part was figuring out what to actually do based on certain scenarios. I wanted to have a somewhat whimsical feel to the PC reactions regardless of what the situation was. Having heard RZach use a somewhat comical text-to-speech voice during class throughout the semester to notify us when our presentation time slot was ending, I decided to follow a similar path and have the machines output responses to me via text-to-speech.

Unfortunately, that did not go over well with my parents when they heard Tars say “Seth, what the hell are you doing? I’m burning over here!” in a robotic voice… right in the middle of their Netflix-watching time. As a result, that code has been omitted for the time being.

Perhaps when I get my own place, I can revisit that. For now, I have to stick with more discrete notifications like plain text messages over MQTT.

Code

Here are the scripts that run on the 3 PC nodes. They are all very similar, but have minor differences to account for Intel vs. AMD CPU (different way of reporting temps), as well as GPU vitals reporting.

For Jarvis…

#!/usr/bin/env python3
"""A PyQt5 GUI utility to monitor and send MQTT server messages."""

################################################################
# Written in 2018-2020 by Garth Zeglin <garthz@cmu.edu>

# To the extent possible under law, the author has dedicated all copyright
# and related and neighboring rights to this software to the public domain
# worldwide. This software is distributed without any warranty.

# You should have received a copy of the CC0 Public Domain Dedication along with this software.
# If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.

################################################################
# standard Python libraries
from __future__ import print_function
import os, sys, struct, time, logging, functools, queue, signal, getpass, psutil

# documentation: https://doc.qt.io/qt-5/index.html
# documentation: https://www.riverbankcomputing.com/static/Docs/PyQt5/index.html
from PyQt5 import QtCore, QtGui, QtWidgets, QtNetwork

# documentation: https://www.eclipse.org/paho/clients/python/docs/
import paho.mqtt.client as mqtt

# default logging output
log = logging.getLogger('main')

# logger to pass to the MQTT library
mqtt_log = logging.getLogger('mqtt')
mqtt_log.setLevel(logging.WARNING)

# IDeATE server instances, as per https://mqtt.ideate.cmu.edu/#ports

ideate_ports = { 8884 : '16-223',
                 8885 : '16-375',
                 8886 : '60-223',
                 8887 : '62-362',
}

mqtt_rc_codes = ['Success', 'Incorrect protocol version', 'Invalid client identifier', 'Server unavailable', 'Bad username or password', 'Not authorized']
counter = 0


################################################################
class MainApp(object):
    """Main application object holding any non-GUI related state."""

    def __init__(self):

        # Attach a handler to the keyboard interrupt (control-C).
        signal.signal(signal.SIGINT, self._sigint_handler)

        # load any available persistent application settings
        QtCore.QCoreApplication.setOrganizationName("IDeATe")
        QtCore.QCoreApplication.setOrganizationDomain("ideate.cmu.edu")
        QtCore.QCoreApplication.setApplicationName('mqtt_monitor')
        self.settings = QtCore.QSettings()

        # uncomment to restore 'factory defaults'
        # self.settings.clear()

        # MQTT server settings
        self.hostname = self.settings.value('mqtt_host', 'mqtt.ideate.cmu.edu')
        self.systemHostname = os.popen('uname -n').read().strip()
        self.portnum  = self.settings.value('mqtt_port', 8887)
        self.portnum = int(self.portnum)
        self.username = self.settings.value('mqtt_user', 'students')
        self.password = self.settings.value('mqtt_password', 'Arduino')

        # Create a default subscription based on the username.  The hash mark is a wildcard.
        username = getpass.getuser()
        self.subscription = self.settings.value('mqtt_subscription', username + '/#')

        # default message to send
        self.topic = self.settings.value('mqtt_topic', username)
        self.payload = self.settings.value('mqtt_payload', 'hello')

        # Initialize the MQTT client system
        self.client = mqtt.Client()
        self.client.enable_logger(mqtt_log)
        self.client.on_log = self.on_log
        self.client.on_connect = self.on_connect
        self.client.on_disconnect = self.on_disconnect
        self.client.on_message = self.on_message
        self.client.tls_set()
        return

    ################################################################
    def app_is_exiting(self):
        if self.client.is_connected():
            self.client.disconnect()
            self.client.loop_stop()

    def _sigint_handler(self, signal, frame):
        print("Keyboard interrupt caught, running close handlers...")
        self.app_is_exiting()
        sys.exit(0)

    ################################################################
    def set_server_name(self, name):
        self.hostname = name
        self.settings.setValue('mqtt_host', name)

    def set_server_port(self, value):
        self.portnum = value
        self.settings.setValue('mqtt_port', self.portnum)

    def set_username(self, name):
        self.username = name
        self.settings.setValue('mqtt_user', name)

    def set_password(self, name):
        self.password = name
        self.settings.setValue('mqtt_password', name)

    def connect_to_mqtt_server(self):
        if self.client.is_connected():
            return
        else:
            if self.portnum is None:
                print("Warning: Please specify the server port before attempting connection.")
            else:
                print("Info: Initiating MQTT connection to %s:%d" % (self.hostname, self.portnum))
                self.client.username_pw_set(self.username, self.password)
                self.client.connect_async(self.hostname, self.portnum)
                self.client.loop_start()

    def disconnect_from_mqtt_server(self):
        if self.client.is_connected():
            self.client.disconnect()
        else:
            print("Warning: Not connected.")
        self.client.loop_stop()

    ################################################################
    # The callback for when the broker responds to our connection request.
    def on_connect(self, client, userdata, flags, rc):
        print("Info: Connected to server with with flags: %s, result code: %s" % (flags, rc))

        if rc == 0:
            print("Info: Connection succeeded.")

        elif rc > 0:
            if rc < len(mqtt_rc_codes):
                print("Warning: Connection failed with error: %s", mqtt_rc_codes[rc])
            else:
                print("Warning: Connection failed with unknown error %d", rc)

        # Subscribing in on_connect() means that if we lose the connection and reconnect then subscriptions will be renewed.
        client.subscribe(self.subscription)
        return

    # The callback for when the broker responds with error messages.
    def on_log(client, userdata, level, buf):
        print("Info: on_log level %s: %s", level, userdata)
        return

    def on_disconnect(self, client, userdata, rc):
        print("Info: disconnected")
        return

    # The callback for when a message has been received on a topic to which this
    # client is subscribed.  The message variable is a MQTTMessage that describes
    # all of the message parameters.

    # Some useful MQTTMessage fields: topic, payload, qos, retain, mid, properties.
    #   The payload is a binary string (bytes).
    #   qos is an integer quality of service indicator (0,1, or 2)
    #   mid is an integer message ID.

    def on_message(self, client, userdata, msg):
        global counter
        if msg.topic == "leffen/pc_vitals":
            if counter == 5:
                counter = 0
                msgList = str(msg.payload)
                msgList = msgList.split(",")
                msgList[-1] = msgList[-1][0:2]
                msgList[-1] = msgList[-1].strip()
                if msgList[0][2:] != self.systemHostname:
                    if (float(msgList[1]) < 40.0 and float(msgList[2]) >= 85.0) or \
                        (int(msgList[3]) >= 85 and (len(msgList) < 5 or (msgList[4] != "" and int(msgList[4]) < 40))):
                        # This is the critical case, where something is probably seriously wrong with the system...
                        sys.stdout.write('\a') # Ring terminal bell
                        sys.stdout.flush()
                        self.send_message("leffen/pc_chatter", "Hey %s you good? No? I'm gonna call the Fire Apartment then... WOO-ooo-WOO-ooo!" % msgList[0])
                    elif (float(msgList[1]) >= 40.0 and float(msgList[2]) >= 85.0) or \
                        (int(msgList[3]) >= 85 and (len(msgList) < 5 or (msgList[4] != "" and int(msgList[4]) >= 40))):
                        # This is the case where the system is under load and getting a bit hot...
                        self.send_message("leffen/pc_chatter", "%s looks like you're running a little hot... why not take a break? I think you've earned it." % msgList[0])
                    elif (float(msgList[1]) >= 80.0 and float(msgList[2]) < 85.0) or \
                        (int(msgList[3]) < 85 and (len(msgList) < 5 or (msgList[4] != "" and int(msgList[4]) >= 80 or \
                            int(msgList[4]) == 0))):
                        # This is the case where the system is under load and temps are in-check...
                        self.send_message("leffen/pc_chatter", "Looks like you're on it %s... keep it up!" % msgList[0])
        elif msg.topic == "leffen/human_vitals":
            msgList = str(msg.payload)
            msgList = msgList.split(",")
            if (float(msgList[0]) < 100 or float(msgList[1]) >= 130):
                self.send_message("leffen/to_human", "Hey man, looks like you need a break.")
            if (int(msgList[2]) == 0):
                self.send_message("leffen/to_human", "Alright, if you aren't gonna take care of yourself, then we're going on strike!")
            elif (int(msgList[3]) < 7 or int(msgList[3]) >= 12):
                self.send_message("leffen/to_human", "Come on, man. Get better sleep!")
        counter += 1                
        print("{%s} %s" % (msg.topic, msg.payload))
        return

    ################################################################
    def set_subscription(self, sub):
        if self.client.is_connected():
            self.client.unsubscribe(self.subscription)
            try:
                self.client.subscribe(sub)
                self.subscription = sub
                self.settings.setValue('mqtt_subscription', sub)
            except ValueError:
                print("Error: Invalid subscription string, not changed.")
                self.client.subscribe(self.subscription)
        else:
            self.subscription = sub
            self.settings.setValue('mqtt_subscription', sub)

    def set_topic(self, sub):
        self.topic = sub
        self.settings.setValue('mqtt_topic', sub)

    def send_message(self, topic, payload):
        if self.client.is_connected():
            self.client.publish(topic, payload)
        else:
            print("Error: Not connected.")
        self.payload = payload
        self.settings.setValue('mqtt_payload', payload)

    ################################################################

def main():
    # Optionally add an additional root log handler to stream messages to the
    # terminal console.
    if False:
        console_handler = logging.StreamHandler()
        console_handler.setLevel(logging.DEBUG)
        console_handler.setFormatter(logging.Formatter('%(levelname)s:%(name)s: %(message)s'))
        logging.getLogger().addHandler(console_handler)

    # initialize the Qt system itself
    app = QtWidgets.QApplication(sys.argv)

    # create the main application controller
    main = MainApp()
    main.connect_to_mqtt_server()

    # run the event loop until the user is done
    print("Info: Starting event loop.")
    while True:
        rawCPUTemp = os.popen('sensors').read()
        rawGPU = os.popen('nvidia-smi').read()
        cpuTempLine = rawCPUTemp.splitlines()[5].strip()
        gpuTempLine = rawGPU.splitlines()[9].strip()
        gpuUtilLine = rawGPU.splitlines()[9].strip()
        cpuUtil = psutil.cpu_percent()
        cpuTempstr = cpuTempLine[15:19]
        gpuTempstr = gpuTempLine[8:10]
        cpuUtilstr = str(cpuUtil)
        gpuUtilstr = gpuUtilLine[60:63]
        cpuTemp = float(cpuTempstr)
        gpuTemp = float(gpuTempstr)
        main.send_message("leffen/pc_vitals", main.systemHostname + "," +
            cpuUtilstr + "," + cpuTempstr + "," + gpuTempstr + "," + gpuUtilstr)
        time.sleep(10)
    sys.exit(app.exec_())

################################################################
# Main script follows. This sequence is executed when the script is initiated
# from the command line.

if __name__ == "__main__":
    main()

For Phoenix…

#!/usr/bin/env python3
"""A PyQt5 GUI utility to monitor and send MQTT server messages."""

################################################################
# Written in 2018-2020 by Garth Zeglin <garthz@cmu.edu>

# To the extent possible under law, the author has dedicated all copyright
# and related and neighboring rights to this software to the public domain
# worldwide. This software is distributed without any warranty.

# You should have received a copy of the CC0 Public Domain Dedication along with this software.
# If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.

################################################################
# standard Python libraries
from __future__ import print_function
import os, sys, struct, time, logging, functools, queue, signal, getpass, psutil

# documentation: https://doc.qt.io/qt-5/index.html
# documentation: https://www.riverbankcomputing.com/static/Docs/PyQt5/index.html
from PyQt5 import QtCore, QtGui, QtWidgets, QtNetwork

# documentation: https://www.eclipse.org/paho/clients/python/docs/
import paho.mqtt.client as mqtt

# default logging output
log = logging.getLogger('main')

# logger to pass to the MQTT library
mqtt_log = logging.getLogger('mqtt')
mqtt_log.setLevel(logging.WARNING)

# IDeATE server instances, as per https://mqtt.ideate.cmu.edu/#ports

ideate_ports = { 8884 : '16-223',
                 8885 : '16-375',
                 8886 : '60-223',
                 8887 : '62-362',
}

mqtt_rc_codes = ['Success', 'Incorrect protocol version', 'Invalid client identifier', 'Server unavailable', 'Bad username or password', 'Not authorized']
counter = 0


################################################################
class MainApp(object):
    """Main application object holding any non-GUI related state."""

    def __init__(self):

        # Attach a handler to the keyboard interrupt (control-C).
        signal.signal(signal.SIGINT, self._sigint_handler)

        # load any available persistent application settings
        QtCore.QCoreApplication.setOrganizationName("IDeATe")
        QtCore.QCoreApplication.setOrganizationDomain("ideate.cmu.edu")
        QtCore.QCoreApplication.setApplicationName('mqtt_monitor')
        self.settings = QtCore.QSettings()

        # uncomment to restore 'factory defaults'
        # self.settings.clear()

        # MQTT server settings
        self.hostname = self.settings.value('mqtt_host', 'mqtt.ideate.cmu.edu')
        self.systemHostname = os.popen('uname -n').read().strip()
        self.portnum  = self.settings.value('mqtt_port', 8887)
        self.portnum = int(self.portnum)
        self.username = self.settings.value('mqtt_user', 'students')
        self.password = self.settings.value('mqtt_password', 'Arduino')

        # Create a default subscription based on the username.  The hash mark is a wildcard.
        username = getpass.getuser()
        self.subscription = self.settings.value('mqtt_subscription', username + '/#')

        # default message to send
        self.topic = self.settings.value('mqtt_topic', username)
        self.payload = self.settings.value('mqtt_payload', 'hello')

        # Initialize the MQTT client system
        self.client = mqtt.Client()
        self.client.enable_logger(mqtt_log)
        self.client.on_log = self.on_log
        self.client.on_connect = self.on_connect
        self.client.on_disconnect = self.on_disconnect
        self.client.on_message = self.on_message
        self.client.tls_set()
        return

    ################################################################
    def app_is_exiting(self):
        if self.client.is_connected():
            self.client.disconnect()
            self.client.loop_stop()

    def _sigint_handler(self, signal, frame):
        print("Keyboard interrupt caught, running close handlers...")
        self.app_is_exiting()
        sys.exit(0)

    ################################################################
    def set_server_name(self, name):
        self.hostname = name
        self.settings.setValue('mqtt_host', name)

    def set_server_port(self, value):
        self.portnum = value
        self.settings.setValue('mqtt_port', self.portnum)

    def set_username(self, name):
        self.username = name
        self.settings.setValue('mqtt_user', name)

    def set_password(self, name):
        self.password = name
        self.settings.setValue('mqtt_password', name)

    def connect_to_mqtt_server(self):
        if self.client.is_connected():
            return
        else:
            if self.portnum is None:
                print("Warning: Please specify the server port before attempting connection.")
            else:
                print("Info: Initiating MQTT connection to %s:%d" % (self.hostname, self.portnum))
                self.client.username_pw_set(self.username, self.password)
                self.client.connect_async(self.hostname, self.portnum)
                self.client.loop_start()

    def disconnect_from_mqtt_server(self):
        if self.client.is_connected():
            self.client.disconnect()
        else:
            print("Warning: Not connected.")
        self.client.loop_stop()

    ################################################################
    # The callback for when the broker responds to our connection request.
    def on_connect(self, client, userdata, flags, rc):
        print("Info: Connected to server with with flags: %s, result code: %s" % (flags, rc))

        if rc == 0:
            print("Info: Connection succeeded.")

        elif rc > 0:
            if rc < len(mqtt_rc_codes):
                print("Warning: Connection failed with error: %s", mqtt_rc_codes[rc])
            else:
                print("Warning: Connection failed with unknown error %d", rc)

        # Subscribing in on_connect() means that if we lose the connection and reconnect then subscriptions will be renewed.
        client.subscribe(self.subscription)
        return

    # The callback for when the broker responds with error messages.
    def on_log(client, userdata, level, buf):
        print("Info: on_log level %s: %s", level, userdata)
        return

    def on_disconnect(self, client, userdata, rc):
        print("Info: disconnected")
        return

    # The callback for when a message has been received on a topic to which this
    # client is subscribed.  The message variable is a MQTTMessage that describes
    # all of the message parameters.

    # Some useful MQTTMessage fields: topic, payload, qos, retain, mid, properties.
    #   The payload is a binary string (bytes).
    #   qos is an integer quality of service indicator (0,1, or 2)
    #   mid is an integer message ID.

    def on_message(self, client, userdata, msg):
        global counter
        if msg.topic == "leffen/pc_vitals":
            if counter == 5:
                counter = 0
                msgList = str(msg.payload)
                msgList = msgList.split(",")
                msgList[-1] = msgList[-1][0:2]
                msgList[-1] = msgList[-1].strip()
                if msgList[0][2:] != self.systemHostname:
                    if (float(msgList[1]) < 40.0 and float(msgList[2]) >= 85.0) or \
                        (int(msgList[3]) >= 85 and (len(msgList) < 5 or (msgList[4] != "" and int(msgList[4]) < 40))):
                        # This is the critical case, where something is probably seriously wrong with the system...
                        sys.stdout.write('\a') # Ring terminal bell
                        sys.stdout.flush()
                        self.send_message("leffen/pc_chatter", "Hey %s you good? No? I'm gonna call the Fire Apartment then... WOO-ooo-WOO-ooo!" % msgList[0])
                    elif (float(msgList[1]) >= 40.0 and float(msgList[2]) >= 85.0) or \
                        (int(msgList[3]) >= 85 and (len(msgList) < 5 or (msgList[4] != "" and int(msgList[4]) >= 40))):
                        # This is the case where the system is under load and getting a bit hot...
                        self.send_message("leffen/pc_chatter", "%s looks like you're running a little hot... why not take a break? I think you've earned it." % msgList[0])
                    elif (float(msgList[1]) >= 70.0 and float(msgList[2]) < 85.0) or \
                        (int(msgList[3]) < 85 and (len(msgList) < 5 or (msgList[4] != "" and int(msgList[4]) >= 80))):
                        # This is the case where the system is under load and temps are in-check...
                        self.send_message("leffen/pc_chatter", "Looks like you're on it %s... keep it up!" % msgList[0])
        elif msg.topic == "leffen/human_vitals":
            msgList = str(msg.payload)
            msgList = msgList.split(",")
            if (float(msgList[0]) < 100 or float(msgList[1]) >= 130):
                self.send_message("leffen/to_human", "Hey man, looks like you need a break.")
            if (int(msgList[2]) == 0):
                self.send_message("leffen/to_human", "Alright, if you aren't gonna take care of yourself, then we're going on strike!")
            elif (int(msgList[3]) < 7 or int(msgList[3]) >= 12):
                self.send_message("leffen/to_human", "Come on, man. Get better sleep!")
        counter += 1
        print("{%s} %s" % (msg.topic, msg.payload))
        return

    ################################################################
    def set_subscription(self, sub):
        if self.client.is_connected():
            self.client.unsubscribe(self.subscription)
            try:
                self.client.subscribe(sub)
                self.subscription = sub
                self.settings.setValue('mqtt_subscription', sub)
            except ValueError:
                print("Error: Invalid subscription string, not changed.")
                self.client.subscribe(self.subscription)
        else:
            self.subscription = sub
            self.settings.setValue('mqtt_subscription', sub)

    def set_topic(self, sub):
        self.topic = sub
        self.settings.setValue('mqtt_topic', sub)

    def send_message(self, topic, payload):
        if self.client.is_connected():
            self.client.publish(topic, payload)
        else:
            print("Error: Not connected.")
        self.payload = payload
        self.settings.setValue('mqtt_payload', payload)

    ################################################################

def main():
    # Optionally add an additional root log handler to stream messages to the
    # terminal console.
    if False:
        console_handler = logging.StreamHandler()
        console_handler.setLevel(logging.DEBUG)
        console_handler.setFormatter(logging.Formatter('%(levelname)s:%(name)s: %(message)s'))
        logging.getLogger().addHandler(console_handler)

    # initialize the Qt system itself
    app = QtWidgets.QApplication(sys.argv)

    # create the main application controller
    main = MainApp()
    main.connect_to_mqtt_server()

    # run the event loop until the user is done
    print("Info: Starting event loop.")
    #rawCPU = os.system("sensors"
    while True:
        rawCPUTemp = os.popen('sensors').read()
        rawGPU = os.popen('nvidia-smi').read()
        cpuTempLine = rawCPUTemp.splitlines()[19].strip()
        gpuTempLine = rawGPU.splitlines()[9].strip()
        cpuUtil = psutil.cpu_percent()
        gpuUtilLine = rawGPU.splitlines()[9].strip()
        cpuTempstr = cpuTempLine[16:20]
        gpuTempstr = gpuTempLine[8:10]
        cpuUtilstr = str(cpuUtil)
        gpuUtilstr = gpuUtilLine[60:63]
        cpuTemp = float(cpuTempstr)
        gpuTemp = float(gpuTempstr)
        cpuUtil = float(cpuUtilstr)
        main.send_message("leffen/pc_vitals", main.systemHostname + "," +
            cpuUtilstr + "," + cpuTempstr + "," + gpuTempstr + "," + gpuUtilstr)
        time.sleep(10)
    sys.exit(app.exec_())

################################################################
# Main script follows. This sequence is executed when the script is initiated
# from the command line.

if __name__ == "__main__":
    main()