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)
