static void orderAndSendEventPackets(outputCommonState state, caerEventPacketContainer currPacketContainer) {
// Sort container by first timestamp (required) and by type ID (convenience).
size_t currPacketContainerSize = (size_t) caerEventPacketContainerGetEventPacketsNumber(currPacketContainer);
qsort(currPacketContainer->eventPackets, currPacketContainerSize, sizeof(caerEventPacketHeader),
&packetsFirstTimestampThenTypeCmp);
// Since we just got new data, let's first check that it does conform to our expectations.
// This means the timestamp didn't slide back! So new smallest TS is >= than last highest TS.
// These checks are needed to avoid illegal ordering. Normal operation will never trigger
// these, as stated in the assumptions at the start of file, but erroneous usage or mixing
// or reordering of packet containers is possible, and has to be caught here.
int64_t highestTimestamp = 0;
for (size_t cpIdx = 0; cpIdx < currPacketContainerSize; cpIdx++) {
caerEventPacketHeader cpPacket = caerEventPacketContainerGetEventPacket(currPacketContainer, (int32_t) cpIdx);
void *cpFirstEvent = caerGenericEventGetEvent(cpPacket, 0);
int64_t cpFirstEventTimestamp = caerGenericEventGetTimestamp64(cpFirstEvent, cpPacket);
if (cpFirstEventTimestamp < state->lastTimestamp) {
// Smaller TS than already sent, illegal, ignore packet.
caerLog(CAER_LOG_ERROR, state->parentModule->moduleSubSystemString,
"Detected timestamp going back, expected at least %" PRIi64 " but got %" PRIi64 "."
" Ignoring packet of type %" PRIi16 " from source %" PRIi16 ", with %" PRIi32 " events!",
state->lastTimestamp, cpFirstEventTimestamp, caerEventPacketHeaderGetEventType(cpPacket),
caerEventPacketHeaderGetEventSource(cpPacket), caerEventPacketHeaderGetEventNumber(cpPacket));
}
else {
// Bigger or equal TS than already sent, this is good. Strict TS ordering ensures
// that all other packets in this container are the same, so we can start sending
// the packets from here on out to the file descriptor.
sendEventPacket(state, cpPacket);
// Update highest timestamp for this packet container, based upon its valid packets.
void *cpLastEvent = caerGenericEventGetEvent(cpPacket, caerEventPacketHeaderGetEventNumber(cpPacket) - 1);
int64_t cpLastEventTimestamp = caerGenericEventGetTimestamp64(cpLastEvent, cpPacket);
if (cpLastEventTimestamp > highestTimestamp) {
highestTimestamp = cpLastEventTimestamp;
}
}
}
// Remember highest timestamp for check in next iteration.
state->lastTimestamp = highestTimestamp;
}
int main(void) {
// Install signal handler for global shutdown.
#if defined(_WIN32)
if (signal(SIGTERM, &globalShutdownSignalHandler) == SIG_ERR) {
caerLog(CAER_LOG_CRITICAL, "ShutdownAction", "Failed to set signal handler for SIGTERM. Error: %d.", errno);
return (EXIT_FAILURE);
}
if (signal(SIGINT, &globalShutdownSignalHandler) == SIG_ERR) {
caerLog(CAER_LOG_CRITICAL, "ShutdownAction", "Failed to set signal handler for SIGINT. Error: %d.", errno);
return (EXIT_FAILURE);
}
#else
struct sigaction shutdownAction;
shutdownAction.sa_handler = &globalShutdownSignalHandler;
shutdownAction.sa_flags = 0;
sigemptyset(&shutdownAction.sa_mask);
sigaddset(&shutdownAction.sa_mask, SIGTERM);
sigaddset(&shutdownAction.sa_mask, SIGINT);
if (sigaction(SIGTERM, &shutdownAction, NULL) == -1) {
caerLog(CAER_LOG_CRITICAL, "ShutdownAction", "Failed to set signal handler for SIGTERM. Error: %d.", errno);
return (EXIT_FAILURE);
}
if (sigaction(SIGINT, &shutdownAction, NULL) == -1) {
caerLog(CAER_LOG_CRITICAL, "ShutdownAction", "Failed to set signal handler for SIGINT. Error: %d.", errno);
return (EXIT_FAILURE);
}
#endif
// Open a DYNAPSE, give it a device ID of 1, and don't care about USB bus or SN restrictions.
caerDeviceHandle dynapse_handle = caerDeviceOpen(1, CAER_DEVICE_DYNAPSE, 0, 0, NULL);
if (dynapse_handle == NULL) {
return (EXIT_FAILURE);
}
// Let's take a look at the information we have on the device.
struct caer_dynapse_info dynapse_info = caerDynapseInfoGet(dynapse_handle);
printf("%s --- ID: %d, Master: %d, Logic: %d.\n", dynapse_info.deviceString, dynapse_info.deviceID,
dynapse_info.deviceIsMaster, dynapse_info.logicVersion);
// Send the default configuration before using the device.
// No configuration is sent automatically!
caerDeviceSendDefaultConfig(dynapse_handle);
// Now let's get start getting some data from the device. We just loop in blocking mode,
// no notification needed regarding new events. The shutdown notification, for example if
// the device is disconnected, should be listened to.
// This automatically turns on the AER and CHIP state machines.
caerDeviceDataStart(dynapse_handle, NULL, NULL, NULL, &usbShutdownHandler, NULL);
// Let's turn on blocking data-get mode to avoid wasting resources.
caerDeviceConfigSet(dynapse_handle, CAER_HOST_CONFIG_DATAEXCHANGE, CAER_HOST_CONFIG_DATAEXCHANGE_BLOCKING, true);
while (!atomic_load_explicit(&globalShutdown, memory_order_relaxed)) {
caerEventPacketContainer packetContainer = caerDeviceDataGet(dynapse_handle);
if (packetContainer == NULL) {
continue; // Skip if nothing there.
}
int32_t packetNum = caerEventPacketContainerGetEventPacketsNumber(packetContainer);
printf("\nGot event container with %d packets (allocated).\n", packetNum);
for (int32_t i = 0; i < packetNum; i++) {
caerEventPacketHeader packetHeader = caerEventPacketContainerGetEventPacket(packetContainer, i);
if (packetHeader == NULL) {
printf("Packet %d is empty (not present).\n", i);
continue; // Skip if nothing there.
}
printf("Packet %d of type %d -> size is %d.\n", i, caerEventPacketHeaderGetEventType(packetHeader),
caerEventPacketHeaderGetEventNumber(packetHeader));
// Spike Events
if (i == SPIKE_EVENT) {
caerSpikeEventPacket spike = (caerSpikeEventPacket) packetHeader;
// Get full timestamp and addresses of first event.
caerSpikeEventConst firstEvent = caerSpikeEventPacketGetEventConst(spike, 0);
int32_t ts = caerSpikeEventGetTimestamp(firstEvent);
uint16_t neuid = caerSpikeEventGetNeuronID(firstEvent);
uint16_t coreid = caerSpikeEventGetSourceCoreID(firstEvent);
printf("First spike event - ts: %d, neu: %d, core: %d\n", ts, neuid, coreid);
}
}
caerEventPacketContainerFree(packetContainer);
}
caerDeviceDataStop(dynapse_handle);
caerDeviceClose(&dynapse_handle);
printf("Shutdown successful.\n");
return (EXIT_SUCCESS);
}
int main(void) {
// Install signal handler for global shutdown.
#if defined(_WIN32)
if (signal(SIGTERM, &globalShutdownSignalHandler) == SIG_ERR) {
caerLog(CAER_LOG_CRITICAL, "ShutdownAction", "Failed to set signal handler for SIGTERM. Error: %d.", errno);
return (EXIT_FAILURE);
}
if (signal(SIGINT, &globalShutdownSignalHandler) == SIG_ERR) {
caerLog(CAER_LOG_CRITICAL, "ShutdownAction", "Failed to set signal handler for SIGINT. Error: %d.", errno);
return (EXIT_FAILURE);
}
#else
struct sigaction shutdownAction;
shutdownAction.sa_handler = &globalShutdownSignalHandler;
shutdownAction.sa_flags = 0;
sigemptyset(&shutdownAction.sa_mask);
sigaddset(&shutdownAction.sa_mask, SIGTERM);
sigaddset(&shutdownAction.sa_mask, SIGINT);
if (sigaction(SIGTERM, &shutdownAction, NULL) == -1) {
caerLog(CAER_LOG_CRITICAL, "ShutdownAction", "Failed to set signal handler for SIGTERM. Error: %d.", errno);
return (EXIT_FAILURE);
}
if (sigaction(SIGINT, &shutdownAction, NULL) == -1) {
caerLog(CAER_LOG_CRITICAL, "ShutdownAction", "Failed to set signal handler for SIGINT. Error: %d.", errno);
return (EXIT_FAILURE);
}
#endif
// Open a DVS128, give it a device ID of 1, and don't care about USB bus or SN restrictions.
caerDeviceHandle dvs128_handle = caerDeviceOpen(1, CAER_DEVICE_DVS128, 0, 0, NULL);
if (dvs128_handle == NULL) {
return (EXIT_FAILURE);
}
// Let's take a look at the information we have on the device.
struct caer_dvs128_info dvs128_info = caerDVS128InfoGet(dvs128_handle);
printf("%s --- ID: %d, Master: %d, DVS X: %d, DVS Y: %d, Logic: %d.\n", dvs128_info.deviceString,
dvs128_info.deviceID, dvs128_info.deviceIsMaster, dvs128_info.dvsSizeX, dvs128_info.dvsSizeY,
dvs128_info.logicVersion);
// Send the default configuration before using the device.
// No configuration is sent automatically!
caerDeviceSendDefaultConfig(dvs128_handle);
// Tweak some biases, to increase bandwidth in this case.
caerDeviceConfigSet(dvs128_handle, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_PR, 695);
caerDeviceConfigSet(dvs128_handle, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_FOLL, 867);
// Let's verify they really changed!
uint32_t prBias, follBias;
caerDeviceConfigGet(dvs128_handle, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_PR, &prBias);
caerDeviceConfigGet(dvs128_handle, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_FOLL, &follBias);
printf("New bias values --- PR: %d, FOLL: %d.\n", prBias, follBias);
// Now let's get start getting some data from the device. We just loop in blocking mode,
// no notification needed regarding new events. The shutdown notification, for example if
// the device is disconnected, should be listened to.
caerDeviceDataStart(dvs128_handle, NULL, NULL, NULL, &usbShutdownHandler, NULL);
// Let's turn on blocking data-get mode to avoid wasting resources.
caerDeviceConfigSet(dvs128_handle, CAER_HOST_CONFIG_DATAEXCHANGE, CAER_HOST_CONFIG_DATAEXCHANGE_BLOCKING, true);
while (!atomic_load_explicit(&globalShutdown, memory_order_relaxed)) {
caerEventPacketContainer packetContainer = caerDeviceDataGet(dvs128_handle);
if (packetContainer == NULL) {
continue; // Skip if nothing there.
}
int32_t packetNum = caerEventPacketContainerGetEventPacketsNumber(packetContainer);
printf("\nGot event container with %d packets (allocated).\n", packetNum);
for (int32_t i = 0; i < packetNum; i++) {
caerEventPacketHeader packetHeader = caerEventPacketContainerGetEventPacket(packetContainer, i);
if (packetHeader == NULL) {
printf("Packet %d is empty (not present).\n", i);
continue; // Skip if nothing there.
}
printf("Packet %d of type %d -> size is %d.\n", i, caerEventPacketHeaderGetEventType(packetHeader),
caerEventPacketHeaderGetEventNumber(packetHeader));
// Packet 0 is always the special events packet for DVS128, while packet is the polarity events packet.
if (i == POLARITY_EVENT) {
caerPolarityEventPacket polarity = (caerPolarityEventPacket) packetHeader;
// Get full timestamp and addresses of first event.
caerPolarityEvent firstEvent = caerPolarityEventPacketGetEvent(polarity, 0);
int32_t ts = caerPolarityEventGetTimestamp(firstEvent);
uint16_t x = caerPolarityEventGetX(firstEvent);
uint16_t y = caerPolarityEventGetY(firstEvent);
bool pol = caerPolarityEventGetPolarity(firstEvent);
printf("First polarity event - ts: %d, x: %d, y: %d, pol: %d.\n", ts, x, y, pol);
}
}
caerEventPacketContainerFree(packetContainer);
}
caerDeviceDataStop(dvs128_handle);
caerDeviceClose(&dvs128_handle);
printf("Shutdown successful.\n");
return (EXIT_SUCCESS);
}
void DvsRosDriver::readout()
{
caerDeviceDataStart(dvs128_handle, NULL, NULL, NULL, NULL, NULL);
caerDeviceConfigSet(dvs128_handle, CAER_HOST_CONFIG_DATAEXCHANGE, CAER_HOST_CONFIG_DATAEXCHANGE_BLOCKING, true);
boost::posix_time::ptime next_send_time = boost::posix_time::microsec_clock::local_time();
dvs_msgs::EventArrayPtr event_array_msg(new dvs_msgs::EventArray());
event_array_msg->height = dvs128_info_.dvsSizeY;
event_array_msg->width = dvs128_info_.dvsSizeX;
while (running_)
{
try
{
caerEventPacketContainer packetContainer = caerDeviceDataGet(dvs128_handle);
if (packetContainer == NULL)
{
continue; // Skip if nothing there.
}
int32_t packetNum = caerEventPacketContainerGetEventPacketsNumber(packetContainer);
for (int32_t i = 0; i < packetNum; i++)
{
caerEventPacketHeader packetHeader = caerEventPacketContainerGetEventPacket(packetContainer, i);
if (packetHeader == NULL)
{
continue; // Skip if nothing there.
}
// Packet 0 is always the special events packet for DVS128, while packet is the polarity events packet.
if (i == POLARITY_EVENT)
{
caerPolarityEventPacket polarity = (caerPolarityEventPacket) packetHeader;
const int numEvents = caerEventPacketHeaderGetEventNumber(packetHeader);
for (int j = 0; j < numEvents; j++)
{
// Get full timestamp and addresses of first event.
caerPolarityEvent event = caerPolarityEventPacketGetEvent(polarity, j);
dvs_msgs::Event e;
e.x = caerPolarityEventGetX(event);
e.y = caerPolarityEventGetY(event);
e.ts = reset_time_ +
ros::Duration().fromNSec(caerPolarityEventGetTimestamp64(event, polarity) * 1000);
e.polarity = caerPolarityEventGetPolarity(event);
event_array_msg->events.push_back(e);
}
// throttle event messages
if (boost::posix_time::microsec_clock::local_time() > next_send_time || current_config_.streaming_rate == 0)
{
event_array_pub_.publish(event_array_msg);
event_array_msg->events.clear();
if (current_config_.streaming_rate > 0)
{
next_send_time += delta_;
}
}
if (camera_info_manager_->isCalibrated())
{
sensor_msgs::CameraInfoPtr camera_info_msg(new sensor_msgs::CameraInfo(camera_info_manager_->getCameraInfo()));
camera_info_pub_.publish(camera_info_msg);
}
}
}
caerEventPacketContainerFree(packetContainer);
ros::spinOnce();
}
catch (boost::thread_interrupted&)
{
return;
}
}
caerDeviceDataStop(dvs128_handle);
}
