Untitled8.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "designed-mistake",
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import board\n",
    "import busio\n",
    "import pandas as pd\n",
    "from pandas import DataFrame\n",
    "from matplotlib import pylab\n",
    "import matplotlib.pyplot as plt\n",
    "from pylab import *\n",
    "import pylab\n",
    "import numpy as np\n",
    "import matplotlib.colors as clrs\n",
    "import matplotlib.cm as cm\n",
    "import matplotlib\n",
    "from collections import deque\n",
    "\n",
    "import time\n",
    "import struct\n",
    "from struct import *\n",
    "from pyModbusTCP.client import ModbusClient\n",
    "\n",
    "#matplotlib.use('TkAgg')\n",
    "%matplotlib notebook\n",
    "#%matplotlib inline\n",
    "\n",
    "\n",
    "#import time\n",
    "import sys\n",
    "import sqlite3\n",
    "#from time import sleep\n",
    "\n",
    "#import adafruit_ads1x15.ads1015 as ADS\n",
    "import adafruit_ads1x15.ads1115 as ADS\n",
    "from adafruit_ads1x15.analog_in import AnalogIn\n",
    "\n",
    "import MySQLdb as db\n",
    "\n",
    "HOST = \"10.208.8.122\"\n",
    "PORT = 3306\n",
    "USER = \"yogi\"\n",
    "PASSWORD = \"bittoo\"\n",
    "DB = \"TemaccessToRemoteRp2\"\n",
    "'''\n",
    "try:\n",
    "    connection = db.Connection(host=HOST, port=PORT,\n",
    "                               user=USER, passwd=PASSWORD, db=DB)\n",
    "\n",
    "    c = connection.cursor()\n",
    "    c.execute(\"SELECT * from temSensor\")\n",
    "    result = c.fetchall()\n",
    "    for item in result:\n",
    "        print (item)\n",
    "\n",
    "except Exception as e:\n",
    "    print (e)\n",
    "'''\n",
    "connectionL = db.connect(host=\"10.208.8.121\",\n",
    "                     user=\"yogi\",\n",
    "                     passwd=\"bittoo\",\n",
    "                     db=\"allSensors\")\n",
    "\n",
    "#c = conn.cursor()\n",
    "connectionR = db.Connection(host=HOST, port=PORT,user=USER, passwd=PASSWORD, db=DB)\n",
    "\n",
    "cR = connectionR.cursor()\n",
    "cL =connectionL.cursor()\n",
    "\n",
    "i2c = busio.I2C(board.SCL, board.SDA)\n",
    "\n",
    "# Create the ADC object using the I2C bus\n",
    "ads = ADS.ADS1115(i2c)\n",
    "\n",
    "ads.gain = 1\n",
    "\n",
    "\n",
    "cL.execute('DROP TABLE IF EXISTS flowReadings;')\n",
    "print ('table flowReadings deleted')\n",
    "\n",
    "\n",
    "cL.execute('CREATE TABLE flowReadings(id INT AUTO_INCREMENT PRIMARY KEY,  \\\n",
    "ts TIMESTAMP DEFAULT CURRENT_TIMESTAMP, \\\n",
    "flowHP FLOAT, flowLoad FLOAT, watt FLOAT) ENGINE=MyISAM;')\n",
    "\n",
    "\n",
    "'''\n",
    "cL.execute('CREATE TABLE flowReadings(id INT AUTO_INCREMENT PRIMARY KEY,  \\\n",
    "ts TIMESTAMP DEFAULT CURRENT_TIMESTAMP, \\\n",
    "flowHP FLOAT, flowLoad FLOAT) ENGINE=MyISAM;')\n",
    "'''\n",
    "'''\n",
    "cL.execute('DROP TABLE IF EXISTS wattReadings;')\n",
    "print ('table wattReadings deleted')\n",
    "cL.execute('CREATE TABLE wattReadings(id INT AUTO_INCREMENT PRIMARY KEY,  \\\n",
    "ts TIMESTAMP DEFAULT CURRENT_TIMESTAMP, \\\n",
    "wattPower FLOAT);')\n",
    "'''\n",
    "\n",
    "#cvsFileName = import os.path\n",
    "#os.path.exists(file_path)\n",
    "\n",
    "lol=[[], [], [], []]\n",
    "flowRateLoad  = []\n",
    "wattMeterKw = []\n",
    "\n",
    "def flatten(l_of_l):\n",
    "    T = l_of_l[0]\n",
    "    flattend_l = [val for sublist in T for val in sublist]\n",
    "    #print ('flattened list is =', flattend_l)\n",
    "    return flattend_l\n",
    "\n",
    "\n",
    "timePeriod = []\n",
    "def timeStampCreator(Lol):\n",
    "    mHP = Lol[2]\n",
    "    T = flatten(Lol)\n",
    "    if len(mHP) == 1:\n",
    "        timeStamp = 2/3600\n",
    "        timePeriod.append(timeStamp)\n",
    "    elif len(mHP) > 1:\n",
    "        timeLast = T[-1][1]\n",
    "        timeSecondLast = T[-2][1]\n",
    "        timeStamp = timeLast -timeSecondLast\n",
    "        timeStamp = timeStamp.total_seconds()/3600\n",
    "        timePeriod.append(timeStamp)\n",
    "    return \n",
    "    \n",
    "def MCT_timeStamp(Lol, time_stamp):\n",
    "    mHP = Lol[2]\n",
    "    T = flatten(Lol)\n",
    "    mL = Lol[1]\n",
    "    watt_kW = Lol[3]\n",
    "    p_LperH = [999.8473664794213 + 6.29265190e-02*x[2] - 8.42930922e-03*x[2]**2 + 6.77190849e-05*x[2]**3 \\\n",
    " - 4.40840180e-07*x[2]**4 + 1.29302849e-09*x[2]**5 for x in T]\n",
    "    mF_kgPerS =[ x*2.7777e-07*y for x, y in zip(p_LperH, mHP)]\n",
    "    cP_kjPerkgK = [4.253264761904763 - 0.00470305*b[2] for b in T]\n",
    "    mCT_kW = [c*a*(b[3]-b[4]) for c, a, b in zip(cP_kjPerkgK,mF_kgPerS, T)]\n",
    "    mCT_kWh_l = [x*y for x,y in zip (time_stamp, mCT_kW)]\n",
    "    mCT_kWh = sum(mCT_kWh_l)\n",
    "    #electricty consumed:\n",
    "    watt_kW_l = [x*y for x,y in zip (time_stamp,  watt_kW)]\n",
    "    watt_kWh = sum(watt_kW_l)\n",
    "    #cop \n",
    "    cop =mCT_kWh/watt_kWh\n",
    "    #print ('cop of system is:', cop)\n",
    "    #print ('kwh heat addition is :', mCT_kWh)\n",
    "    #print ('whole kW list is:', mCT_kW)\n",
    "    #print ('electricity in khW is:', watt_kWh)\n",
    "    #print ('electricity consumption kW :', watt_kW)\n",
    "    return mCT_kW\n",
    "#electrictyPlotterList = []\n",
    "copPlotterList = []\n",
    "def Cop(Lol, time_stamp):\n",
    "    mHP = Lol[2]\n",
    "    T = flatten(Lol)\n",
    "    mL = Lol[1]\n",
    "    watt_kW = Lol[3]\n",
    "    p_LperH = [999.8473664794213 + 6.29265190e-02*x[2] - 8.42930922e-03*x[2]**2 + 6.77190849e-05*x[2]**3 \\\n",
    " - 4.40840180e-07*x[2]**4 + 1.29302849e-09*x[2]**5 for x in T]\n",
    "    mF_kgPerS =[ x*2.7777e-07*y for x, y in zip(p_LperH, mHP)]\n",
    "    cP_kjPerkgK = [4.253264761904763 - 0.00470305*b[2] for b in T]\n",
    "    mCT_kW = [c*a*(b[3]-b[4]) for c, a, b in zip(cP_kjPerkgK,mF_kgPerS, T)]\n",
    "    mCT_kWh_l = [x*y for x,y in zip (time_stamp, mCT_kW)]\n",
    "    mCT_kWh = sum(mCT_kWh_l)\n",
    "    #electricty consumed:\n",
    "    watt_kW_l = [x*y for x,y in zip (time_stamp,  watt_kW)]\n",
    "    watt_kWh = sum(watt_kW_l)\n",
    "    #cop \n",
    "    cop =mCT_kWh/watt_kWh\n",
    "    copPlotterList.append(cop)\n",
    "    #print ('cop of system is:', cop)\n",
    "    #print ('kwh heat addition is :', mCT_kWh)\n",
    "    #print ('whole kW list is:', mCT_kW)\n",
    "    #print ('electricity in khW is:', watt_kWh)\n",
    "    \n",
    "    #print ('electricity consumption kW :', watt_kW)\n",
    "    return cop\n",
    "\n",
    "\n",
    "l_id = []\n",
    "\n",
    "def idGenerator(Id, l_id):\n",
    "    if Id not in l_id:\n",
    "       l_id.append(Id) \n",
    "    #print (l_id)\n",
    "    return l_id\n",
    "\n",
    "#df_conc= None\n",
    "def dfs(Lol):\n",
    "    mHP = Lol[2]\n",
    "    T = flatten(Lol)\n",
    "    mL = Lol[1]\n",
    "    StartTemTestingtank = [ 'id', 'dateTime', 'Tamb', 'TtopTestTankHPCir', 'TbottomTestTankHpCir', 'TtopSourceTank', \\\n",
    "'TloadTankMix','TTopTestTankLoadCir', 'TloadMix', 'TbottomSourceTank', 'TbottomTestTankLoadCir']\n",
    "    l_T = ['T{}'.format(x) for x in range(0,10)]\n",
    "    L = StartTemTestingtank +l_T\n",
    "    df_mHP = DataFrame(mHP, columns=['flowHP'])\n",
    "    df_mL = DataFrame(mL, columns=['flowLoad'])\n",
    "    df_tem = DataFrame(T, columns = L)\n",
    "    df_conc = pd.concat([df_tem, df_mHP, df_mL], axis=1)\n",
    "    \n",
    "    #print (df_mL)\n",
    "    #print (df_mHP)\n",
    "    #print (df_tem)\n",
    "    #print ('TOut and Tin in Df is:', df_conc[['TTopTestTankLoadCir', 'TbottomTestTankLoadCir']])\n",
    "    return df_conc\n",
    "\n",
    "def list2df(lis, column_name = None):\n",
    "    df  = pd.DataFrame(lis, columns = [column_name]) \n",
    "    return df\n",
    "\n",
    "\n",
    "def toCsv(df_full, load_kW, heatCapacity_kW, electrictyUsed_kW, COP):\n",
    "    df_Tem_Flow_Load_capacity_conc = pd.concat([df_full, load_kW, heatCapacity_kW, electrictyUsed_kW, \\\n",
    "                                                COP], axis=1)\n",
    "    import os.path\n",
    "    import datetime\n",
    "    file_name = 'csvFile_{}'.format(datetime.datetime.now().strftime(\"%Y_%m_%d\"))\n",
    "    suffix = '.csv'\n",
    "    filePath = os.path.join(os.getcwd(), file_name + suffix)\n",
    "    df_Tem_Flow_Load_capacity_conc.to_csv(filePath, header=True)\n",
    "    return df_Tem_Flow_Load_capacity_conc\n",
    "\n",
    "'''\n",
    "def toCsv(df_full, load_kW, heatCapacity_kW):\n",
    "    df_Tem_Flow_Load_capacity_conc = pd.concat([df_full, load_kW, heatCapacity_kW], axis=1)\n",
    "    import os.path\n",
    "    import datetime\n",
    "    file_name = 'csvFile_{}'.format(datetime.datetime.now().strftime(\"%Y_%m_%d\"))\n",
    "    suffix = '.csv'\n",
    "    filePath = os.path.join(os.getcwd(), file_name + suffix)\n",
    "    df_Tem_Flow_Load_capacity_conc.to_csv(filePath, header=True)\n",
    "    return df_Tem_Flow_Load_capacity_conc\n",
    "'''\n",
    "\n",
    "def Load_kWh(Lol):\n",
    "    \n",
    "    mHP = Lol[2]\n",
    "    T = flatten(Lol)\n",
    "    mL = Lol[1]\n",
    "    #this is density as polynomial function of T\n",
    "    p_LperH = [999.8473664794213 + 6.29265190e-02*x[10] - 8.42930922e-03*x[10]**2 + 6.77190849e-05*x[10]**3 \\\n",
    " - 4.40840180e-07*x[10]**4 + 1.29302849e-09*x[10]**5 for x in T]\n",
    "    #print ('denisty is:', p_LperH )\n",
    "    #print ('Tem is:', [x[10] for x in T])\n",
    "    # this is mass flow  in kg/S =  density*V(flow rate in m^3/sec)= d * (1000^-3/3600)\n",
    "    mF_kgPerS =[ x*2.7777e-07*y for x, y in zip(p_LperH, mL)]\n",
    "    #this is Cp as functiono of T linear function\n",
    "    cP_kjPerkgK = [4.253264761904763 - 0.00470305*b[10] for b in T]\n",
    "    #print ('Cp is:', cP_kjPerkgK)\n",
    "    #Cp*M*deltaT\n",
    "    load_mCT_kW = [c*a*(b[7]-b[10]) for c, a, b in zip(cP_kjPerkgK,mF_kgPerS, T)]\n",
    "    #mCT2_kWh = sum([m*c*(dt[7]-dt[10])*0.0013888889 for m, c, dt in zip(mF_kgPerS,  cP_kjPerkgK, T)])\n",
    "    #load_mCT2_kWh = sum([m*c*(dt[7]-dt[10])*2.7777777e-05 for m, c, dt in zip(mF_kgPerS,  cP_kjPerkgK, T)])\n",
    "    #Time stamp uis 2 seconds 2* 1/3600\n",
    "    load_mCT2_kWh = sum([m*c*(dt[7]-dt[10])*0.000555555556 for m, c, dt in zip(mF_kgPerS,  cP_kjPerkgK, T)])\n",
    "    #print ('Load in kWh is:', load_mCT2_kWh)\n",
    "    return load_mCT_kW\n",
    "\n",
    "def tankStrat(df):\n",
    "    dfT = df.iloc[:, 11:-2]\n",
    "    #print (dfT.columns)\n",
    "    #print (dfT)\n",
    "    dfT = dfT[['T4', 'T3', 'T2', 'T1', 'T0', 'T9', 'T8', 'T7', 'T6', 'T5']]\n",
    "    dfT = dfT.rename({'T4':'T0', 'T3':'T1', 'T2':'T2', 'T1':'T3', 'T0':'T4', 'T9':'T5', 'T8':'T6',\\\n",
    "              'T7':'T7','T6':'T8','T5':'T9'}, axis='columns')\n",
    "    #dfT = dfT[['T4', 'T3', 'T2', 'T1', 'T0', 'T5', 'T6', 'T7', 'T8', 'T9']]\n",
    "    #dfT = dfT[['T4', 'T3', 'T2', 'T1', 'T0', 'T8', 'T9', 'T5', 'T6', 'T7']]\n",
    "    #dfT = dfT.rename({'T4':'T0', 'T3':'T1', 'T2':'T2', 'T1':'T3', 'T0':'T4', 'T8':'T5', 'T9':'T6',\\\n",
    "    #           'T5':'T7','T6':'T8','T7':'T9'}, axis='columns')\n",
    "    #dfT = dfT.rename({'T4':'T0', 'T3':'T1', 'T2':'T2', 'T1':'T3', 'T0':'T4', 'T5':'T5', 'T6':'T6',\\\n",
    "    #          'T7':'T7','T8':'T8','T9':'T9'}, axis='columns')\n",
    "    #dfT.columns = ['T4', 'T3', 'T2', 'T1', 'T0', 'T5', 'T6', 'T7', 'T8', 'T9']\n",
    "    #print (dfT)\n",
    "    return dfT\n",
    "#tankStratTem = tankStrat(df_conc)\n",
    "\n",
    "def create_color_step_obj(cmap_name, n):\n",
    "    \"\"\"\n",
    "    Return scalarMap object with n colors in gradient from color map\n",
    "    given in cmap_name.\n",
    "    \"\"\"\n",
    "    cmap = plt.get_cmap(cmap_name)\n",
    "    values = range(n)\n",
    "    cNorm  = clrs.Normalize(vmin=values[0], vmax=values[-1])\n",
    "    scalarMap = cm.ScalarMappable(norm=cNorm, cmap=cmap)\n",
    "    return scalarMap\n",
    "\n",
    "#import logging\n",
    "#logging.getLogger().setLevel(logging.CRITICAL)\n",
    "\n",
    "# colors\n",
    "\n",
    "\n",
    "cmap_name = \"jet\"\n",
    "scm = create_color_step_obj(cmap_name, 10)\n",
    "\n",
    "plt.ion()\n",
    "#plt.rcParams[\"figure.figsize\"]=5,5\n",
    "fig_size = plt.rcParams[\"figure.figsize\"]\n",
    "fig_size[0] = 8\n",
    "fig_size[1] = 3\n",
    "def plotObject(df, ax, fig, alpha =0.7, scm=None):\n",
    "    ax.clear()\n",
    "    for i in range (0, df.shape[1]):\n",
    "        ax.plot(df.index, df.iloc[:, i], color= scm.to_rgba(i, alpha=alpha),\\\n",
    "                label = 'Layer ' + str(i))\n",
    "        ax.legend(bbox_to_anchor=(0.4,0.8))\n",
    "    fig.canvas.draw()\n",
    "    ax.legend()\n",
    "    #plt.legend(loc='upper left')\n",
    "    return fig, ax\n",
    "    \n",
    "# initialize figure and interactivity\n",
    "fig = plt.figure(1)\n",
    "fig2 = plt.figure(2)\n",
    "\n",
    "\n",
    "ax = fig.add_subplot(121)\n",
    "ax_2 = fig.add_subplot(122)\n",
    "ax2 = fig2.add_subplot(122)\n",
    "ax2_1 = fig2.add_subplot(121)\n",
    "\n",
    "fig.canvas.draw()\n",
    "#plt.ion()\n",
    "\n",
    "fig.show()\n",
    "\n",
    "ax.legend(loc='best')\n",
    "ax.set_xlabel('Index')\n",
    "ax.set_ylabel('Tem, C', color='r')\n",
    "#################################\n",
    "#Plot for HPin, Hpout, TmixL tem.\n",
    "\n",
    "fig.show()\n",
    "fig.canvas.draw()\n",
    "ax_2.legend(loc='best')\n",
    "ax_2.set_xlabel('Index')\n",
    "ax_2.set_ylabel('Load in kW', color='r')\n",
    "def plotObject_Tem_HpAndLoad(df, ax_2, fig):\n",
    "    ax_2.clear()\n",
    "    ax_2.plot(df.index, df.iloc[:, 3], label = 'Hp to Testing tank top')\n",
    "    ax_2.plot(df.index, df.iloc[:, 4], label = 'Testing tank to HP Bottom')\n",
    "    ax_2.plot(df.index, df.iloc[:, 8], label = 'load tem Mixed')\n",
    "    \n",
    "    ax_2.legend(bbox_to_anchor=(0.4,0.8))\n",
    "    fig.canvas.draw()\n",
    "    ax_2.legend()\n",
    "    #plt.legend(loc='upper left')\n",
    "    return fig, ax_2\n",
    "##################################\n",
    "\n",
    "#fig2 = plt.figure(2)\n",
    "\n",
    "#plt.ion()\n",
    "\n",
    "fig2.show()\n",
    "fig2.canvas.draw()\n",
    "ax2.legend(loc='best')\n",
    "ax2.set_xlabel('Index')\n",
    "ax2.set_ylabel('Load in kW', color='r')\n",
    "def plotObject_Load(df, ax2, fig2):\n",
    "    ax2.clear()\n",
    "    ax2.plot(df.index, df.iloc[:, -2], label = 'Load in kW')\n",
    "    #ax2.plot(df.index, COP, label = 'cop')\n",
    "    print (df.index)\n",
    "    ax2.legend(bbox_to_anchor=(0.4,0.8))\n",
    "    fig2.canvas.draw()\n",
    "    ax2.legend()\n",
    "    #plt.legend(loc='upper left')\n",
    "    return fig2, ax2\n",
    "    \n",
    "# initialize figure and interactivity\n",
    "####Plot for heat_Capacity:\n",
    "\n",
    "fig2.show()\n",
    "fig2.canvas.draw()\n",
    "ax2_1.legend(loc='best')\n",
    "ax2_1.set_xlabel('Index')\n",
    "ax2_1.set_ylabel('Heat_Capacity in kW', color='r')\n",
    "def plotObject_Heat_Capacity(df, ax2_1, fig2):\n",
    "    ax2_1.clear()\n",
    "    ax2_1.plot(df.index, df.iloc[:, -3], label = 'heat_Capacity in kW')\n",
    "    ax2_1.plot(df.index, df.iloc[:, -2], label = 'electrcity_kW')\n",
    "    ax2_1.plot(df.index, df.iloc[:, -1], label = 'cop of system')\n",
    "    ax2_1.legend(bbox_to_anchor=(0.4,0.8))\n",
    "    fig2.canvas.draw()\n",
    "    ax2_1.legend()\n",
    "    #plt.legend(loc='upper left')\n",
    "    return fig2, ax2_1\n",
    "############\n",
    "\n",
    "while True:\n",
    "    #c.execute(\"INSERT INTO flowReadings(flowHp, flowLoad) VALUES(?,?,?,?)\", (chan2.voltage, chan1.voltage))\n",
    "    #connection.commit()\n",
    "    \n",
    "    ###################################################################################\n",
    "    ################################################\n",
    "    ##Modbus connection for wattmeter readings in kW\n",
    "    ##https://stackoverflow.com/questions/28186746/python-convert-2-ints-to-float\n",
    "    ################################################\n",
    "    \n",
    "    c = ModbusClient(host=\"10.208.8.125\", port=502, auto_open=True)\n",
    "    \n",
    "    #This reads the register address 19026 where all teh meteric(values of wattmeter) \n",
    "    #values are stored in a 16 bit values.county = 2, means read two values in the\n",
    "    #same register address.Register is a column (like in spreadsheet). each register\n",
    "    #store a 16 bit value, we read two 16 bit value and would convert those 2 16 bit \n",
    "    #value to a 32 bit floating point value by the formula\n",
    "    regs = c.read_input_registers(19026, 2)\n",
    "    #this is forst value of two counts\n",
    "    a = regs[0]\n",
    "    #This is second value of two counts\n",
    "    b = regs[1]\n",
    "    #This is how we convert two 16 bit value to a single 32 floating point number.\n",
    "    #from stackoverflow\n",
    "    mypack = pack('>HH',a,b)\n",
    "    #print (mypack)\n",
    "    fl = unpack('>f', mypack)\n",
    "    #fl = struct.unpack('!f', bytes.fromhex('{0:02x}'.format(a) + '{0:02x}'.format(b)))\n",
    "    #fl is a tuple (5.0186,) I need to unpack it index it with [0] \n",
    "    fl = fl[0]*10**-3\n",
    "    wattMeterKw.append(fl)\n",
    "    #lol[3].append(fl)\n",
    "    #print ('watter meter reaidngs are:', wattMeterKw)\n",
    "    #print ('gross lol is:', lol)\n",
    "    ####################################################################################\n",
    "    \n",
    "    chan1 = AnalogIn(ads, ADS.P0)\n",
    "    chan2 = AnalogIn(ads, ADS.P1)\n",
    "\n",
    "    chan1Vol = chan1.voltage\n",
    "    chan1curr = chan1Vol/159.42\n",
    "\n",
    "    chan2Vol = chan2.voltage\n",
    "    chan2curr=chan2Vol/159.65\n",
    "    #flow1 = ((chan1Vol/159.42)*1000 -4)/16*1000\n",
    "    flow1 = ((chan1Vol/159.42)-0.003956)/0.0000159\n",
    "    #flow2 = ((chan2Vol/159.65)*1000 -4)/16*4000 +20\n",
    "    #flow2 = ((chan2Vol/159.65)- 0.0005468893873066417)/1.09561608e-05\n",
    "    flow2 = ((chan2Vol/159.65)- 0.003973767754877122)/5.3038815e-06\n",
    "    cL.execute(\"INSERT INTO flowReadings(flowHp, flowLoad, watt) VALUES(%s, %s, %s)\", (flow2, flow1, fl))\n",
    "    connectionL.commit()\n",
    "    \n",
    "    #cL =connectionL.cursor()\n",
    "    cL.execute(\"SELECT * FROM flowReadings ORDER BY id DESC LIMIT 1\")\n",
    "    FlowFormDb = cL.fetchall()\n",
    "    print ('flow from FlowDB is :',FlowFormDb)\n",
    "\n",
    "    '''\n",
    "    #######################\n",
    "    ###Insert watt data into warrreadinsg table\n",
    "    ##################\n",
    "    cL.execute(\"INSERT INTO wattReadings(wattPower) VALUES(%s)\", (fl))\n",
    "    connectionL.commit()\n",
    "    cL.execute(\"SELECT * FROM wattReadings ORDER BY id DESC LIMIT 1\")\n",
    "    wattFromDB = cL.fetchall()\n",
    "    print ('wattData from DB is :', wattFromDB )\n",
    "    '''\n",
    "    \n",
    "\n",
    "    #c.execute(\"SELECT * from temSensor\")\n",
    "    #cR.execute(\"SELECT * FROM temSensor ORDER BY id DESC LIMIT 1\")\n",
    "    #result = cR.fetchall()\n",
    "    \n",
    "    #print('flow HP:',\"{:>5}\\t{:>5.3f}\".format(chan2.value, chan2.voltage), '\\n\\n')\n",
    "    #print('flow load:',\"{:>5}\\t{:>5.3f}\".format(chan1.value, chan1.voltage, '\\n\\n'))\n",
    "    print('flow rates load is = ',chan1Vol, chan1curr,flow1 )\n",
    "    print('flow rates HP is = ',chan2Vol, chan2curr,flow2 )\n",
    "\n",
    "    connectionR = db.Connection(host=HOST, port=PORT,user=USER, passwd=PASSWORD, db=DB)\n",
    "    cR = connectionR.cursor()\n",
    "    #c.execute(\"SELECT * from temSensor\")\n",
    "    cR.execute(\"SELECT * FROM temSensor ORDER BY id DESC LIMIT 1\")\n",
    "    result = cR.fetchall()\n",
    "    print ('result is',result)\n",
    "    id = result[0][0]\n",
    "    #idGenerator(id, l_id)\n",
    "    #print ('id is :', id)\n",
    "    flowRateLoad.append(flow1)\n",
    "\n",
    "    if lol[0] ==[] or id < lol[0][-1][0][0] :\n",
    "        lol[0].append(result)\n",
    "        #print (lol)\n",
    "        lol[1].append(flow1)\n",
    "        lol[2].append(flow2)\n",
    "        lol[3].append(fl)\n",
    "        timeStampCreator(lol)\n",
    "    elif lol[0] != [] and id > lol[0][-1][0][0]:\n",
    "\n",
    "        lol[0].append(result)\n",
    "        lol[1].append(flow1)\n",
    "        lol[2].append(flow2)\n",
    "        lol[3].append(fl)\n",
    "        timeStampCreator(lol)\n",
    "\n",
    "    print ('lengths of inner lists are:', len(lol[0]), len(lol[1]), len(lol[2]))\n",
    "    print ('last values in inner lists:', lol[0][-1], lol[1][-1])\n",
    "    #mct(lol)\n",
    "    #Load = Load_kWh(lol)\n",
    "    #print ('load in kWh is:', Load)\n",
    "    #print ('lol is:',lol)\n",
    "    #print ('df of tem is:',df_tem)\n",
    "    #print ('df is:', tankStrat(dfs(lol)))\n",
    "    df = tankStrat(dfs(lol))\n",
    "    #restTem = InletTem(dfs(lol))\n",
    "    #print (df)\n",
    "    cop = Cop(lol, timePeriod)\n",
    "    #print ('type of cop function in :', type(cop))\n",
    "    #print ('cop list shoudl look like this:', copPlotterList)\n",
    "    '''\n",
    "    GrossDf = toCsv(dfs(lol), list2df(Load_kWh(lol), 'Load_kW'), \\\n",
    "                    list2df(MCT_timeStamp(lol, timePeriod),'Heat_Capacity_kW'),\\\n",
    "                    list2df(wattMeterKw, 'electrcity_kW'), list2df(copPlotterList, 'COP'))\n",
    "    '''\n",
    "    #print ('gorss DF is :',GrossDf )\n",
    "    #GrossDf = toCsv(dfs(lol), list2df(Load_kWh(lol), 'Load_kW'), list2df(MCT_timeStamp(lol, timePeriod),'Heat_Capacity_kW'))\n",
    "    #heatAddition_kwh, cop = MCT_timeStamp(lol, timePeriod)\n",
    "    # Plot tem values as a seperate first fig\n",
    "    '''\n",
    "    fig, ax = plotObject(df, ax,  fig, alpha=0.7, scm=scm)\n",
    "    #plot load_kW in different fig2 \n",
    "    fig2, ax2 = plotObject_Load(GrossDf, ax2, fig2)\n",
    "    #Plot heat_Capacity in the same fig as fig2 but as a subplot\n",
    "    fig2, ax2_1 =plotObject_Heat_Capacity(GrossDf, ax2_1, fig2)\n",
    "    #This plot the HP in and out and tmixL laod tem.\n",
    "    fig, ax_1 = plotObject_Tem_HpAndLoad(GrossDf, ax_2, fig)\n",
    "    '''\n",
    "    #print ('df whole is:', dfs(lol))\n",
    "    #print ('df is:', df)\n",
    "    #plot(tankStrat(dfs(lol)), plotObject(tankStrat(dfs(lol))))\n",
    "    #plotObject(tankStrat(dfs(lol)))for i in range (0, 10):\n",
    "    #x = tankStrat(dfs(lol)).index[-1]\n",
    "    #y =tankStrat(dfs(lol)).iloc[-1]\n",
    "    #print ('x is:',x,'y is :',y)\n",
    "    #restTem = InletTem(dfs(lol))\n",
    "    #print ('rets of inlet tem values are:', restTem.iloc[:, 1])\n",
    "    #print ('gross lol is:', lol)\n",
    "    #print ('values in teh list are:', lol[0][-1][0][0])\n",
    "    #print ('GrossDf is :', GrossDf.iloc[:, 0:2])\n",
    "    #print ('grand lollolo is :', lol)\n",
    "    #MCT_timeStamp(lol)\n",
    "    #timeStampCreator(lol)\n",
    "    #MCT_timeStamp(lol, timePeriod)\n",
    "    \n",
    "    #print ('time stamp list is :',timePeriod )\n",
    "    print('________________________________________________________________')\n",
    "    time.sleep(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "urban-league",
   "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
}