def test_existing_manager(self):
# Map the existing manager
existing_shared_buffer = SharedBufferManager(shared_mem_name, boost_mmap_mode=boost_mmap_mode)
# Test that the configuration matches the original
assert_equal(self.shared_buffer_manager.get_manager_id(), existing_shared_buffer.get_manager_id())
assert_equal(self.shared_buffer_manager.get_num_buffers(), existing_shared_buffer.get_num_buffers())
assert_equal(self.shared_buffer_manager.get_buffer_size(), existing_shared_buffer.get_buffer_size())
class ExcaliburTestApp(npyscreen.NPSAppManaged):
def __init__(self, ready_endpoint, release_endpoint, buffer, filepath):
super(ExcaliburTestApp, self).__init__()
self._ready_endpoint = ready_endpoint
self._release_endpoint = release_endpoint
self._buffer = buffer
self._ctrl_channel = None
self._release_channel = None
self._current_value = None
self._prev_value = None
self._no_of_frames = 1
self._frame_rate = 1.0
self._running = False
self._frames_sent = 0
self._last_millis = 0
self._filename = "excalibur-test-12bit.raw"
self._filepath = filepath
self._frames = 1
def onStart(self):
self.keypress_timeout_default = 1
self.registerForm("MAIN", IntroForm())
self.registerForm("MAIN_MENU", MainMenu())
self.registerForm("SETUP", SetupAcquisition())
def send_message(self, ipc_message):
self._ctrl_channel.send(ipc_message.encode())
def setup_buffer(self, filename, buffer_size, frames):
self._filename = filename
self._frames = frames
# Create the shared buffer
self._shared_buffer_manager = SharedBufferManager(
self._buffer,
buffer_size * num_buffers,
buffer_size,
remove_when_deleted=True,
boost_mmap_mode=boost_mmap_mode)
# Now load in the file
with open(self._filepath + "/" + self._filename, mode='rb') as file:
fileContent = file.read()
print("Writing file content to ", shared_mem_name)
self._shared_buffer_manager.write_buffer(0, fileContent)
def read_message(self, timeout):
pollevts = self._ctrl_channel.poll(timeout)
if pollevts == zmq.POLLIN:
reply = IpcMessage(from_str=self._ctrl_channel.recv())
return reply
return None
def setup_buffer(self, filename, buffer_size, frames):
self._filename = filename
self._frames = frames
# Create the shared buffer
self._shared_buffer_manager = SharedBufferManager(self._buffer,
buffer_size*num_buffers,
buffer_size,
remove_when_deleted=True,
boost_mmap_mode=boost_mmap_mode)
# Now load in the file
with open(self._filepath + "/" + self._filename, mode='rb') as file:
fileContent = file.read()
print("Writing file content to ", shared_mem_name)
self._shared_buffer_manager.write_buffer(0, fileContent)
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 test_existing_manager_already_exists(self):
# Attempt to create a shared buffer manager that already exists
with assert_raises(SharedBufferManagerException) as cm:
clobbered_shared_buffer = SharedBufferManager(shared_mem_name,
100, 100, True, boost_mmap_mode=boost_mmap_mode)
ex = cm.exception
assert_regexp_matches(ex.msg, "Shared memory with the specified name already exists")
def test_existing_manager_absent(self):
# Attempt to map a shared buffer manager that doesn't already exist
absent_manager_name = "AbsentBufferManager"
with assert_raises(SharedBufferManagerException) as cm:
existing_shared_buffer = SharedBufferManager(absent_manager_name, boost_mmap_mode=boost_mmap_mode)
ex = cm.exception
assert_regexp_matches(ex.msg, "No shared memory exists with the specified name")
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('FrameProcessor')
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
self.shared_buffer_manager = SharedBufferManager(self.config.sharedbuf)
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 setup_class(cls):
# Create a shared buffer manager for use in all tests
cls.shared_buffer_manager = SharedBufferManager(
shared_mem_name, shared_mem_size,
buffer_size, remove_when_deleted=True, boost_mmap_mode=boost_mmap_mode)
class FrameProcessor(object):
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('FrameProcessor')
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
self.shared_buffer_manager = SharedBufferManager(self.config.sharedbuf)
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")
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()))
# 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'')
# 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")
def process_frames(self):
self.frame_header = Struct('<LLQQL')
while self._run:
if (self.ready_channel.poll(100)):
ready_msg = self.ready_channel.recv()
ready_decoded = IpcMessage(from_str=ready_msg)
if ready_decoded.get_msg_type() == 'notify' and ready_decoded.get_msg_val() == 'frame_ready':
frame_number = ready_decoded.get_param('frame')
buffer_id = ready_decoded.get_param('buffer_id')
self.logger.debug("Got frame ready notification for frame %d buffer ID %d" %(frame_number, buffer_id))
if not self.config.bypass_mode:
self.handle_frame(frame_number, buffer_id)
release_msg = IpcMessage(msg_type='notify', msg_val='frame_release')
release_msg.set_param('frame', frame_number)
release_msg.set_param('buffer_id', buffer_id)
self.release_channel.send(release_msg.encode())
self.frames_received += 1
else:
self.logger.error("Got unexpected message on ready notification channel:", ready_decoded)
self.logger.info("Frame processing thread interrupted, terminating")
def handle_frame(self, frame_number, buffer_id):
self.frame_decoder.decode_header(buffer_id)
self.logger.debug("Frame %d in buffer %d decoded header values: frame_number %d state %d start_time %s packets_received %d" %
(frame_number, buffer_id, self.frame_decoder.header.frame_number,
self.frame_decoder.header.frame_state, self.frame_decoder.header.frame_start_time.isoformat(),
self.frame_decoder.header.packets_received))
self.frame_decoder.decode_data(buffer_id)
self.logger.debug("Frame start: " + ' '.join("0x{:04x}".format(val) for val in self.frame_decoder.data.pixels[:32]))
self.logger.debug("Frame end : " + ' '.join("0x{:04x}".format(val) for val in self.frame_decoder.data.pixels[-32:]))
class FrameProcessor(object):
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")
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()))
# 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'')
# 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")
def process_frames(self):
self.frame_header = Struct('<LLQQL')
while self._run:
if (self.ready_channel.poll(100)):
ready_msg = self.ready_channel.recv()
ready_decoded = IpcMessage(from_str=ready_msg)
if ready_decoded.get_msg_type() == 'notify' and ready_decoded.get_msg_val() == 'frame_ready':
frame_number = ready_decoded.get_param('frame')
buffer_id = ready_decoded.get_param('buffer_id')
self.logger.debug("Got frame ready notification for frame %d buffer ID %d" %(frame_number, buffer_id))
if not self.config.bypass_mode:
self.handle_frame(frame_number, buffer_id)
release_msg = IpcMessage(msg_type='notify', msg_val='frame_release')
release_msg.set_param('frame', frame_number)
release_msg.set_param('buffer_id', buffer_id)
self.release_channel.send(release_msg.encode())
self.frames_received += 1
else:
self.logger.error("Got unexpected message on ready notification channel:", ready_decoded)
self.logger.info("Frame processing thread interrupted, terminating")
def handle_frame(self, frame_number, buffer_id):
self.frame_decoder.decode_header(buffer_id)
self.logger.debug("Frame %d in buffer %d decoded header values: frame_number %d state %d start_time %s packets_received %d" %
(frame_number, buffer_id, self.frame_decoder.header.frame_number,
self.frame_decoder.header.frame_state, self.frame_decoder.header.frame_start_time.isoformat(),
self.frame_decoder.header.packets_received))
self.logger.debug("Frame info :\n " +
' '.join("0x{:02x}".format(val) for val in self.frame_decoder.header.frame_info[:21]) + '\n ' +
' '.join("0x{:02x}".format(val) for val in self.frame_decoder.header.frame_info[21:]))
if self.config.packet_state:
self.logger.debug("Packet state : \n" + self.frame_decoder.packet_state_str())
self.frame_decoder.decode_data(buffer_id)
self.logger.debug("Frame start: " + ' '.join("0x{:04x}".format(val) for val in self.frame_decoder.data.pixels[:16]))
self.logger.debug("Frame end : " + ' '.join("0x{:04x}".format(val) for val in self.frame_decoder.data.pixels[-16:]))
