void HealthCheckedConnection::UpdateReceiveTimer() { TimeInterval timeout_interval(static_cast<int>( 2.5 * m_heartbeat_interval.AsInt())); m_receive_timeout_id = m_scheduler->RegisterSingleTimeout( timeout_interval, NewSingleCallback(this, &HealthCheckedConnection::HeartbeatTimeout)); }
bool ClientRDMAPIShim::RDMSet(rdm_callback *callback, unsigned int universe, const ola::rdm::UID &uid, uint16_t sub_device, uint16_t pid, const uint8_t *data, unsigned int data_length) { SendRDMArgs args(NewSingleCallback( this, &ClientRDMAPIShim::HandleResponse, callback)); m_client->RDMSet(universe, uid, sub_device, pid, data, data_length, args); return true; }
/* * Trigger RDM discovery for this universe */ void Universe::RunRDMDiscovery(RDMDiscoveryCallback *on_complete, bool full) { if (full) OLA_INFO << "Full RDM discovery triggered for universe " << m_universe_id; else OLA_INFO << "Incremental RDM discovery triggered for universe " << m_universe_id; m_clock->CurrentTime(&m_last_discovery_time); // we need to make a copy of the ports first, because the callback may run at // any time so we need to guard against the port list changing. vector<OutputPort*> output_ports(m_output_ports.size()); copy(m_output_ports.begin(), m_output_ports.end(), output_ports.begin()); // the multicallback that indicates when discovery is done BaseCallback0<void> *discovery_complete = NewMultiCallback( output_ports.size(), NewSingleCallback(this, &Universe::DiscoveryComplete, on_complete)); // Send Discovery requests to all ports, as each of these return they'll // update the UID map. When all ports callbacks have run, the MultiCallback // will trigger, running the DiscoveryCallback. vector<OutputPort*>::iterator iter; for (iter = output_ports.begin(); iter != output_ports.end(); ++iter) { if (full) { (*iter)->RunFullDiscovery( NewSingleCallback(this, &Universe::PortDiscoveryComplete, discovery_complete, *iter)); } else { (*iter)->RunIncrementalDiscovery( NewSingleCallback(this, &Universe::PortDiscoveryComplete, discovery_complete, *iter)); } } }
void WidgetDetectorThread::DispatchWidget(WidgetType *widget, const InfoType *information) { // default the on remove to us widget->GetDescriptor()->SetOnClose(NewSingleCallback( this, &WidgetDetectorThread::FreeWidget, reinterpret_cast<SerialWidgetInterface*>(widget))); ola::SingleUseCallback0<void> *cb = ola::NewSingleCallback( this, &WidgetDetectorThread::SignalNewWidget<WidgetType, InfoType>, widget, information); m_other_ss->Execute(cb); }
/** * Handle a RDM UID Message */ void RobeWidgetDetector::HandleUidMessage(DispatchingRobeWidget *widget, const uint8_t *data, unsigned int length) { WidgetStateMap::iterator iter = m_widgets.find(widget); if (iter == m_widgets.end()) return; if (length != ola::rdm::UID::UID_SIZE) { OLA_INFO << "Robe widget returned invalid UID size: " << length; return; } iter->second.information.uid = ola::rdm::UID(data); if (!IsUnlocked(iter->second.information)) { OLA_WARN << "This Robe widget isn't unlocked, please visit " "http://www.robe.cz/nc/support/search-for/DSU%20RUNIT/ to download " "the new firmware."; return; } // ok this is a good interface at this point RemoveTimeout(&iter->second); const RobeWidgetInformation *widget_info = new RobeWidgetInformation( iter->second.information); m_widgets.erase(iter); OLA_INFO << "Detected Robe Device, UID : " << widget_info->uid << ", Hardware version: 0x" << std::hex << static_cast<int>(widget_info->hardware_version) << ", software version: 0x" << static_cast<int>(widget_info->software_version) << ", eeprom version 0x" << static_cast<int>(widget_info->eeprom_version); // given that we've been called via the widget's stack, schedule execution of // the method that deletes the widget. m_scheduler->Execute( NewSingleCallback(this, &RobeWidgetDetector::DispatchWidget, widget, widget_info)); }
/* * Start the discovery process for a widget * @param widget, the RobeWidget to run discovery on. * @return true if the process started ok, false otherwise. */ bool RobeWidgetDetector::Discover( ola::io::ConnectedDescriptor *descriptor) { DispatchingRobeWidget *widget = new DispatchingRobeWidget(descriptor); widget->SetHandler( NewCallback(this, &RobeWidgetDetector::HandleMessage, widget)); if (!widget->SendMessage(BaseRobeWidget::INFO_REQUEST, NULL, 0)) { delete widget; return false; } // Set the onclose handler so we can mark this as failed. descriptor->SetOnClose(NewSingleCallback(this, &RobeWidgetDetector::WidgetRemoved, widget)); // Register a timeout for this widget SetupTimeout(widget, &m_widgets[widget]); return true; }