static void dvsConfigSend(sshsNode node, caerModuleData moduleData) { caerDeviceConfigSet(moduleData->moduleState, DVS128_CONFIG_DVS, DVS128_CONFIG_DVS_ARRAY_RESET, sshsNodeGetBool(node, "ArrayReset")); caerDeviceConfigSet(moduleData->moduleState, DVS128_CONFIG_DVS, DVS128_CONFIG_DVS_TIMESTAMP_RESET, sshsNodeGetBool(node, "TimestampReset")); caerDeviceConfigSet(moduleData->moduleState, DVS128_CONFIG_DVS, DVS128_CONFIG_DVS_RUN, sshsNodeGetBool(node, "Run")); }
static void usbConfigSend(sshsNode node, caerModuleData moduleData) { caerDeviceConfigSet(moduleData->moduleState, CAER_HOST_CONFIG_USB, CAER_HOST_CONFIG_USB_BUFFER_NUMBER, U32T(sshsNodeGetInt(node, "BufferNumber"))); caerDeviceConfigSet(moduleData->moduleState, CAER_HOST_CONFIG_USB, CAER_HOST_CONFIG_USB_BUFFER_SIZE, U32T(sshsNodeGetInt(node, "BufferSize"))); caerDeviceConfigSet(moduleData->moduleState, DAVIS_CONFIG_USB, DAVIS_CONFIG_USB_EARLY_PACKET_DELAY, U32T(sshsNodeGetInt(node, "EarlyPacketDelay"))); caerDeviceConfigSet(moduleData->moduleState, DAVIS_CONFIG_USB, DAVIS_CONFIG_USB_RUN, sshsNodeGetBool(node, "Run")); }
static void systemConfigSend(sshsNode node, caerModuleData moduleData) { caerDeviceConfigSet(moduleData->moduleState, CAER_HOST_CONFIG_PACKETS, CAER_HOST_CONFIG_PACKETS_MAX_CONTAINER_PACKET_SIZE, U32T(sshsNodeGetInt(node, "PacketContainerMaxPacketSize"))); caerDeviceConfigSet(moduleData->moduleState, CAER_HOST_CONFIG_PACKETS, CAER_HOST_CONFIG_PACKETS_MAX_CONTAINER_INTERVAL, U32T(sshsNodeGetInt(node, "PacketContainerInterval"))); // Changes only take effect on module start! caerDeviceConfigSet(moduleData->moduleState, CAER_HOST_CONFIG_DATAEXCHANGE, CAER_HOST_CONFIG_DATAEXCHANGE_BUFFER_SIZE, U32T(sshsNodeGetInt(node, "DataExchangeBufferSize"))); }
static void dvsConfigListener(sshsNode node, void *userData, enum sshs_node_attribute_events event, const char *changeKey, enum sshs_node_attr_value_type changeType, union sshs_node_attr_value changeValue) { UNUSED_ARGUMENT(node); caerModuleData moduleData = userData; if (event == SSHS_ATTRIBUTE_MODIFIED) { if (changeType == SSHS_BOOL && caerStrEquals(changeKey, "TimestampReset")) { caerDeviceConfigSet( moduleData->moduleState, EDVS_CONFIG_DVS, EDVS_CONFIG_DVS_TIMESTAMP_RESET, changeValue.boolean); } else if (changeType == SSHS_BOOL && caerStrEquals(changeKey, "Run")) { caerDeviceConfigSet(moduleData->moduleState, EDVS_CONFIG_DVS, EDVS_CONFIG_DVS_RUN, changeValue.boolean); } } }
static void systemConfigListener(sshsNode node, void *userData, enum sshs_node_attribute_events event, const char *changeKey, enum sshs_node_attr_value_type changeType, union sshs_node_attr_value changeValue) { UNUSED_ARGUMENT(node); caerModuleData moduleData = userData; if (event == SSHS_ATTRIBUTE_MODIFIED) { if (changeType == SSHS_INT && caerStrEquals(changeKey, "PacketContainerMaxPacketSize")) { caerDeviceConfigSet(moduleData->moduleState, CAER_HOST_CONFIG_PACKETS, CAER_HOST_CONFIG_PACKETS_MAX_CONTAINER_PACKET_SIZE, U32T(changeValue.iint)); } else if (changeType == SSHS_INT && caerStrEquals(changeKey, "PacketContainerInterval")) { caerDeviceConfigSet(moduleData->moduleState, CAER_HOST_CONFIG_PACKETS, CAER_HOST_CONFIG_PACKETS_MAX_CONTAINER_INTERVAL, U32T(changeValue.iint)); } } }
static void usbConfigListener(sshsNode node, void *userData, enum sshs_node_attribute_events event, const char *changeKey, enum sshs_node_attr_value_type changeType, union sshs_node_attr_value changeValue) { UNUSED_ARGUMENT(node); caerModuleData moduleData = userData; if (event == ATTRIBUTE_MODIFIED) { if (changeType == INT && caerStrEquals(changeKey, "BufferNumber")) { caerDeviceConfigSet(moduleData->moduleState, CAER_HOST_CONFIG_USB, CAER_HOST_CONFIG_USB_BUFFER_NUMBER, U32T(changeValue.iint)); } else if (changeType == INT && caerStrEquals(changeKey, "BufferSize")) { caerDeviceConfigSet(moduleData->moduleState, CAER_HOST_CONFIG_USB, CAER_HOST_CONFIG_USB_BUFFER_SIZE, U32T(changeValue.iint)); } } }
static void logLevelListener(sshsNode node, void *userData, enum sshs_node_attribute_events event, const char *changeKey, enum sshs_node_attr_value_type changeType, union sshs_node_attr_value changeValue) { UNUSED_ARGUMENT(node); caerModuleData moduleData = userData; if (event == SSHS_ATTRIBUTE_MODIFIED && changeType == SSHS_INT && caerStrEquals(changeKey, "logLevel")) { caerDeviceConfigSet( moduleData->moduleState, CAER_HOST_CONFIG_LOG, CAER_HOST_CONFIG_LOG_LEVEL, U32T(changeValue.iint)); } }
static void serialConfigListener(sshsNode node, void *userData, enum sshs_node_attribute_events event, const char *changeKey, enum sshs_node_attr_value_type changeType, union sshs_node_attr_value changeValue) { UNUSED_ARGUMENT(node); caerModuleData moduleData = userData; if (event == SSHS_ATTRIBUTE_MODIFIED) { if (changeType == SSHS_INT && caerStrEquals(changeKey, "ReadSize")) { caerDeviceConfigSet(moduleData->moduleState, CAER_HOST_CONFIG_SERIAL, CAER_HOST_CONFIG_SERIAL_READ_SIZE, U32T(changeValue.iint)); } } }
static void usbConfigListener(sshsNode node, void *userData, enum sshs_node_attribute_events event, const char *changeKey, enum sshs_node_attr_value_type changeType, union sshs_node_attr_value changeValue) { UNUSED_ARGUMENT(node); caerModuleData moduleData = userData; if (event == SSHS_ATTRIBUTE_MODIFIED) { if (changeType == SSHS_INT && caerStrEquals(changeKey, "BufferNumber")) { caerDeviceConfigSet(moduleData->moduleState, CAER_HOST_CONFIG_USB, CAER_HOST_CONFIG_USB_BUFFER_NUMBER, U32T(changeValue.iint)); } else if (changeType == SSHS_INT && caerStrEquals(changeKey, "BufferSize")) { caerDeviceConfigSet(moduleData->moduleState, CAER_HOST_CONFIG_USB, CAER_HOST_CONFIG_USB_BUFFER_SIZE, U32T(changeValue.iint)); } else if (changeType == SSHS_INT && caerStrEquals(changeKey, "EarlyPacketDelay")) { caerDeviceConfigSet( moduleData->moduleState, DAVIS_CONFIG_USB, DAVIS_CONFIG_USB_EARLY_PACKET_DELAY, U32T(changeValue.iint)); } else if (changeType == SSHS_BOOL && caerStrEquals(changeKey, "Run")) { caerDeviceConfigSet(moduleData->moduleState, DAVIS_CONFIG_USB, DAVIS_CONFIG_USB_RUN, changeValue.boolean); } } }
void DvsRosDriver::resetTimestamps() { if (caerDeviceConfigSet(dvs128_handle, DVS128_CONFIG_DVS, DVS128_CONFIG_DVS_TIMESTAMP_RESET, 1)) { ROS_INFO("Reset timestamps on %s", device_id_.c_str()); reset_time_ = ros::Time::now(); // if master, publish reset time to slaves if (master_) { std_msgs::Time reset_msg; reset_msg.data = reset_time_; reset_pub_.publish(reset_msg); } } else { ROS_ERROR("Failed to reset timestamps on %s", device_id_.c_str()); } }
static bool caerInputDVS128Init(caerModuleData moduleData) { caerLog(CAER_LOG_DEBUG, moduleData->moduleSubSystemString, "Initializing module ..."); // USB port/bus/SN settings/restrictions. // These can be used to force connection to one specific device at startup. sshsNodePutShortIfAbsent(moduleData->moduleNode, "BusNumber", 0); sshsNodePutShortIfAbsent(moduleData->moduleNode, "DevAddress", 0); sshsNodePutStringIfAbsent(moduleData->moduleNode, "SerialNumber", ""); // Add auto-restart setting. sshsNodePutBoolIfAbsent(moduleData->moduleNode, "Auto-Restart", true); // Start data acquisition, and correctly notify mainloop of new data and module of exceptional // shutdown cases (device pulled, ...). char *serialNumber = sshsNodeGetString(moduleData->moduleNode, "SerialNumber"); moduleData->moduleState = caerDeviceOpen(moduleData->moduleID, CAER_DEVICE_DVS128, U8T(sshsNodeGetShort(moduleData->moduleNode, "BusNumber")), U8T(sshsNodeGetShort(moduleData->moduleNode, "DevAddress")), serialNumber); free(serialNumber); if (moduleData->moduleState == NULL) { // Failed to open device. return (false); } // Put global source information into SSHS. struct caer_dvs128_info devInfo = caerDVS128InfoGet(moduleData->moduleState); sshsNode sourceInfoNode = sshsGetRelativeNode(moduleData->moduleNode, "sourceInfo/"); sshsNodePutShort(sourceInfoNode, "logicVersion", devInfo.logicVersion); sshsNodePutBool(sourceInfoNode, "deviceIsMaster", devInfo.deviceIsMaster); sshsNodePutShort(sourceInfoNode, "dvsSizeX", devInfo.dvsSizeX); sshsNodePutShort(sourceInfoNode, "dvsSizeY", devInfo.dvsSizeY); // Put source information for "virtual" APS frame that can be used to display and debug filter information. sshsNodePutShort(sourceInfoNode, "apsSizeX", devInfo.dvsSizeX); sshsNodePutShort(sourceInfoNode, "apsSizeY", devInfo.dvsSizeY); caerModuleSetSubSystemString(moduleData, devInfo.deviceString); // Ensure good defaults for data acquisition settings. // No blocking behavior due to mainloop notification, and no auto-start of // all producers to ensure cAER settings are respected. caerDeviceConfigSet(moduleData->moduleState, CAER_HOST_CONFIG_DATAEXCHANGE, CAER_HOST_CONFIG_DATAEXCHANGE_BLOCKING, false); caerDeviceConfigSet(moduleData->moduleState, CAER_HOST_CONFIG_DATAEXCHANGE, CAER_HOST_CONFIG_DATAEXCHANGE_START_PRODUCERS, false); caerDeviceConfigSet(moduleData->moduleState, CAER_HOST_CONFIG_DATAEXCHANGE, CAER_HOST_CONFIG_DATAEXCHANGE_STOP_PRODUCERS, true); // Create default settings and send them to the device. createDefaultConfiguration(moduleData); sendDefaultConfiguration(moduleData); // Start data acquisition. bool ret = caerDeviceDataStart(moduleData->moduleState, &mainloopDataNotifyIncrease, &mainloopDataNotifyDecrease, caerMainloopGetReference(), &moduleShutdownNotify, moduleData->moduleNode); if (!ret) { // Failed to start data acquisition, close device and exit. caerDeviceClose((caerDeviceHandle *) &moduleData->moduleState); return (false); } return (true); }
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); }
static void usbConfigSend(sshsNode node, caerModuleData moduleData) { caerDeviceConfigSet(moduleData->moduleState, CAER_HOST_CONFIG_USB, CAER_HOST_CONFIG_USB_BUFFER_NUMBER, U32T(sshsNodeGetInt(node, "BufferNumber"))); caerDeviceConfigSet(moduleData->moduleState, CAER_HOST_CONFIG_USB, CAER_HOST_CONFIG_USB_BUFFER_SIZE, U32T(sshsNodeGetInt(node, "BufferSize"))); }
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); }
static void biasConfigListener(sshsNode node, void *userData, enum sshs_node_attribute_events event, const char *changeKey, enum sshs_node_attr_value_type changeType, union sshs_node_attr_value changeValue) { UNUSED_ARGUMENT(node); caerModuleData moduleData = userData; if (event == ATTRIBUTE_MODIFIED) { if (changeType == INT && caerStrEquals(changeKey, "cas")) { caerDeviceConfigSet(moduleData->moduleState, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_CAS, U32T(changeValue.iint)); } else if (changeType == INT && caerStrEquals(changeKey, "injGnd")) { caerDeviceConfigSet(moduleData->moduleState, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_INJGND, U32T(changeValue.iint)); } else if (changeType == INT && caerStrEquals(changeKey, "reqPd")) { caerDeviceConfigSet(moduleData->moduleState, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_REQPD, U32T(changeValue.iint)); } else if (changeType == INT && caerStrEquals(changeKey, "puX")) { caerDeviceConfigSet(moduleData->moduleState, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_PUX, U32T(changeValue.iint)); } else if (changeType == INT && caerStrEquals(changeKey, "diffOff")) { caerDeviceConfigSet(moduleData->moduleState, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_DIFFOFF, U32T(changeValue.iint)); } else if (changeType == INT && caerStrEquals(changeKey, "req")) { caerDeviceConfigSet(moduleData->moduleState, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_REQ, U32T(changeValue.iint)); } else if (changeType == INT && caerStrEquals(changeKey, "refr")) { caerDeviceConfigSet(moduleData->moduleState, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_REFR, U32T(changeValue.iint)); } else if (changeType == INT && caerStrEquals(changeKey, "puY")) { caerDeviceConfigSet(moduleData->moduleState, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_PUY, U32T(changeValue.iint)); } else if (changeType == INT && caerStrEquals(changeKey, "diffOn")) { caerDeviceConfigSet(moduleData->moduleState, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_DIFFON, U32T(changeValue.iint)); } else if (changeType == INT && caerStrEquals(changeKey, "diff")) { caerDeviceConfigSet(moduleData->moduleState, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_DIFF, U32T(changeValue.iint)); } else if (changeType == INT && caerStrEquals(changeKey, "foll")) { caerDeviceConfigSet(moduleData->moduleState, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_FOLL, U32T(changeValue.iint)); } else if (changeType == INT && caerStrEquals(changeKey, "pr")) { caerDeviceConfigSet(moduleData->moduleState, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_PR, U32T(changeValue.iint)); } } }
DvsRosDriver::DvsRosDriver(ros::NodeHandle & nh, ros::NodeHandle nh_private) : nh_(nh), parameter_update_required_(false) { // load parameters nh_private.param<std::string>("serial_number", device_id_, ""); nh_private.param<bool>("master", master_, true); double reset_timestamps_delay; nh_private.param<double>("reset_timestamps_delay", reset_timestamps_delay, -1.0); // start driver bool device_is_running = false; while (!device_is_running) { const char* serial_number_restrict = (device_id_ == "") ? NULL : device_id_.c_str(); dvs128_handle = caerDeviceOpen(1, CAER_DEVICE_DVS128, 0, 0, serial_number_restrict); //dvs_running = driver_->isDeviceRunning(); device_is_running = !(dvs128_handle == NULL); if (!device_is_running) { ROS_WARN("Could not find DVS. Will retry every second."); ros::Duration(1.0).sleep(); ros::spinOnce(); } else { // configure as master or slave caerDeviceConfigSet(dvs128_handle, DVS128_CONFIG_DVS, DVS128_CONFIG_DVS_TS_MASTER, master_); } if (!ros::ok()) { return; } } dvs128_info_ = caerDVS128InfoGet(dvs128_handle); device_id_ = "DVS128-V1-" + std::string(dvs128_info_.deviceString).substr(15, 4); ROS_INFO("%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); current_config_.streaming_rate = 30; delta_ = boost::posix_time::microseconds(1e6/current_config_.streaming_rate); // set namespace std::string ns = ros::this_node::getNamespace(); if (ns == "/") ns = "/dvs"; event_array_pub_ = nh_.advertise<dvs_msgs::EventArray>(ns + "/events", 1); camera_info_pub_ = nh_.advertise<sensor_msgs::CameraInfo>(ns + "/camera_info", 1); // camera info handling ros::NodeHandle nh_ns(ns); camera_info_manager_ = new camera_info_manager::CameraInfoManager(nh_ns, device_id_); // reset timestamps is publisher as master, subscriber as slave if (master_) { reset_pub_ = nh_.advertise<std_msgs::Time>((ns + "/reset_timestamps").c_str(), 1); } else { reset_sub_ = nh_.subscribe((ns + "/reset_timestamps").c_str(), 1, &DvsRosDriver::resetTimestampsCallback, this); } // initialize timestamps resetTimestamps(); // spawn threads running_ = true; parameter_thread_ = boost::shared_ptr< boost::thread >(new boost::thread(boost::bind(&DvsRosDriver::changeDvsParameters, this))); readout_thread_ = boost::shared_ptr< boost::thread >(new boost::thread(boost::bind(&DvsRosDriver::readout, this))); // Dynamic reconfigure dynamic_reconfigure_callback_ = boost::bind(&DvsRosDriver::callback, this, _1, _2); server_.reset(new dynamic_reconfigure::Server<dvs_ros_driver::DVS_ROS_DriverConfig>(nh_private)); server_->setCallback(dynamic_reconfigure_callback_); // start timer to reset timestamps for synchronization if (reset_timestamps_delay > 0.0 && master_) { timestamp_reset_timer_ = nh_.createTimer(ros::Duration(reset_timestamps_delay), &DvsRosDriver::resetTimerCallback, this); ROS_INFO("Started timer to reset timestamps on master DVS for synchronization (delay=%3.2fs).", reset_timestamps_delay); } }
static void biasConfigSend(sshsNode node, caerModuleData moduleData) { caerDeviceConfigSet(moduleData->moduleState, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_CAS, U32T(sshsNodeGetInt(node, "cas"))); caerDeviceConfigSet(moduleData->moduleState, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_INJGND, U32T(sshsNodeGetInt(node, "injGnd"))); caerDeviceConfigSet(moduleData->moduleState, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_REQPD, U32T(sshsNodeGetInt(node, "reqPd"))); caerDeviceConfigSet(moduleData->moduleState, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_PUX, U32T(sshsNodeGetInt(node, "puX"))); caerDeviceConfigSet(moduleData->moduleState, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_DIFFOFF, U32T(sshsNodeGetInt(node, "diffOff"))); caerDeviceConfigSet(moduleData->moduleState, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_REQ, U32T(sshsNodeGetInt(node, "req"))); caerDeviceConfigSet(moduleData->moduleState, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_REFR, U32T(sshsNodeGetInt(node, "refr"))); caerDeviceConfigSet(moduleData->moduleState, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_PUY, U32T(sshsNodeGetInt(node, "puY"))); caerDeviceConfigSet(moduleData->moduleState, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_DIFFON, U32T(sshsNodeGetInt(node, "diffOn"))); caerDeviceConfigSet(moduleData->moduleState, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_DIFF, U32T(sshsNodeGetInt(node, "diff"))); caerDeviceConfigSet(moduleData->moduleState, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_FOLL, U32T(sshsNodeGetInt(node, "foll"))); caerDeviceConfigSet(moduleData->moduleState, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_PR, U32T(sshsNodeGetInt(node, "pr"))); }
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); }
static bool caerInputEDVSInit(caerModuleData moduleData) { caerModuleLog(moduleData, CAER_LOG_DEBUG, "Initializing module ..."); // Start data acquisition, and correctly notify mainloop of new data and module of exceptional // shutdown cases (device pulled, ...). char *serialPortName = sshsNodeGetString(moduleData->moduleNode, "serialPort"); moduleData->moduleState = caerDeviceOpenSerial(U16T(moduleData->moduleID), CAER_DEVICE_EDVS, serialPortName, U32T(sshsNodeGetInt(moduleData->moduleNode, "baudRate"))); free(serialPortName); if (moduleData->moduleState == NULL) { // Failed to open device. return (false); } // Initialize per-device log-level to module log-level. caerDeviceConfigSet(moduleData->moduleState, CAER_HOST_CONFIG_LOG, CAER_HOST_CONFIG_LOG_LEVEL, atomic_load(&moduleData->moduleLogLevel)); // Put global source information into SSHS. struct caer_edvs_info devInfo = caerEDVSInfoGet(moduleData->moduleState); sshsNode sourceInfoNode = sshsGetRelativeNode(moduleData->moduleNode, "sourceInfo/"); sshsNodeCreateBool(sourceInfoNode, "deviceIsMaster", devInfo.deviceIsMaster, SSHS_FLAGS_READ_ONLY | SSHS_FLAGS_NO_EXPORT, "Timestamp synchronization support: device master status."); sshsNodeCreateInt(sourceInfoNode, "polaritySizeX", devInfo.dvsSizeX, devInfo.dvsSizeX, devInfo.dvsSizeX, SSHS_FLAGS_READ_ONLY | SSHS_FLAGS_NO_EXPORT, "Polarity events width."); sshsNodeCreateInt(sourceInfoNode, "polaritySizeY", devInfo.dvsSizeY, devInfo.dvsSizeY, devInfo.dvsSizeY, SSHS_FLAGS_READ_ONLY | SSHS_FLAGS_NO_EXPORT, "Polarity events height."); // Put source information for generic visualization, to be used to display and debug filter information. sshsNodeCreateInt(sourceInfoNode, "dataSizeX", devInfo.dvsSizeX, devInfo.dvsSizeX, devInfo.dvsSizeX, SSHS_FLAGS_READ_ONLY | SSHS_FLAGS_NO_EXPORT, "Data width."); sshsNodeCreateInt(sourceInfoNode, "dataSizeY", devInfo.dvsSizeY, devInfo.dvsSizeY, devInfo.dvsSizeY, SSHS_FLAGS_READ_ONLY | SSHS_FLAGS_NO_EXPORT, "Data height."); // Generate source string for output modules. size_t sourceStringLength = (size_t) snprintf(NULL, 0, "#Source %" PRIu16 ": eDVS4337\r\n", moduleData->moduleID); char sourceString[sourceStringLength + 1]; snprintf(sourceString, sourceStringLength + 1, "#Source %" PRIu16 ": eDVS4337\r\n", moduleData->moduleID); sourceString[sourceStringLength] = '\0'; sshsNodeCreateString(sourceInfoNode, "sourceString", sourceString, sourceStringLength, sourceStringLength, SSHS_FLAGS_READ_ONLY | SSHS_FLAGS_NO_EXPORT, "Device source information."); // Ensure good defaults for data acquisition settings. // No blocking behavior due to mainloop notification, and no auto-start of // all producers to ensure cAER settings are respected. caerDeviceConfigSet( moduleData->moduleState, CAER_HOST_CONFIG_DATAEXCHANGE, CAER_HOST_CONFIG_DATAEXCHANGE_BLOCKING, false); caerDeviceConfigSet( moduleData->moduleState, CAER_HOST_CONFIG_DATAEXCHANGE, CAER_HOST_CONFIG_DATAEXCHANGE_START_PRODUCERS, false); caerDeviceConfigSet( moduleData->moduleState, CAER_HOST_CONFIG_DATAEXCHANGE, CAER_HOST_CONFIG_DATAEXCHANGE_STOP_PRODUCERS, true); // Create default settings and send them to the device. sendDefaultConfiguration(moduleData); // Start data acquisition. bool ret = caerDeviceDataStart(moduleData->moduleState, &caerMainloopDataNotifyIncrease, &caerMainloopDataNotifyDecrease, NULL, &moduleShutdownNotify, moduleData->moduleNode); if (!ret) { // Failed to start data acquisition, close device and exit. caerDeviceClose((caerDeviceHandle *) &moduleData->moduleState); return (false); } // Add config listeners last, to avoid having them dangling if Init doesn't succeed. sshsNode biasNode = sshsGetRelativeNode(moduleData->moduleNode, "bias/"); sshsNodeAddAttributeListener(biasNode, moduleData, &biasConfigListener); sshsNode dvsNode = sshsGetRelativeNode(moduleData->moduleNode, "dvs/"); sshsNodeAddAttributeListener(dvsNode, moduleData, &dvsConfigListener); sshsNode serialNode = sshsGetRelativeNode(moduleData->moduleNode, "serial/"); sshsNodeAddAttributeListener(serialNode, moduleData, &serialConfigListener); sshsNode sysNode = sshsGetRelativeNode(moduleData->moduleNode, "system/"); sshsNodeAddAttributeListener(sysNode, moduleData, &systemConfigListener); sshsNodeAddAttributeListener(moduleData->moduleNode, moduleData, &logLevelListener); return (true); }
static void serialConfigSend(sshsNode node, caerModuleData moduleData) { caerDeviceConfigSet(moduleData->moduleState, CAER_HOST_CONFIG_SERIAL, CAER_HOST_CONFIG_SERIAL_READ_SIZE, U32T(sshsNodeGetInt(node, "ReadSize"))); }
void DvsRosDriver::changeDvsParameters() { while(running_) { try { if (parameter_update_required_) { parameter_update_required_ = false; caerDeviceConfigSet(dvs128_handle, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_CAS, current_config_.cas); caerDeviceConfigSet(dvs128_handle, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_INJGND, current_config_.injGnd); caerDeviceConfigSet(dvs128_handle, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_REQPD, current_config_.reqPd); caerDeviceConfigSet(dvs128_handle, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_PUX, current_config_.puX); caerDeviceConfigSet(dvs128_handle, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_DIFFOFF, current_config_.diffOff); caerDeviceConfigSet(dvs128_handle, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_REQ, current_config_.req); caerDeviceConfigSet(dvs128_handle, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_REFR, current_config_.refr); caerDeviceConfigSet(dvs128_handle, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_PUY, current_config_.puY); caerDeviceConfigSet(dvs128_handle, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_DIFFON, current_config_.diffOn); caerDeviceConfigSet(dvs128_handle, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_DIFF, current_config_.diff); caerDeviceConfigSet(dvs128_handle, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_FOLL, current_config_.foll); caerDeviceConfigSet(dvs128_handle, DVS128_CONFIG_BIAS, DVS128_CONFIG_BIAS_PR, current_config_.Pr); } boost::this_thread::sleep(boost::posix_time::milliseconds(100)); } catch(boost::thread_interrupted&) { return; } } }