sensors-sences.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "\n",
    "# GrovePi\n",
    "import grovepi# import *\n",
    "\n",
    "# LCD\n",
    "from drivers.LCD import *\n",
    "# import decimal\n",
    "# import drivers.grove_rgb_lcd as grove_rgb_lcd  #import *\n",
    "# import drivers.grove_oled as grove_oled #import *\n",
    "\n",
    "# Auxilary packages\n",
    "import time, math, csv, os\n",
    "import random as rd\n",
    "import numpy as np\n",
    "\n",
    "noiseTreshold = 700\n",
    "distanceTreshold0 = 30\n",
    "distanceTreshold1 = 600\n",
    "lightTreshold = 100\n",
    "gasTreshold = 0.7 #----------------------TODO: the sensor needs to be calibrated\n",
    "\n",
    "# Connected devices\n",
    "Devices = {\n",
    "    'sound_sensor': 1,    \n",
    "    'gas_sensor': 0,\n",
    "    'photoresistor': 2,\n",
    "    'led_red': 4,\n",
    "    'led_green': 3,\n",
    "    'led_yellow': 2,\n",
    "    'ledbar': 5,\n",
    "    'dht_sensor': 7,\n",
    "    'ultrasonic_ranger': 8\n",
    "}\n",
    "\n",
    "#sentences that will appear if a sensor theshold is exceeded\n",
    "sentences_sound = [\n",
    "        \"I've heard a noise!\", \n",
    "        \"Who's there?\", \n",
    "        'I can hear you!',\n",
    "        'Who is making noise?'\n",
    "        ]\n",
    "sentences_distance0 = [\n",
    "        'This is ultrasonic sensor', \n",
    "        'Hello there!', \n",
    "        'Ultrasonic sensor says it is close',\n",
    "        'Proximity alert!'\n",
    "        ]\n",
    "sentences_distance1 = [\n",
    "        'I can see you!', \n",
    "        'Who is there?', \n",
    "        'Someone is in front of me.',\n",
    "        'Hello?'\n",
    "        ]\n",
    "sentences_light = [\n",
    "        'This is dark', \n",
    "        'Who turned off the light?', \n",
    "        'Did you cover photo diod?',\n",
    "        'Photo diod says it is dark'\n",
    "        ]\n",
    "sentences_gas = [\n",
    "        'I smell gas!', \n",
    "        'Gas norm exceded',\n",
    "        'Combustible gas?',\n",
    "        'Gas sensor is picking something'\n",
    "        ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "unit_test = False\n",
    "\n",
    "if unit_test:\n",
    "    lcd = LCD()\n",
    "    lcd.defaultColour()\n",
    "    \n",
    "    lcd.newMessage('hello0', colour=[10,200,200])\n",
    "    lcd.newMessage('hello1', colour=[10,200,100])\n",
    "    lcd.newMessage('hello2', colour=[200,100,10])\n",
    "\n",
    "    print(lcd.pendingMessages)\n",
    "    \n",
    "    for i in lcd.pendingMessages:\n",
    "        lcd.displayMessage()\n",
    "        time.sleep(2)\n",
    "        lcd.endDisplayMessage()\n",
    "        \n",
    "# LED Bar methods\n",
    "# grovepi.ledBar_init(pin,orientation)\n",
    "# grovepi.ledBar_orientation(pin,orientation)\n",
    "# grovepi.ledBar_setLevel(pin,level)\n",
    "# grovepi.ledBar_setLed(pin,led,state)\n",
    "# grovepi.ledBar_toggleLed(pin,led)\n",
    "# grovepi.ledBar_setBits(pin,state)\n",
    "# grovepi.ledBar_getBits(pin)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "file <readings/2018-01-15_17:09:45.csv> open\n",
      "date_and_time        dist   light  sound  hum    temp   gas  \n",
      "2018-01-15 17:09:51, 515cm, 35lum,107dB, 42.0%, 22.0C, 0.503   \n",
      "process interrupted 2018-01-15 17:09:53\n",
      "file <readings/2018-01-15_17:09:45.csv> closed\n",
      "\n",
      "\n",
      "average iteration processing time: 0.4494523321 ms\n",
      "maximum fps possible: 2.2249300507 ms\n"
     ]
    }
   ],
   "source": [
    "computationalSpeed = []\n",
    "\n",
    "def resetLEDs():      \n",
    "    grovepi.analogWrite(Devices['led_green'],0) \n",
    "    grovepi.digitalWrite(Devices['led_yellow'],0)\n",
    "    grovepi.digitalWrite(Devices['led_red'],0)    \n",
    "    grovepi.ledBar_init(Devices['ledbar'], 1)\n",
    "    grovepi.ledBar_setBits(Devices['ledbar'], 0)\n",
    "    \n",
    "def resetPINs():\n",
    "    grovepi.pinMode(Devices['led_red'],\"OUTPUT\")\n",
    "    grovepi.pinMode(Devices['led_green'],\"OUTPUT\")\n",
    "    grovepi.pinMode(Devices['led_yellow'],\"OUTPUT\")\n",
    "    grovepi.pinMode(Devices['ledbar'],\"OUTPUT\")\n",
    "    grovepi.pinMode(Devices['photoresistor'],\"INPUT\")\n",
    "    grovepi.pinMode(Devices['sound_sensor'],\"INPUT\")\n",
    "    grovepi.pinMode(Devices['gas_sensor'],\"INPUT\")\n",
    "    grovepi.pinMode(Devices['ultrasonic_ranger'],\"INPUT\")\n",
    "    grovepi.pinMode(Devices['dht_sensor'],\"INPUT\")     \n",
    "    \n",
    "def rectify(param,paramTreshold):\n",
    "    if param < paramTreshold:\n",
    "        return 1\n",
    "    else:   \n",
    "        return 0 \n",
    "\n",
    "\n",
    "def mainEvent(fps = 1.0, lcd_fps = 0.25, messageDuration = 3.0, readCooldown = 0.01, lcdMessages=True, interactive = True, exitOnReadError=False):       \n",
    "    \n",
    "    spf = 1 / fps\n",
    "    lcdMain_spf = 1 / lcd_fps  \n",
    "    frametime = spf    \n",
    "    lcdMain_frametime = lcdMain_spf\n",
    "    lcdMain_starttime = time.time()        \n",
    "    lcdMessage_starttime = 3.0\n",
    "    lcdMessage_frametime = 3.0   \n",
    "    messageInProgress = False   \n",
    "    \n",
    "    lcd = LCD()\n",
    "    resetPINs()\n",
    "    resetLEDs()    \n",
    "    dst_prev, dst_next = 0, 0\n",
    "    lt_prev, lt_next = 0, 0\n",
    "    lcd.defaultColour()\n",
    "        \n",
    "    \n",
    "    outfilename = os.path.join('readings',time.strftime('%Y-%m-%d_%H:%M:%S', time.localtime(time.time())) + '.csv')\n",
    "    with open(outfilename, 'w') as csvfile:\n",
    "        print(\"file <%s> open\" % outfilename)\n",
    "        fieldnames = ['starttime','distance','light','sound','hum','temp','gas']\n",
    "        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)\n",
    "        writer.writeheader()        \n",
    "        try:\n",
    "            print('date_and_time        dist   light  sound  hum    temp   gas  ')\n",
    "            while True:                  \n",
    "                if frametime >= spf:\n",
    "                    starttime = time.time()               \n",
    "\n",
    "                    # reading from sensors analogWrite\n",
    "                    try:\n",
    "                        time.sleep(readCooldown)\n",
    "                        sound = grovepi.analogRead(Devices['sound_sensor'])\n",
    "                        if not type(sound) is int:\n",
    "                            sound = 0\n",
    "                        time.sleep(readCooldown)\n",
    "                        light = grovepi.analogRead(Devices['photoresistor'])\n",
    "                        time.sleep(readCooldown)\n",
    "                        distance = grovepi.ultrasonicRead(Devices['ultrasonic_ranger'])\n",
    "                        time.sleep(readCooldown)\n",
    "                        [temp, hum] = grovepi.dht(Devices['dht_sensor'], 0) \n",
    "                        time.sleep(readCooldown)\n",
    "                        gas = (float)(grovepi.analogRead(Devices['gas_sensor']) / 1023)      \n",
    "                        time.sleep(readCooldown)\n",
    "                    except TypeError:\n",
    "                        distance,light,sound,hum,temp,gas = -1,-1,-1,-1,-1,-1\n",
    "                        if exitOnReadError:\n",
    "                            raise SystemExit()                   \n",
    "\n",
    "                    # write to CSV                \n",
    "                    t = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(starttime))\n",
    "                    if not interactive:\n",
    "                        writer.writerow({'starttime':starttime,'distance':distance,'light':light,'sound':sound,'hum':hum,'temp':temp,'gas':gas})\n",
    "                    \n",
    "                    # message on LCD ?\n",
    "                    if lcdMessages:\n",
    "                        if not messageInProgress:\n",
    "                            if sound > noiseTreshold:     \n",
    "                                sentence = rd.randint(0,len(sentences_sound)-1)\n",
    "                                lcd.newMessage(sentences_sound[sentence], colour=[10,200,200])\n",
    "                            if distance < distanceTreshold0 and distance>0:\n",
    "                                sentence = rd.randint(0,len(sentences_distance0)-1)\n",
    "                                lcd.newMessage(sentences_distance0[sentence], colour=[10,200,10]) \n",
    "                            if light < lightTreshold:\n",
    "                                sentence = rd.randint(0,len(sentences_light)-1)\n",
    "                                lcd.newMessage(sentences_light[sentence], colour=[200,200,10])  \n",
    "                            if gas > gasTreshold:\n",
    "                                sentence = rd.randint(0,len(sentences_gas)-1)\n",
    "                                lcd.newMessage(sentences_gas[sentence], colour=[250,50,10])  \n",
    "\n",
    "                        if len(lcd.pendingMessages) > 0: \n",
    "                            if not messageInProgress:\n",
    "                                lcdMessage_starttime = time.time()\n",
    "                                lcd.displayMessage() \n",
    "                                messageInProgress = True\n",
    "\n",
    "                        if messageInProgress:\n",
    "                            if lcdMessage_frametime >= messageDuration:\n",
    "                                lcd.endDisplayMessage()     \n",
    "                                messageInProgress = False\n",
    "\n",
    "                    if lcdMain_frametime >= lcdMain_spf:\n",
    "                        if not messageInProgress:\n",
    "                            lcdMain_starttime = time.time() \n",
    "                            stringForLCD = 'lumi temp  humid%4d%5.1fC%5.1f%%' % (light, temp, hum)\n",
    "                            lcd.updateTextVar(stringForLCD)\n",
    "                            lcd.updateText()\n",
    "                    \n",
    "                    if interactive:\n",
    "                        #if interactive:\n",
    "                        #    grovepi.ledBar_setLevel(Devices['ledbar'],int(sound/102.3))\n",
    "                        #LED reaction\n",
    "    #                     grovepi.analogWrite(Devices['led_green'],int(sound/4))\n",
    "                        #grovepi.analogWrite(Devices['led_green'],255-int(light/4))\n",
    "                        grovepi.ledBar_setLevel(Devices['ledbar'],int(sound/102.3))\n",
    "                        grovepi.analogWrite(Devices['led_green'],255-int(distance*255/1023))   #int(distance/4))\n",
    "                        \n",
    "                        #---avoiding excessive write to LEDs                \n",
    "                        dst_next = rectify(distance, distanceTreshold0)                \n",
    "                        if dst_prev != dst_next:  \n",
    "                            grovepi.digitalWrite(Devices['led_red'],dst_next)\n",
    "                            dst_prev = dst_next     \n",
    "                        \n",
    "                        \n",
    "                        lt_next = rectify(light,lightTreshold)\n",
    "                        if lt_prev != lt_next:\n",
    "                            grovepi.digitalWrite(Devices['led_yellow'],lt_next)\n",
    "                            lt_prev = lt_next\n",
    "                    \n",
    "                    computationalSpeed.append(time.time()-starttime)\n",
    "                    if time.time()-starttime > fps:\n",
    "                        print('\\nwarning: frame skipping')\n",
    "                    #print('%s, %dcm, %dlum,%ddB' % (t,distance,light,sound) )  \n",
    "                    print('%s, %dcm, %dlum,%ddB, %3.1f%%, %3.1fC, %3.3f   ' % (t,distance,light,sound,hum,temp,gas), end='\\r')\n",
    "                    \n",
    "    #             else:\n",
    "    #                 if grovepi.analogRead(Devices['sound_sensor']) > noiseTreshold:     \n",
    "    #                     sentence = rd.randint(0,len(sentences_sound)-1)\n",
    "    #                     lcd.newMessage(sentences_sound[sentence], colour=[10,200,200])\n",
    "\n",
    "                # FIXED TIME STEP technique\n",
    "                frametime = time.time() - starttime\n",
    "                lcdMain_frametime = time.time() - lcdMain_starttime\n",
    "                lcdMessage_frametime = time.time() - lcdMessage_starttime\n",
    "        except (KeyboardInterrupt, SystemExit):\n",
    "            resetLEDs()      \n",
    "            grovepi.ledBar_setBits(Devices['ledbar'], 0)\n",
    "            lcd.reset()\n",
    "            print(\"\\nprocess interrupted %s\" % time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())))            \n",
    "            \n",
    "    print(\"file <%s> closed\" % outfilename)    \n",
    "    aipt = np.mean(computationalSpeed)\n",
    "    print(\"\\n\\naverage iteration processing time: %5.10f ms\" % aipt)\n",
    "    print(\"maximum fps possible: %5.10f ms\" % (1/aipt))\n",
    "           \n",
    "# mainEvent(fps=1.0, exitOnReadError=True, readCooldown = 0.005, interactive = True, lcdMessages=True)\n",
    "\n",
    "mainEvent(fps=1.0, lcdMessages=False, exitOnReadError=True, readCooldown = 0.05)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "Tuple or struct_time argument required",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-3-d0b93321660c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"\\nprocess interrupted %s\"\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0mtime\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstrftime\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'%Y-%m-%d %H:%M:%S'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtime\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: Tuple or struct_time argument required"
     ]
    }
   ],
   "source": [
    "print(\"\\nprocess interrupted %s\" % time.strftime('%Y-%m-%d %H:%M:%S', time.time()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2017-11-24 23:14:19'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "file opened <readings/2017-11-24_23:13:42.csv>\n",
      "file closed <readings/2017-11-24_23:13:42.csv>\n"
     ]
    }
   ],
   "source": [
    "outfilename = os.path.join('readings',time.strftime('%Y-%m-%d_%H:%M:%S', time.localtime(time.time())) + '.csv')\n",
    "with open(outfilename, 'w') as csvfile:\n",
    "    print(\"file opened <%s>\" % outfilename)\n",
    "print(\"file closed <%s>\" % outfilename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "resetLEDs()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "outfilename = 'readings.csv'\n",
    "with open(outfilename, 'w') as csvfile:\n",
    "    print(\"writing to <%s>\" % outfilename)\n",
    "    fieldnames = ['starttime','distance','light','sound','hum','temp']\n",
    "\n",
    "    starttime = time.time()\n",
    "    sound = 55\n",
    "    distance = 527    \n",
    "    light = 600\n",
    "    temp = 25.6\n",
    "    hum = 20.2\n",
    "\n",
    "    writer = csv.DictWriter(csvfile, fieldnames=fieldnames)\n",
    "\n",
    "    writer.writeheader()\n",
    "    writer.writerow({'starttime':starttime,'distance':distance,'light':light,'sound':sound,'hum':hum,'temp':temp})\n",
    "print(\"<%s> closed\" % outfilename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "unit_test = False\n",
    "if unit_test:\n",
    "\n",
    "    light = 653\n",
    "    temp = 25.6\n",
    "    hum = 20.2\n",
    "\n",
    "#     stringForLCD = 'lumi temp  humid'+str(int(light*999/1024))+'  '+str(temp)+'C '+str(hum)+'%'\n",
    "    stringForLCD = 'lumi temp  humid%4d%5.1fC%5.1f%%' % (light, temp, hum)\n",
    "    lcd.updateTextVar(stringForLCD)\n",
    "    lcd.updateText()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2017-11-22 01:28:05,   266cm,   567lum,   320\n",
      "\n",
      "average iteration processing time: 0.0785594881 ms\n",
      "maximum fps possible: 12.7292071870 ms\n"
     ]
    }
   ],
   "source": [
    "computationalSpeed = []\n",
    "\n",
    "def event(fps=1.0, distanceTreshold0=25):    \n",
    "    frametime = fps\n",
    "    \n",
    "    dst_prev, dst_next = 0, 0   \n",
    "    lt_prev, lt_next = 0, 0\n",
    "    \n",
    "    try:\n",
    "        while True:\n",
    "            if frametime >= 1/fps:\n",
    "                starttime = time.time()  \n",
    "                \n",
    "                # reading from sensors        \n",
    "                sound = grovepi.analogRead(Devices['sound_sensor'])     \n",
    "#                 sound = 0\n",
    "                light = grovepi.analogRead(Devices['photoresistor'])\n",
    "                distance = grovepi.ultrasonicRead(Devices['ultrasonic_ranger'])\n",
    "                [temp, hum] = grovepi.dht(Devices['dht_sensor'], 0)        \n",
    "#                 gas = grovepi.analogRead(Devices['gas_sensor'])  \n",
    "                \n",
    "                #LED reaction\n",
    "#                 grovepi.analogWrite(Devices['led_green'],int(sound/4))\n",
    "                #grovepi.analogWrite(Devices['led_green'],255-int(light/4))\n",
    "                grovepi.ledBar_setLevel(Devices['ledbar'],int(sound/102.3))  \n",
    "                #---avoiding excessive write to LEDs                \n",
    "                dst_next = rectify(distance, distanceTreshold0)                \n",
    "                if dst_prev != dst_next:\n",
    "                    grovepi.digitalWrite(Devices['led_red'],dst_next)\n",
    "                    dst_prev = dst_next                    \n",
    "                \n",
    "                lt_next = rectify(light,lightTreshold)\n",
    "                if lt_prev != lt_next:\n",
    "                    grovepi.digitalWrite(Devices['led_yellow'],lt_next)\n",
    "                    lt_prev = lt_next\n",
    "                    \n",
    "                print('%s, %5dcm, %5dlum, %5d' % (time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(starttime)),distance, light, sound), end='\\r')\n",
    "                \n",
    "                computationalSpeed.append(time.time()-starttime)\n",
    "            # FIXED TIME STEP technique\n",
    "            frametime = time.time() - starttime\n",
    "\n",
    "    except (KeyboardInterrupt, SystemExit):\n",
    "        grovepi.analogWrite(Devices['led_green'],0)  \n",
    "        grovepi.digitalWrite(Devices['led_yellow'],0)\n",
    "        grovepi.digitalWrite(Devices['led_red'],0)\n",
    "        aipt = np.mean(computationalSpeed)\n",
    "        print(\"\\n\\naverage iteration processing time: %5.10f ms\" % aipt)\n",
    "        print(\"maximum fps possible: %5.10f ms\" % (1/aipt))\n",
    "        if fps > 1/aipt:\n",
    "            print(\"warning: frame skipping\")\n",
    "\n",
    "event()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grovepi.digitalWrite(4,1)\n",
    "# grovepi.analogWrite(Devices['led_red'],100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grovepi.ledBar_init(5, 1)\n",
    "grovepi.ledBar_setLevel(5, 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# grovepi.analogWrite(3,200)  \n",
    "# grovepi.digitalWrite(2,1)\n",
    "# grovepi.digitalWrite(Devices['led_yellow'],0)\n",
    "# grovepi.digitalWrite(Devices['led_red'],0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grovepi.analogWrite(3,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for i in range(1023):\n",
    "#     sound = analogRead(Devices['sound_sensor'])\n",
    "#     analogWrite(Devices['led_green'],i)\n",
    "#     if i%10==0:\n",
    "#         time.sleep(0.3)\n",
    "#     print('%d, %f' % (i,sound), end='\\r', flush=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "writing to <readings.csv>\n",
      "<readings.csv> closed\n"
     ]
    }
   ],
   "source": [
    "# if False:\n",
    "#     outfilename = 'readings.csv'\n",
    "#     with open(outfilename, 'w') as csvfile:\n",
    "#         print(\"writing to <%s>\" % outfilename)\n",
    "#         fieldnames = ['starttime','distance','light','sound','hum','temp']\n",
    "\n",
    "#         starttime = time.time()\n",
    "#         sound = 55\n",
    "#         distance = 527    \n",
    "#         light = 600\n",
    "#         temp = 25.6\n",
    "#         hum = 20.2\n",
    "\n",
    "#         writer = csv.DictWriter(csvfile, fieldnames=fieldnames)\n",
    "\n",
    "#         writer.writeheader()\n",
    "#         writer.writerow({'starttime':starttime,'distance':distance,'light':light,'sound':sound,'hum':hum,'temp':temp})\n",
    "#     print(\"<%s> closed\" % outfilename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # from grovepi import *\n",
    "# # from grove_oled import *\n",
    "\n",
    "\n",
    "# #Start and initialize the OLED\n",
    "# oled_init()\n",
    "# oled_clearDisplay()\n",
    "# oled_setNormalDisplay()\n",
    "# oled_setVerticalMode()\n",
    "# time.sleep(.1)\n",
    "\n",
    "# while True:\n",
    "#     try:\n",
    "#         [ temp,hum ] = dht(dht_sensor,1)\t\t#Get the temperature and Humidity from the DHT sensor\n",
    "#         string = \"temp =\"+ str(temp)+ \"C\\thumidity =\"+ str(hum)+\"%\"\n",
    "#         print(string, end='\\r', flush=True)\n",
    "#         t = str(temp)\n",
    "#         h = str(hum)\n",
    "\n",
    "#         oled_setTextXY(0,1)\t\t\t#Print \"WEATHER\" at line 1\n",
    "#         oled_putString(\"WEATHER\")\n",
    "\n",
    "#         oled_setTextXY(2,0)\t\t\t#Print \"TEMP\" and the temperature in line 3\n",
    "#         oled_putString(\"Temp:\")\n",
    "#         oled_putString(t+'C')\n",
    "\n",
    "#         oled_setTextXY(3,0)\t\t\t#Print \"HUM :\" and the humidity in line 4\n",
    "#         oled_putString(\"Hum :\")\n",
    "#         oled_putString(h+\"%\")\n",
    "#     except (IOError,TypeError) as e:\n",
    "#         print(\"Error\", end='\\r', flush=True)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import decimal\n",
    "# from grovepi import *\n",
    "# from drivers.grove_rgb_lcd import *\n",
    "\n",
    "\n",
    "# dht_sensor_port = 7     # Connect the DHt sensor to port 7\n",
    "# lastTemp = 0.1          # initialize a floating point temp variable\n",
    "# lastHum = 0.1           # initialize a floating Point humidity variable\n",
    "# tooLow = 62.0           # Lower limit in fahrenheit\n",
    "# justRight = 68.0        # Perfect Temp in fahrenheit\n",
    "# tooHigh = 74.0          # Temp Too high\n",
    "\n",
    "\n",
    "# # Function Definitions\n",
    "# def CtoF( tempc ):\n",
    "#    \"This converts celcius to fahrenheit\"\n",
    "#    tempf = round((tempc * 1.8) + 32, 2);\n",
    "#    return tempf;\n",
    "\n",
    "# def FtoC( tempf ):\n",
    "#    \"This converts fahrenheit to celcius\"\n",
    "#    tempc = round((tempf - 32) / 1.8, 2)\n",
    "#    return tempc;\n",
    "\n",
    "# def calcColorAdj(variance):     # Calc the adjustment value of the background color\n",
    "#     \"Because there is 6 degrees mapping to 255 values, 42.5 is the factor for 12 degree spread\"\n",
    "#     factor = 42.5;\n",
    "#     adj = abs(int(factor * variance));\n",
    "#     if adj > 255:\n",
    "#         adj = 255;\n",
    "#     return adj;\n",
    "\n",
    "# def calcBG(ftemp):\n",
    "#     \"This calculates the color value for the background\"\n",
    "#     variance = ftemp - justRight;   # Calculate the variance\n",
    "#     adj = calcColorAdj(variance);   # Scale it to 8 bit int\n",
    "#     bgList = [0,0,0]               # initialize the color array\n",
    "#     if(variance < 0):\n",
    "#         bgR = 0;                    # too cold, no red\n",
    "#         bgB = adj;                  # green and blue slide equally with adj\n",
    "#         bgG = 255 - adj;\n",
    "        \n",
    "#     elif(variance == 0):             # perfect, all on green\n",
    "#         bgR = 0;\n",
    "#         bgB = 0;\n",
    "#         bgG = 255;\n",
    "        \n",
    "#     elif(variance > 0):             #too hot - no blue\n",
    "#         bgB = 0;\n",
    "#         bgR = adj;                  # Red and Green slide equally with Adj\n",
    "#         bgG = 255 - adj;\n",
    "        \n",
    "#     bgList = [bgR,bgG,bgB]          #build list of color values to return\n",
    "#     return bgList;\n",
    "\n",
    "# while True:\n",
    "\n",
    "#     try:\n",
    "#         temp = 0.01\n",
    "#         hum = 0.01\n",
    "#         [ temp,hum ] = dht(dht_sensor_port,0)       #Get the temperature and Humidity from the DHT sensor\n",
    "#                                                     #Change the second parameter to 0 when using DHT (instead of DHT Pro)\n",
    "#                                                     #You will get very large number values if you don't!\n",
    "#         if (CtoF(temp) != lastTemp) and (hum != lastHum) and not math.isnan(temp) and not math.isnan(hum):\n",
    "#                 print(\"lowC : \",FtoC(tooLow),\"C\\t\\t\",\"rightC  : \", FtoC(justRight),\"C\\t\\t\",\"highC : \",FtoC(tooHigh),\"C\") # comment these three lines\n",
    "#                 print(\"lowF : \",tooLow,\"F\\t\\tjustRight : \",justRight,\"F\\t\\ttoHigh : \",tooHigh,\"F\")                       # if no monitor display\n",
    "#                 print(\"tempC : \", temp, \"C\\t\\ttempF : \",CtoF(temp),\"F\\t\\tHumidity =\", hum,\"%\\r\\n\")\n",
    "                \n",
    "#                 lastHum = hum          # save temp & humidity values so that there is no update to the RGB LCD\n",
    "# #                 ftemp = CtoF(temp)     # unless the value changes\n",
    "#                 lastTemp = temp       # this reduces the flashing of the display\n",
    "#                 # print \"ftemp = \",ftemp,\"  temp = \",temp   # this was just for test and debug\n",
    "                \n",
    "#                 bgList = calcBG(temp)           # Calculate background colors\n",
    "                \n",
    "#                 t = str(temp)   # \"stringify\" the display values\n",
    "#                 h = str(hum)\n",
    "#                 # print \"(\",bgList[0],\",\",bgList[1],\",\",bgList[2],\")\"   # this was to test and debug color value list\n",
    "#                 setRGB(bgList[0],bgList[1],bgList[2])   # parse our list into the color settings\n",
    "#                 setText(\"Temp:\" + t + \"C      \" + \"Humidity :\" + h + \"%\") # update the RGB LCD display\n",
    "                \n",
    "#     except (IOError,TypeError) as e:\n",
    "#         print(\"Error\" + str(e))\n",
    "    \n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.5.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}