def testLookupByName(self): self.called = False def recieve(event): self.called = True # Create a publisher with an event hub eventHub = core.EventHub() mypub = core.EventPublisher(eventHub = eventHub, name = TestEventPublisher.EVTP_NAME) # Look it up and make sure it works epub = core.EventPublisher.lookupByName(TestEventPublisher.EVTP_NAME) self.assertNotEquals(None, epub) self.assertEquals(TestEventPublisher.EVTP_NAME, epub.getPublisherName()) # Subscribe to the new one (which is wrapper of the same underlying # C++ object as self.epub) # BUG: This line below should work instead of the one two down # eventHub.subscribe("TestEvent", epub, recieve) eventHub.subscribe("TestEvent", mypub, recieve) # Send through our local mypub.publish("TestEvent", core.Event()) # Make sure we got it self.assert_(self.called)
def runMachine(start): eventHub = core.EventHub() qeventHub = core.QueuedEventHub(eventHub) subsystems = core.SubsystemList() subsystems.append(qeventHub) machine = state.Machine(deps=subsystems) sequence = raw_input('Enter sequence: ') machine.start(start) assert machine.currentState() is not None, 'State machine not started' for x in sequence: eventType = globals()[x.upper()] qeventHub.publish(eventType, core.Event()) qeventHub.publishEvents() assert machine.currentState( ) is not None, 'State machine ended prematurely' # State machine finished, send finish event qeventHub.publish(FINISH, core.Event()) qeventHub.publishEvents() assert machine.currentState() is None, 'State machine has not ended' machine.stop()
def __init__(self, eventHub=core.EventHub(), cfg=None): vehicle.IVehicle.__init__(self, "Vehicle", eventHub) if cfg is None: cfg = {} self.validObj = set('vehicle') self._depth = {'vehicle': 0} self._orientation = {'vehicle': ext.math.Quaternion.IDENTITY} self._velocity = {'vehicle': ext.math.Vector2.ZERO} self._position = {'vehicle': ext.math.Vector2.ZERO} self._devices = [] # Move through the configuration file and add objects for name, pos in cfg.get('StateEstimator', {}).iteritems(): self.validObj.add(name) self._depth[name] = pos[2] self._orientation[name] = ext.math.Quaternion( ext.math.Degree(pos[3]), ext.math.Vector3.UNIT_Z) self._velocity[name] = ext.math.Vector2(0, 0) self._position[name] = ext.math.Vector2(pos[0], pos[1]) # Take the name of the device and store it # don't care about the contents for device in cfg.get('Devices', {}).iterkeys(): self._devices.append(device) self.markersDropped = 0 self.torpedosFired = 0 self.grabberRelease = False self.unsafed = True self.linAccel = ext.math.Vector3.ZERO self.angRate = ext.math.Vector3.ZERO self.force = ext.math.Vector3.ZERO self.torque = ext.math.Vector3.ZERO
def testInit(self): # A subsystemA = SubsystemA({}, []) subsystemA = SubsystemA({'name': 'John'}, [core.EventHub()]) # B subsystemB = SubsystemB({}, None) subsystemB = SubsystemB({'name': 'Bob'}, None) # C subsystemC = SubsystemC({}, None) subsystemC = SubsystemC({}, core.SubsystemList()) subsystemC = SubsystemC({}, []) deps = core.SubsystemList() deps.append(core.EventHub()) subsystemC = SubsystemC({'name': 'Dave'}, deps) subsystemC = SubsystemC({'name': 'Dave'}, [core.EventHub()])
def testSubsystemPassing(self): eventHub = core.EventHub("EventHub") qeventHub = core.QueuedEventHub(eventHub, "QueuedEventHub") machine = state.Machine(deps = [eventHub, qeventHub]) machine.start(Start) startState = machine.currentState() # Check for subsystems self.assertEquals(eventHub, startState.eventHub) self.assertEquals(qeventHub, startState.queuedEventHub)
def __init__(self, eventHub=core.EventHub(), cfg=None): estimation.IStateEstimator.__init__(self, "StateEstimator", eventHub) self._position = math.Vector2(0, 0) self._velocity = math.Vector2(0, 0) self._orientation = math.Quaternion.IDENTITY self._depth = 0 self.linAccel = math.Vector3.ZERO self.angRate = math.Vector3.ZERO self.depthRate = 0 self._obstacles = {}
def testSubsystemMaker(self): # Must pass an event hub to the network publisher eventHub = core.EventHub() deps = core.SubsystemList() deps.append(eventHub) cfg = {'type': 'NetworkPublisher'} cfg = core.ConfigNode.fromString(str(cfg)) obj = core.SubsystemMaker.newObject(cfg, deps) # Make sure we have the right methods on the network object self.assert_(hasattr(obj, 'subscribe')) self.assert_(hasattr(obj, 'publish'))
def testNewTimer(self): # Set up publisher and event handler timerManager = timer.TimerManager(deps=[core.EventHub()]) timerManager.subscribe(TestTimer.TIMER_EVENT, self.handleTimer) # Create times newTimer = timerManager.newTimer(TestTimer.TIMER_EVENT, 0.25) # Start the timer and sleep to wait for it to complete, then check newTimer.start() time.sleep(0.1) self.assertEquals(0, self.sec) self.assertEquals(0.25 * 1e9, self.nsec) self.assertEquals(TestTimer.TIMER_EVENT, self.event.type)
def testBuoyDetector(self): # Create a vision system with two mock cameras and an EventHub cfg = { 'testing': 1, 'BuoyDetector': { 'filtRedLMin': 0, 'filtRedLMax': 255, 'filtRedCMin': 0, 'filtRedCMax': 255, 'filtRedHMin': 230, 'filtRedHMax': 20 } } cfg = core.ConfigNode.fromString(str(cfg)) forwardCamera = vision.Camera(640, 480) backwardCamera = vision.Camera(640, 480) eventHub = core.EventHub() deps = core.SubsystemList() deps.append(eventHub) visionSystem = vision.VisionSystem(forwardCamera, backwardCamera, cfg, deps) # Subscribe to our events about the red light eventHub.subscribeToType(vision.EventType.BUOY_FOUND, self.buoyFoundHandler) eventHub.subscribeToType(vision.EventType.BUOY_LOST, self.buoyLostHandler) # Load our test image (really upper right) image = vision.Image.loadFromFile( os.path.join(getConfigRoot(), 'red_light_upper_left.png')) # Start detector then unbackground it visionSystem.buoyDetectorOn() visionSystem.unbackground(True) forwardCamera.capturedImage(image) forwardCamera.background(0) # This stops the background thread visionSystem.update(0) visionSystem.buoyDetectorOff() # Check the event self.assert_(self.found) self.assert_(self.event)
def setUp(self): # Create the event hub to collect all published events self.eventHub = core.EventHub() self.vehicle = MockVehicle(self.eventHub) self.controller = MockController(self.eventHub) # The QueuedEventHub lets us queue the events to be released when ready self.qeventHub = core.QueuedEventHub(self.eventHub) deps = [self.vehicle, self.controller, self.qeventHub, self.eventHub] self.motionManager = motion.basic.MotionManager({}, deps) # Replace Timer with out Mock Timer Class MockTimer.LOG = {} timer._origTimer = timer.Timer timer.Timer = MockTimer
def __init__(self, eventHub=core.EventHub(), cfg=None): vehicle.IVehicle.__init__(self, "Vehicle", eventHub) if cfg is None: cfg = {} # Take the name of the device and store it # don't care about the contents self._devices = [] for device in cfg.get('Devices', {}).iterkeys(): self._devices.append(device) self.markersDropped = 0 self.torpedosFired = 0 self.grabberRelease = False self.unsafed = True self.force = math.Vector3.ZERO self.torque = math.Vector3.ZERO
def testRedLightDetector(self): # Create a vision system with two mock cameras and an EventHub cfg = {'testing': 1} cfg = core.ConfigNode.fromString(str(cfg)) forwardCamera = vision.Camera(640, 480) backwardCamera = vision.Camera(640, 480) eventHub = core.EventHub() deps = core.SubsystemList() deps.append(eventHub) visionSystem = vision.VisionSystem(forwardCamera, backwardCamera, cfg, deps) # Subscribe to our events about the red light eventHub.subscribeToType(vision.EventType.LIGHT_FOUND, self.redFoundHandler) eventHub.subscribeToType(vision.EventType.LIGHT_LOST, self.redLostHandler) # Load our test image (really upper right) image = vision.Image.loadFromFile( os.path.join(getConfigRoot(), 'red_light_upper_left.png')) # Start detector then unbackground it visionSystem.redLightDetectorOn() visionSystem.unbackground(True) forwardCamera.capturedImage(image) forwardCamera.background(0) # This stops the background thread visionSystem.update(0) visionSystem.redLightDetectorOff() # Check the event self.assert_(self.found) self.assert_(self.event) self.assertAlmostEqual(0.5 * 4.0 / 3.0, self.event.x, 2) self.assertAlmostEqual(0.5, self.event.y, 2) self.assertAlmostEqual(3, self.event.range, 1) self.assertAlmostEqual(-78.0 / 4, self.event.azimuth.valueDegrees(), 2) self.assertAlmostEqual(105.0 / 4, self.event.elevation.valueDegrees(), 0)
def setUp(self): # Need a QueuedEventHub self.eventHub = core.EventHub() self.qeventHub = core.QueuedEventHub(self.eventHub) cfg = { 'Monitor': { 'Systems': { 'Test': { 'eventType': 'ram.test.monitor.TestMonitor.TESTEVENT', 'property': 'number', 'name': 'testing123', 'warning': 5, 'critical': 10 } } } } self.monitor = monitor.Monitor(cfg=cfg.get('Monitor', {}), deps=[self.qeventHub])
def setUp(self): self.vehicle = MockVehicle() cfg = { 'name': 'TestController', 'type': 'BWPDController', 'angularPGain': 10, 'angularDGain': 1, 'desiredQuaternion': [0, 0, 0, 1] } cfg = core.ConfigNode.fromString(str(cfg)) self.eventHub = core.EventHub() deps = core.SubsystemList() deps.append(self.eventHub) deps.append(self.vehicle) self.actualDepth = 0 self.desiredDepth = 0 self.controller = core.SubsystemMaker.newObject(cfg, deps) self.qeventHub = core.QueuedEventHub(self.eventHub)
def testQueuedEvents(self): self.event = None eventHub = core.EventHub() qeventHub = core.QueuedEventHub(eventHub) timerManager = timer.TimerManager(deps=[eventHub]) # Subscribe event queue qeventHub.subscribeToType(TestTimer.TIMER_EVENT, self.handleTimer) # Create times newTimer = timerManager.newTimer(TestTimer.TIMER_EVENT, 0.25) # Start the timer and sleep to wait for it to complete, then check newTimer.start() time.sleep(0.1) self.assertEquals(0, self.sec) self.assertEquals(0.25 * 1e9, self.nsec) self.assertEquals(None, self.event) # Now release the events qeventHub.publishEvents() self.assertEquals(TestTimer.TIMER_EVENT, self.event.type)
def setUp(self, extraDeps=None, cfg=None): # Handle case where the timer is still mocked for some reason, we make # sure to un mock it if AITestCase.__timerMocked: self.mockTimer() # Replace the Timer class with the Mock one self.mockTimer() if extraDeps is None: extraDeps = [] if cfg is None: cfg = {} self.eventHub = core.EventHub() self.qeventHub = core.QueuedEventHub(self.eventHub) self.timerManager = timer.TimerManager(deps=[self.eventHub]) self.estimator = MockEstimator(cfg=cfg.get('StateEstimator', {})) self.controller = MockController(eventHub=self.eventHub, estimator=self.estimator) self.vehicle = MockVehicle(cfg=cfg.get('Vehicle', {})) self.visionSystem = MockVisionSystem() aCfg = cfg.get('Ai', {}) self.ai = AI(aCfg) deps = [ self.controller, self.timerManager, self.eventHub, self.qeventHub, self.vehicle, self.visionSystem, self.ai, self.estimator ] mCfg = cfg.get('MotionManager', {}) self.motionManager = motion.basic.MotionManager(mCfg, deps) deps.append(self.motionManager) deps.extend(extraDeps) sCfg = cfg.get('StateMachine', {}) self.machine = state.Machine(cfg=sCfg, deps=deps)
def testEventHub(self): eventHub = core.EventHub() qeventHub = core.QueuedEventHub(eventHub) mockEventSource = MockEventSource(eventHub) machine = state.Machine(deps = [eventHub, qeventHub]) machine.start(Start) # Send an event, and make sure it does get through until the queue # releases it mockEventSource.sendEvent(MockEventSource.ANOTHER_EVT, value = 20) startState = machine.currentState() self.assertEquals(Start, type(startState)) # Release events and make sure we have transition properly qeventHub.publishEvents() self.assertEquals(QueueTestState, type(machine.currentState())) self.assert_(startState.anotherEvtEvent) self.assertEquals(20, startState.anotherEvtEvent.value) # Fire off another event and make sure we haven't gone anywhere mockEventSource.sendEvent(MockEventSource.THING_UPDATED, value = 34) qeventHub.publishEvents() self.assertEquals(QueueTestState, type(machine.currentState()))
def setUp(self): self.eventHub = core.EventHub() self.qeventHub = core.QueuedEventHub(self.eventHub) self.epub = core.EventPublisher()
def AnalyzeComputer(log_name, suppress, size, type_locs): data = [0] * 7 type_index = type_locs def numToCpuType(num): return { 0: 'User', 1: 'Nice', 2: 'Sys', 3: 'Idle', 4: 'IOWait', 5: 'IRQ', 6: 'SIRQ' }.get(num, 'Invalid') def _onUser(event): data[0] = event.number def _onNice(event): data[1] = event.number def _onSys(event): data[2] = event.number def _onIdle(event): data[3] = event.number def _onIowt(event): data[4] = event.number def _onIrq(event): data[5] = event.number def _onSirq(event): data[6] = event.number def rewrite(): output = '' for l in type_index: output += numToCpuType(l) + ': %%%5.2f ' % data[l] print '\r', output, sys.stdout.flush() print 'PyTop, a CPU analysis program (Crtl+C to exit)' # Create subsystems eventHub = core.EventHub() qeventHub = core.QueuedEventHub(eventHub) cfg = { 'CpuMonitor': { 'type': 'CpuMonitor', 'depends_on': '[ "QueuedEventHub" ]', 'log_results': suppress, 'bufferSize': size } } if log_name is not None: cfg['CpuMonitor']['log_name'] = log_name monitor = ram.monitor.CpuMonitor(cfg=cfg.get('CpuMonitor'), deps=[qeventHub]) # Register events we are listening to connections = [] eventTypes = [ ram.monitor.CpuMonitor.USER_UPDATE, ram.monitor.CpuMonitor.NICE_UPDATE, ram.monitor.CpuMonitor.SYS_UPDATE, ram.monitor.CpuMonitor.IDLE_UPDATE, ram.monitor.CpuMonitor.IOWT_UPDATE, ram.monitor.CpuMonitor.IRQ_UPDATE, ram.monitor.CpuMonitor.SIRQ_UPDATE ] eventFuncs = [_onUser, _onNice, _onSys, _onIdle, _onIowt, _onIrq, _onSirq] for index in type_index: conn = qeventHub.subscribeToType(eventTypes[index], eventFuncs[index]) connections.append(conn) start = time.time() while True: try: # Allow cpu time to pass time.sleep(1.0 / size) end = time.time() # Update monitor and publish the events monitor.update(end - start) qeventHub.publishEvents() rewrite() start = end except KeyboardInterrupt: break # Unbackground monitor and close connections monitor.unbackground() for conn in connections: conn.disconnect()
def setUp(self): self.ehub = core.EventHub() self.epubA = core.EventPublisher(self.ehub) self.epubB = core.EventPublisher(self.ehub)