C++ DeviceDescriptor类代码示例

    void Set(const DeviceConfig &config, const DeviceDescriptor &device,
             const NMEAInfo &basic) {
      /* if a DeviceDescriptor is "unconfigured" but its DeviceConfig
         contains a valid configuration, then it got disabled by
         DeviceConfigOverlaps(), i.e. it's duplicate */
      duplicate = !config.IsDisabled() && !device.IsConfigured();

      switch (device.GetState()) {
      case PortState::READY:
        open = true;
        error = false;
        break;

      case PortState::FAILED:
        open = false;
        error = true;
        break;

      case PortState::LIMBO:
        open = false;
        error = false;
        break;
      }

      alive = basic.alive;
      location = basic.location_available;
      gps = basic.gps.fix_quality_available;
      baro = basic.baro_altitude_available ||
        basic.pressure_altitude_available ||
        basic.static_pressure_available;
      airspeed = basic.airspeed_available;
      vario = basic.total_energy_vario_available;
      traffic = basic.flarm.IsDetected();
      debug = device.IsDumpEnabled();
    }

static bool
DeviceDeclare(DeviceDescriptor &dev, const Declaration &declaration,
              const Waypoint *home)
{
  if (dev.IsOccupied())
    return false;

  if (ShowMessageBox(_("Declare task?"), dev.GetDisplayName(),
                  MB_YESNO | MB_ICONQUESTION) != IDYES)
    return false;

  if (!dev.Borrow())
    return false;

  const TCHAR *caption = dev.GetDisplayName();
  if (caption == NULL)
    caption = _("Declare task");

  bool success = DoDeviceDeclare(dev, declaration, home);
  dev.Return();

  if (!success) {
    ShowMessageBox(_("Error occured,\nTask NOT declared!"),
                caption, MB_OK | MB_ICONERROR);
    return false;
  }

  ShowMessageBox(_("Task declared!"),
              caption, MB_OK | MB_ICONINFORMATION);
  return true;
}

    void MPICommunicatorImpl::Initialize(const std::vector<NDArrayViewPtr>& values)
    {
        assert(CPUDEVICE < 0); // just in case somebody decides to change CPUDEVICE macro.
        DeviceDescriptor lastGpuDevice = DeviceDescriptor::CPUDevice();
        m_gpuDataTransferers.resize(values.size());
        m_intermediateCPUBuffers.resize(values.size());
        for (auto i = 0; i < values.size(); ++i)
        {
            auto view = values[i];
            auto device = view->Device();

            // Make sure none of the values are sparse - we currently do not support aggregation of sparse matrices
            if (view->GetStorageFormat() != StorageFormat::Dense)
                RuntimeError("Aggregation for sparse matrices is currently not supported!");

            // TODO: device.Type should be called Kind.
            if (device.Type() != DeviceKind::GPU)
            {
                m_intermediateCPUBuffers[i] = Buffer();
                m_gpuDataTransferers[i] = nullptr;
            }
            else
            {
                if (lastGpuDevice.Type() == DeviceKind::CPU)
                    lastGpuDevice = device;
                else if (device.Id() != lastGpuDevice.Id()) // For the time being, assume all devices have the same id.
                    LogicError("Not all values are on the same GPU device id");

                auto requiredSize = GetBufferSize(view);
                m_gpuDataTransferers[i] = std::make_shared<GPUDataTransferer>(device.Id(), true);
                if (m_intermediateCPUBuffers[i].totalSize < requiredSize)
                    m_intermediateCPUBuffers[i] = AllocateIntermediateBuffer(device.Id(), requiredSize);
            }
        }
    }

static bool
devInitOne(DeviceDescriptor &device, const DeviceConfig &config,
           DeviceDescriptor *&nmeaout)
{
  if (config.port_type == DeviceConfig::INTERNAL) {
#ifdef ANDROID
    if (is_simulator())
      return true;

    device.internal_gps = InternalGPS::create(Java::GetEnv(), native_view,
                                              device.GetIndex());
    return device.internal_gps != NULL;
#else
    return false;
#endif
  }

  const struct DeviceRegister *Driver = devGetDriver(config.driver_name);
  if (Driver == NULL)
    return false;

  Port *Com = OpenPort(config, device);
  if (Com == NULL)
    return false;

  if (!device.Open(Com, Driver)) {
    delete Com;
    return false;
  }

  if (nmeaout == NULL && (Driver->Flags & (1l << dfNmeaOut)))
    nmeaout = &device;

  return true;
}

