def __init__(self):
# Initialise the logging module with log messages directed to stdout
#logging.basicConfig(format='%(asctime)s %(levelname)s FrameProcessor - %(message)s', level=logging.DEBUG)
#ch = logging.StreamHandler(sys.stdout)
#logging.addHandler(ch)
# create logger
self.logger = logging.getLogger('frame_processor')
self.logger.setLevel(logging.DEBUG)
# create console handler and set level to debug
ch = logging.StreamHandler(sys.stdout)
ch.setLevel(logging.DEBUG)
# create formatter
formatter = logging.Formatter('%(asctime)s %(levelname)s %(name)s - %(message)s')
# add formatter to ch
ch.setFormatter(formatter)
# add ch to logger
self.logger.addHandler(ch)
# Instantiate a configuration container object, which will be populated
# with sensible default values
self.config = FrameProcessorConfig("FrameProcessor", "FrameProcessor - test harness to simulate operation of FrameProcessor application")
# Create the appropriate IPC channels
self.ctrl_channel = IpcChannel(IpcChannel.CHANNEL_TYPE_REQ)
self.ready_channel = IpcChannel(IpcChannel.CHANNEL_TYPE_SUB)
self.release_channel = IpcChannel(IpcChannel.CHANNEL_TYPE_PUB)
# Map the shared buffer manager
try:
self.shared_buffer_manager = SharedBufferManager(self.config.sharedbuf, boost_mmap_mode=self.config.boost_mmap_mode)
except SharedBufferManagerException as e:
self.logger.error("Failed to create shared buffer manager: %s" % str(e))
self.frame_decoder = PercivalEmulatorFrameDecoder(self.shared_buffer_manager)
# Zero frames recevied counter
self.frames_received = 0
# Create the thread to handle frame processing
self.frame_processor = threading.Thread(target=self.process_frames)
self.frame_processor.daemon = True
self._run = True
def run(self):
self.logger.info("Frame processor starting up")
# Connect the IPC channels
self.ctrl_channel.connect(self.config.ctrl_endpoint)
self.ready_channel.connect(self.config.ready_endpoint)
self.release_channel.connect(self.config.release_endpoint)
# Ready channel subscribes to all topics
self.ready_channel.subscribe(b'')
# Map the shared buffer manager - quit if this fails
if not self.map_shared_buffer():
self._run = False
return
self.logger.info(
"Mapped shared buffer manager ID %d with %d buffers of size %d" %
(self.shared_buffer_manager.get_manager_id(),
self.shared_buffer_manager.get_num_buffers(),
self.shared_buffer_manager.get_buffer_size()))
if self.config.sensortype == 'percivalemulator':
self.frame_decoder = PercivalEmulatorFrameDecoder(
self.shared_buffer_manager)
self.logger.debug(
'Loaded frame decoder for PERCIVAL emulator sensor type')
elif self.config.sensortype == 'excalibur':
self.frame_decoder = ExcaliburFrameDecoder(
self.shared_buffer_manager)
self.logger.debug('Loaded frame decoder for EXCALIBUR sensor type')
else:
self.frame_decoder = None
self.logger.error("Unrecognised sensor type specified: %s" %
self.config.sensortype)
return
# Launch the frame processing thread
self.frame_processor.start()
try:
while self._run:
if self.config.frames and self.frames_received >= self.config.frames:
self.logger.info(
"Specified number of frames (%d) received, terminating"
% self.config.frames)
self._run = False
else:
msg = IpcMessage(msg_type='cmd', msg_val='status')
#self.logger.debug("Sending status command message")
self.ctrl_channel.send(msg.encode())
reply = self.ctrl_channel.recv()
reply_decoded = IpcMessage(from_str=reply)
#self.logger.debug("Got reply, msg_type = " + reply_decoded.get_msg_type() + " val = " + reply_decoded.get_msg_val())
time.sleep(1)
except KeyboardInterrupt:
self.logger.info("Got interrupt, terminating")
self._run = False
self.frame_processor.join()
self.logger.info("Frame processor shutting down")
