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;
}