void TestCheckpointing(const DeviceDescriptor& device)
{
    auto featureStreamName = L"features";
    auto labelsStreamName = L"labels";

    size_t inputDim = 784;
    size_t numOutputClasses = 10;
    auto features1 = InputVariable({ inputDim }, false /*isSparse*/, DataType::Float, featureStreamName);
    auto labels1 = InputVariable({ numOutputClasses }, DataType::Float, labelsStreamName);
    auto net1_1 = BuildFFClassifierNet(features1, numOutputClasses, device, 1);
    FunctionPtr net1_2;

    if (device.Type() == DeviceKind::GPU)
    {
        // TODO: instead of cloning here, reset curand generator to make sure that parameters are initialized to the same state.
        for (auto& p : net1_1->Parameters()) 
        {
            // make sure all parameters are initialized
            assert(p.Value() != nullptr);
        }
        net1_2 = net1_1->Clone();
    }
    else 
    {
        net1_2 = BuildFFClassifierNet(features1, numOutputClasses, device, 1);
    }

    auto minibatchSource1 = TextFormatMinibatchSource(L"Train-28x28_cntk_text.txt", { { featureStreamName, inputDim }, { labelsStreamName, numOutputClasses } },  1000, false);

    TestTrainingWithCheckpointing(net1_1, net1_2, labels1, minibatchSource1, device);

    inputDim = 2000;
    numOutputClasses = 5;
    auto features2 = InputVariable({ inputDim }, true /*isSparse*/, DataType::Float, featureStreamName);
    auto labels2 = InputVariable({ numOutputClasses }, DataType::Float, labelsStreamName, { Axis::DefaultBatchAxis() });
    auto net2_1 = BuildLSTMClassifierNet(features2, numOutputClasses, device, 1);
    FunctionPtr net2_2;

    if (device.Type() == DeviceKind::GPU)
    {
        // TODO: instead of cloning here, reset curand generator to make sure that parameters are initialized to the same state.
        for (auto& p : net2_1->Parameters()) 
        {
            // make sure all parameters are initialized
            assert(p.Value() != nullptr);
        }
        net2_2 = net2_1->Clone();
    }
    else 
    {
        net2_2 = BuildLSTMClassifierNet(features2, numOutputClasses, device, 1);
    }

    auto minibatchSource2 = TextFormatMinibatchSource(L"Train.ctf", { { featureStreamName, inputDim, true, L"x" }, {  labelsStreamName, numOutputClasses, false, L"y" } }, 1000, false);

    TestTrainingWithCheckpointing(net2_1, net2_2, labels2, minibatchSource2, device);
}

void
devTick(const NMEA_INFO &basic, const DERIVED_INFO &calculated)
{
  int i;

  for (i = 0; i < NUMDEV; i++) {
    DeviceDescriptor *d = &DeviceList[i];
    d->OnSysTicker(basic, calculated);
  }
}

void
devTick(const DerivedInfo &calculated)
{
  int i;

  for (i = 0; i < NUMDEV; i++) {
    DeviceDescriptor *d = &DeviceList[i];
    d->OnSysTicker(calculated);
  }
}

static void
devInitOne(DeviceDescriptor &device, const DeviceConfig &config)
{
  device.SetConfig(config);

  /* this OperationEnvironment instance must be persistent, because
     DeviceDescriptor::Open() is asynchronous */
  static PopupOperationEnvironment env;

  device.ResetFailureCounter();
  device.Open(env);
}

