def monitor(self, PV_name, value, char_value): """Handle client changes to PVs""" with self.lock: # Allow only one thread at a time inside this function. info("Received request %s=%r" % (PV_name, value)) # Delay execution of client requests storing them in a command queue. from CAServer import casput if PV_name == self.prefix + ".SCAN": self.scan_time = value casput(self.prefix + ".SCAN", self.scan_time) for i in range(0, self.N): if PV_name == self.prefix + "%d.AOUT" % (i + 1): self.queue.commands[i] = value # queue for execution elif PV_name == self.prefix + "%d:VOLUME.VAL" % (i + 1): self.queue.volume_values[i] = value # queue for execution elif PV_name == self.prefix + "%d:VOLUME.VELO" % (i + 1): self.queue.volume_speeds[i] = value # queue for execution elif PV_name == self.prefix + "%d:VOLUME.STOP" % (i + 1): self.queue.volume_moving[ i] = not value # queue for execution elif PV_name == self.prefix + "%d:PORT.VAL" % (i + 1): self.queue.ports_values[i] = value # queue for execution elif PV_name == self.prefix + "%d:PORT.STOP" % (i + 1): self.queue.ports_values_moving[ i] = not value # queue for execution info("Command count: %r" % len(self.queue.commands))
def lightwave_monitor(self,PV_name,value,char_value): #print('time: %r, PV_name = %r,value= %r,char_value = %r' %(time(),PV_name,value,char_value) ) from CA import cainfo from CAServer import casput prefix = self.lightwave_prefix if PV_name == prefix+".VAL": arr = empty((2,1)) arr[0] = cainfo(prefix+".VAL","timestamp") arr[1] = float(value) self.buffers['lightwave_VAL'].append(arr) casput(self.prefix +'.VAL',value = float(value)) if PV_name == prefix+".RBV": arr = empty((2,1)) arr[0] = cainfo(prefix+".RBV","timestamp") arr[1] = float(value) self.buffers['lightwave_RBV'].append(arr) casput(self.prefix +'.RBV',value = float(value)) if PV_name == prefix+".P": arr = empty((2,1)) arr[0] = cainfo(prefix+".P","timestamp") arr[1] = float(value) self.buffers['lightwave_P'].append(arr) casput(self.prefix +'.P',value = float(value)) if PV_name == prefix+".I": arr = empty((2,1)) arr[0] = cainfo(prefix+".I","timestamp") arr[1] = float(value) self.buffers['lightwave_I'].append(arr) casput(self.prefix +'.I',value = float(value)) #Done Move PV if PV_name == prefix+".DMOV": casput(self.prefix +'.DMOV',value = float(value))
def run(self): from time import time,sleep from CAServer import casget,casput from SAXS_WAXS_control import SAXS_WAXS_control from temperature_controller import temperature_controller casput(self.CAS_prefix+'.ENABLED', self.intervention_enabled) casput(self.CAS_prefix+'.RUNNING', self.deice_enabled) try: print('current temperature %r' % temperature_controller.value) info('current temperature %r' % temperature_controller.value) except: warn('could not get temperature') last_image_file = "" while self.deice_enabled: try: self.intervention_enabled = casget(self.CAS_prefix+'.ENABLED') except: error('Failed to get CA %r' % (self.CAS_prefix+'.ENABLED')) self.intervention_enabled = False self.running_timestamp = time() if self.current_image_file != last_image_file: last_image_file = self.current_image_file if self.sample_frozen(self.current_image_file) and not self.aux_deicing and self.intervention_enabled and (temperature_controller.value < -5.0) : self.aux_deicing = True elif self.sample_frozen(self.current_image_file) and SAXS_WAXS_control.inserted and self.retract_deicing and (temperature_controller.value < -5.0): SAXS_WAXS_control.retracted = True sleep(self.retracted_time) SAXS_WAXS_control.inserted = True else: pass else: sleep(0.25)
def run(): from time import sleep casput("NIH:CHILLER.AUTOTUNE", 1) while True: autotune() sleep(5)
def running(self): info("Starting IOC...") from CAServer import casget, casput, casdel, casmonitor from time import time from sleep import sleep for name in self.PV_names: PV_name = self.PV_name(name) casmonitor(PV_name, callback=self.monitor) while not self.running_cancelled: t = time() for name in self.PV_names: if time() - self.last_updated(name) > self.update_period(name): PV_name = self.PV_name(name) value = getattr(self.object, name) ##info("%s=%r" % (PV_name,value)) casput(PV_name, self.transform(name, value), update=False) self.set_update_time(name) if not self.running_cancelled: sleep(t + self.min_update_period - time()) for name in self.names: PV_name = self.PV_name(name) casdel(PV_name)
def monitor(self, PV_name, value, char_value): """Handle PV change requests""" info("%s = %r" % (PV_name, value)) from CAServer import casput for name in self.property_names: if PV_name == self.prefix + name.upper(): setattr(self, name, value) casput(PV_name, getattr(self, name))
def set_is_running(self,value): from thread import start_new_thread if value and not self.running: self.init() self.running = True start_new_thread(self.run,()) else: self.running = False casput(self.CAS_prefix+'.RUNNING', self.running)
def set_running(self,value): from thread import start_new_thread from CAServer import casput if value and not self.running: casput(self.CAS_prefix+'.RUNNING', value) self.deice_enabled = True start_new_thread(self.run,()) else: self.deice_enabled = False
def analyze_commands(self, command_dict): """Updaste state info base on serial commands snet directly to the pump onctroller""" from CAServer import casput from parse import parse for i, command in command_dict.iteritems(): values = parse("/{}A{value:g},1{}", command) # Absolute volume if values: casput(self.prefix + "%d:VOLUME.VAL" % (i + 1), values["value"])
def sample_frozen(self,image_file): from CAServer import casput total_spots = self.diffraction_spots_of_image(image_file) try: casput(self.CAS_prefix+'.SPOTS',total_spots) except: pass flag = total_spots >= self.threshold_N_spts return flag
def monitor(self, PV_name, value, char_value): """Process PV change requests""" from CAServer import casput info("%s = %r" % (PV_name, value)) if PV_name == self.prefix + ".SCAN": oasis_chiller_driver.wait_time = float(value) casput(self.prefix + ".SCAN", oasis_chiller_driver.wait_time) else: attr = PV_name.replace(self.prefix + ".", "") self.command_queue.append([attr, float(value)])
def monitor(self, PV_name, value, char_value): """Handle PV change requests""" info("%s = %r" % (PV_name, value)) from CAServer import casput for name in self.PV_names: if PV_name == self.PV_name(name): info("%s.%s=%r" % (self.object, name, value)) setattr(self.object, name, self.back_transform(name, value)) value = getattr(self.object, name) casput(PV_name, self.transform(name, value))
def monitor(self, PV_name, value, char_value): """Process PV change requests""" from CAServer import casput info("%s = %r" % (PV_name, value)) if PV_name == self.prefix + ".SCAN": self.SCAN = float(value) casput(self.prefix + ".SCAN", self.SCAN) if PV_name == self.prefix + ".VAL": Ramsey_RF_driver.VAL = float(value) casput(self.prefix + ".VAL", float(Ramsey_RF_driver.VAL))
def oasis_monitor(self,PV_name,value,char_value): #print('oasis_monitor: time: %r, PV_name = %r,value= %r,char_value = %r' %(time(),PV_name,value,char_value) ) from CA import cainfo prefix = self.oasis_prefix if PV_name == prefix+".VAL": arr = empty((2,1)) arr[0] = cainfo(prefix+".VAL","timestamp") arr[1] = float(value) self.buffers['oasis_VAL'].append(arr) casput(self.prefix +'.oasis_VAL',value = float(value)) if PV_name == prefix+".RBV": arr = empty((2,1)) arr[0] = cainfo(prefix+".RBV","timestamp") arr[1] = float(value) self.buffers['oasis_RBV'].append(arr) casput(self.prefix +'.oasis_RBV',value = float(value))
def socketserver_init(self): socket_port_lst = range(2030, 2050) i = 0 flag = True while flag: try: port = socket_port_lst[i] self.sock = socket(AF_INET, SOCK_STREAM) self.sock.bind(('', port)) self.sock.listen(5) info('Trial %r, Connection to 127.0.0.1:%r is successful' % (i, port)) self.socket_port = port self.socket = [gethostbyname(gethostname()), self.socket_port] casput(self.prefix + '.SOCKET', self.socket) flag = False info('flag in socketserver_init = %r' % flag) except Exception as e: i += 1 error(e) self.server_command_dict = {} self.server_command_dict[-2] = '-2:dev_info(in: None, out: dict)' self.server_command_dict[-1] = '-1:type_def(in:None, out: dict)' self.server_command_dict[0] = '0:init()' self.server_command_dict[1] = '1:close()' self.server_command_dict[ 2] = '2:broadcast fixed rate(in: float, out: None)' self.server_command_dict[ 3] = '3:request average of N (in:N, out:float)' self.server_command_dict[ 4] = '4:request buffer all(in: None, out: nparray)' self.server_command_dict[ 5] = '5:request buffer update(in:pointer, out:nparray)' self.server_command_dict[ 6] = '6:perform calibration(in: None, out: nparray)' self.server_command_dict[ 7] = '7:get calibration(in: None, out: nparray)' #stores 1 oldest calibration record. self.server_command_dict[8] = '8:save to a file(in: None, out: none)' self.type_def = msgpack.packb(self.server_command_dict, default=m.encode) msg_in = [-1, -1, -1, -1] self._run()
def startup(self): from CAServer import casput,casmonitor from CA import caput,camonitor from numpy import nan casput(self.prefix+".ENABLE",self.intervention_enabled) casput(self.prefix+'.RUNNING', self.running) casput(self.prefix+".KILL",value = 'write password to kill the process') casput(self.prefix+".LIST_ALL_PVS",value = self.get_pv_list()) # Monitor client-writable PVs. casmonitor(self.prefix+".KILL",callback=self.monitor)
def running(self): info("Starting IOC: Prefix: %s ..." % self.prefix) from CAServer import casget, casput, casdel from time import time from sleep import sleep self.monitors_setup() while not self.running_cancelled: t = time() for name in self.property_names: if time() - self.last_updated(name) > self.update_period(name): PV_name = self.prefix + name.upper() value = getattr(self, name) ##info("Update: %s=%r" % (PV_name,value)) casput(PV_name, value, update=False) self.set_update_time(name) if not self.running_cancelled: sleep(t + self.min_update_period - time()) casdel(self.prefix)
def monitor(self, PV_name, value, char_value): """Handle PV change requests""" info("%s = %r" % (PV_name, value)) from configuration_driver import configuration from CAServer import casput for conf in configuration.configurations: for prop in self.configuration_properties: if PV_name == (self.prefix + "." + conf.name + "." + prop).upper(): self.setattr(conf, prop, value) value = self.getattr(conf, prop, expand=True) if value is not None: casput(PV_name, value, update=False) for motor_num in range(0, conf.n_motors): for prop in self.motor_properties: if PV_name == (self.prefix + "." + conf.name + ".MOTOR" + str(motor_num + 1) + "." + prop).upper(): self.setitem(self.getattr(conf, prop), motor_num, value) value = self.getitem(self.getattr(conf, prop), motor_num) if value is not None: casput(PV_name, value, update=False)
def monitor(self, PV_name, value, char_value): """Process PV change requests""" from CAServer import casput debug("%s = %r" % (PV_name, value)) if PV_name == self.prefix + ".SCAN": self.SCAN = value casput(self.prefix + ".SCAN", self.SCAN) if PV_name == self.prefix + ".MFILTER": thermocouple_driver.MFILTER = value casput(self.prefix + ".MFILTER", thermocouple_driver.MFILTER) if PV_name == self.prefix + ".IFILTER": thermocouple_driver.IFILTER = value casput(self.prefix + ".IFILTER", thermocouple_driver.IFILTER) if PV_name == self.prefix + ".TCTYPE": thermocouple_driver.TCTYPE = value casput(self.prefix + ".TCTYPE", thermocouple_driver.TCTYPE)
def process_command_queue(self): """Handle client changes to PVs that where queued up by 'monitor' in a synchronous ways.""" with self.lock: # Allow only one thread at a time inside this function. if not self.queue_halted: from CAServer import casput if self.queue.commands: info("Sending commands %r" % self.queue.commands) replies = comm_ports.write_read(self.queue.commands) self.analyze_commands(self.queue.commands) info("Got replies %r" % replies) for i in replies: info("Updating %s=%r" % (self.prefix + "%d.AINP" % (i + 1), replies[i])) casput(self.prefix + "%d.AINP" % (i + 1), replies[i], update=True) self.queue.commands = {} if self.queue.volume_values: volumes.set_values(self.queue.volume_values.keys(), self.queue.volume_values.values()) V = self.queue.volume_values for i in V: casput(self.prefix + "%d:VOLUME.VAL" % (i + 1), V[i]) self.queue.volume_values = {} if self.queue.volume_speeds: volumes.set_speeds(self.queue.volume_speeds.keys(), self.queue.volume_speeds.values()) indices = self.queue.volume_speeds.keys() speeds = volumes.speeds(indices) # read back values for i in indices: casput(self.prefix + "%d:VOLUME.VELO" % (i + 1), speeds[i]) self.queue.volume_speeds = {} if self.queue.ports_values: ports.set_values(self.queue.ports_values.keys(), self.queue.ports_values.values()) p = self.queue.ports_values for i in p: casput(self.prefix + "%d:PORT.VAL" % (i + 1), p[i]) self.queue.ports_values = {} if self.queue.volume_moving: volumes.set_moving(self.queue.volume_moving.keys(), self.queue.volume_moving.values()) self.queue.volume_moving = {}
def broadcast(self, method="on demand"): dt = self.broadcast_period number = int(dt * 50) if method == "on demand": #debug('Broadcasting on demand') ch1 = mean( ((self.circular_buffer.get_last_N(N=number)[0] - 8192.) / 8192.) * float(self.gain_lst[0])) / self.calib[0] casput(self.prefix + ".pressure_upstream", ch1) ch2 = mean( ((self.circular_buffer.get_last_N(N=number)[1] - 8192.) / 8192.) * float(self.gain_lst[1])) / self.calib[1] casput(self.prefix + ".pressure_downstream", ch2) ch3 = mean( ((108.364 - 88.0461) / 2.0**13) * (self.circular_buffer.get_last_N(N=number)[2] - 2.0**13) + 88.0461 + 0.2) casput(self.prefix + ".pressure_barometric", ch3) ch4 = mean(self.circular_buffer.get_last_N(N=number)[3] - 8192.) * 0.036621 + 100. + self.calib[3] casput(self.prefix + ".temperature_hutch", ch4) else: debug("unknown method(%r) requested" % method)
def update(self): from CAServer import casput, casmonitor from configuration_driver import configuration for prop in self.global_properties: PV_name = (self.prefix + "." + prop).upper() value = self.getattr(configuration, prop, expand=True) if value is not None: casput(PV_name, value, update=False) casmonitor(PV_name, callback=self.monitor) for conf in configuration.configurations: for prop in self.configuration_properties: PV_name = (self.prefix + "." + conf.name + "." + prop).upper() value = self.getattr(conf, prop, expand=True) if value is not None: casput(PV_name, value, update=False) casmonitor(PV_name, callback=self.monitor) for prop in self.motor_properties: for motor_num in range(0, conf.n_motors): PV_name = (self.prefix + "." + conf.name + ".MOTOR" + str(motor_num + 1) + "." + prop).upper() value = self.getitem(self.getattr(conf, prop), motor_num) if value is not None: casput(PV_name, value, update=False) casmonitor(PV_name, callback=self.monitor)
def run(self): """Run EPICS IOC""" from CAServer import casput, casmonitor, casdel from numpy import isfinite, isnan from time import time self.running = True casput(self.prefix + ".SCAN", self.SCAN) casput(self.prefix + ".DESC", "Temp") casput(self.prefix + ".EGU", "C") # Monitor client-writable PVs. casmonitor(self.prefix + ".SCAN", callback=self.monitor) casmonitor(self.prefix + ".MFILTER", callback=self.monitor) casmonitor(self.prefix + ".IFILTER", callback=self.monitor) casmonitor(self.prefix + ".TCTYPE", callback=self.monitor) while self.running: if self.SCAN > 0 and isfinite(self.SCAN): if time() - self.last_valid_reply > 10: if not isnan(thermocouple_driver.VAL): info("Reading configuration") casput(self.prefix + ".COMM", thermocouple_driver.COMM) casput(self.prefix + ".MFILTER", thermocouple_driver.MFILTER) casput(self.prefix + ".IFILTER", thermocouple_driver.IFILTER) casput(self.prefix + ".TCTYPE", thermocouple_driver.TCTYPE) t = time() VAL = thermocouple_driver.VAL if not isnan(VAL): self.last_valid_reply = time() casput(self.prefix + ".VAL", VAL) sleep(t + 1.00 * self.SCAN - time()) casput(self.prefix + ".SCANT", time() - t) # post actual scan time for diagnostics else: casput(self.prefix + ".SCANT", nan) sleep(0.1) casdel(self.prefix)
def set_queue_halted(self, value): from CAServer import casput return casput(self.prefix + ".SPMG", 0 if value else 3)
def run(self): """Run EPICS IOC""" from CAServer import casput, casmonitor, casdel from numpy import isfinite from time import time self.running = True # Initialization casput(self.prefix + ".SCAN", self.scan_time) casput(self.prefix + ".SPMG", 3) # 0:Stop,1:Pause,2:Move,3:Go for i in range(0, self.N): casput(self.prefix + "%d.AOUT" % (i + 1), "") # ASCII output string to device casput(self.prefix + "%d.AINP" % (i + 1), "") # ASCII input string from device # Static PVs for i in range(0, self.N): casput(self.prefix + "%d:VOLUME.DESC" % (i + 1), "Pump%d" % (i + 1)) casput(self.prefix + "%d:VOLUME.EGU" % (i + 1), "uL") casput(self.prefix + "%d:PORT.DESC" % (i + 1), "Valve%d" % (i + 1)) casput(self.prefix + "%d:PORT.EGU" % (i + 1), "OIB") casput(self.prefix + "%d:VOLUME.CNEN" % (i + 1), 1) casput(self.prefix + "%d:PORT.CNEN" % (i + 1), 1) # Monitor client-writable PVs casmonitor(self.prefix + ".SCAN", callback=self.monitor) casmonitor(self.prefix + ".SPMG", callback=self.monitor) for i in range(0, self.N): casmonitor(self.prefix + "%d.AOUT" % (i + 1), callback=self.monitor) casmonitor(self.prefix + "%d.AINP" % (i + 1), callback=self.monitor) casmonitor(self.prefix + "%d:VOLUME.VAL" % (i + 1), callback=self.monitor) casmonitor(self.prefix + "%d:VOLUME.VELO" % (i + 1), callback=self.monitor) casmonitor(self.prefix + "%d:PORT.VAL" % (i + 1), callback=self.monitor) casmonitor(self.prefix + "%d:VOLUME.STOP" % (i + 1), callback=self.monitor) casmonitor(self.prefix + "%d:PORT.STOP" % (i + 1), callback=self.monitor) while self.running: if self.scan_time > 0 and isfinite(self.scan_time): for i in range(0, self.N): if comm_ports.max_time_between_replies[i] > 10: comm_ports.max_time_between_replies[i] = 0 debug("Reading pump %d configuration" % (i + 1)) casput(self.prefix + "%d:VOLUME.VAL" % (i + 1), volumes.values([i])[0]) casput(self.prefix + "%d:VOLUME.LLM" % (i + 1), volumes.low_limits([i])[0]) casput(self.prefix + "%d:VOLUME.HLM" % (i + 1), volumes.high_limits([i])[0]) casput(self.prefix + "%d:PORT.VAL" % (i + 1), ports.values([i])[0]) t = time() values = volumes.values(range(0, self.N)) for i in range(0, self.N): casput(self.prefix + "%d:VOLUME.RBV" % (i + 1), values[i]) self.process_command_queue() values = ports.values(range(0, self.N)) for i in range(0, self.N): casput(self.prefix + "%d:PORT.RBV" % (i + 1), values[i]) self.process_command_queue() moving = volumes.moving(range(0, self.N)) for i in range(0, self.N): casput(self.prefix + "%d:VOLUME.DMOV" % (i + 1), not moving[i]) casput(self.prefix + "%d:PORT.DMOV" % (i + 1), not moving[i]) self.process_command_queue() speeds = volumes.speeds(range(0, self.N)) for i in range(0, self.N): casput(self.prefix + "%d:VOLUME.VELO" % (i + 1), speeds[i]) self.process_command_queue() sleep(t + 1 * self.scan_time - time()) casput(self.prefix + ".SCANT", time() - t) # post actual scan time for diagnostics else: casput(self.prefix + ".SCANT", nan) sleep(0.1) casdel(self.prefix)
def init(self): """ define parameters for current operation initializes image analyzer """ from optical_image_analyzer import image_analyzer image_analyzer.init() from CAServer import casput, casmonitor from CA import caput, camonitor from numpy import nan info('initializing the %s server' % self.prefix) casput(self.prefix + ".RBV", nan) casput(self.prefix + ".VAL", nan) casput(self.prefix + ".MEAN_TOP", nan) casput(self.prefix + ".MEAN_BOTTOM", nan) casput(self.prefix + ".MEAN_MIDDLE", nan) casput(self.prefix + ".MEAN", nan) casput(self.prefix + ".STDEV", nan) casput(self.prefix + '.RUNNING', self.running) #changable control parameters casput(self.prefix + '.region_offset_x', self.region_offset_x) casput(self.prefix + '.region_size_x', self.region_size_x) casput(self.prefix + '.region_offset_y', self.region_offset_y) casput(self.prefix + '.region_size_y', self.region_size_y) casput(self.prefix + '.warning', self.warning) casput(self.prefix + '.warning_threshold', self.warning_threshold) casput(self.prefix + ".KILL", value='write password to kill the process') #PV with a list of all process variable registered at the current Channel Access Server casput(self.prefix + ".LIST_ALL_PVS", value=self.get_pv_list()) # Monitor client-writable PVs. casmonitor(self.prefix + ".KILL", callback=self.monitor) casmonitor(self.prefix + ".region_size_x", callback=self.monitor) casmonitor(self.prefix + ".region_offset_x", callback=self.monitor) casmonitor(self.prefix + ".region_size_y", callback=self.monitor) casmonitor(self.prefix + ".region_offset_y", callback=self.monitor) casmonitor(self.prefix + ".warning_threshold", callback=self.monitor)
def run_once(self): from optical_image_analyzer import image_analyzer from CAServer import casput, casget from numpy import rot90 img = image_analyzer.get_image() debug('image received: image counter %r, image dimensions %r' % (image_analyzer.imageCounter, img.shape)) if self.orientation == 'horizontal2' or self.orientation == 'horizontal' or self.orientation == 'on-axis-h': img = rot90(img, 3, axes=(1, 2)) res_dic = self.is_frozen(img) debug('res_dic = %r' % res_dic) is_frozen_flag = res_dic['flag'] casput(self.prefix + ".MEAN_TOP", round(res_dic['mean_top'], 2)) casput(self.prefix + ".MEAN_BOTTOM", round(res_dic['mean_bottom'], 2)) casput(self.prefix + ".MEAN_MIDDLE", round(res_dic['mean_middle'], 2)) casput(self.prefix + ".MEAN", round(res_dic['mean_value'], 2)) casput(self.prefix + ".RBV", round(res_dic['mean_value'], 2)) casput(self.prefix + ".warning", res_dic['mean_value'] >= self.warning_threshold) casput(self.prefix + ".STDEV", round(res_dic['stdev'], 2)) self.intervention_enabled = casget(self.prefix + '.INTERVENTION_ENABLED') casput(self.prefix + ".VAL", is_frozen_flag) if is_frozen_flag and temperature.value < self.frozen_threshold_temperature: print('freezing detected') """Intervention""" if self.intervention_enabled: self.retract_intervention() else: print('Intervention was disabled')
def CAserver_update(self): from CAServer import casget, casput casput(self.prefix + '.RUNNING', self.running) casput(self.prefix + '.UPDATE_T', self.CA_update_t)
def CAserver_init(self): from CAServer import casget, casput self.running = False self.CA_update_t = 0.3 casput(self.prefix + '.RUNNING', self.running) casput(self.prefix + '.UPDATE_T', self.CA_update_t) #controls casput(self.prefix + ".broadcast_period", self.broadcast_period) #indicators casput(self.prefix + ".pressure_upstream", nan) casput(self.prefix + ".pressure_downstream", nan) casput(self.prefix + ".pressure_barometric", nan) casput(self.prefix + ".temperature_hutch", nan) #monitors casmonitor(self.prefix + ".broadcast_period", callback=self.monitor) try: casput(self.prefix + '.SOCKET', self.socket) except: error(traceback.format_exc())
def server_init(self): casput(self.prefix + '.SOCKET', ['', '']) self.socketserver_init() self.CAserver_init()