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)