bool UsbDmxPlugin::AddDeviceDescriptor(int fd) {
  vector<DeviceDescriptor*>::const_iterator iter = m_descriptors.begin();
  for (; iter != m_descriptors.end(); ++iter) {
    if ((*iter)->ReadDescriptor() == fd)
      return true;
  }
  DeviceDescriptor *socket = new DeviceDescriptor(fd);
  socket->SetOnData(NewCallback(this, &UsbDmxPlugin::SocketReady));
  m_plugin_adaptor->AddReadDescriptor(socket);
  m_descriptors.push_back(socket);
  return true;
}

 void Manager::devicePlugged( DeviceDescriptor * physicalDevice )
 {
     bool matchedExisting = false;
     
     Index * existing = findIndexWithPhysicalDevice(physicalDevice);
     if( existing ) return;
     
     //look for matching deviceless index
     for( tIndices::iterator i = mIndices.begin(); i != mIndices.end() ; i++ )
     {
         Index * index = * i;
         if( !index->getPhysicalDevice() )
         {
             DeviceDescriptor * dd = index->recallDevice();
             if( dd && dd->fuzzyCompareType( physicalDevice ) )
             {
                 index->setPhysicalDevice( physicalDevice );
                 index->forgetDevice();
                 matchedExisting = true;
                 
                  BOOST_LOG_TRIVIAL(trace) << "Reconnected physical device (" << physicalDevice->getVendorProductCombo() << ") to Player [" << index->getPlayer() << "] with existing index \"" << index->getName() << "\"" << std::endl;
             }
         }
     }
     
     if( !matchedExisting )
     {
         //build look for matching index delcaration and create an index
         for( ast::hidCollapseList::iterator d = indexDefinitions.begin();
             d != indexDefinitions.end() ;
             d++ )
         {
             //build a comparable device descriptor ot compare with the ones
             //generated by the operating system specific code
             DeviceDescriptor declaredDevice = boost::apply_visitor( makeDescriptor() , d->device );
             
             if( declaredDevice.fuzzyCompareType( physicalDevice ) > DeviceDescriptor::MATCH_THRESHOLD )
             {
                 //build an index for this device
                 //element mapping occurrs at an OS-aware level
                 //so let the implementaiton of createIndex and createElements handle that
                 Index * newIndex = new Index( this, d->entries , d->index );
                 newIndex->setPhysicalDevice( physicalDevice );
                 mIndices.push_back( newIndex );
                 
                 putInNextAvailablePlayerSlot( newIndex );
                 return;
             }
         }
     }
 }

 void Manager::buildIndices()
 {
     /*
     BOOST_LOG_TRIVIAL(trace) << "Initially available physical devices: " << std::endl;
     if( mPhysicalDevices.size() == 0 )
          BOOST_LOG_TRIVIAL(trace) << "\t No physical devices." << std::endl;
     
     for( tPhysicalDevices::iterator i= mPhysicalDevices.begin() ;
         i!= mPhysicalDevices.end() ;
         i++ )
     {
         DeviceDescriptor * dd = *i;
          BOOST_LOG_TRIVIAL(trace) << "\t" << dd->getVendorProductCombo() << std::endl;
     }
     */
     
     for( ast::hidCollapseList::iterator d = indexDefinitions.begin();
         d != indexDefinitions.end() ;
         d++ )
     {
         //build a comparable device descriptor ot compare with the ones
         //generated by the operating system specific code
         DeviceDescriptor declaredDevice = boost::apply_visitor( makeDescriptor() , d->device );
         
         for( tPhysicalDevices::iterator i= mPhysicalDevices.begin() ;
             i!= mPhysicalDevices.end() ;
             i++ )
         {
             DeviceDescriptor * physicalDevice = *i;
             
             Index * existing = findIndexWithPhysicalDevice( physicalDevice );
             
             if( !existing )
             {
                 if( declaredDevice.fuzzyCompareType( physicalDevice ) > DeviceDescriptor::MATCH_THRESHOLD )
                 {
                     //build an index for this device
                     //element mapping occurrs at an OS-aware level
                     //so let the implementaiton of createIndex and createElements handle that
                     Index * newIndex = new Index( this, d->entries , d->index );
                     newIndex->setPhysicalDevice( physicalDevice );
                     mIndices.push_back( newIndex );
                     
                     putInNextAvailablePlayerSlot(newIndex);
                 }
             }
         }
     }
 }

