public static string ToApiString(this DeviceKind value) { switch (value) { case DeviceKind.Unknown: return(UNKNOWN); case DeviceKind.OfficialWeb: return(OFFICIAL_WEB); case DeviceKind.Ios: return(IOS); case DeviceKind.Android: return(ANDROID); case DeviceKind.Uwp: return(UWP); case DeviceKind.Chrome: return(CHROME); case DeviceKind.Firefox: return(FIREFOX); } return(value.ToString("G").ToLower()); }
private int SetupConfigurationDevices(MinerConfiguration minerConfiguration, DeviceKind deviceKinds, IList <DeviceConfiguration> deviceConfigurations) { int deviceCount = 0; for (int i = 0; i < deviceConfigurations.Count; i++) { DeviceConfiguration enabledConfiguration = deviceConfigurations[i]; Device device = devices.SingleOrDefault(d => d.Equals(enabledConfiguration)); if ((deviceKinds & device.Kind) == 0) { continue; } deviceCount++; //don't actually add stratum device as a device index if (device.Kind != DeviceKind.PXY) { minerConfiguration.DeviceDescriptors.Add(device); } else { //only enable the stratum proxy if these devices contain the PXY device minerConfiguration.StratumProxy = engineConfiguration.XgminerConfiguration.StratumProxy; minerConfiguration.StratumProxyPort = engineConfiguration.XgminerConfiguration.StratumProxyPort; minerConfiguration.StratumProxyStratumPort = engineConfiguration.XgminerConfiguration.StratumProxyStratumPort; } } return(deviceCount); }
/// <summary> /// Creates a new instance containing device information for the specified <paramref name="kind"/>. /// </summary> /// <param name="kind">The kind of device.</param> public DeviceInfo(DeviceKind kind) { switch (kind) { case DeviceKind.RCX: break; case DeviceKind.NXT: HasUSB = true; HasBluetooth = true; break; case DeviceKind.NXTFirmwareUpdate: HasUSB = true; break; case DeviceKind.EV3: HasUSB = true; HasBluetooth = true; HasWiFi = true; break; case DeviceKind.EV3FirmwareUpdate: HasUSB = true; break; default: throw new ArgumentOutOfRangeException("Unknown kind of device", nameof(kind)); } }
private DeviceKind _Type() { DeviceKind ret = (DeviceKind)CNTKLibPINVOKE.DeviceDescriptor__Type(swigCPtr); if (CNTKLibPINVOKE.SWIGPendingException.Pending) { throw CNTKLibPINVOKE.SWIGPendingException.Retrieve(); } return(ret); }
public MinerDescriptor GetMiner(DeviceKind deviceKind, string algorithmName, SerializableDictionary<string, string> miners) { CoinAlgorithm algorithm = GetAlgorithm(algorithmName); if (algorithm == null) //algorithm for name not found return null; return GetMiner(deviceKind, algorithm, miners); }
public MinerDescriptor GetMiner(DeviceKind deviceKind, CoinAlgorithm algorithm, SerializableDictionary<CoinAlgorithm, string> miners) { if (deviceKind != DeviceKind.GPU) return GetDefaultMiner(); if (miners.ContainsKey(algorithm)) return Miners.Single(m => m.Name.Equals(miners[algorithm], StringComparison.OrdinalIgnoreCase)); else return DefaultMiners[algorithm]; }
public MinerDescriptor GetMiner(DeviceKind deviceKind, string algorithmName, SerializableDictionary <string, string> miners) { CoinAlgorithm algorithm = GetAlgorithm(algorithmName); if (algorithm == null) { //algorithm for name not found return(null); } return(GetMiner(deviceKind, algorithm, miners)); }
public LinuxHealthHub() { var devId = Bluez.hci_get_route(IntPtr.Zero); var sockFd = Linux.socket(Consts.AF_BLUETOOTH, Consts.SOCK_RAW | Consts.SOCK_CLOEXEC, Consts.BTPROTO_HCI); var addr = new Sockaddr_hci { hci_family = Consts.AF_BLUETOOTH, hci_dev = (ushort)devId, hci_channel = Consts.HCI_CHANNEL_RAW }; var status = Linux.bind(sockFd, ref addr, Marshal.SizeOf(addr)); status = Bluez.hci_le_set_scan_parameters(sockFd, 0, 0x10, 0x10, 0, 0, 1000); var filter = new Hci_filter { type_mask = 0x00000010, event_mask = 0x4000000000000000ul, opcode = 0 }; status = Linux.setsockopt(sockFd, Consts.SOL_HCI, Consts.HCI_FILTER, ref filter, Marshal.SizeOf(filter)); status = Bluez.hci_le_set_scan_enable(sockFd, 1, 0, 1000); watcher = new Thread(() => { while (shouldRun) { var bytes = new byte[44]; Reflect.Call("Mono.Unix.Native.Syscall, Mono.Posix", "recv", sockFd, bytes, (ulong)bytes.Length, 0); var offset = 16; const DeviceKind kind = DeviceKind.Scale; var ts = new DateTimeOffset(); var weightKg = BitConverter.ToUInt16(new[] { bytes[5 + offset], bytes[4 + offset] }, 0) / 10f; var finished = bytes[6 + offset] != 255 && bytes[7 + offset] != 255; OnHealthEvent?.Invoke(this, new SimpleData { Kind = kind, Time = ts, Data = weightKg, Unit = Unit.kg, Status = finished ? DataKind.Final : DataKind.Transitional }); } }) { IsBackground = true, Name = "Watcher" }; watcher.Start(); }
private Task <Device> PostDeviceAsyncCore(string name, DeviceKind kind, string deviceIdentifier, string notificationIdentifier, bool subscribeNotification, HttpRequestMessage req) { var d = new[] { new KeyValuePair <string, string>("name", name), new KeyValuePair <string, string>("kind", kind.ToApiString()), new KeyValuePair <string, string>("device_identifier", deviceIdentifier), new KeyValuePair <string, string>("notification_identifier", notificationIdentifier), new KeyValuePair <string, string>("subscribe_notification", subscribeNotification ? "true" : "false") }; req.Content = new FormUrlEncodedContent(d); return(SendAsync <Device>(req)); }
public MinerDescriptor GetMiner(DeviceKind deviceKind, CoinAlgorithm algorithm, SerializableDictionary <CoinAlgorithm, string> miners) { if (deviceKind != DeviceKind.GPU) { return(GetDefaultMiner()); } if (miners.ContainsKey(algorithm)) { return(Miners.Single(m => m.Name.Equals(miners[algorithm], StringComparison.OrdinalIgnoreCase))); } else { return(DefaultMiners[algorithm]); } }
public DeviceSetting[] GetDevices(DeviceKind kind) { var result = new List <DeviceSetting>(); foreach (var kv in Settings) { if (kv.Value.DeviceKind != kind) { continue; } result.Add(kv.Value); } return(result.ToArray()); }
private Process LaunchMinerProcess(Xgminer.Data.Configuration.Miner minerConfiguration, string reason) { minerConfiguration.Priority = this.engineConfiguration.XgminerConfiguration.Priority; //we launch 1 process per device kind now DeviceKind deviceKind = minerConfiguration.DeviceDescriptors.First().Kind; MinerDescriptor descriptor = MinerFactory.Instance.GetMiner(deviceKind, minerConfiguration.Algorithm, engineConfiguration.XgminerConfiguration.AlgorithmMiners); Xgminer.Miner miner = new Xgminer.Miner(minerConfiguration, descriptor.LegacyApi); miner.LogLaunch += this.LogProcessLaunch; miner.LaunchFailed += this.ProcessLaunchFailed; miner.AuthenticationFailed += this.ProcessAuthenticationFailed; Process process = miner.Launch(reason); return(process); }
public MinerDescriptor GetMiner(DeviceKind deviceKind, CoinAlgorithm algorithm, SerializableDictionary<string, string> miners) { if (deviceKind != DeviceKind.GPU) return GetDefaultMiner(); string algorithmName = algorithm.Name; MinerDescriptor result = null; if (miners.ContainsKey(algorithmName)) // SingleOrDefault - the user may have a config file with a backend // miner registered that no longer exists in their Miners\ folder result = Miners.SingleOrDefault(m => m.Name.Equals(miners[algorithmName], StringComparison.OrdinalIgnoreCase)); if ((result == null) && (algorithm.DefaultMiner != null)) result = Miners.Single(m => m.Name.Equals(algorithm.DefaultMiner, StringComparison.OrdinalIgnoreCase)); return result; }
private void LaunchMiners(ref int apiPort, string coinSymbol, DeviceKind deviceKind, bool terminateProcess) { Xgminer.Data.Configuration.Miner minerConfiguration = CreateMinerConfiguration(apiPort, coinSymbol, deviceKind); //null if no pools configured if (minerConfiguration != null) { Process process = LaunchMinerProcess(minerConfiguration, "Starting mining"); if (!process.HasExited) { MinerDescriptor miner = MinerFactory.Instance.GetMiner(deviceKind, minerConfiguration.Algorithm, engineConfiguration.XgminerConfiguration.AlgorithmMiners); MinerProcess minerProcess = StoreMinerProcess(process, miner, coinSymbol, minerConfiguration, apiPort); minerProcess.TerminateProcess = terminateProcess; } apiPort++; } }
public MinerDescriptor GetMiner(DeviceKind deviceKind, CoinAlgorithm algorithm, SerializableDictionary <string, string> miners) { if (deviceKind != DeviceKind.GPU) { return(GetDefaultMiner()); } string algorithmName = algorithm.Name; if (miners.ContainsKey(algorithmName)) { return(Miners.Single(m => m.Name.Equals(miners[algorithmName], StringComparison.OrdinalIgnoreCase))); } if (algorithm.DefaultMiner != null) { return(Miners.Single(m => m.Name.Equals(algorithm.DefaultMiner, StringComparison.OrdinalIgnoreCase))); } return(null); }
private void Scale_Received(BluetoothLEAdvertisementWatcher sender, BluetoothLEAdvertisementReceivedEventArgs args) { const DeviceKind kind = DeviceKind.Scale; var addr = args.BluetoothAddress; var ts = args.Timestamp; var data = args.Advertisement.DataSections.First(d => d.DataType == 255); var bytes = data.Data.ToArray(); var weightKg = BitConverter.ToUInt16(new[] { bytes[5], bytes[4] }, 0) / 10f; var finished = bytes[6] != 255 && bytes[7] != 255; OnHealthEvent?.Invoke(this, new SimpleData { Kind = kind, Origin = addr, Time = ts, Data = weightKg, Unit = Unit.kg, Status = finished ? DataKind.Final : DataKind.Transitional }); }
public static async void RegisterBackgroundTask(DeviceKind kind) { try { BackgroundAccessStatus status = BackgroundAccessStatus.Unspecified; if (kind == DeviceKind.WindowsPhone) { status = await ApplicationManger.CheckAppVersion(); } else if (kind == DeviceKind.Windows) { status = await BackgroundExecutionManager.RequestAccessAsync(); } if (status == BackgroundAccessStatus.AllowedMayUseActiveRealTimeConnectivity || status == BackgroundAccessStatus.AllowedWithAlwaysOnRealTimeConnectivity) { foreach (var task in BackgroundTaskRegistration.AllTasks) { if (task.Value.Name == taskName) { task.Value.Unregister(true); } } BackgroundTaskBuilder taskBuilder = new BackgroundTaskBuilder(); taskBuilder.Name = taskName; taskBuilder.TaskEntryPoint = (kind == DeviceKind.Windows) ? taskEntryPointWindows : taskEntryPointWindowsPhone; taskBuilder.SetTrigger(new TimeTrigger(15, false)); var registration = taskBuilder.Register(); } } catch (Exception) { //new MessageDialog(e.Message).ShowAsync(); } }
public MinerDescriptor GetMiner(DeviceKind deviceKind, CoinAlgorithm algorithm, SerializableDictionary <string, string> miners) { if (deviceKind != DeviceKind.GPU) { return(GetDefaultMiner()); } string algorithmName = algorithm.Name; MinerDescriptor result = null; if (miners.ContainsKey(algorithmName)) { // SingleOrDefault - the user may have a config file with a backend // miner registered that no longer exists in their Miners\ folder result = Miners.SingleOrDefault(m => m.Name.Equals(miners[algorithmName], StringComparison.OrdinalIgnoreCase)); } if ((result == null) && (algorithm.DefaultMiner != null)) { result = Miners.Single(m => m.Name.Equals(algorithm.DefaultMiner, StringComparison.OrdinalIgnoreCase)); } return(result); }
public Task <Device> PostDeviceAsync(string email, string password, string name, DeviceKind kind, string deviceIdentifier, string notificationIdentifier = null, bool subscribeNotification = false) { var req = new HttpRequestMessage(HttpMethod.Post, EndPoint + "/v1/devices"); req.Headers.Add("X-Account-Token", Convert.ToBase64String(new UTF8Encoding(false).GetBytes(email + ":" + password))); return(PostDeviceAsyncCore(name, kind, deviceIdentifier, notificationIdentifier, subscribeNotification, req)); }
private int SetupConfigurationDevices(Xgminer.Data.Configuration.Miner minerConfiguration, DeviceKind deviceKinds, IList<Engine.Data.Configuration.Device> deviceConfigurations) { int deviceCount = 0; for (int i = 0; i < deviceConfigurations.Count; i++) { Engine.Data.Configuration.Device enabledConfiguration = deviceConfigurations[i]; Xgminer.Data.Device device = devices.SingleOrDefault(d => d.Equals(enabledConfiguration)); if ((deviceKinds & device.Kind) == 0) continue; deviceCount++; //don't actually add stratum device as a device index if (device.Kind != DeviceKind.PXY) { minerConfiguration.DeviceDescriptors.Add(device); } else { //only enable the stratum proxy if these devices contain the PXY device minerConfiguration.StratumProxy = engineConfiguration.XgminerConfiguration.StratumProxy; minerConfiguration.StratumProxyPort = engineConfiguration.XgminerConfiguration.StratumProxyPort; minerConfiguration.StratumProxyStratumPort = engineConfiguration.XgminerConfiguration.StratumProxyStratumPort; } } return deviceCount; }
private Xgminer.Data.Configuration.Miner CreateMinerConfiguration(int port, string coinSymbol, DeviceKind includeKinds) { Data.Configuration.Coin coinConfiguration = engineConfiguration.CoinConfigurations.Single(c => c.CryptoCoin.Symbol.Equals(coinSymbol)); if (coinConfiguration.Pools.Count == 0) // no pools configured return null; IList<Engine.Data.Configuration.Device> enabledConfigurations = engineConfiguration.DeviceConfigurations.Where(c => c.Enabled && c.CoinSymbol.Equals(coinSymbol)).ToList(); Xgminer.Data.Configuration.Miner minerConfiguration = new Xgminer.Data.Configuration.Miner() { ExecutablePath = MinerPath.GetPathToInstalledMiner(), Algorithm = coinConfiguration.CryptoCoin.Algorithm, ApiPort = port, ApiListen = true, AllowedApiIps = engineConfiguration.XgminerConfiguration.AllowedApiIps, CoinName = coinConfiguration.CryptoCoin.Name, DisableGpu = engineConfiguration.XgminerConfiguration.DisableGpu }; SetupConfigurationPools(minerConfiguration, coinConfiguration); int deviceCount = SetupConfigurationDevices(minerConfiguration, includeKinds, enabledConfigurations); if (deviceCount == 0) return null; SetupConfigurationArguments(minerConfiguration, coinConfiguration); return minerConfiguration; }
public ImageAcquisitionService(DeviceKind deviceKind) { _deviceKind = deviceKind; }
private static void Main(string[] args) { try { DeviceKind device = DeviceKind.Unknown; int option = -1; if (args.Length == 2) { Enum.TryParse(args[0], out device); option = Convert.ToInt32(args[1]); } else { ShowUsage(); return; } switch (device) { case DeviceKind.RaspberryPi: s_ledPinNumber = (int)RaspberryPiSettings.Led; s_buttonPinNumber = (int)RaspberryPiSettings.Button; s_spiBusId = (uint)RaspberryPiSettings.SpiBusId; s_chipSelectLinePinNumber = (int)RaspberryPiSettings.SpiChipSelectLine; s_i2cBusId = (uint)RaspberryPiSettings.I2cBusId; break; case DeviceKind.Odroid: s_ledPinNumber = (int)OdroidSettings.Led; s_buttonPinNumber = (int)OdroidSettings.Button; s_spiBusId = (uint)OdroidSettings.SpiBusId; s_chipSelectLinePinNumber = (int)OdroidSettings.SpiChipSelectLine; s_i2cBusId = (uint)OdroidSettings.I2cBusId; break; case DeviceKind.Hummingboard: s_ledPinNumber = (int)HummingboardSettings.Led; s_buttonPinNumber = (int)HummingboardSettings.Button; s_spiBusId = (uint)HummingboardSettings.SpiBusId; s_chipSelectLinePinNumber = (int)HummingboardSettings.SpiChipSelectLine; s_i2cBusId = (uint)HummingboardSettings.I2cBusId; break; default: Console.WriteLine("Unknown device"); ShowUsage(); return; } switch (option) { case 0: Unix_BlinkingLed(); break; case 1: Unix_ButtonLed(); break; case 2: RaspberryPi_BlinkingLed(); break; case 3: RaspberryPi_ButtonLed(); break; case 4: UnixDriver_BlinkingLed(); break; case 5: UnixDriver_ButtonLed(); break; case 6: RaspberryPiDriver_BlinkingLed(); break; case 7: RaspberryPiDriver_ButtonLed(); break; case 8: RaspberryPiDriver_ButtonPullDown(); break; case 9: UnixDriver_DetectButton(); break; case 10: UnixDriver_DetectButtonLed(); break; case 11: RaspberryPiDriver_DetectButton(); break; case 12: RaspberryPiDriver_DetectButtonLed(); break; case 13: UnixDriver_ButtonWait(); break; case 14: RaspberryPiDriver_ButtonWait(); break; case 15: RaspberryPi_ButtonPullDown(); break; case 16: Unix_DetectButton(); break; case 17: Unix_DetectButtonLed(); break; case 18: RaspberryPi_DetectButton(); break; case 19: RaspberryPi_DetectButtonLed(); break; case 20: Unix_ButtonWait(); break; case 21: RaspberryPi_ButtonWait(); break; case 22: Unix_Lcd(); break; case 23: RaspberryPi_Lcd(); break; case 24: Spi_Roundtrip(); break; case 25: Unix_Spi_Pressure(); break; case 26: RaspberryPi_Spi_Pressure(); break; case 27: Unix_Spi_Pressure_Lcd(); break; case 28: RaspberryPi_Spi_Pressure_Lcd(); break; case 29: I2c_Pressure(); break; case 30: Unix_I2c_Pressure_Lcd(); break; case 31: RaspberryPi_I2c_Pressure_Lcd(); break; case 32: I2c_Color(); break; case 33: AzureIoTSendData(); break; case 34: AzureIoTSendCommands(); break; case 35: AzureIoTReceiveCommands(); break; default: Console.WriteLine("Unknown sample"); ShowUsage(); return; } } catch (Exception ex) { Console.WriteLine(ex); } finally { Console.WriteLine("Done!"); } }
private Xgminer.Data.Configuration.Miner CreateMinerConfiguration(int apiPort, string coinSymbol, DeviceKind deviceKind) { Data.Configuration.Coin coinConfiguration = engineConfiguration.CoinConfigurations.Single(c => c.CryptoCoin.Symbol.Equals(coinSymbol)); if (coinConfiguration.Pools.Count == 0) { // no pools configured return(null); } MinerDescriptor miner = MinerFactory.Instance.GetMiner(deviceKind, coinConfiguration.CryptoCoin.Algorithm, engineConfiguration.XgminerConfiguration.AlgorithmMiners); Xgminer.Data.Configuration.Miner minerConfiguration = CreateBasicConfiguration(miner, coinConfiguration, apiPort); IList <Engine.Data.Configuration.Device> enabledConfigurations = engineConfiguration.DeviceConfigurations .Where(c => c.Enabled && c.CoinSymbol.Equals(coinSymbol)).ToList(); int deviceCount = SetupConfigurationDevices(minerConfiguration, deviceKind, enabledConfigurations); if (deviceCount == 0) { return(null); } return(minerConfiguration); }
public Task <Device> PostDeviceAsync(string name, DeviceKind kind, string deviceIdentifier, string notificationIdentifier = null, bool subscribeNotification = false) { var req = new HttpRequestMessage(HttpMethod.Post, EndPoint + "/v1/devices"); return(PostDeviceAsyncCore(name, kind, deviceIdentifier, notificationIdentifier, subscribeNotification, req)); }
private Xgminer.Data.Configuration.Miner CreateMinerConfiguration(int apiPort, string coinSymbol, DeviceKind deviceKind) { Data.Configuration.Coin coinConfiguration = engineConfiguration.CoinConfigurations.Single(c => c.CryptoCoin.Symbol.Equals(coinSymbol)); if (coinConfiguration.Pools.Count == 0) // no pools configured return null; MinerDescriptor miner = MinerFactory.Instance.GetMiner(deviceKind, coinConfiguration.CryptoCoin.Algorithm, engineConfiguration.XgminerConfiguration.AlgorithmMiners); Xgminer.Data.Configuration.Miner minerConfiguration = CreateBasicConfiguration(miner, coinConfiguration, apiPort); IList<Engine.Data.Configuration.Device> enabledConfigurations = engineConfiguration.DeviceConfigurations .Where(c => c.Enabled && c.CoinSymbol.Equals(coinSymbol)).ToList(); int deviceCount = SetupConfigurationDevices(minerConfiguration, deviceKind, enabledConfigurations); if (deviceCount == 0) return null; return minerConfiguration; }
private int SetupConfigurationDevices(Xgminer.Data.Configuration.Miner minerConfiguration, DeviceKind deviceKind, IList<Engine.Data.Configuration.Device> deviceConfigurations) { int deviceCount = 0; for (int i = 0; i < deviceConfigurations.Count; i++) { Engine.Data.Configuration.Device enabledConfiguration = deviceConfigurations[i]; Xgminer.Data.Device device = devices.SingleOrDefault(d => d.Equals(enabledConfiguration)); if (deviceKind != device.Kind) continue; deviceCount++; minerConfiguration.DeviceDescriptors.Add(device); } return deviceCount; }
private int SetupConfigurationDevices(Xgminer.Data.Configuration.Miner minerConfiguration, DeviceKind deviceKind, IList <Engine.Data.Configuration.Device> deviceConfigurations) { int deviceCount = 0; for (int i = 0; i < deviceConfigurations.Count; i++) { Engine.Data.Configuration.Device enabledConfiguration = deviceConfigurations[i]; Xgminer.Data.Device device = devices.SingleOrDefault(d => d.Equals(enabledConfiguration)); if (deviceKind != device.Kind) { continue; } deviceCount++; minerConfiguration.DeviceDescriptors.Add(device); } return(deviceCount); }
/// <summary> /// Returns the name of the given device kind. /// </summary> /// <param name="deviceKind">The device kind whose name is to be returned.</param> /// <returns></returns> public static string DeviceKindName(DeviceKind deviceKind) { return(CNTKLib.DeviceKindName(deviceKind)); }
private Xgminer.Data.Configuration.Miner CreateMinerConfiguration(int apiPort, string coinSymbol, DeviceKind deviceKind) { Data.Configuration.Coin coinConfiguration = engineConfiguration.CoinConfigurations.Single(c => c.PoolGroup.Id.Equals(coinSymbol)); if (coinConfiguration.Pools.Count == 0) { // no pools configured return(null); } MinerDescriptor miner = MinerFactory.Instance.GetMiner(deviceKind, coinConfiguration.PoolGroup.Algorithm, engineConfiguration.XgminerConfiguration.AlgorithmMiners); if (miner == null) { //no miner configured for the algorithm / custom algorithm throw new Xgminer.MinerLaunchException(String.Format("No miner defined for algorithm {0}.", coinConfiguration.PoolGroup.Algorithm)); } Xgminer.Data.Configuration.Miner minerConfiguration = CreateBasicConfiguration(miner, coinConfiguration, apiPort); IList <Engine.Data.Configuration.Device> enabledConfigurations = engineConfiguration.DeviceConfigurations .Where(c => c.Enabled && c.CoinSymbol.Equals(coinSymbol)).ToList(); int deviceCount = SetupConfigurationDevices(minerConfiguration, deviceKind, enabledConfigurations); if (deviceCount == 0) { return(null); } return(minerConfiguration); }
private MinerConfiguration CreateMinerConfiguration(int port, string coinSymbol, DeviceKind includeKinds) { CoinConfiguration coinConfiguration = engineConfiguration.CoinConfigurations.Single(c => c.Coin.Symbol.Equals(coinSymbol)); IList<DeviceConfiguration> enabledConfigurations = engineConfiguration.DeviceConfigurations.Where(c => c.Enabled && c.CoinSymbol.Equals(coinSymbol)).ToList(); MinerConfiguration minerConfiguration = new MinerConfiguration(); minerConfiguration.ExecutablePath = MinerPath.GetPathToInstalledMiner(); //minerConfiguration.Pools = coinConfiguration.Pools; foreach (MiningPool pool in coinConfiguration.Pools) { pool.Quota = 0; minerConfiguration.Pools.Add(pool); } //using bfgminer quotas for failover, that way we can augment for donations minerConfiguration.Pools.First().Quota = 100 - donationPercent; if (donationPercent > 0) AddDonationPool(coinSymbol, minerConfiguration); minerConfiguration.Algorithm = coinConfiguration.Coin.Algorithm; minerConfiguration.ApiPort = port; minerConfiguration.ApiListen = true; minerConfiguration.AllowedApiIps = engineConfiguration.XgminerConfiguration.AllowedApiIps; minerConfiguration.CoinName = coinConfiguration.Coin.Name; minerConfiguration.DisableGpu = engineConfiguration.XgminerConfiguration.DisableGpu; int deviceCount = 0; for (int i = 0; i < enabledConfigurations.Count; i++) { DeviceConfiguration enabledConfiguration = enabledConfigurations[i]; Device device = devices.SingleOrDefault(d => d.Equals(enabledConfiguration)); if ((includeKinds & device.Kind) == 0) continue; deviceCount++; //don't actually add stratum device as a device index if (device.Kind != DeviceKind.PXY) { minerConfiguration.DeviceDescriptors.Add(device); } else { //only enable the stratum proxy if these devices contain the PXY device minerConfiguration.StratumProxy = engineConfiguration.XgminerConfiguration.StratumProxy; minerConfiguration.StratumProxyPort = engineConfiguration.XgminerConfiguration.StratumProxyPort; minerConfiguration.StratumProxyStratumPort = engineConfiguration.XgminerConfiguration.StratumProxyStratumPort; } } if (deviceCount == 0) return null; string arguments = string.Empty; //apply algorithm-specific parameters if (engineConfiguration.XgminerConfiguration.AlgorithmFlags.ContainsKey(coinConfiguration.Coin.Algorithm)) arguments = String.Format("{0} {1}", arguments, engineConfiguration.XgminerConfiguration.AlgorithmFlags[coinConfiguration.Coin.Algorithm]); //apply coin-specific parameters if (!string.IsNullOrEmpty(coinConfiguration.MinerFlags)) arguments = string.Format("{0} {1}", arguments, coinConfiguration.MinerFlags); if (engineConfiguration.XgminerConfiguration.DesktopMode) arguments = arguments + " -I D"; if (donationPercent > 0) arguments = arguments + " --load-balance"; minerConfiguration.LaunchArguments = arguments; return minerConfiguration; }
private Xgminer.Data.Configuration.Miner CreateMinerConfiguration(int apiPort, string coinSymbol, DeviceKind deviceKind) { Data.Configuration.Coin coinConfiguration = engineConfiguration.CoinConfigurations.Single(c => c.PoolGroup.Id.Equals(coinSymbol)); if (coinConfiguration.Pools.Count == 0) // no pools configured return null; MinerDescriptor miner = MinerFactory.Instance.GetMiner(deviceKind, coinConfiguration.PoolGroup.Algorithm, engineConfiguration.XgminerConfiguration.AlgorithmMiners); if (miner == null) { //no miner configured for the algorithm / custom algorithm throw new Xgminer.MinerLaunchException(String.Format("No miner defined for algorithm {0}.", coinConfiguration.PoolGroup.Algorithm)); } Xgminer.Data.Configuration.Miner minerConfiguration = CreateBasicConfiguration(miner, coinConfiguration, apiPort); IList<Engine.Data.Configuration.Device> enabledConfigurations = engineConfiguration.DeviceConfigurations .Where(c => c.Enabled && c.CoinSymbol.Equals(coinSymbol)).ToList(); int deviceCount = SetupConfigurationDevices(minerConfiguration, deviceKind, enabledConfigurations); if (deviceCount == 0) return null; return minerConfiguration; }
private Xgminer.Data.Configuration.Miner CreateMinerConfiguration(int port, string coinSymbol, DeviceKind includeKinds) { Data.Configuration.Coin coinConfiguration = engineConfiguration.CoinConfigurations.Single(c => c.CryptoCoin.Symbol.Equals(coinSymbol)); IList <Engine.Data.Configuration.Device> enabledConfigurations = engineConfiguration.DeviceConfigurations.Where(c => c.Enabled && c.CoinSymbol.Equals(coinSymbol)).ToList(); Xgminer.Data.Configuration.Miner minerConfiguration = new Xgminer.Data.Configuration.Miner() { ExecutablePath = MinerPath.GetPathToInstalledMiner(), Algorithm = coinConfiguration.CryptoCoin.Algorithm, ApiPort = port, ApiListen = true, AllowedApiIps = engineConfiguration.XgminerConfiguration.AllowedApiIps, CoinName = coinConfiguration.CryptoCoin.Name, DisableGpu = engineConfiguration.XgminerConfiguration.DisableGpu }; SetupConfigurationPools(minerConfiguration, coinConfiguration); int deviceCount = SetupConfigurationDevices(minerConfiguration, includeKinds, enabledConfigurations); if (deviceCount == 0) { return(null); } SetupConfigurationArguments(minerConfiguration, coinConfiguration); return(minerConfiguration); }
private MinerConfiguration CreateMinerConfiguration(int port, string coinSymbol, DeviceKind includeKinds) { CoinConfiguration coinConfiguration = engineConfiguration.CoinConfigurations.Single(c => c.Coin.Symbol.Equals(coinSymbol)); IList <DeviceConfiguration> enabledConfigurations = engineConfiguration.DeviceConfigurations.Where(c => c.Enabled && c.CoinSymbol.Equals(coinSymbol)).ToList(); MinerConfiguration minerConfiguration = new MinerConfiguration(); minerConfiguration.ExecutablePath = MinerPath.GetPathToInstalledMiner(); //minerConfiguration.Pools = coinConfiguration.Pools; foreach (MiningPool pool in coinConfiguration.Pools) { pool.Quota = 0; minerConfiguration.Pools.Add(pool); } //using bfgminer quotas for failover, that way we can augment for donations minerConfiguration.Pools.First().Quota = 100; if (donating) { minerConfiguration.Pools.First().Quota--; //99% AddDonationPool(coinSymbol, minerConfiguration); } minerConfiguration.Algorithm = coinConfiguration.Coin.Algorithm; minerConfiguration.ApiPort = port; minerConfiguration.ApiListen = true; minerConfiguration.AllowedApiIps = engineConfiguration.XgminerConfiguration.AllowedApiIps; minerConfiguration.CoinName = coinConfiguration.Coin.Name; minerConfiguration.DisableGpu = engineConfiguration.XgminerConfiguration.DisableGpu; int deviceCount = 0; for (int i = 0; i < enabledConfigurations.Count; i++) { DeviceConfiguration enabledConfiguration = enabledConfigurations[i]; Device device = devices.SingleOrDefault(d => d.Equals(enabledConfiguration)); if ((includeKinds & device.Kind) == 0) { continue; } deviceCount++; //don't actually add stratum device as a device index if (device.Kind != DeviceKind.PXY) { minerConfiguration.DeviceDescriptors.Add(device); } else { //only enable the stratum proxy if these devices contain the PXY device minerConfiguration.StratumProxy = engineConfiguration.XgminerConfiguration.StratumProxy; minerConfiguration.StratumProxyPort = engineConfiguration.XgminerConfiguration.StratumProxyPort; minerConfiguration.StratumProxyStratumPort = engineConfiguration.XgminerConfiguration.StratumProxyStratumPort; } } if (deviceCount == 0) { return(null); } string arguments = string.Empty; //apply algorithm-specific parameters if (engineConfiguration.XgminerConfiguration.AlgorithmFlags.ContainsKey(coinConfiguration.Coin.Algorithm)) { arguments = String.Format("{0} {1}", arguments, engineConfiguration.XgminerConfiguration.AlgorithmFlags[coinConfiguration.Coin.Algorithm]); } //apply coin-specific parameters if (!string.IsNullOrEmpty(coinConfiguration.MinerFlags)) { arguments = string.Format("{0} {1}", arguments, coinConfiguration.MinerFlags); } if (engineConfiguration.XgminerConfiguration.DesktopMode) { arguments = arguments + " -I D"; } if (donating) { arguments = arguments + " --load-balance"; } minerConfiguration.Arguments = arguments; return(minerConfiguration); }