Helper Functions *************************************************************''' def convert_rf_to_if(self,rf_freq): #Convert freq based on RF/IF of Analog Tuner if self.rfinfo.if_center_freq > 0: ifoffset = rf_freq - self.rfinfo.rf_center_freq if_freq =self.rfinfo.if_center_freq+ifoffset else: if_freq = rf_freq self._log.debug("Converted RF Freq of %s to IF Freq %s based on Input RF of %s, IF of %s, and spectral inversion %s" %(rf_freq,if_freq,self.rfinfo.rf_center_freq,self.rfinfo.if_center_freq,self.rfinfo.spectrum_inverted)) return float(if_freq) #Start with smallest possible and see if that can satisfy request. # Sending 0 for don't care should pass because we are looking for requested to be less than available def findBestBWSR(self,requestedBW,requestedSR): self._log.debug("findBestBWSR") for bw,sr,decimation in self.AVAILABLE_BW_SR: self._log.debug("findBestBWSR. Requested: " + str(requestedBW) +" "+ str(requestedSR) + " evaluating: " + str(bw)+" "+ str(sr)) if bw>= requestedBW and sr>=requestedSR: return (bw,sr,decimation) return (False,False,False) if __name__ == '__main__': logging.getLogger().setLevel(logging.INFO) logging.debug("Starting Device") start_device(RX_Digitizer_Sim_i)
if packet.dataBuffer is None: return NOOP outData = range(len(packet.dataBuffer)) for i in range(len(packet.dataBuffer)): if self.increaseAmplitude: outData[i] = float(packet.dataBuffer[i]) * self.amplitude else: outData[i] = float(packet.dataBuffer[i]) # NOTE: You must make at least one valid pushSRI call if packet.sriChanged: self.port_dataFloat_out.pushSRI(packet.SRI); self.port_dataFloat_out.pushPacket(outData, packet.T, packet.EOS, packet.streamID) return NORMAL """ # TODO fill in your code here self._log.debug("process() example log message") return NOOP if __name__ == '__main__': logging.getLogger().setLevel(logging.INFO) logging.debug("Starting Device") start_device(PropertyFilteringDev_i)
if packet.dataBuffer is None: return NOOP outData = range(len(packet.dataBuffer)) for i in range(len(packet.dataBuffer)): if self.increaseAmplitude: outData[i] = float(packet.dataBuffer[i]) * self.amplitude else: outData[i] = float(packet.dataBuffer[i]) # NOTE: You must make at least one valid pushSRI call if packet.sriChanged: self.port_dataFloat_out.pushSRI(packet.SRI); self.port_dataFloat_out.pushPacket(outData, packet.T, packet.EOS, packet.streamID) return NORMAL """ # TODO fill in your code here self._log.debug("process() example log message") return NOOP if __name__ == '__main__': logging.getLogger().setLevel(logging.INFO) logging.debug("Starting Device") time.sleep(15) start_device(SlowLaunchDevice_i)
self.lastScanStrategy = "%s = %s" % (allocation_id, str(scan_strategy)) ''' ************************************************************* Functions servicing the RFInfo port(s) - port_name is the port over which the call was received *************************************************************''' def get_rf_flow_id(self,port_name): return "" def set_rf_flow_id(self,port_name, _id): pass def get_rfinfo_pkt(self,port_name): _antennainfo=FRONTEND.AntennaInfo('','','','') _freqrange=FRONTEND.FreqRange(0,0,[]) _feedinfo=FRONTEND.FeedInfo('','',_freqrange) _sensorinfo=FRONTEND.SensorInfo('','','',_antennainfo,_feedinfo) _rfcapabilities=FRONTEND.RFCapabilities(_freqrange,_freqrange) _rfinfopkt=FRONTEND.RFInfoPkt('',0.0,0.0,0.0,False,_sensorinfo,[],_rfcapabilities,[]) return _rfinfopkt def set_rfinfo_pkt(self,port_name, pkt): pass if __name__ == '__main__': logging.getLogger().setLevel(logging.INFO) logging.debug("Starting Device") start_device(scanner_i)
data, T, EOS, streamID, sri, sriChanged, inputQueueFlushed = self.port_dataShort_in.getPacket() if data == None: return NOOP outData = range(len(data)) for i in range(len(data)): if self.increaseAmplitude: outData[i] = float(data[i]) * self.amplitude else: outData[i] = float(data[i]) // NOTE: You must make at least one valid pushSRI call if sriChanged: self.port_dataFloat_out.pushSRI(sri); } self.port_dataFloat_out.pushPacket(outData, T, EOS, streamID) return NORMAL """ # TODO fill in your code here self._log.debug("process() example log message") return NOOP if __name__ == '__main__': logging.getLogger().setLevel(logging.WARN) logging.debug("Starting Device") start_device(issue_111_i)
def setTunerEnable(self,allocation_id, enable): idx = self.getTunerMapping(allocation_id) if idx < 0: raise FRONTEND.FrontendException("Invalid allocation id") if allocation_id != self.getControlAllocationId(idx): raise FRONTEND.FrontendException(("ID "+str(allocation_id)+" does not have authorization to modify the tuner")) # set hardware to new value. Raise an exception if it's not possible self.frontend_tuner_status[idx].enabled = enable def getTunerEnable(self,allocation_id): idx = self.getTunerMapping(allocation_id) if idx < 0: raise FRONTEND.FrontendException("Invalid allocation id") return self.frontend_tuner_status[idx].enabled def get_rf_flow_id(self,port_name): return "none" def set_rf_flow_id(self,port_name, id): pass def get_rfinfo_pkt(self,port_name): return frontend.RFInfoPkt() def set_rfinfo_pkt(self,port_name, pkt): pass if __name__ == '__main__': logging.getLogger().setLevel(logging.INFO) logging.debug("Starting Device") start_device(analogTuner_i)
# NOTE: You must make at least one valid pushSRI call if sriChanged: self.port_dataFloat_out.pushSRI(sri); self.port_dataFloat_out.pushPacket(outData, T, EOS, streamID) return NORMAL """ # TODO fill in your code here self._log.debug("process() example log message") return NOOP def allocate_simple_prop(self,value): self._log.info("Calling allocate_simple_prop passing value " + str(value)) return True def allocate_prop_with_spaces(self,value): self._log.info("Calling allocate_prop_with_spaces " + str(value)) return True def allocate_prop__with_colons(self,value): self._log.info("Calling allocate_prop__with_colons " + str(value)) return True if __name__ == '__main__': logging.getLogger().setLevel(logging.INFO) logging.debug("Starting Device") start_device(ticket_1502_i)
if self._props["memCapacity"] < value: return False self._props["memCapacity"] = self._props["memCapacity"] - value return True def allocate_BogoMipsCapacity(self, value): if self._props["BogoMipsCapacity"] < value: return False self._props["BogoMipsCapacity"] = self._props["BogoMipsCapacity"] - value return True def deallocate_memCapacity(self, value): self._props["memCapacity"] = self._props["memCapacity"] + value def deallocate_BogoMipsCapacity(self, value): self._props["BogoMipsCapacity"] = self._props["BogoMipsCapacity"] + value def updateUsageState(self): # Update usage state if self._props["memCapacity"] == 0 and self._props["BogoMipsCapacity"] == 0: self._usageState = CF.Device.BUSY elif self._props["memCapacity"] == 100000000 and self._props["BogoMipsCapacity"] == 100000000: self._usageState = CF.Device.IDLE else: self._usageState = CF.Device.ACTIVE if __name__ == "__main__": logging.getLogger().setLevel(logging.WARN) logging.debug("Starting Device") start_device(PortDevice_impl)
def deallocate_memCapacity(self, value): self._props["memCapacity"] = self._props["memCapacity"] + value def deallocate_BogoMipsCapacity(self, value): self._props["BogoMipsCapacity"] = self._props["BogoMipsCapacity"] + value def updateUsageState(self): # Update usage state self._usageState = CF.Device.BUSY class SomeStruct(object): field1 = simple_property(id_="item1", type_="string", defvalue="value1") field2 = simple_property(id_="item2", type_="long", defvalue=100) field3 = simple_property(id_="item3", type_="double", defvalue=3.14156) struct = struct_property(id_="DCE:ffe634c9-096d-425b-86cc-df1cce50612f", name="struct_test", structdef=SomeStruct) if __name__ == "__main__": logging.getLogger().setLevel(logging.DEBUG) logging.debug("Starting Device") start_device(BasicAlwaysBusyDevice)
mode="readonly", kinds=("allocation",)) def allocate_BogoMipsCapacity (self, value): if self.BogoMipsCapacity < value: return False self.BogoMipsCapacity -= value return True def deallocate_BogoMipsCapacity (self, value): self.BogoMipsCapacity += value def updateUsageState (self): # Update usage state if self.BogoMipsCapacity == 0: self._usageState = CF.Device.BUSY elif self.BogoMipsCapacity == 100000000: self._usageState = CF.Device.IDLE else: self._usageState = CF.Device.ACTIVE def execute (self, *args): if self.crashEnabled: os.kill(os.getpid(), signal.SIGKILL) return ExecutableDevice.execute(self, *args) if __name__ == "__main__": logging.getLogger().setLevel(logging.DEBUG) logging.debug("Starting Device") start_device(CrashableExecutableDevice)
if self.long_capacity <= other.long_capacity: return False if self.float_capacity <= other.float_capacity: return False return True def __iadd__(self, other): self.long_capacity += other.long_capacity self.float_capacity += other.float_capacity return self def __isub__(self, other): self.long_capacity -= other.long_capacity self.float_capacity -= other.float_capacity return self allocStruct = struct_property(id_="DCE:001fad60-b4b3-4ed2-94cb-40e1d956bf4f", name="allocStruct", configurationkind=("configure", "allocation"), structdef=AllocStruct) structseq = structseq_property(id_="DCE:e836f007-5821-4671-b05a-e0ff5147fe86", name="structseq_test", structdef=SomeStruct, defvalue=[]) if __name__ == "__main__": logging.getLogger().setLevel(logging.DEBUG) logging.debug("Starting Device") start_device(BadRelease)
# Demonstrate the attribute MixIn class BasicChildDevice(CF__POA.Device, Device, PropertyAttributeMixIn): def __init__(self, devmgr, uuid, label, softwareProfile, compositeDevice, execparams): Device.__init__(self, devmgr, uuid, label, softwareProfile, compositeDevice, execparams, PROPERTIES) def _allocateCapacity(self, propname, value): if propname == "someCapacity": self.prop_someCapacity = self.props_someCapacity - value if self.prop_someCapacity < 0: return False return True else: return False def _deallocateCapacity(self, propname, value): if propname == "someCapacity": self.prop_someCapacity = self.prop_someCapacity + value def updateUsageState(self): if self.prop_someCapacity == 0 and self.prop_someCapacity == 0: self._usageState = CF.Device.BUSY elif self.prop_someCapacity == 100000000 and self.prop_someCapacity == 100000000: self._usageState = CF.Device.IDLE else: self._usageState = CF.Device.ACTIVE if __name__ == "__main__": start_device(BasicChildDevice)
packet = self.port_dataShort_in.getPacket() if packet.dataBuffer is None: return NOOP outData = range(len(packet.dataBuffer)) for i in range(len(packet.dataBuffer)): if self.increaseAmplitude: outData[i] = float(packet.dataBuffer[i]) * self.amplitude else: outData[i] = float(packet.dataBuffer[i]) # NOTE: You must make at least one valid pushSRI call if packet.sriChanged: self.port_dataFloat_out.pushSRI(packet.SRI) self.port_dataFloat_out.pushPacket(outData, packet.T, packet.EOS, packet.streamID) return NORMAL """ # TODO fill in your code here self._log.debug("process() example log message") return NOOP if __name__ == '__main__': logging.getLogger().setLevel(logging.INFO) logging.debug("Starting Device") start_device(dev_props_bad_numbers_i)
data, T, EOS, streamID, sri, sriChanged, inputQueueFlushed = self.port_dataShort_in.getPacket() if data == None: return NOOP outData = range(len(data)) for i in range(len(data)): if self.increaseAmplitude: outData[i] = float(data[i]) * self.amplitude else: outData[i] = float(data[i]) // NOTE: You must make at least one valid pushSRI call if sriChanged: self.port_dataFloat_out.pushSRI(sri); } self.port_dataFloat_out.pushPacket(outData, T, EOS, streamID) return NORMAL """ # TODO fill in your code here self._log.debug("process() example log message") return NOOP if __name__ == '__main__': logging.getLogger().setLevel(logging.WARN) logging.debug("Starting Device") start_device(test_collocation_device_i)
if data == None: return NOOP outData = range(len(data)) for i in range(len(data)): if self.increaseAmplitude: outData[i] = float(data[i]) * self.amplitude else: outData[i] = float(data[i]) # NOTE: You must make at least one valid pushSRI call if sriChanged: self.port_dataFloat_out.pushSRI(sri); self.port_dataFloat_out.pushPacket(outData, T, EOS, streamID) return NORMAL """ # TODO fill in your code here self._log.debug("process() example log message") return NOOP if __name__ == '__main__': logging.getLogger().setLevel(logging.WARN) logging.debug("Starting Device") start_device(bad_init_device_i)
def initialize(self): DeviceStub_base.initialize(self) self.sampleSRIPushed = False def updateUsageState(self): return NOOP def process(self): packet = self.port_dataFloat_in.getPacket() if packet.dataBuffer is None: # Slow pushes of small sample data if not self.sampleSRIPushed: self.sampleSRIPushed = True self.port_dataFloat_out.pushSRI(bulkio.sri.create("DeviceStub_sample")) outData = [ 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0 ] self.port_dataFloat_out.pushPacket(outData, bulkio.timestamp.now(), False, "DeviceStub_sample") return NOOP # Feed through existing data if packet.sriChanged: self.port_dataFloat_out.pushSRI(packet.SRI) self.port_dataFloat_out.pushPacket(packet.dataBuffer, packet.T, packet.EOS, packet.streamID) return NORMAL if __name__ == '__main__': logging.getLogger().setLevel(logging.INFO) logging.debug("Starting Device") start_device(DeviceStub_i)
if tmp_val < 0: raise Exception('Cannot deallocate more than %d' % self.__MAX_BOGOMIPS) self.allocated_bog = tmp_val self._props[self.__bog_id] = self.allocated_bog return True except Exception, e: print "\tGot an error while deallocationg BogoMips: %s" % str(e) return False def updateUsageState(self): """ This is called automatically after allocateCapacity or deallocateCapacity are called. Your implementation should determine the current state of the device: self._usageState = CF.Device.IDLE # not in use self._usageState = CF.Device.ACTIVE # in use, with capacity remaining for allocation self._usageState = CF.Device.BUSY # in use, with no capacity remaining for allocation """ pass ########################################### # program execution ########################################### if __name__ == "__main__": logging.getLogger().setLevel(logging.WARN) logging.debug("Starting Device") start_device(BasicTestDevice_python_impl1)
outData = range(len(packet.dataBuffer)) for i in range(len(packet.dataBuffer)): if self.increaseAmplitude: outData[i] = float(packet.dataBuffer[i]) * self.amplitude else: outData[i] = float(packet.dataBuffer[i]) # NOTE: You must make at least one valid pushSRI call if packet.sriChanged: self.port_dataFloat_out.pushSRI(packet.SRI); self.port_dataFloat_out.pushPacket(outData, packet.T, packet.EOS, packet.streamID) return NORMAL """ # TODO fill in your code here self._log.debug("process() DEBUG example log message") self._log.info("process() INFO example log message") self._log.error("process() ERROR example log message") self._log.trace("process() TRACE example log message") self._log.warn("process() WARN example log message") return NOOP if __name__ == '__main__': logging.getLogger().setLevel(logging.INFO) logging.debug("Starting Device") start_device(python_dev_i)
def get_mcastnicEgressFree(self): return self.mcastnicEgressCapacity mcastnicEgressFree = rebind(GPP_base.mcastnicEgressFree, fget=get_mcastnicEgressFree) def get_loadTotal(self): return self.processor_cores * self.loadCapacityPerCore loadTotal = rebind(GPP_base.loadTotal, fget=get_loadTotal) def get_loadAverage(self): loadavg = self._loadavg() result = GPP_base.LoadAverage() result.onemin = loadavg[0] result.fivemin = loadavg[1] result.fifteenmin = loadavg[2] return result loadAverage = rebind(GPP_base.loadAverage, fget=get_loadAverage) def get_loadFree(self): return self.loadCapacity loadFree = rebind(GPP_base.loadFree, fget=get_loadFree) def get_hostName(self): return socket.gethostname() hostName = rebind(GPP_base.hostName, fget=get_hostName) ########################################### # program execution ########################################### if __name__ == "__main__": start_device(GPP)
data, T, EOS, streamID, sri, sriChanged, inputQueueFlushed = self.port_dataShort_in.getPacket() if data == None: return NOOP outData = range(len(data)) for i in range(len(data)): if self.increaseAmplitude: outData[i] = float(data[i]) * self.amplitude else: outData[i] = float(data[i]) # NOTE: You must make at least one valid pushSRI call if sriChanged: self.port_dataFloat_out.pushSRI(sri); self.port_dataFloat_out.pushPacket(outData, T, EOS, streamID) return NORMAL """ # TODO fill in your code here self._log.debug("process() example log message") return NOOP if __name__ == '__main__': logging.getLogger().setLevel(logging.WARN) logging.debug("Starting Device") start_device(ticket_cf_939_dev_i)
def get_rfinfo_pkt(self,port_name): return frontend.RFInfoPkt() def set_rfinfo_pkt(self,port_name, pkt): pass ''' ************************************************************* Functions servicing the GPS port(s) - port_name is the port over which the call was received *************************************************************''' #TODO: Implement GPS readback from radio def get_gps_info(self,port_name): return frontend.GPSInfo() def set_gps_info(self,port_name, gps_info): pass def get_gps_time_pos(self,port_name): return frontend.GpsTimePos() def set_gps_time_pos(self,port_name, gps_time_pos): pass if __name__ == '__main__': logging.getLogger().setLevel(logging.INFO) logging.debug("Starting Device") start_device(NDRFEI_i)
if data == None: return NOOP outData = range(len(data)) for i in range(len(data)): if self.increaseAmplitude: outData[i] = float(data[i]) * self.amplitude else: outData[i] = float(data[i]) # NOTE: You must make at least one valid pushSRI call if sriChanged: self.port_dataFloat_out.pushSRI(sri); self.port_dataFloat_out.pushPacket(outData, T, EOS, streamID) return NORMAL """ # TODO fill in your code here self._log.debug("process() example log message") return NOOP if __name__ == '__main__': logging.getLogger().setLevel(logging.INFO) logging.debug("Starting Device") start_device(alloc_test_i)
if packet.dataBuffer is None: return NOOP outData = range(len(packet.dataBuffer)) for i in range(len(packet.dataBuffer)): if self.increaseAmplitude: outData[i] = float(packet.dataBuffer[i]) * self.amplitude else: outData[i] = float(packet.dataBuffer[i]) # NOTE: You must make at least one valid pushSRI call if packet.sriChanged: self.port_dataFloat_out.pushSRI(packet.SRI); self.port_dataFloat_out.pushPacket(outData, packet.T, packet.EOS, packet.streamID) return NORMAL """ # TODO fill in your code here self._log.debug("process() example log message") return NOOP if __name__ == '__main__': logging.getLogger().setLevel(logging.INFO) logging.debug("Starting Device") start_device(nocmdline_dev_i)
data, T, EOS, streamID, sri, sriChanged, inputQueueFlushed = self.port_dataShort_in.getPacket() if data == None: return NOOP outData = range(len(data)) for i in range(len(data)): if self.increaseAmplitude: outData[i] = float(data[i]) * self.amplitude else: outData[i] = float(data[i]) # NOTE: You must make at least one valid pushSRI call if sriChanged: self.port_dataFloat_out.pushSRI(sri); self.port_dataFloat_out.pushPacket(outData, T, EOS, streamID) return NORMAL """ # TODO fill in your code here self._log.debug("process() example log message") return NOOP if __name__ == '__main__': logging.getLogger().setLevel(logging.WARN) logging.debug("Starting Device") start_device(SADUsesDevice_i)
if self.long_capacity <= other.long_capacity: return False if self.float_capacity <= other.float_capacity: return False return True def __iadd__(self, other): self.long_capacity += other.long_capacity self.float_capacity += other.float_capacity return self def __isub__(self, other): self.long_capacity -= other.long_capacity self.float_capacity -= other.float_capacity return self allocStruct = struct_property(id_="DCE:001fad60-b4b3-4ed2-94cb-40e1d956bf4f", name="allocStruct", configurationkind=("configure", "allocation"), structdef=AllocStruct) structseq = structseq_property(id_="DCE:e836f007-5821-4671-b05a-e0ff5147fe86", name="structseq_test", structdef=SomeStruct, defvalue=[]) if __name__ == "__main__": logging.getLogger().setLevel(logging.DEBUG) logging.debug("Starting Device") start_device(BadReleaseBefore)
data, T, EOS, streamID, sri, sriChanged, inputQueueFlushed = self.port_dataShort_in.getPacket() if data == None: return NOOP outData = range(len(data)) for i in range(len(data)): if self.increaseAmplitude: outData[i] = float(data[i]) * self.amplitude else: outData[i] = float(data[i]) # NOTE: You must make at least one valid pushSRI call if sriChanged: self.port_dataFloat_out.pushSRI(sri); self.port_dataFloat_out.pushPacket(outData, T, EOS, streamID) return NORMAL """ # TODO fill in your code here self._log.debug("process() example log message") return NOOP if __name__ == '__main__': logging.getLogger().setLevel(logging.WARN) logging.debug("Starting Device") start_device(ExampleExecutableDevice01_i)
""" streamID = "TCP port {0}".format(self.port_num) data, samplePeriod = self._server.getDataAndSampleTime() returnCode = NOOP if (0 < len(data)): returnCode = NORMAL utcNow = None gpsInfo = self.port_GPS_uses._get_gps_info() if (None != gpsInfo): utcNow = gpsInfo.timestamp else: utcNow = bulkio.timestamp.now() if (self._sendSRI): sri = bulkio.sri.create(streamID) sri.xdelta = samplePeriod self.port_dataFloat_out.pushSRI(sri) self._sendSRI = False self.port_dataFloat_out.pushPacket(data, utcNow, False, streamID) return returnCode if __name__ == '__main__': logging.getLogger().setLevel(logging.WARN) logging.debug("Starting Device") start_device(simple_tcp_i)
if packet.dataBuffer is None: return NOOP outData = range(len(packet.dataBuffer)) for i in range(len(packet.dataBuffer)): if self.increaseAmplitude: outData[i] = float(packet.dataBuffer[i]) * self.amplitude else: outData[i] = float(packet.dataBuffer[i]) # NOTE: You must make at least one valid pushSRI call if packet.sriChanged: self.port_dataFloat_out.pushSRI(packet.SRI); self.port_dataFloat_out.pushPacket(outData, packet.T, packet.EOS, packet.streamID) return NORMAL """ # TODO fill in your code here self._log.debug("process() example log message") return NOOP if __name__ == '__main__': logging.getLogger().setLevel(logging.INFO) logging.debug("Starting Device") start_device(cmdline_dev_i)
# - A provides (input) port of type BULKIO.dataShort called dataShort_in # - A uses (output) port of type BULKIO.dataFloat called dataFloat_out # The mapping between the port and the class if found in the component # base class. # This example also makes use of the following Properties: # - A float value called amplitude # - A boolean called increaseAmplitude data, T, EOS, streamID, sri = self.port_dataShort_in.getPacket() if data == None: return NOOP outData = range(len(data)) for i in range(len(data)): if self.increaseAmplitude: outData[i] = float(data[i]) * self.amplitude else: outData[i] = float(data[i]) self.port_dataFloat_out.pushPacket(outData, T, EOS, streamID) """ self.updateUsageState() return NOOP if __name__ == '__main__': logging.getLogger().setLevel(logging.WARN) logging.debug("Starting Device") start_device(PythonExecDev_python_impl1_i)
data, T, EOS, streamID, sri, sriChanged, inputQueueFlushed = self.port_dataShort_in.getPacket() if data == None: return NOOP outData = range(len(data)) for i in range(len(data)): if self.increaseAmplitude: outData[i] = float(data[i]) * self.amplitude else: outData[i] = float(data[i]) # NOTE: You must make at least one valid pushSRI call if sriChanged: self.port_dataFloat_out.pushSRI(sri); self.port_dataFloat_out.pushPacket(outData, T, EOS, streamID) return NORMAL """ # TODO fill in your code here self._log.debug("process() example log message") return NOOP if __name__ == "__main__": logging.getLogger().setLevel(logging.WARN) logging.debug("Starting Device") start_device(MatchingDevice_i)
def __iadd__(self, other): self.long_capacity += other.long_capacity self.float_capacity += other.float_capacity return self def __isub__(self, other): self.long_capacity -= other.long_capacity self.float_capacity -= other.float_capacity return self allocStruct = struct_property(id_="DCE:001fad60-b4b3-4ed2-94cb-40e1d956bf4f", name="allocStruct", configurationkind=("configure", "allocation"), structdef=AllocStruct) structseq = structseq_property(id_="DCE:e836f007-5821-4671-b05a-e0ff5147fe86", name="structseq_test", structdef=SomeStruct, defvalue=[]) hex_props = simpleseq_property(id_="hex_props", name="hex_props", type_='short', defvalue=(0x01, 0x02)) if __name__ == "__main__": logging.getLogger().setLevel(logging.DEBUG) logging.debug("Starting Device") start_device(BasicTestDevice)
# details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see http://www.gnu.org/licenses/. # from ossie.cf import CF, CF__POA from ossie.device import ExecutableDevice, AggregateDevice, start_device import os, sys, stat from omniORB import URI, any import commands, copy, time, signal, pprint, subprocess import logging import signal import shutil from BasicTestDeviceProps import PROPERTIES class BasicTestDevice(CF__POA.AggregateExecutableDevice, ExecutableDevice, AggregateDevice): def __init__(self, devmgr, uuid, label, softwareProfile, compositeDevice, execparams): ExecutableDevice.__init__(self, devmgr, uuid, label, softwareProfile, compositeDevice, execparams, PROPERTIES) AggregateDevice.__init__(self) if __name__ == "__main__": logging.getLogger().setLevel(logging.DEBUG) logging.debug("Starting Device") start_device(BasicTestDevice)