# 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 """

# 4.184 is cal -> joule, specific heat is cal/g/c, we want joule/g/k

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

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']/10000.0, shared_memory['i']/10000.0, shared_memory['d']/10000.0)

# Whilst the UI is open

while window_thread.is_alive():

# Kick over

get_temp()

#get_temp()

if shared_memory['start'] and shared_memory['data_fresh']:

cycleStart = time.time()

dist = None

target_reached = False

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

cycleStart = time.time()

To = shared_memory['target']

Ta = shared_memory['env_temp']

Tb = shared_memory['bath_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'])

if Tb >= To: target_reached = True

# Calculate desired energy within medium

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

# print "Set point is {0} Joules".format(set_point)

# Add boltzmann radiated loss for that moment

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

# Assess the current energy within medium

current_energy = temperature_to_joules(Tb, Ta, m, h)

print "\nCurrent stored energy is {0} Joules".format(current_energy)

bltz = boltzmann_loss(e,a, Tb, Ta)

# Add boltzamn

energy_deficit = set_point - current_energy #+ bltz

# First loop? save total error for adaptive tuning

if dist is None: dist = energy_deficit

print "Energy deficit is {0} Joules".format(set_point - current_energy)#+ bltz)

if energy_deficit > 0:

# Adaptive tuning

# Below 33% and more than 20Kj, agressive tuning

# if energy_deficit >= (dist/3)*2 and energy_deficit >= 20000:

# print 'Mode: Agrressive '

# pid.setKp(shared_memory['p'] / 100.00)

# pid.setKi(shared_memory['i'] / 100.00)

# pid.setKd(shared_memory['d'] / 100.00)

# Within 25%, use a more conservative tuning

# if energy_deficit <= (dist/10):

# print 'Mode: Conservative '

# pid.setKp(shared_memory['p'] / 20000.00)

# pid.setKi(shared_memory['i'] / 20000.00)

# pid.setKd(shared_memory['d'] / 20000.00)

# # Within 25%, use a more conservative tuning

# elif energy_deficit <= (dist/4):

# print 'Mode: Conservative '

# pid.setKp(shared_memory['p'] / 10000.00)

# pid.setKi(shared_memory['i'] / 10000.00)

# pid.setKd(shared_memory['d'] / 10000.00)

# # Else normal tuning

# else:

print 'Mode: SINGLE STAGE '

pid.setKp(shared_memory['p'] / 1000.00)

pid.setKi(shared_memory['i'] / 1000.00)

pid.setKd(shared_memory['d'] / 1000.00)

# 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 "PID wants {0} Joules".format(energy_output)

if element_time > 0.0 and element_time < 10.0:

print 'Element time = ', element_time

get_temp(send=True, on_time=int(element_time*1000))

elif element_time > 10.0:

print 'Element time = 10.0 [CLAMPED]'

get_temp(send=True, on_time=10000)

# Update temps

get_temp()

# dt

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

else:

time.sleep(5)