class Manager(Observer):
def __init__(self):
self.hardwareManager = HardwareManager()
self.logger = LoggerWrapper()
def update(self, *args, **kwargs):
#print("Params from rf: {0}".format(args))
rfid = args[0]
self.logger.info('rf recievied: ' + rfid)
self.sendRfAndProcessResponse(rfid)
time.sleep(1)
self.hardwareManager.startSimSequence2()
time.sleep(1)
def sendRfAndProcessResponse(self, rfid):
json_data = ServerComm.sendRfId(rfid)
if json_data['status'] >= 0:
output = json_data['smell_data']['output_id']
self.hardwareManager.startOutputSequence(output)
elif json_data['status'] == -1:
print("SERVER DID NOT RECOGNIZE RFID: " + str(rfid))
elif json_data['status'] == -2:
print("no smell was matched to that ball: " + str(rfid))
def __init__(self, TempMeter):
self.state = ThermometerState.Undefined
self.tempurature = -1002
self.threadValidator = ThreadTimeValidator()
self.tempuratureControl = TempMeter
self.hardware = HardwareManager()
self.tempuratureKeeper = TempuratureReader()
self.StartControlLogicThread()
def __init__(self, configurations):
print("Workshop Unit created")
self.__unitName = configurations['unitName']
self.__vms = configurations['vms']
self.__description = configurations['description']
self.__referenceMaterial = configurations['referenceMaterial']
self.__connectionString = configurations['connectionString']
self.__sessionType = configurations['sessionType']
self.__status = configurations['status']
self.__hwmgr = HardwareManager()
def __init__(self):
# super(self.__class__, self).__init__(self) # super doesn't work
HardwareManager.__init__(self)
self.relative = False
self.las_on = False
self.cmd_list = [
"G0 X Y F", "G1 X Y F", # Move
# "G20", "G21", # Set units # not implemented
"G28", # Home
"G90", "G91", "G92 X Y", # Set abs/rel, position
"M0", "M1", # Stop
"M3 S", "M5", # las on/off
"M17", "M18", # mot en/disable
# "M42", "M72", # not implemented
"M92 X Y", # Set step cal (mm/min)
# "M106 P S", "M107", # fan control # not implemented
"M114", "M115", "M119" # diagnostics, return values
]
def load_settings(self, filepath):
self.gParams = yaml.load(open(filepath)) # load defaults
self.gScreen = ExperimentDisplay(self.gParams) # exp display
self.gTimer = Timer(self.gParams) # timers
self.gData = DataManager(self.gParams) # data manager
self.gHardware = HardwareManager(self.gParams) # data manager
self.gDiagnostic = DiagnosticDisplay(self.gParams) # diagnostic window
self.gKeyboard = Keyboard(self.gParams) # keyboard input polling
self.gVariables = Variables(self.gParams) # experiment variables
self.gStates = [] # trial states
def __init__(self):
self.hardwareManager = HardwareManager()
self.logger = LoggerWrapper()
class WorkshopUnit():
def __init__(self, configurations):
print("Workshop Unit created")
self.__unitName = configurations['unitName']
self.__vms = configurations['vms']
self.__description = configurations['description']
self.__referenceMaterial = configurations['referenceMaterial']
self.__connectionString = configurations['connectionString']
self.__sessionType = configurations['sessionType']
self.__status = configurations['status']
self.__hwmgr = HardwareManager()
#self.__createUnitRecord()
def getName(self):
return self.__unitName
def __eq__(self, other):
return self.__unitName == other.getUnitName()
def __hash__(self):
return hash(self.__unitName)
def getVmList(self):
return self.__vms
def getUnitName(self):
return self.__unitName
def getConnectionString(self):
return self.__connectionString
def getStatus(self):
return self.__status
def isAvailable(self):
return self.__status == 0 #Available
def __createUnitRecord(self):
dbMgr = DatabaseManager.Instance()
dbMgr.addRecord(dbMgr.getUnitID(), self.__toDict())
def __toDict(self):
dict = {
'unitName': self.__unitName,
'vms': self.__vms,
'connectionString': self.__connectionString
}
return dict
def startAllVMs(self):
for vmname in self.__vms:
self.startVM(vmname)
def startVM(self, vmname):
if vmname in self.__vms:
self.__hwmgr.startVM(vmname)
# the followig methods exist but still need to be implemented
def pauseVM(self, vmname):
if vmname in self.__vms:
self.__hwmgr.pauseVM(vmname)
def pauseAllVMs(self):
for vmname in self.__vms:
self.pauseVM(vmname)
def resumeVM(self, vmname):
if vmname in self.__vms:
self.__hwmgr.resumeVM(vmname)
def resumeAllVMs(self):
for vmname in self.__vms:
self.resumeVM(vmname)
def power_downVM(self, vmname):
if vmname in self.__vms:
self.__hwmgr.power_downVM(vmname)
def power_downAllVMs(self):
for vmname in self.__vms:
self.power_downVM(vmname)
def removeVM(self, vmname):
if vmname in self.__vms:
vms.remove(vmname)
def removeAllVMs(self):
self.__vms.clear()
#def createUnit(self, configurations):
#newUnit = WorkshopUnit(configurations)
#new = set()
#for vm in vms:
#set.add(HardwareManager.clone(vm))
def cloneUnits(self, numUnits):
newUnits = set()
vmList = []
for vm in self.__vms:
newVMs = self.__hwmgr.cloneVM(vm, numUnits)
print(newVMs)
vmList.append(list(newVMs))
print(vmList)
for i in range(0, numUnits):
uName = self.__unitName + str(i)
uPort = self.__connectionString
vmSet = set()
for j in range(0, len(vmList)):
vmSet.add(vmList[j][i])
print(vmSet)
unitConfig = {
"unitName": uName,
"vms": vmSet,
"description": self.__description,
"referenceMaterial": self.__referenceMaterial,
"connectionString": uPort,
"sessionType": self.__sessionType,
"status": self.__status
}
newUnit = WorkshopUnit(unitConfig)
newUnits.add(newUnit)
return newUnits
def unitDetailView(self):
return configurations
"host": "172.19.156.75"
}
vms = {vm1['vmname'], vm2['vmname']}
unit1 = {
"unitName": "unit1",
"vms": vms,
"description": "desc",
"referenceMaterial": "filename.txt",
"connectionString": "172.19.156.75",
"sessionType": "persistent",
"status": "available"
}
hwmgr = HardwareManager()
wsmgr = WorkshopManager()
line = ""
while (line != "EXIT"):
line = input()
if (line == "Add VMs"):
hwmgr.addVirtualMachine(vm1)
hwmgr.addVirtualMachine(vm2)
elif (line == "Add Unit"):
wsmgr.addWorkshopUnit(unit1)
elif (line == "Start Unit"):
wsmgr.startUnit("unit1")
elif (line == "Pause Unit"):
def CleanThermostat():
Cleaner = HardwareManager()
Cleaner.DoCleanUp()
class ControlLogic():
def __init__(self, TempMeter):
self.state = ThermometerState.Undefined
self.tempurature = -1002
self.threadValidator = ThreadTimeValidator()
self.tempuratureControl = TempMeter
self.hardware = HardwareManager()
self.tempuratureKeeper = TempuratureReader()
self.StartControlLogicThread()
def StartControlLogicThread(self):
t = threading.Thread(target=self.ControlLogicThread)
t.daemon = True
t.start()
self.threadValidator.SetControlLogicTimerThread(t)
def ControlLogicThread(self):
waitTime = self.threadValidator.GetControlLogicWaitTime()
while True:
time.sleep(waitTime)
CurrentTemp_Avg = self.tempuratureKeeper.AverageTempurature()
self.DetermineState(CurrentTemp_Avg)
def DetermineState(self, Temp):
if Temp is None:
self.SetTempurature(-1002)
self.hardware.Off()
self.SetState(ThermometerState.Undefined)
else:
self.SetTempurature(Temp)
if self.GetState() == ThermometerState.Comfortable:
self.ComfortLogic()
elif self.state == ThermometerState.Heating:
self.HeatingLogic()
elif self.GetState() == ThermometerState.Cooling:
self.CoolingLogic()
elif self.GetState() == ThermometerState.Fan:
self.hardware.StartFan()
elif self.GetState() == ThermometerState.Off:
self.hardware.Off()
else:
self.DefaultLogic()
def ComfortLogic(self):
self.DefaultLogic()
self.hardware.Off()
def HeatingLogic(self):
self.DefaultLogic(1)
self.hardware.StartHeat()
def CoolingLogic(self):
self.DefaultLogic(-1)
self.hardware.StartCool()
def DefaultLogic(self, differential=0):
if self.tempurature <= self.tempuratureControl.GetCoolLimit() + differential:
self.SetState(ThermometerState.Heating)
elif self.tempurature >= self.tempuratureControl.GetHeatLimit() + differential:
self.SetState(ThermometerState.Cooling)
else:
self.SetState(ThermometerState.Comfortable)
def SetState(self, state):
if state >= 0 and state < ThermometerState.numberOfThermometerStates:
self.state = state
def GetState(self):
return self.state
def GetAverageTempurature(self):
return self.tempurature
def SetTempurature(self, temp):
self.tempurature = temp
def GetLowestTempurature(self):
return self.tempuratureKeeper.FindLowestTempurature()
def GetHighestTempurature(self):
return self.tempuratureKeeper.FindHighestTempurature()
def FanOn(self):
self.SetState(ThermometerState.Fan)
def TurnOff(self):
self.SetState(ThermometerState.Off)
def TurnOn(self):
self.SetState(ThermometerState.Undefined)
def GetValidSensorCount(self):
return self.tempuratureKeeper.GetValidSensorCount()
def CleanUpHW(self):
self.TurnOff()
self.hardware.DoCleanUp()
def __del__(self):
self.las_on = False
HardwareManager.__del__(self)