tPtr<DeviceHandleImpl> DriverMIDI::connect(const DeviceDescriptor& device_)
{
  M_LOG("[DriverMIDI] connecting to " << device_.name() << ":" << device_.vendorId() << ":"
                                      << device_.productId());
  try
  {
    return tPtr<DeviceHandleImpl>(new DeviceHandleMIDI(device_));
  }
  catch (RtMidiError& error)
  {
	std::string strError(error.getMessage());
    M_LOG("[DriverMIDI] RtMidiError: " << strError);
    return nullptr;
  }
}

    void Set(const DeviceDescriptor &device, const NMEAInfo &basic) {
      switch (device.GetState()) {
      case PortState::READY:
        open = true;
        error = false;
        break;

      case PortState::FAILED:
        open = false;
        error = true;
        break;

      case PortState::LIMBO:
        open = false;
        error = false;
        break;
      }

      alive = basic.alive;
      location = basic.location_available;
      gps = basic.gps.fix_quality_available;
      baro = basic.baro_altitude_available ||
        basic.pressure_altitude_available ||
        basic.static_pressure_available;
      airspeed = basic.airspeed_available;
      vario = basic.total_energy_vario_available;
      traffic = basic.flarm.IsDetected();
    }

/// <summary> 
/// Инициализирует канал связи с указанным устройством.
/// До вызова этой функции никакие настроики порта или операции ввода-вывода проводиться не могут.
/// </summary>
/// <param name="d"> Описатель устройства. Экземпляр класса, позволяющего идентефицировать устройство, к которому надо подключиться.
/// Как получить список доступных устройств, см: <see cref="DeviceDescriptor::GetDevicesList()">Класс перечисления совместимых устройств</see></param> 
/// <returns> Результат попытки открытия канала</returns>
bool COM_CommCh::Init(DeviceDescriptor d)
{
	this->setDeviceName(d.GetCOMname());

    std::cout<<"Device COM name = "<<this->deviceName().toStdString()<<std::endl;
		
    if (this->AbstractSerial::open(this->ReadWrite | AbstractSerial::Unbuffered))
    {
		// при небуферизованном режиме, необходимо выставить не нулевое время таймаутов !!!
		// ИНАЧЕ НИЧЕГО ЧИТАТЬСЯ НЕ БУДЕТ!!! 
		const int CharIntervalTimeout__ = 10;
		const int TotalReadConstantTimeout__ = 10;
		this->setCharIntervalTimeout(CharIntervalTimeout__); 
		this->setTotalReadConstantTimeout(TotalReadConstantTimeout__);

        std::cout<<"Device opened."<<std::endl;

		// устанавливаем состояние
		opened = true;
		return true;
	}
    else
	{
        std::cout<<"Failed to open Device"<<std::endl;
		// устанавливаем состояние
		opened = false;
		return false;
	}
};

void
ShowPortMonitor(SingleWindow &parent, const DialogLook &dialog_look,
                const TerminalLook &terminal_look,
                DeviceDescriptor &device)
{
  /* create the dialog */

  WindowStyle dialog_style;
  dialog_style.Hide();
  dialog_style.ControlParent();

  TCHAR buffer[64];
  StaticString<128> caption;
  caption.Format(_T("%s: %s"), _("Port monitor"),
                 device.GetConfig().GetPortName(buffer, ARRAY_SIZE(buffer)));

  WndForm dialog(dialog_look);
  dialog.Create(parent, caption, dialog_style);

  ContainerWindow &client_area = dialog.GetClientAreaWindow();

  PortMonitorGlue glue(device, terminal_look);

  ButtonPanel buttons(client_area, dialog_look);
  buttons.Add(_("Close"), dialog, mrOK);
  glue.CreateButtons(buttons);
  glue.CreateTerminal(client_area, buttons.UpdateLayout());

  /* run it */

  dialog.ShowModal();
}