def set_mode(self, client, userdata, message): mode = message.payload.decode('utf-8') previous_mode = self.mode # reset PID if switching between modes if previous_mode != mode: pid_options = self.config.getPIDOptions(mode) temp_options = self.config.getTempOptions(mode) self.temp = Temp(**{**temp_options, **pid_options}) if mode == 'off': self.manual = True self.mode = 'auto' self.power.state = False self.logger.info('Set mode to off') if mode == 'auto': self.manual = True self.power.state = True self.mode = 'auto' self.temp.temp_set = self.temp.temp_request self.logger.info('Set mode to manual') elif mode == 'heat': self.manual = False self.mode = mode self.logger.info('Set mode to %s', self.mode) elif mode == 'cool': self.manual = False self.mode = mode self.temp.temp_set = self.temp.temp_absolute self.logger.info('Set mode to %s', self.mode) self.state.setMode(mode) self.publish_mode() self.setHVAC() self.set_next_iteration(2)
def __init__(self): self.logger = logging.getLogger('hvac-pid') self.logger.info('Starting hvac-pid') self.config = Config() self.util = Util() # PID options pid_options = self.config.getPIDOptions(self.mode) temp_options = self.config.getTempOptions(self.mode) # Temp self.temp = Temp(**{**temp_options, **pid_options}) # Fan self.fan = Fan() # Power self.power = Power() # Occupancy state self.state = State(**self.config.getStateOptions()) # MQTT self.topic_prefix = os.getenv('MQTT_PID_TOPIC_PREFIX') self.mqtt = MQTTClient(os.getenv('MQTT_CLIENT_ID'), os.getenv('MQTT_BROKER_HOST')) self.mqtt.connect() # subscribe self.mqtt.subscribe(os.getenv('MQTT_TEMP_TOPIC'), 0, self.temp_update_callback) self.mqtt.subscribe(os.getenv('MQTT_TEMP_OUTDOORS_TOPIC'), 0, self.temp_outdoors_update_callback) self.mqtt.subscribe(os.getenv('MQTT_HVAC_STATE_TOPIC'), 0, self.hvac_callback) self.mqtt.subscribe(self.topic_prefix + '/mode/set', 0, self.set_mode) self.mqtt.subscribe(self.topic_prefix + '/temperature/set', 0, self.set_temp) self.mqtt.subscribe(self.topic_prefix + '/fan/set', 0, self.set_fan) self.mqtt.subscribe(os.getenv('MQTT_HVAC_OCCUPANCY_STATE_TOPIC'), 0, self.set_occupancy_state) self.logger.info('MQTT connected') self.publish_temp() self.publish_mode() self.publish_fan() self.next_iteration = datetime.now() + timedelta(minutes=2) # wait a bit before enabling control time.sleep(5) self.control_enable = True
def test_lowerLimit(): temp = Temp(**{ 'Kp': 1, 'Ki': 1, 'Kd': 1, 'temp_min': 17, 'temp_max': 30, 'mode': 'heat', }) temp.temp_set = 17 temp.setMeasurement(17, 17) temp.setRequest(17) temp.iteratePID() assert temp.temp_set == 17
def test_upperLimit(): temp = Temp(**{ 'Kp': 1, 'Ki': 1, 'Kd': 1, 'temp_min': 17, 'temp_max': 30, 'mode': 'heat', }) temp.temp_set = 40 temp.setMeasurement(40, 40) temp.setRequest(40) temp.iteratePID() assert temp.temp_set == 30
def __init__(self, conf, name): threading.Thread.__init__(self) self.daemon = True if conf["enabled"] == "true": self.enabled = True else: self.enabled = False self.gpio_number = conf["gpio_number"] self.target = int(conf["target"]) self.sensor = Temp(fileName = conf["temp_sensor"], correctionFactor = conf["temp_offset"]) self.band = conf["band"] self.jee = Adafruit_MCP230XX(address=0x26, num_gpios=8, busnum=1) self.jee.config(self.gpio_number,self.jee.OUTPUT) self.name = name self.state = conf["state"] self.usePid = conf["usePid"] self.pid_Kp = conf["pid_Kc"] self.pid_Ki = conf["pid_Ti"] self.pid_Kd = conf["pid_Td"] self.cycle_time = conf["cycle_time"] self.pid = mypid.mypid(kp=self.pid_Kp,ki=self.pid_Ki,kd=self.pid_Kd, history_depth=3)
def __init__(self): self.motionDetected = False; self.relay = Relays(7); self.relay.setAllOff(); self.motion = Motion(0, 3, self); self.light = Light(3, 1000, self); self.temp = Temp(1, 85, self); self.start = time.time(); while True: print('********** Switch Module Starting **********'); time.sleep(5);
class HVACPIDController(object): logger = None mqtt = None temp = None fan = None power = None config = None state = None temp_outdoors = 0 mode = 'auto' manual = False control_enable = False hvac_state = {} next_iteration = None def __init__(self): self.logger = logging.getLogger('hvac-pid') self.logger.info('Starting hvac-pid') self.config = Config() self.util = Util() # PID options pid_options = self.config.getPIDOptions(self.mode) temp_options = self.config.getTempOptions(self.mode) # Temp self.temp = Temp(**{**temp_options, **pid_options}) # Fan self.fan = Fan() # Power self.power = Power() # Occupancy state self.state = State(**self.config.getStateOptions()) # MQTT self.topic_prefix = os.getenv('MQTT_PID_TOPIC_PREFIX') self.mqtt = MQTTClient(os.getenv('MQTT_CLIENT_ID'), os.getenv('MQTT_BROKER_HOST')) self.mqtt.connect() # subscribe self.mqtt.subscribe(os.getenv('MQTT_TEMP_TOPIC'), 0, self.temp_update_callback) self.mqtt.subscribe(os.getenv('MQTT_TEMP_OUTDOORS_TOPIC'), 0, self.temp_outdoors_update_callback) self.mqtt.subscribe(os.getenv('MQTT_HVAC_STATE_TOPIC'), 0, self.hvac_callback) self.mqtt.subscribe(self.topic_prefix + '/mode/set', 0, self.set_mode) self.mqtt.subscribe(self.topic_prefix + '/temperature/set', 0, self.set_temp) self.mqtt.subscribe(self.topic_prefix + '/fan/set', 0, self.set_fan) self.mqtt.subscribe(os.getenv('MQTT_HVAC_OCCUPANCY_STATE_TOPIC'), 0, self.set_occupancy_state) self.logger.info('MQTT connected') self.publish_temp() self.publish_mode() self.publish_fan() self.next_iteration = datetime.now() + timedelta(minutes=2) # wait a bit before enabling control time.sleep(5) self.control_enable = True def iterate(self): if self.manual: self.logger.info('Manual mode, skipping PID iteration') else: compensated_request_temp = self.state.compensateRequestTemp( self.temp.temp_request, self.temp_outdoors) max_set_temp = ceil(self.temp.temp_absolute) + 3 # temp hax # limit min temp when outdoors is < -10 if self.temp_outdoors < -10: self.temp.setLimits( floor(compensated_request_temp) - 1, max_set_temp) self.logger.debug( 'Limiting min temp to %g when outdoor temp is %g', self.temp.temp_min, self.temp_outdoors) else: self.temp.setLimits(self.config.getSetTempMin(), max_set_temp) self.temp.iteratePID(compensated_request_temp) self.fan.calculate(self.temp.pid_offset, self.mode) self.power.calculate(self.temp.temp_request, self.temp.temp_measure, self.mode, self.temp_outdoors) if not self.power.state: self.temp.reset() self.publish_state() def temp_update_callback(self, client, userdata, message): payload_json = json.loads(message.payload.decode('utf-8')) if 'temperature' in payload_json: temp = payload_json['temperature'] else: temp = payload_json['tempc'] if 'humidity' in payload_json: humidity = payload_json['humidity'] else: humidity = payload_json['hum'] if self.mode == 'cool': dew_point = self.util.dewPoint(temp, humidity) self.temp.setMeasurement(round(dew_point, 2), temp) else: self.temp.setMeasurement(temp, temp) def temp_outdoors_update_callback(self, client, userdata, message): payload_json = json.loads(message.payload.decode('utf-8')) self.temp_outdoors = float(payload_json['temperature']) def hvac_callback(self, client, userdata, message): payload_json = json.loads(message.payload.decode('utf-8')) self.logger.info('Received hvac state change %s', payload_json) self.hvac_state = payload_json def setHVAC(self): if self.control_enable: topic = os.getenv('MQTT_HVAC_TOPIC') new_state = { 'power': self.power.state, 'mode': self.mode.upper(), 'temperature': self.temp.temp_set, 'fan': self.fan.speed, } is_state_changed = (new_state['power'] and self.hvac_state != new_state) is_power_state_changed = ( self.hvac_state and new_state['power'] != self.hvac_state['power']) old_state_doesnt_exists = (not self.hvac_state) if is_state_changed or is_power_state_changed or old_state_doesnt_exists: message = json.dumps(new_state) self.logger.debug('Controlling HVAC with command %s', message) self.mqtt.publish(topic, message, 1) else: self.logger.debug('HVAC state unchanged %s', self.hvac_state) else: self.logger.debug('Controlling HVAC disabled') def set_mode(self, client, userdata, message): mode = message.payload.decode('utf-8') previous_mode = self.mode # reset PID if switching between modes if previous_mode != mode: pid_options = self.config.getPIDOptions(mode) temp_options = self.config.getTempOptions(mode) self.temp = Temp(**{**temp_options, **pid_options}) if mode == 'off': self.manual = True self.mode = 'auto' self.power.state = False self.logger.info('Set mode to off') if mode == 'auto': self.manual = True self.power.state = True self.mode = 'auto' self.temp.temp_set = self.temp.temp_request self.logger.info('Set mode to manual') elif mode == 'heat': self.manual = False self.mode = mode self.logger.info('Set mode to %s', self.mode) elif mode == 'cool': self.manual = False self.mode = mode self.temp.temp_set = self.temp.temp_absolute self.logger.info('Set mode to %s', self.mode) self.state.setMode(mode) self.publish_mode() self.setHVAC() self.set_next_iteration(2) def publish_mode(self): if not self.control_enable: return topic = self.topic_prefix + '/mode/state' if self.manual: if self.power.state == False: mode = 'off' else: mode = 'manual' elif self.mode == 'auto': mode = 'manual' else: mode = self.mode self.mqtt.publish(topic, mode, 1, True) def set_temp(self, client, userdata, message): temp = round(float(message.payload.decode('utf-8')), 2) if temp >= float(os.getenv('REQUEST_MIN_TEMP', 0)) and temp <= float( os.getenv('REQUEST_MAX_TEMP', 100)): self.temp.setRequest(temp) if self.manual: self.temp.temp_set = self.temp.temp_request else: self.temp.reset() self.publish_temp() self.setHVAC() def publish_temp(self): if not self.control_enable: return self.mqtt.publish(self.topic_prefix + '/temperature/state', self.temp.temp_request, 1, True) self.mqtt.publish(self.topic_prefix + '/measured_temperature', self.temp.temp_measure, 1, True) def set_fan(self, client, userdata, message): fan = message.payload.decode('utf-8') if fan != "auto": fan_int = int(fan) if self.manual and fan_int >= 0 and fan_int <= 5: self.fan.speed = fan_int self.publish_fan() self.setHVAC() self.logger.info('Manually set fan speed to %s/5', self.fan.speed) def publish_fan(self): if not self.control_enable: return topic = self.topic_prefix + '/fan/state' if self.manual: fan = self.fan.speed else: fan = 'auto' self.mqtt.publish(topic, fan, 1, True) def publish_state(self): if not self.control_enable: return topic = os.getenv('MQTT_PID_TOPIC_PREFIX') + '/state' message = json.dumps({ 'mode': self.mode, 'manual': self.manual, 'temperature_request': float(self.temp.temp_request), 'temperature_set': float(self.temp.temp_set), 'temperature_measure': float(self.temp.temp_measure), 'temperature_error': float(self.temp.pid.previous_error), 'set_temperature_lower_limit': float(self.temp.temp_min), 'set_temperature_upper_limit': float(self.temp.temp_max), 'fan': int(self.fan.speed if self.power.state else 0), 'power': self.power.state, 'Kp': float(self.temp.pid.Kp), 'Ki': float(self.temp.pid.Ki), 'Kd': float(self.temp.pid.Kd), 'integral': float(self.temp.pid.integral), 'integral_max': float(self.temp.pid.integral_max), 'pid_offset': float(self.temp.pid_offset), 'pid_result': float(self.temp.pid_result), }) self.mqtt.publish(topic, message, 1) def set_occupancy_state(self, client, userdata, message): state = message.payload.decode('utf-8') prev_state = self.state.state self.state.setState(state) self.logger.info('Setting occupancy state to %s', self.state.state) # only reset if going or returning away state if prev_state == 'away' or self.state.state == 'away': self.temp.reset() self.set_next_iteration(2) def set_next_iteration(self, interval): self.next_iteration = datetime.now() + timedelta(minutes=interval) self.logger.info('Next iteration at %s', self.next_iteration)
web_server.stop() if 'yes' == MASTER: my_screen.stop() time.sleep(0.5) sys.exit(0) # The main program, start thread, then update continuously if __name__ == '__main__': # Install the signal handler signal.signal(signal.SIGTERM, signal_handler) signal.signal(signal.SIGINT, signal_handler) # Create a new temp object with specified temp modifier, and polling rate temp = Temp(-3, 1) temp.start() # Create a new web server and bind it to the specified address:port web_server = MyServer(WEB_BIND_ADDRESS, WEB_BIND_PORT) web_server.start() # If this is the MASTER, setup slave URL, screen thread and web server thread if 'yes' == MASTER: # Construct the URL for getting the slave's temperature SLAVE_TEMP_URL = 'http://' + SLAVE_IP + ':' + str( WEB_BIND_PORT) + '/api/temp-F' debug("--> SLAVE_TEMP_URL = \"" + SLAVE_TEMP_URL + "\"") # Create a new screen handler object
#battery.volts() #print("Battery volts: {0:.2f}v".format(battery.volts())) #if battery.alarm(): # print('Battery Needs a charge') #else: # print('Battery okay') # roughly works ... vin = Vin('P16', 'P10') led = Led('P11') battery = Battery(py) # still need work stateMachine = StateMachine() bilgeSwitch = BilgeSwitch('P13') temp = Temp('P9') button = Button('P14') check = Checks(led, vin, bilgeSwitch, battery, temp, stateMachine) check.whichToDo() # https://forum.pycom.io/topic/1626/pytrack-gps-api/12 # to sleep with GPS VBACKUP on # should go down to 17ua # https://forum.pycom.io/topic/2525/power-consumption/16 # # py.go_to_sleep(True) # tell us why we woke # display the reset reason code and the sleep remaining in seconds
class Kettle(threading.Thread): """ A class for managing a brew kettle """ def __init__(self, conf, name): threading.Thread.__init__(self) self.daemon = True if conf["enabled"] == "true": self.enabled = True else: self.enabled = False self.gpio_number = conf["gpio_number"] self.target = int(conf["target"]) self.sensor = Temp(fileName = conf["temp_sensor"], correctionFactor = conf["temp_offset"]) self.band = conf["band"] self.jee = Adafruit_MCP230XX(address=0x26, num_gpios=8, busnum=1) self.jee.config(self.gpio_number,self.jee.OUTPUT) self.name = name self.state = conf["state"] self.usePid = conf["usePid"] self.pid_Kp = conf["pid_Kc"] self.pid_Ki = conf["pid_Ti"] self.pid_Kd = conf["pid_Td"] self.cycle_time = conf["cycle_time"] self.pid = mypid.mypid(kp=self.pid_Kp,ki=self.pid_Ki,kd=self.pid_Kd, history_depth=3) def run(self): self.sensor.start() duty = 0 while True: if self.state == "control": self.sensor.setEnabled(True) currentTemp = self.sensor.getCurrentTemp() if currentTemp != -999: duty = self.getDuty(currentTemp) self._updatedb(currentTemp,duty) #print self.name + " is targetting " + str(self.target) + " and is at " + str(currentTemp) + " and " + str(duty) self._switch(duty) elif self.state == "monitor": self.sensor.setEnabled(True) currentTemp = self.sensor.getCurrentTemp() if currentTemp != 999: self._updatedb(currentTemp, duty) time.sleep(2) #print self.name + " is at " + str(currentTemp) else: self.sensor.setEnabled(False) self.jee.output(self.gpio_number,0) def getDuty(self, currentTemp): duty = 0 #return manual duty if self.target > 299: return self.target - 300 #if no temp is given, turn it off. if currentTemp == -999: return 0 #insert pid logics here if self.usePid: duty = self.pid.get_duty(currentTemp, self.target) return duty #simple on/off logic else: if currentTemp < (self.target - 10): duty = 100 elif (self.target - 5) < currentTemp < (self.target + self.band): duty = 50 elif (self.target - 10) < currentTemp < (self.target - self.band): duty = 75 else: duty = 0 return duty def getTarget(self): return self.target def setTarget(self, target): self.target = int(target) def setEnabled(self, enabled): if enabled == "true": self.enabled = True else: self.enabled = False def isEnabled(self): return self.enabled def setState(self, state): if (state == "disabled") or (state == "monitor") or (state == "control"): self.state = state else: print "invalid state configured, setting state to disabled" self.state = "disabled" def getState(self): return self.state def setConfig(self, conf): if conf["enabled"] == "true": self.enabled = True else: self.enabled = False self.target = int(conf["target"]) self.band = conf["band"] self.state = conf["state"] self.usePid = conf["usePid"] self.pid_Kp = conf["pid_Kc"] self.pid_Ki = conf["pid_Ti"] self.pid_Kd = conf["pid_Td"] self.cycle_time = conf["cycle_time"] self.pid = mypid.mypid(kp=self.pid_Kp,ki=self.pid_Ki,kd=self.pid_Kd, history_depth=3) ''' Takes the pin on a jeelabs output plug and sets it to 1 or 0 depending on if the heat should be on or not. ''' def _switch(self, duty_cycle): self.jee.config(self.gpio_number,self.jee.OUTPUT) cycle_time = self.cycle_time if duty_cycle == 100: self.jee.output(self.gpio_number,1) time.sleep(cycle_time) elif duty_cycle == 0: self.jee.output(self.gpio_number,0) time.sleep(cycle_time) else: duty = duty_cycle/100.0 self.jee.output(self.gpio_number,1) time.sleep(cycle_time*(duty)) self.jee.output(self.gpio_number,0) time.sleep(cycle_time*(1.0-duty)) return ''' takes the temperature and updates the database as well as the ramdisk file ''' def _updatedb(self, temp, duty): try: logfile = "/mnt/ramdisk/" + self.name with open (logfile, 'w+') as f: f.write(str(temp)) except: print "Error writing to ramdisk file" #send to graphite if self.state == "control": target=self.target else: target=0 summary = {'temperature':temp, 'target':target, 'duty':duty} try: graph = graphitesend.init(graphite_server='192.168.1.3',prefix="brewing", system_name=self.name) graph.send_dict(summary) except: print("error sending to graphite") traceback.print_exc()
def main(): global temp if sys.argv[1] is None: raise ValueError('Need to set target temparature as float') temp = Temp(float(sys.argv[1])) run(server='paste', host='0.0.0.0', port=8080, debug=True, reloader=False)
#!/usr/bin/env python import time import eeml from temp import Temp # COSM variables. API_KEY and FEED are specific API_KEY = 'SCf8E2SZG3W68pbyUuf1qzg9umMWy6VCkHoeVuuDPEjI2SPN' FEED = '2053937525' API_URL = '/v2/feeds/{feednum}.xml'.format(feednum=FEED) #replace 28-00000449ef31 below with the id of your temperature probe sensor1 = Temp(fileName='28-000004d93f9d') sensor2 = Temp(fileName='28-000004d9ad58') sensor1.start() sensor2.start() #the rest of your code is below. # The Temp class will be updating on its own thread which will allow you to do # anything you want on the main thread. while True: temp1 = sensor1.getCurrentTemp() temp2 = sensor2.getCurrentTemp() print temp1 print temp2 #open cosm feed pac = eeml.Pachube(API_URL, API_KEY) #send fahrenheit data
def __init__(self, vrtx, edge, attr, router=None, core=None, rdonly=True): Entry.__init__(self, router, core) self._temp = Temp(self, rdonly) self._vrtx = vrtx self._edge = edge self._attr = attr
class Data(Entry): def __init__(self, vrtx, edge, attr, router=None, core=None, rdonly=True): Entry.__init__(self, router, core) self._temp = Temp(self, rdonly) self._vrtx = vrtx self._edge = edge self._attr = attr def can_load(self): return True def can_scan(self): return True def can_enable(self): return True def can_disable(self): return True def truncate(self, uid, name, length): path = self.get_path(uid, name) self._fs.truncate(uid, path, length) self._temp.truncate(uid, name, length) def getattr(self, uid, name): return self.lsattr(uid, name) def create(self, uid, name): self.check_path(uid, name) self._vrtx.check_path(uid, parent=name) self._edge.check_path(uid, parent=name) self._attr.check_path(uid, parent=name) return self._temp.create(uid, name) def open(self, uid, name, flags): return self._temp.open(uid, name, flags) def release(self, uid, name, fh): return self._temp.release(uid, name, fh) def _unlink(self, uid, name): if self._core: self._core.remove(name) def unlink(self, uid, name): self._vrtx.remove(uid, name) self._edge.unlink(uid, name) self._attr.unlink(uid, name) self._temp.remove(uid, name) self._unlink(uid, name) self.remove(uid, name) def readdir(self, uid, name): if not name: return self.lsdir(uid, name) else: return [] def initialize(self, uid, name): f = self.create(uid, name) self.release(uid, name, f) def discard(self, uid, name): return self._temp.discard(uid, name) def commit(self, uid, name): return self._temp.commit(uid, name)
def run(delay, sensor_type, pin, webhook, source, metric_prefix, output, format): sensor = None is_polling = False if sensor_type.startswith('DHT'): pin = int(pin) sensor = Temp(source, metric_prefix, output, sensor_type, pin, format) is_polling = True elif sensor_type == 'HC-SRO': pins = pin.split(',') sensor = Distance(source, metric_prefix, output, sensor_type, int(pins[0]), int(pins[1]), format) is_polling = True elif sensor_type == 'SSM-1': pin = int(pin) sensor = Generic(source, metric_prefix, output, sensor_type, pin, 'Sound') elif sensor_type == 'HC-SR501': pin = int(pin) sensor = Motion(source, metric_prefix, output, sensor_type, pin) elif sensor_type == 'SEO53': pin = int(pin) sensor = Generic(source, metric_prefix, output, sensor_type, pin, 'Vibration') elif sensor_type == 'SEO23': pin = int(pin) sensor = Generic(source, metric_prefix, output, sensor_type, pin, 'Tilt') elif sensor_type == 'YL-69': pin = int(pin) sensor = Moisture(source, metric_prefix, output, sensor_type, pin, 'Moisture', delay) else: sensor = Host(source, metric_prefix, output) is_polling = True while True: sensor.get_info() metrics = sensor.format_metrics() if webhook is not None: send_metrics(metrics, output, webhook, source) else: print(metrics) # check if the senor is something that needs to poll for results based on a delay. if is_polling: time.sleep(delay)
class Attr(Entry): def __init__(self, router=None, core=None, rdonly=True): Entry.__init__(self, router, core) self._temp = Temp(self, rdonly) def _log(self, text): if LOG_ATTR: log_debug(self, text) def may_update(self, flags): return flags & os.O_APPEND or flags & os.O_RDWR or flags & os.O_TRUNC or flags & os.O_WRONLY def can_invalidate(self): return True def truncate(self, uid, name, length): if not self._core: path = self.get_path(uid, name) self._fs.truncate(uid, path, length) self._temp.truncate(uid, name, length) def is_expired(self, uid, name): temp = get_temp(self.get_path(uid, name)) return self._fs.exist(uid, temp) def getattr(self, uid, name): return self.lsattr(uid, name) def create(self, uid, name): self.check_path(uid, name) return self._temp.create(uid, name) def open(self, uid, name, flags): if self._core: flags = 0 return self._temp.open(uid, name, flags) def release(self, uid, name, fh): return self._temp.release(uid, name, fh) def _unlink(self, uid, name): if not self._core: return child = self.child(name) parent = self.parent(name) if parent != child: if child == ATTR_HANDLER: self._core.remove_handler(parent) elif child == ATTR_FILTER: self._core.remove_filter(parent) elif child == ATTR_DISPATCHER: self._core.remove_dispatcher(parent) elif child == ATTR_MODE: self._core.remove_mode(parent) elif child == ATTR_FREQ: self._core.remove_freq(parent) elif child == ATTR_TIMEOUT: self._core.remove_timeout(parent) def unlink(self, uid, name): self.remove(uid, name) self._unlink(uid, name) def invalidate(self, uid, name): self._log('invalidate, name=%s' % str(name)) path = self.get_path(uid, name) temp = get_temp(path) if self._fs.exist(uid, path): self._fs.rename(uid, path, temp) self._unlink(uid, name) else: self._fs.touch(uid, temp) def signature(self, uid, name): res = '' if RSYNC: temp = get_temp(self.get_path(uid, name)) with open(temp, 'rb') as f: sigature = librsync.signature(f) res = b64encode(sigature.read()) return res def patch(self, uid, name, buf): if not buf: log_warnning(self, 'cannot patch, no content, name=%s' % str(name)) return dest = self.get_path(uid, name) src = get_temp(dest) tmp = b64decode(buf) if RSYNC: delta = StringIO(tmp) with open(dest, 'wb') as f_dest: with open(src, 'rb') as f_src: try: librsync.patch(f_src, delta, f_dest) except: log_warnning(self, 'failed to patch, name=%s' % str(name)) self._fs.rename(uid, src, dest) return self._fs.remove(uid, src) else: with open(src, 'wb') as f: f.write(tmp) self._fs.rename(uid, src, dest) def readdir(self, uid, name): return self.lsdir(uid, name) def _create_attr(self, uid, name, attr, val): error = False name = os.path.join(name, attr) f = self.create(uid, name) try: os.write(f, str(val)) except: error = True finally: os.close(f) if error: self.discard(uid, name) return self.commit(uid, name) def initialize(self, uid, name, attr, val): if attr not in ATTRIBUTES: log_err(self, 'failed to initialize, invalid attribute %s, name=%s' % (str(attr), str(name))) raise Exception(log_get(self, 'failed to initialize')) if attr == ATTR_PROFILE: val = json.dumps(val) self._create_attr(uid, name, attr, val) def discard(self, uid, name): return self._temp.discard(uid, name) def commit(self, uid, name): return self._temp.commit(uid, name)
def __init__(self, router=None, core=None, rdonly=True): Entry.__init__(self, router, core) self._temp = Temp(self, rdonly)
#!/usr/bin/env python import time import eeml from temp import Temp # COSM variables. API_KEY and FEED are specific API_KEY = 'SCf8E2SZG3W68pbyUuf1qzg9umMWy6VCkHoeVuuDPEjI2SPN' FEED = '2053937525' API_URL = '/v2/feeds/{feednum}.xml' .format(feednum = FEED) #replace 28-00000449ef31 below with the id of your temperature probe sensor1=Temp(fileName='28-000004d93f9d') sensor2=Temp(fileName='28-000004d9ad58') sensor1.start() sensor2.start() #the rest of your code is below. # The Temp class will be updating on its own thread which will allow you to do # anything you want on the main thread. while True: temp1 = sensor1.getCurrentTemp() temp2 = sensor2.getCurrentTemp() print temp1 print temp2 #open cosm feed pac = eeml.Pachube(API_URL, API_KEY) #send fahrenheit data