MasterMonitorScript-CCS811-Final.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5e90696e",
   "metadata": {},
   "source": [
    "# Environment Monitor Script\n",
    "\n",
    "This is an example script monitoring values form the Enviro board and the external temperature sensor. I tried to organize the code in a way that makes it easy learn and to use parts of it for your scripts."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36ff110b",
   "metadata": {},
   "source": [
    "### Google Sheets \n",
    "\n",
    "For this part to work, you will need to create a Google Sheet and setup a service account. The file `client_secret.json` needs to be present for authentication. Make sure you do *not* add that file to your GitHub repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ebf61b9",
   "metadata": {},
   "outputs": [],
   "source": [
    "import gspread\n",
    "from oauth2client.service_account import ServiceAccountCredentials\n",
    "\n",
    "sheet_name = \"PiLog\"   # Make sure this matches your Google sheet name\n",
    "\n",
    "# use creds to create a client to interact with the Google Drive API\n",
    "scopes = [\"https://www.googleapis.com/auth/drive\", \"https://www.googleapis.com/auth/drive.file\", \n",
    "          \"https://www.googleapis.com/auth/spreadsheets\"]\n",
    "creds = ServiceAccountCredentials.from_json_keyfile_name('client_secret.json', scopes)\n",
    "client = gspread.authorize(creds)\n",
    "\n",
    "# Find the workbook by name and open the first sheet\n",
    "sheet = client.open(sheet_name).worksheet(\"Values\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0444c607",
   "metadata": {},
   "source": [
    "### Adafruit Cloud\n",
    "\n",
    "This part initializes communication with the <a href=\"https://io.adafruit.com\">Adafruit cloud</a>. For this to work, the file `.env` containing the Adafruit username and token must exist in the same directory of of the Notebook. The format of the `.env` file is \n",
    "\n",
    "```\n",
    "ADAFRUIT_IO_USERNAME = \"username\"\n",
    "ADAFRUIT_IO_KEY = \"token\"\n",
    "```\n",
    "\n",
    "The rountine `getFeed(name)` will get the ID of the Adafruit feed called `name`. If the feed does not exist, it will be created."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "04a76c58",
   "metadata": {},
   "outputs": [],
   "source": [
    "from Adafruit_IO import Client, Feed, RequestError\n",
    "from dotenv import load_dotenv\n",
    "import os\n",
    "\n",
    "load_dotenv()   \n",
    "\n",
    "ADAFRUIT_IO_USERNAME = os.environ.get('ADAFRUIT_IO_USERNAME')\n",
    "ADAFRUIT_IO_KEY = os.environ.get('ADAFRUIT_IO_KEY')\n",
    "\n",
    "aio = Client(ADAFRUIT_IO_USERNAME, ADAFRUIT_IO_KEY)\n",
    "\n",
    "def getFeed(name):\n",
    "    try:\n",
    "        feedID = aio.feeds(name)\n",
    "    except RequestError:\n",
    "        feed = Feed(name=name)\n",
    "        feedID = aio.create_feed(feed)\n",
    "    return feedID"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "557c76c3",
   "metadata": {},
   "source": [
    "### Initialization of sensors\n",
    "\n",
    "Here we initialize all sensors we use and create routines that we use later. Make sure all these cells are run first.\n",
    "\n",
    "##### BME280\n",
    "\n",
    "This is the temperature, humidity and pressure sensor on the Enviro board."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e6a74354",
   "metadata": {},
   "outputs": [],
   "source": [
    "from bme280 import BME280\n",
    "bme280 = BME280()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90cb5864",
   "metadata": {},
   "source": [
    "##### LTR559\n",
    "\n",
    "This is the light sensor on the Enviro board."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8140588f",
   "metadata": {},
   "outputs": [],
   "source": [
    "from ltr559 import LTR559\n",
    "ltr559 = LTR559()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9333368",
   "metadata": {},
   "source": [
    "##### CCS811\n",
    "\n",
    "This is the external gas sensor reading CO2 and TVOC (total volatile organic compounds) sensor. Note that this sensor requires the I2C bus to run slower to work. You will need to add the line below to `/boot/config.txt` and reboot the Pi before using it or the first time:\n",
    "\n",
    "```\n",
    "dtparam=i2c_arm_baudrate=10000\n",
    "```\n",
    "\n",
    "Note the sensor will need some time to run before giving sensible values. Also since it determines its 'baseline' it should be started in 'clean' air."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75d0d258",
   "metadata": {},
   "outputs": [],
   "source": [
    "import busio\n",
    "import board\n",
    "import adafruit_ccs811\n",
    "\n",
    "i2c = board.I2C() \n",
    "ccs = adafruit_ccs811.CCS811(i2c)\n",
    "\n",
    "# Wait for the sensor to be ready\n",
    "\n",
    "while (not ccs.data_ready):\n",
    "    pass\n",
    "\n",
    "print (\"CCS811 Sensor ready.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38baf365",
   "metadata": {},
   "source": [
    "##### External temperature sensor\n",
    "\n",
    "This adds a routine to read the temperature on Celcius form the external temperature sensor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b28c91f9",
   "metadata": {},
   "outputs": [],
   "source": [
    "import smbus\n",
    "\n",
    "def readTemp():\n",
    "    # By default the address of LM75A is set to 0x48\n",
    "    address = 0x48\n",
    "\n",
    "    # Read I2C data and calculate temperature\n",
    "    bus = smbus.SMBus(1)\n",
    "    raw = bus.read_word_data(address, 0) & 0xFFFF\n",
    "    raw = ((raw << 8) & 0xFF00) + (raw >> 8)\n",
    "    temperature = (raw / 32.0) / 8.0\n",
    "    return temperature"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26b6f75b",
   "metadata": {},
   "source": [
    "### LCD screen\n",
    "\n",
    "This initializes the LCD screen and adds a routine to write sensor values to the screen. Adjust colors and setting below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6fa69b1d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import ST7735\n",
    "from PIL import Image, ImageDraw, ImageFont\n",
    "from fonts.ttf import RobotoMedium as UserFont\n",
    "\n",
    "disp = ST7735.ST7735(port=0,cs=1,dc=9,backlight=12,rotation=270,spi_speed_hz=10000000)\n",
    "disp.begin()\n",
    "\n",
    "back_color = (0, 60, 20)\n",
    "text_color = (255, 255, 255)\n",
    "head_color = (255, 255,   0)\n",
    "warn_color = (255,  50,  50)\n",
    "font_size  = 14\n",
    "text_margin= 5\n",
    "\n",
    "img = Image.new('RGBA', (disp.width, disp.height))\n",
    "draw = ImageDraw.Draw(img)\n",
    "font = ImageFont.truetype(UserFont, font_size)\n",
    "font_big = ImageFont.truetype(UserFont, 2*font_size)\n",
    "size_x, size_y = draw.textsize('text', font)\n",
    "\n",
    "# We pass the name and the value so we can 'cycle' through the sensors\n",
    "def updateLCD(label, value, unit): \n",
    "    if (value < 1000):\n",
    "        vstr=\"{0:.1f} {1}\".format(value, unit)\n",
    "    else:\n",
    "        vstr=\"{0:.0f} {1}\".format(value, unit)\n",
    "        \n",
    "    draw.rectangle((0, 0, disp.width, disp.height), back_color)\n",
    "    draw.text((text_margin, text_margin), \"ORCSPICamp Station\", font=font, fill=head_color)\n",
    "    draw.text((text_margin, text_margin+2.0*size_y), label, font=font, fill=text_color)\n",
    "    draw.text((text_margin, text_margin+3.5*size_y), vstr, font=font_big, fill=text_color)\n",
    "    disp.display(img)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c3f7dd0",
   "metadata": {},
   "source": [
    "## Monitoring\n",
    "##### Setup\n",
    "\n",
    "This is the main part. First some settings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "374e57d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Some general settings\n",
    "import time\n",
    "from datetime import datetime\n",
    "from IPython.display import clear_output, display, update_display\n",
    "\n",
    "# Get feeds using our routine\n",
    "tempFeed  = getFeed(\"temperature\")\n",
    "temp2Feed = getFeed(\"tempexternal\")\n",
    "humidFeed = getFeed(\"humidity\")\n",
    "pressFeed = getFeed(\"pressure\")\n",
    "lightFeed = getFeed(\"brightness\")\n",
    "co2Feed   = getFeed(\"co2\")\n",
    "tvocFeed  = getFeed(\"tvoc\")\n",
    "msgFeed   = getFeed(\"message\")\n",
    "\n",
    "# Set metadata associated with our measurement station. Update for your location\n",
    "metadata = {'lat': 36.010357, 'lon': -84.269646, 'ele': 850, 'created_at': None}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd38c13f",
   "metadata": {},
   "source": [
    "##### Loop\n",
    "\n",
    "We can only write data to the Adafruit cloud every 60 seconds but want to update the LCD screen more often cycling through the different readings. We use `time.time()` to keep track of the time elapsed since the last cycle through the loop. So we have the loop go as fast as we want for the LCD setup. When checking the time, we update values in the cloud only of the elaped time is greater than 60 seconds."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "50d4fd19",
   "metadata": {},
   "outputs": [],
   "source": [
    "start_time   = time.time()\n",
    "current_time = start_time\n",
    "\n",
    "update_data = 60.0\n",
    "update_msg  = 1800.0\n",
    "update_lcd  = 3.0\n",
    "next_lcd    = 't'\n",
    "\n",
    "running = True\n",
    "\n",
    "tvoc_alert = False\n",
    "tvoc_alert_level = 1500\n",
    "\n",
    "dashboard_url = \"https://io.adafruit.com/tproffen/dashboards/air-quality-oak-ridge\" # Update as needed\n",
    "\n",
    "while running:\n",
    "    try:        \n",
    "        # Only do the data update if elapsed time is multiple of upodate_data\n",
    "        if ((int (current_time - start_time) % update_data) == 0):\n",
    "            p  = bme280.get_pressure()\n",
    "            t  = bme280.get_temperature()\n",
    "            h  = bme280.get_humidity()\n",
    "            l  = ltr559.get_lux()\n",
    "            c  = ccs.eco2\n",
    "            v  = ccs.tvoc\n",
    "            t2 = readTemp() \n",
    "\n",
    "            clear_output(wait=True)          \n",
    "\n",
    "            out=\"T1: {0:.1f} C - T2: {1:.1f} C - Humidity: {2:.1f} % - Pressure: {3:.0f} hPa\".format(t,t2,h,p)\n",
    "            print(out)\n",
    "            out=\"CO2: {0:.1f} ppm - TVOC: {1:.1f} ppb\".format(c,v)\n",
    "            print(out)\n",
    "            print('Updated:',datetime.now())\n",
    "\n",
    "            # Send values to Adafruit cloud\n",
    "            \n",
    "            aio.send_data(tempFeed.key,  t, metadata)\n",
    "            aio.send_data(temp2Feed.key, t2, metadata)\n",
    "            aio.send_data(humidFeed.key, h, metadata)\n",
    "            aio.send_data(pressFeed.key, p, metadata)\n",
    "            aio.send_data(lightFeed.key, l, metadata)\n",
    "            aio.send_data(co2Feed.key, c, metadata)\n",
    "            aio.send_data(tvocFeed.key, v, metadata)\n",
    "        \n",
    "            # Sending data to Google Sheet\n",
    "            \n",
    "            now=datetime.now()\n",
    "            now_time = now.strftime(\"%H:%M:%S\")\n",
    "            now_day = now.strftime(\"%m/%d/%Y\")\n",
    "            row=[now_day, now_time, t, t2, h, p, l, c, v]\n",
    "            sheet.append_row(row)\n",
    "            \n",
    "            # Work through alerts\n",
    "            \n",
    "            if(v > tvoc_alert_level):\n",
    "                if(not tvoc_alert):\n",
    "                    tvoc_alert=True\n",
    "                    msg=\"⚠⚠⚠TVOC Reading is over {} ppb ⚠⚠⚠\".format(tvoc_alert_level)\n",
    "                    aio.send_data(msgFeed.key, msg, metadata)\n",
    "            else:\n",
    "                if(tvoc_alert):\n",
    "                    tvoc_alert=False\n",
    "                    msg=\"😀😃😃 TVOC Reading returned to below {} ppb 😀😃😃 \".format(tvoc_alert_level)\n",
    "                    aio.send_data(msgFeed.key, msg, metadata)\n",
    "                    \n",
    "        \n",
    "        # We send a status message to the message feed every update_msg\n",
    "        if ((int (current_time - start_time) % update_msg) == 0):\n",
    "            msg =\"<br>Temperature Internal: *{0:.1f} C* - External: *{1:.1f} C*\".format(t,t2)\n",
    "            msg+=\"<br>Humidity: *{0:.1f} %* - Pressure: *{1:.0f} hPa*\".format(h,p)\n",
    "            msg+=\"<br>Air quality: CO2: *{0:.1f} ppm* - TVOC: *{1:.1f} ppb*<br>\".format(c,v)\n",
    "            msg+=\"<br>Full dashboard: {}\".format(dashboard_url)\n",
    "            aio.send_data(msgFeed.key, msg, metadata)\n",
    "            \n",
    "        # We update the LCD every cycle\n",
    "        if (next_lcd == 't'):\n",
    "            updateLCD('Temperature', t, 'C')\n",
    "            next_lcd = 't2'\n",
    "        elif (next_lcd == 't2'):\n",
    "            updateLCD('Temperature (ext)', t2, 'C')\n",
    "            next_lcd = 'h'\n",
    "        elif (next_lcd == 'h'):\n",
    "            updateLCD('Humidity', h, '%')\n",
    "            next_lcd = 'p'\n",
    "        elif (next_lcd == 'p'):\n",
    "            updateLCD('Pressure', p, 'hPa')\n",
    "            next_lcd = 'c'\n",
    "        elif (next_lcd == 'c'):\n",
    "            updateLCD('CO2', c, 'ppm')\n",
    "            next_lcd = 'v'\n",
    "        elif (next_lcd == 'v'):\n",
    "            updateLCD('TVOC', v, 'ppb')\n",
    "            next_lcd = 't'\n",
    "\n",
    "        current_time = time.time()\n",
    "        time.sleep(update_lcd)\n",
    "        \n",
    "    except IOError:\n",
    "        pass\n",
    "    except KeyboardInterrupt:\n",
    "        print (\"Loop terminated by user.\")\n",
    "        running = False\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd4dc368",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}