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 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++;
}
}
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));
}
public ImageAcquisitionService(DeviceKind deviceKind)
{
_deviceKind = 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);
}
