Detailed Description

The MUXOperator is a multiplexer that selects one source by Index from a selection of many sources.

The default input will always be source 0. Additional sources can be added as Arguments into the MUXOperator. The source selection is done by setting the MUXOperator Index to the desired 0-based source number to use. Index can be routed from another value.

Example

To select between a signal value and the values 10,20 and 30; add a Signal<double>, go into it and add two additional Arguments. Go into the first Argument and set Value to 10, then go into the second Argument and set Value to 20, and finally go into the third argument and set Value to 30.

How to Run the Example

To run the example from CDP Studio, open Welcome mode and find it under Examples. Next, in Configure mode right-click on the system project and select Run & Connect. See the Running the Example Project tutorial for more information.

Click into the signal containing the MUXOperator, change the Index between 0 and 3, and validate that the signal value changes according to the selected source index.

Arguments

When operator is used inside a signal its default input is automatically tied to signal's InternalValue or previous operator's output. Its default output is automatically tied to next operator's input or to signal's Value. See also CDP Operator Usage In CDP Signals.

Actual Processing Code of the MUXOperator

unsigned int MUXOperator<T>::Process()
{
  if (!m_index)
    return STATUS_ERROR;

  auto index = static_cast<unsigned int>(*m_index);
  T selectedValue = GetIndexedInputValue(index);

  if constexpr (!std::is_same<T, std::string>::value && !std::is_same<T, bool>::value)
  {
    if (m_interpolationTime && m_lastKnownIndex.has_value() && m_lastKnownIndex != index)
    {
      if (m_interpolationTime->GetUnit() == "cycles")
        m_interpolationCyclesLeft = (unsigned int)*m_interpolationTime;
      else
        m_interpolationCyclesLeft = (double)*m_interpolationTime / CDPOperatorBase::GetOperatorPeriod();
      m_interpolationState = GetIndexedInputValue(m_lastKnownIndex.value());
    }
    if (m_interpolationCyclesLeft > 0)
    {
      const double interpolationStep = (double)(selectedValue - m_interpolationState) / m_interpolationCyclesLeft;
      m_interpolationState += interpolationStep;
      m_output = m_interpolationState; // round down from precise interpolation to the precision possible with operator type T
      --m_interpolationCyclesLeft;
    }
    else
      m_output = selectedValue;
    m_lastKnownIndex = index;
  }
  else
    m_output = selectedValue;

  return STATUS_OK;
}