# standard library

import sys

import os

import time

import logging

# third party

from PyQt4 import QtCore

from PyQt4 import QtGui

from PyQt4 import uic

# local library

import gr # TESTING shell

import qtgr

from qtgr.backend import QtCore, QtGui

from qtgr.events import GUIConnector, MouseEvent, PickEvent, LegendEvent

from gr.pygr import Plot, PlotAxes, PlotCurve, ErrorBar

class MainWindow(QtGui.QMainWindow):

shared_memory['start'] = False

def get_temp( send=False, on_time=0 ):

shared_memory['data_fresh'] = True

def window_main(*args):

sys.exit(app.exec_())

if __name__ == "__main__":

import PID

from BathController import BathController

from multiprocessing import Process, Manager, Lock

from ConfigParser import SafeConfigParser

def resistance_to_watts(resistance, voltage):

""" Calculate element wattage from resitance and voltage """

return (voltage**2)/resistance

def joules_to_watt_seconds(joules, element_wattage):

""" Calculate element time from energy in joules """

return float(joules/element_wattage)

def temperature_to_joules(temp_obj, temp_amb, mass_kg, heat_capacity):

""" Calculate energy contained within the bath medium """

return float((heat_capacity * (mass_kg*1000) * (temp_obj - temp_amb)))

def boltzmann_loss(emissivity, area, temp_obj, temp_amb):

return emissivity*boltzmann_const*a

manager = Manager()

config = SafeConfigParser()

config.read('config.conf')

shared_memory = manager.dict({

'env_temp':None,

'bath_temp':None,

'heatCapacity':float(config.get('Tuning', 'Heat_Capacity')),

'mass':float(config.get('Tuning', 'Mass')),

'emissivity':float(config.get('Tuning', 'Emissivity')),

'area':float(config.get('Tuning', 'Area')),

'resistance':float(config.get('Tuning', 'Resistance')),

'voltage':float(config.get('Tuning', 'Voltage')),

'p':float(config.get('Tuning', 'P')),

'i':float(config.get('Tuning', 'I')),

'd':float(config.get('Tuning', 'D')),

'target':None,

'start':False,

'data_fresh':False

})

controller = BathController(config.get('Connection', 'Port'),

config.get('Connection', 'Baud'))

time.sleep(3)

print "\rLift off!"

get_temp()

# Start main window thread

window_thread = Process(target = window_main, args = (sys.argv, shared_memory))

window_thread.daemon = True

window_thread.start()

# Initialise PID object

pid = PID.control(shared_memory['p'], shared_memory['i'], shared_memory['d'])

# Whilst the UI is open

while window_thread.is_alive():

# Kick over

get_temp()

#get_temp()

if shared_memory['start'] and shared_memory['target'] is not None:

To = shared_memory['target']

Ta = shared_memory['env_temp']

m = shared_memory['mass']

h = shared_memory['heatCapacity']

e = shared_memory['emissivity']

a = shared_memory['area']

w = resistance_to_watts(shared_memory['resistance'], shared_memory['voltage'])

set_point = temperature_to_joules(To, Ta, m, h)

set_point += boltzmann_loss(e, a, To, Ta)

if shared_memory['start'] and window_thread.is_alive():

cycleStart = time.time()

current_energy = temperature_to_joules(shared_memory['bath_temp'],

shared_memory['env_temp'], m, h)

# send the PID controller set_energy - stored energy (error)

energy_output = pid.genOut(set_point - current_energy)

# pid returns energy to put in, convert to watt seconds

element_time = joules_to_watt_seconds(energy_output, w)

print 'Element time = ', element_time

if element_time > 0.0: get_temp(send=True, on_time=int(element_time*1000))

time.sleep(10 - (time.time()-cycleStart))

time.sleep(5)