def main(rtc_file_name, casu_number, worker_address): import zmq_sock_utils print('[I] Main function for CASU {}'.format(casu_number)) # open ZMQ server socket context = zmq.Context() socket = context.socket(zmq.REP) print('[I] Binding to {}'.format(worker_address)) socket.bind(worker_address) # Initialize domset algorithm a_casu = casu.Casu(rtc_file_name, log=True) # main thread loop go = True print('[I] Entering main loop for CASU {}'.format(casu_number)) while go: message = zmq_sock_utils.recv(socket) if message[0] == INITIALIZE: print('[I] Initialize message for CASU {}'.format(casu_number)) zmq_sock_utils.send(socket, [OK]) elif message[0] == START: print('[I] Start message for CASU {}'.format(casu_number)) infrared_hit( casu=a_casu, temperature_reference=message['temperature_reference'], experiment_duration=message['experiment_duration'], ) go = False zmq_sock_utils.send(socket, [OK]) else: print('Unknown message {}'.format(message)) a_casu.stop() print('[I] End of worker for CASU {}'.format(casu_number))
def __init__(self, rtc_file, calib_steps=50, interval=0.1, verb=False): self.verb = verb self.interval = interval self.calib_gain = 1.1 # connect to CASU self.__casu = casu.Casu(rtc_file, log=True) # calibrate sensor levels self._calibrate(calib_steps)
def connect_all_casus(top=9, rtc_path='physical'): ''' returns a list of handles to the list of casus 1..top. assumes that RTC files exist in the directory rtc_path/casu-xxx/casu-xxx.rtc these files are created by the deployment part of assisipy (see example "deployment"). ''' C = [] for n in xrange(1, 1 + top): rtc = '{0}/casu-{1:03d}/casu-{1:03d}.rtc'.format(rtc_path, n) print "using casu {}".format(rtc) C.append(casu.Casu(rtc_file_name=rtc, log=True)) return C
def main(rtc_file_name, casu_number, worker_address): import zmq_sock_utils print('[I] Main function for CASU {}'.format(casu_number)) # open ZMQ server socket context = zmq.Context() socket = context.socket(zmq.REP) print('[I] Binding to {}'.format(worker_address)) socket.bind(worker_address) # Initialize domset algorithm a_casu = casu.Casu(rtc_file_name, log=True) # main thread loop go = True print('[I] Entering main loop for CASU {}'.format(casu_number)) while go: message = zmq_sock_utils.recv(socket) if message[0] == INITIALIZE: print('[I] Initialize message for CASU {}'.format(casu_number)) zmq_sock_utils.send(socket, [OK]) elif message[0] == START_LEAF: print('[I] Start leaf message for CASU {}'.format(casu_number)) temperature_profile_leaf( casu=a_casu, initial_temperature=message['temperature_reference'], first_period_length=message['first_period_length'], rate_temperature_increase=message[ 'rate_temperature_increase_leaf'], target_temperature=message['target_temperature'], airflow_duration=message['airflow_duration'], third_period_length=message['third_period_length']) go = False zmq_sock_utils.send(socket, [OK]) elif message[0] == START_CORE: print('[I] Start core message for CASU {}'.format(casu_number)) temperature_profile_core( casu=a_casu, initial_temperature=message['temperature_reference'], first_period_length=message['first_period_length'], rate_temperature_increase=message[ 'rate_temperature_increase_core'], target_temperature=message['target_temperature'], airflow_duration=message['airflow_duration'], rate_temperature_decrease=message['rate_temperature_decrease'], third_period_length=message['third_period_length']) zmq_sock_utils.send(socket, [OK]) go = False else: print('Unknown message {}'.format(message)) a_casu.stop() print('[I] End of worker for CASU {}'.format(casu_number))
def __init__(self, casu_name, logname, conf_file=None, DO_LOG=True): self._rtc_pth, self._rtc_fname = os.path.split(casu_name) if self._rtc_fname.endswith('.rtc'): self.name = self._rtc_fname[:-4] else: self.name = self._rtc_fname self.parse_conf(conf_file) self.logname = logname self._casu = casu.Casu(rtc_file_name=os.path.join( self._rtc_pth, self.name + ".rtc"), log=DO_LOG) self.calib_data = {} self.update_calib_time(time.time()) self.calib_data['IR'] = []
def main(): parser = argparse.ArgumentParser( description= 'simple tester program to flash casus in an externally-defined order') parser.add_argument('rtc', help='') parser.add_argument('--order', help='how long a delay before this one starts?', default=1.0, type=float) parser.add_argument('--sync_period', type=float, default=10.0) parser.add_argument('--interval', type=float, default=2.0) args = parser.parse_args() # NOTE: we can't actually do this because there is a non-deterministic start! hmm # connect to casu if args.rtc.endswith('.rtc'): _name = args.rtc[:-4] else: _name = args.rtc _casu = casu.Casu(rtc_file_name=_name + '.rtc', log=DO_LOG) # first, read sensor values, and write to file # TODO (this can be done asynch, but really requires a log to file, then # TODO automatic check on the final results.) #sensor_test(_name, _casu) with open("{}-msgtest.log".format(_name), 'w') as logfile: logfile.write("# {} msg test on {} started\n".format( datetime.datetime.now().strftime(TSTR_FMT), _name)) writeback_test(_casu, _name, logfile) # to run a coordinated flash test, with delays appropriate to sync all the casus. flash_test(_name, _casu, args.order, SYNC_PERIOD=args.sync_period, INTERVAL=args.interval) print "=============== ALL done!! ==============="
def __init__(self, casu_name, logname, delay, nbg, msg_spec=None, timeout=50.0, sync_period=10.0, interval=6.0, layer_select=None): self._rtc_pth, self._rtc_fname = os.path.split(casu_name) if self._rtc_fname.endswith('.rtc'): self.name = self._rtc_fname[:-4] else: self.name = self._rtc_fname self.verb = 1 self.timeout = timeout self.interval = interval self.sync_period = sync_period self.layer_select = layer_select self.nbg = nbg self.read_interactions() self.msg_spec = msg_spec self.read_msg_spec() self.logname = logname self.delay_steps = delay self._casu = casu.Casu(rtc_file_name=os.path.join( self._rtc_pth, self.name + ".rtc"), log=DO_LOG) self.seq = 0 self.msgs_recv = 0 self.log_file_name = "{}-msgtest.log".format(self.name) self.log_file = open(self.log_file_name, 'w') self.log_file.write("# {} msg test on {} started\n".format( datetime.datetime.now().strftime(self.TSTR_FMT), self.name))
def main(): parser = argparse.ArgumentParser( description='stop all casus in a given depployment') parser.add_argument('project', help='name of .assisi file specifying the proejct') parser.add_argument('--layer', help='Name of single layer to deploy', default=None) args = parser.parse_args() proj = {} dep = {} with open(args.project) as f: proj = yaml.safe_load(f) root = os.path.dirname(os.path.abspath(args.project)) proj_name = os.path.splitext(os.path.basename(args.project))[0] sandbox_dir = proj_name + '_sandbox' depspec = proj.get('dep') if depspec is not None: with open(os.path.join(root, depspec)) as f: dep = yaml.safe_load(f) for layer in dep: if args.layer is None or layer == args.layer: print "[I] processing layer {}".format(layer) for _casu in dep[layer]: rtc = os.path.join(sandbox_dir, layer, _casu, '{}.rtc'.format(_casu)) c = casu.Casu(rtc_file_name=rtc) c.stop() print "[I] stopped casu {}".format(_casu) else: print "[W] skipping layer {}".format(layer)
#!/usr/bin/env python # -*- coding: utf-8 -*- import sys import time from assisipy import casu if __name__ == '__main__': c = casu.Casu(sys.argv[1]) time_begin = time.time() time_now = time.time() while (time_now - time_begin < 1800): c.set_temp(30) c.set_diagnostic_led_rgb(b=1) time.sleep(300) c.set_temp(35) c.set_diagnostic_led_rgb(r=1) time.sleep(300) time_now = time.time()
def __init__(self, rtc_file, log=False): Thread.__init__(self) self.casu = casu.Casu(rtc_file,log=True) # Parse rtc file name to get CASU id # assumes casu-xxx.rtc file name format self.casu_id = int(rtc_file[-7:-4]) nbg_ids = [] for name in self.casu._Casu__neighbors: if not ('cats' in name): nbg_ids.append(int(name[-3:])) #nbg_ids = [int(name[-3:]) for name in self.casu._Casu__neighbors] self.nbg_data_buffer = {} self._is_master = 1 # master in CASU group calculates new temp ref self.group_size = 1 # only counts the neighbours; have to add myself for nb in nbg_ids: self.group_size += 1 self.nbg_data_buffer[nb] = [] if nb < self.casu_id: self._is_master = 0 print("CASU: " + str(self.casu_id) + ", group size: " + str(self.group_size)) self.fish_info = [] if self._is_master == 0: master_id = self.casu_id master = self.casu for nbg in self.casu._Casu__neighbors: if "cats" in nbg: pass else: nbg_id = int(nbg[-3:]) if nbg_id < master_id: master = nbg master_id = nbg_id self.group_master = master self.group_master_id = master_id self._Td = 0.1 # Sample time for sensor readings is 0.1 second Ttemp = 5.0 # discretisation period self._temp_control_freq = 1.0 / Ttemp # Sample frequency for temperature control in seconds is once in 5 seconds self.time_start = time.time() self._time_length = 1500.0 #1500.0 self._time_length_cool = self._time_length * 0.5 self._time_length_heat = self._time_length * 0.3333 self.t_prev = time.time() self.stop_flag = Event() self.temp_ref = 28.0 self.temp_ref_old = 28.0 self.blow = 0.0 self.blow_prev = 0.0 # sensor activity variables - denote bee presence self.activeSensors = [0] self._sensors_buf_len = 10 * Ttemp # last 2 sec? should be Ttemp/Td self.ir_thresholds = [25000, 25000, 25000, 25000, 25000, 25000] self.integrate_activity = 0.0 self.average_activity = 0.0 self.maximum_activity = 0.0 self.minimum_activity = 1.0 self.temp_ctrl = 0 self.initial_heating = 0 self.heat_float = 0.0 self.cool_float = 0.0 # constants for temperature control self._integration_limit = 100.0 self._integrate_limit_lower = 10.0 / Ttemp self._integrate_limit_upper = 20.0 / Ttemp self._stop_initial_heating = 10 self._inflection_heat = 0.17 self._inflection_cool = 0.85 self._start_heat = 0.1 self._stop_heat = 0.7 self._start_cool = 0.2 self._stop_cool = 0.5 self._rho = 0.85 self._step_heat = 0.05 self._step_cool = 0.03 self._epsilon = 0.3 self.integrate_minimum_activity = 0.0 self._blow_allowed_start = 5 * 60.0 # no blow first 5 min self._blow_allowed_stop = 1500.0 - 10 * 60.0 # no blowing in last n minutes self._scaling_blow = 0.2 # 1 sensor active (0.16.) is not enough to stay in the domset self._integrate_min_windup = 100 self._blow_start_condition = 12 # n x Td seconds minimum activity below threshold before we start blowing self._default_blow_duration = 180.0 # Set up zeta logging now_str = datetime.now().__str__().split('.')[0] now_str = now_str.replace(' ','-').replace(':','-') self.logfile = open(now_str + '-' + self.casu.name() + '-domset.csv','wb') self.logger = csv.writer(self.logfile, delimiter=';') self.i = 0
#!/usr/bin/env python # -*- coding: utf-8 -*- import sys import time from assisipy import casu if __name__ == '__main__': if len(sys.argv) < 2: sys.exit('Please provide .rtc file name!') c = casu.Casu(sys.argv[1], log=True) while True: time.sleep(10)
#}}} #{{{ set up the casu objects / handles heaters = [] loggers = [] init_upd_time = time.time() _logtime = strftime("%H:%M:%S-%Z", gmtime()) for name in [ INPUT_CASU_NAME, ]: fname = "{}.rtc".format(name) rtc = os.path.join(args.rtc_path, fname) print "connecting to casu {} ('{}')".format(name, rtc) # connect to the casu and set up extra properties h = casu.Casu(rtc_file_name=rtc, log=True) # identify the logical/physical mapping to neighbours. # ONLY REQD UNTIL # PR#12 merged h.comm_links = clib.find_comms_mapping(name, rtc_path=args.rtc_path, suffix='', verb=True) # basic params, from setup file h._thename = name h._listento = casu_conf[name]['listen'] h._sendto = casu_conf[name]['sendto'] h.self_bias = casu_conf[name]['self_bias'] h.friend_bias = casu_conf[name]['friend_bias'] h.enemy_bias = casu_conf[name]['enemy_bias'] h.verb = args.verb h.max_steps = float(shared_conf.max_steps) h.sat_lim = shared_conf.sat_lim
""" import sys from time import sleep from assisipy import casu if __name__ == '__main__': rtc = sys.argv[1] heating_temp = 36 cooling_temp = 26 sample_time = 5 heatcasu = casu.Casu(rtc_file_name=rtc) temp = heating_temp heatcasu.set_diagnostic_led_rgb(r=1) while True: msg = heatcasu.read_message() print(msg) if msg: if 'Warm' in msg['data']: temp = heating_temp heatcasu.set_diagnostic_led_rgb(r=1) elif 'Cool' in msg['data']: temp = cooling_temp heatcasu.set_diagnostic_led_rgb(b=1) heatcasu.set_temp(temp)
def __init__(self, rtc_file, id_): self.casu = casu.Casu(rtc_file,log=False) self.time_on = 0 self.time_start = time.time() self.id = int(id_)
#!/usr/bin/env python # -*- coding: utf-8 -*- from time import sleep import sys from assisipy import casu if __name__ == '__main__': rtc = sys.argv[1] senscasu = casu.Casu(rtc_file_name=rtc) max_temp = 30 min_temp = 28 while True: temp = senscasu.get_temp(casu.TEMP_R) print('Temperature on EAST sensor: {0}'.format(temp)) if temp > max_temp: senscasu.send_message('east', 'Cool down you maniac!') print('Temperature too hot!') senscasu.set_diagnostic_led_rgb(r=1) elif temp < min_temp: senscasu.send_message('east', 'Warm up!') print('Temperature too low!') senscasu.set_diagnostic_led_rgb(b=1) else: senscasu.set_diagnostic_led_rgb(g=1) sleep(5)
do not influence directional changes. ''') parser.add_argument('-c', '--num-casus', type=int, default=3) parser.add_argument('-rt', '--right-temp', type=float, default=28.0) parser.add_argument('-lt', '--left-temp', type=float, default=45.0) parser.add_argument('-t', '--runtime', type=int, default=60) args = parser.parse_args() # connect to all of the CASUs l_casus = [] r_casus = [] for i in xrange(0, args.num_casus): side = 'l' cname = 'casu-{}0{}'.format(side, i) c = casu.Casu(name=cname) l_casus.append(c) side = 'r' cname = 'casu-{}0{}'.format(side, i) c = casu.Casu(name=cname) r_casus.append(c) # set temp as desired start = time.time() # turn the temperature up try: i = 0 for c in l_casus: clr = (args.left_temp - MIN_TEMP) / (MAX_TEMP - MIN_TEMP)
import sys import time from datetime import datetime import csv if __name__ == '__main__': rtc = sys.argv[1] temp_values = [42,26,38,30,34] log_period = 1 #log_cycles = 1200 # A cycle is about 20 minutes = 1200 seconds log_cycles = 5 heater = casu.Casu(rtc_file_name=rtc) heater.set_diagnostic_led_rgb(r=1,b=1) # Open the log file now_str = datetime.now().__str__().split('.')[0] now_str = now_str.replace(' ','-').replace(':','-') with open('logs/'+now_str+'-'+'heat'+'.csv','wb') as logfile: logger = csv.writer(logfile,delimiter=';') logger.writerow(['time','t_ref','t1','t2','t3','t4','t5']); for t in temp_values: print('Setting temperature to {0}!'.format(t)) heater.set_temp(t) for k in range(log_cycles): logger.writerow([time.time(),t]+heater.get_temp(casu.ARRAY)) time.sleep(log_period)
print('Calibrating IR reading thresholds.') for i in range(num_readings): ir_values = thiscasu.get_ir_raw_value(casu.ARRAY) for k in range(len(thresholds)): if thresholds[k] < ir_values[k]: thresholds[k] = ir_values[k] print('Reading {0}/{1}'.format(i + 1, num_readings)) sleep(1) thresholds = [1.1 * x for x in thresholds] if __name__ == '__main__': rtc = sys.argv[1] mycasu = casu.Casu(rtc_file_name=rtc, log=True, log_folder='logs') thresholds = mycasu.get_ir_raw_value(casu.ARRAY) calibrate_thresholds(mycasu, thresholds) print(thresholds) count = 0 # NOTE: This CASU controller implementation is quite naive. # The sleep can not ensure a consistent sample time # A more sophisticated implementation would use threads. while True: red = green = blue = 0 if mycasu.get_ir_raw_value(casu.IR_F) > thresholds[0]: green = 1 count += 1
from assisipy import casu from time import sleep if __name__ == '__main__': heating_temp = 38 cooling_temp = 25 HEATING = 1 COOLING = 0 period = 60 heater = casu.Casu(name='casu-001') state = COOLING while True: if state == COOLING: state = HEATING heater.set_temp(heating_temp) heater.set_diagnostic_led_rgb(r=1) elif state == HEATING: state = COOLING heater.set_temp(cooling_temp) heater.set_diagnostic_led_rgb(b=1) sleep(period)
# NOTE: THE #! IS CRUCIAL! in the deploy tools, it is agnostic to python # so could be a different language. (gotcha #1) from assisipy import casu import argparse import time if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument('rtc', ) parser.add_argument('-t', '--temp', type=float, default=None) args = parser.parse_args() # connect to casu c = casu.Casu(rtc_file_name=args.rtc, log=True) # set temperature if args.temp is None: c.temp_standby() else: c.set_temp(args.temp) r = (args.temp - 25.0) / (45.0 - 25.0) c.set_diagnostic_led_rgb(r=r, g=0.1, b=0.1) # wait until interrupt try: while True: time.sleep(0.5) except KeyboardInterrupt: c.temp_standby() c.set_diagnostic_led_rgb(0,0,0)