void UpdateAbilityMomentumCounters(MomentumData newMomentumData) { HardwareType[] allEquippedActiveHardware = InventoryController.GetEquippedActiveHardware(); for (int i = 0; i < abilityMomentumCounters.Length; i++) { HardwareType activeHardwareType = allEquippedActiveHardware[i]; if (activeHardwareType != HardwareType.None) { int newMomentumValue = MomentumManager.GetMomentumPointsByHardwareType(activeHardwareType); if (newMomentumValue != displayedMomentumValues[i]) { Color flashColor = newMomentumValue > displayedMomentumValues[i] ? momentumIncreasedFlashColor : momentumDecreasedFlashColor; Image momentumCounterImage = abilityMomentumCounters[i].GetComponent <Image>(); Sprite counterSprite = Resources.Load <Sprite>(MOMENTUM_COUNTER_PATH + newMomentumValue.ToString()); momentumCounterImage.sprite = counterSprite; StartCoroutine(FlashAbilityMomentumCounter(momentumCounterImage, flashColor)); displayedMomentumValues[i] = newMomentumValue; } } } }
public Miner CreateMiner(MinerBaseType minerBaseType, HardwareType hardwareType, bool is64Bit = true) { switch (minerBaseType) { case MinerBaseType.CCMiner: return(new Ccminer(hardwareType, minerBaseType, hardwareMonitor, is64Bit)); case MinerBaseType.CCMinerNanashi: return(new CCMinerForkNanashi(hardwareType, minerBaseType, hardwareMonitor)); case MinerBaseType.EWBF: return(new EWBF(hardwareType, minerBaseType, hardwareMonitor)); case MinerBaseType.EWBF_NO_ASIC: return(new EWBF_NO_ASIC(hardwareType, minerBaseType, hardwareMonitor)); case MinerBaseType.DSTM: return(new DSTM(hardwareType, minerBaseType, hardwareMonitor)); case MinerBaseType.Claymore: return(new Claymore(hardwareType, minerBaseType, hardwareMonitor)); default: throw new ApplicationException(string.Format("The miner base type {0} is not yet supported.", minerBaseType.ToString())); } }
public void UpdateAbilities(ref IHardware[] activeHardwareList) { for (int i = 0; i < activeHardwareList.Length; i++) { IHardware activeHardware = activeHardwareList[i]; Sprite activeHardwareBubSprite; if (activeHardware == null) { activeHardwareBubSprite = emptyAbilityBub; abilityBubImages[i].sprite = activeHardwareBubSprite; abilityMomentumCounters[i].SetActive(false); if (cooldownOverlays[i].enabled == true) { cooldownOverlays[i].enabled = false; } } else { HardwareType activeHardwareType = activeHardware.Type; activeHardwareBubSprite = DataAssociations.GetHardwareTypeBubImage(activeHardwareType); abilityBubImages[i].sprite = activeHardwareBubSprite; abilityMomentumCounters[i].SetActive(true); activeHardware.CooldownPercentUpdater = null; activeHardware.CooldownPercentUpdater += GenerateCooldownPercentUpdater(i); activeHardware.CooldownDurationUpdater = null; activeHardware.CooldownDurationUpdater += GenerateCooldownDurationUpdater(i); } } }
private IVideoProvider CreateSigleCaptureObject(XmlNode node, HardwareType hw) { if (node == null) { return(null); } XmlNode item = node.SelectSingleNode(hw.ToString()); if (item == null) { return(null); } if (hwLib.ContainsKey(hw) && hwLib[hw] is IVideoProvider) { return((IVideoProvider)hwLib[hw]); } try { IVideoProvider provider = Serialize.XmlDeSerialize(item) as IVideoProvider; return(provider); } catch (Exception ex) { LogHelper.WriteDebugException(ex); return(null); } }
private List <HardwareItemModel> ParseCPU(string[] CPUs, List <ParserRule> cpuRules) { //Задаем тип комплектующего HardwareType type = new HardwareType("Процессор"); //Создаем новый список процессоров List <HardwareItemModel> cpu_list = new List <HardwareItemModel>(); //Создаем список производителей процессоров List <ManufacturerModel> cpu_manufacturers = new List <ManufacturerModel>(); //Заполняем список производителей из правил foreach (ParserRule r in cpuRules) { cpu_manufacturers.Add(new ManufacturerModel(r.Rule_name)); } //Перебираем все строки процессоров из прайса foreach (string s in CPUs) { //Для каждого правила foreach (ParserRule rule in cpuRules) { //Если правило подходит к данной строке, заполняем характеристики if (Regex.IsMatch(s, rule.Rule_name, RegexOptions.IgnoreCase)) { var description = s.SelectDescription(); var cost = s.SelectCost(); var sock = Regex.Match(s, rule.Property_templates["Сокет"]).Value; var cpu_name = Regex.Match(s, string.Format(rule.Property_templates["Name"], Regex.Escape(sock))).Value; var cpu = new HardwareItemModel(cpu_name, cost, description, cpu_manufacturers.Where(m => m.Name == rule.Rule_name).FirstOrDefault(), type); cpu.PropertyList.Add(new CompatibilityPropertyModel("Сокет", sock)); cpu_list.Add(cpu); } } } return(cpu_list); }
private List <HardwareItemModel> ParseMB(string[] MBs, List <ParserRule> mbRules) { List <HardwareItemModel> mb_list = new List <HardwareItemModel>(); List <ManufacturerModel> manufacturers = new List <ManufacturerModel>(); HardwareType motherboard = new HardwareType("Материнская плата"); foreach (ParserRule r in mbRules) { manufacturers.Add(new ManufacturerModel(r.Rule_name)); } foreach (string s in MBs) { foreach (ParserRule r in mbRules) { if (Regex.IsMatch(s, r.Rule_name)) { HardwareItemModel mb = new HardwareItemModel(); var socket = Regex.Match(s, r.Property_templates["Сокет"]).Value; mb.PropertyList.Add(new CompatibilityPropertyModel("Сокет", socket)); mb.Name = Regex.Match(s, r.Property_templates["Name"]).Value; mb.Cost = s.SelectCost(); mb.Description = s.SelectDescription(); mb.Manufacturer = manufacturers.Where(m => m.Name == r.Rule_name).FirstOrDefault(); mb.HardwareType = motherboard; mb_list.Add(mb); } } } return(mb_list); }
private List <HardwareItemModel> ParseHDD(string[] hdds, List <ParserRule> hddRules) { List <HardwareItemModel> hdd_list = new List <HardwareItemModel>(); List <ManufacturerModel> manufacturers = new List <ManufacturerModel>(); HardwareType hd = new HardwareType("Жесткий диск"); foreach (ParserRule r in hddRules) { manufacturers.Add(new ManufacturerModel(r.Rule_name)); } foreach (string s in hdds) { foreach (ParserRule r in hddRules) { if (Regex.IsMatch(s, r.Rule_name)) { HardwareItemModel hdd = new HardwareItemModel(); var prop = Regex.Match(s, r.Property_templates["Тип устройства"], RegexOptions.IgnoreCase).Value; hdd.PropertyList.Add(new CompatibilityPropertyModel("Тип устройства", prop)); prop = Regex.Match(s, r.Property_templates["Разъём"]).Value; hdd.PropertyList.Add(new CompatibilityPropertyModel("Разъём", prop)); prop = Regex.Match(s, r.Property_templates["Объём памяти"], RegexOptions.IgnoreCase).Value; hdd.PropertyList.Add(new CompatibilityPropertyModel("Объём памяти", prop)); hdd.Name = Regex.Match(s, r.Property_templates["Name"]).Value; hdd.Cost = s.SelectCost(); hdd.Description = s.SelectDescription(); hdd.Manufacturer = manufacturers.Where(m => m.Name == r.Rule_name).FirstOrDefault(); hdd.HardwareType = hd; hdd_list.Add(hdd); } } } return(hdd_list); }
private List <HardwareItemModel> ParseGPU(string[] gpus, List <ParserRule> gpuRules) { List <HardwareItemModel> gpu_list = new List <HardwareItemModel>(); List <ManufacturerModel> manufacturers = new List <ManufacturerModel>(); HardwareType videocard = new HardwareType("Видеокарта"); foreach (ParserRule r in gpuRules) { manufacturers.Add(new ManufacturerModel(r.Rule_name)); } foreach (string s in gpus) { foreach (ParserRule r in gpuRules) { if (Regex.IsMatch(s, r.Rule_name)) { HardwareItemModel gpu = new HardwareItemModel(); var prop = Regex.Match(s, r.Property_templates["Объём памяти"], RegexOptions.IgnoreCase).Value; gpu.PropertyList.Add(new CompatibilityPropertyModel("Объём памяти", prop)); gpu.Name = Regex.Match(s, r.Property_templates["Name"], RegexOptions.IgnoreCase).Groups[3].Value; gpu.Description = Regex.Match(s, r.Property_templates["Описание"]).Value; gpu.Cost = s.SelectCost(); gpu.Manufacturer = manufacturers.Where(m => m.Name == r.Rule_name).FirstOrDefault(); gpu.HardwareType = videocard; gpu_list.Add(gpu); } } } return(gpu_list); }
Type GetHardwareType(HardwareType hardwareType) { switch (hardwareType) { case HardwareType.None: return(null); case HardwareType.Parry: return(typeof(ParryHardware)); case HardwareType.Blink: return(typeof(BlinkHardware)); case HardwareType.Nullify: return(typeof(NullifyHardware)); case HardwareType.Fracture: return(typeof(FractureHardware)); case HardwareType.Yank: return(typeof(YankHardware)); default: return(null); } }
private List <HardwareItemModel> ParseMemory(string[] mems, List <ParserRule> memRules) { List <HardwareItemModel> mem_list = new List <HardwareItemModel>(); List <ManufacturerModel> manufacturers = new List <ManufacturerModel>(); HardwareType ram = new HardwareType("Оперативная память"); foreach (ParserRule r in memRules) { manufacturers.Add(new ManufacturerModel(r.Rule_name)); } foreach (string s in mems) { foreach (ParserRule r in memRules) { if (Regex.IsMatch(s, r.Rule_name)) { HardwareItemModel mem = new HardwareItemModel(); var prop = Regex.Match(s, r.Property_templates["Тип памяти"]).Value; mem.PropertyList.Add(new CompatibilityPropertyModel("Тип памяти", prop)); prop = Regex.Match(s, r.Property_templates["Объём памяти"]).Value; mem.PropertyList.Add(new CompatibilityPropertyModel("Объём памяти", prop)); mem.Name = Regex.Match(s, r.Property_templates["Name"]).Value; mem.Cost = s.SelectCost(); mem.Description = Regex.Match(s, r.Property_templates["Description"]).Value; mem.Manufacturer = manufacturers.Where(m => m.Name == r.Rule_name).FirstOrDefault(); mem.HardwareType = ram; mem_list.Add(mem); } } } return(mem_list); }
private void SetDevice(HardwareType device) { CommSettings.HardwareIndex = device; switch (device) { case HardwareType.ELM327: m_log.TraceInfo("Set device to ELM327"); m_obdDevice = new OBDDeviceELM327(m_log); break; case HardwareType.ELM320: m_log.TraceInfo("Set device to ELM320"); m_obdDevice = new OBDDeviceELM320(m_log); break; case HardwareType.ELM322: m_log.TraceInfo("Set device to ELM322"); m_obdDevice = new OBDDeviceELM322(m_log); break; case HardwareType.ELM323: m_log.TraceInfo("Set device to ELM323"); m_obdDevice = new OBDDeviceELM323(m_log); break; default: m_log.TraceInfo("Set device to ELM327"); m_obdDevice = new OBDDeviceELM327(m_log); break; } }
// This helper function retrieve active Dll Major version number // private CANResult DllMajorVersion(HardwareType hType, out int majorVersion) { CANResult Res; String dllVersionStr = ""; // We execute the "DllVersionInfo" function of the PCANLight // using as parameter the Hardware type and a string // variable to get the info like "x.xx" // Res = PCANLight.DllVersionInfo(hType, out dllVersionStr); // We retrieve major version number // spliting versionNumberStr based on "." decimal symbol // String[] versionTabInfo = dllVersionStr.Split('.'); if (versionTabInfo.Length > 0) { Int32.TryParse(versionTabInfo[0].ToString(), out majorVersion); } else { majorVersion = 0; } return(Res); }
public void ApplyPassiveHardware(HardwareType activeHardwareType, IHardware hardware, GameObject subject) { switch (activeHardwareType) { case HardwareType.Parry: ApplyPassiveHardware_Parry(subject); break; case HardwareType.Blink: ApplyPassiveHardware_Blink(hardware as BlinkHardware); break; case HardwareType.Nullify: ApplyPassiveHardware_Nullify(subject); break; case HardwareType.Fracture: Debug.LogError("Trying to apply Fracture pasive effect to Fracture active hardware."); break; case HardwareType.Yank: ApplyPassiveHardware_Yank(subject); break; default: break; } }
public void ApplyPassiveHardware(HardwareType activeHardwareType, IHardware activeHardware, GameObject subject) { switch (activeHardwareType) { case HardwareType.Parry: StartCoroutine(ApplyNullifyToBullet(subject)); break; case HardwareType.Blink: StartCoroutine(ApplyPassiveHardware_Blink(activeHardware, subject)); break; case HardwareType.Nullify: Debug.LogError("Trying to apply Nullify passive effect to Nullify active hardware."); break; case HardwareType.Fracture: StartCoroutine(ApplyNullifyToBullet(subject)); break; case HardwareType.Yank: ApplyPassiveHardware_Yank(subject); break; default: break; } }
void UpdateMomentumPointButtons(MomentumData momentumData) { int availablePoints = momentumData.UnassignedAvailableMomentumPoints; if (availablePoints <= 0) { ToggleMomentumButtons(false); return; } ToggleMomentumButtons(true); HardwareType[] activeHardware = InventoryController.GetEquippedActiveHardware(); for (int i = 0; i < activeHardware.Length; i++) { HardwareType hardwareType = activeHardware[i]; bool isSlotOccupied = hardwareType != HardwareType.None; bool isMaxedOut = false; if (isSlotOccupied) { isMaxedOut = momentumData.HardwareTypeToMomentumMap[hardwareType] >= 5; } assignMomentumButtons[i].interactable = isSlotOccupied && !isMaxedOut; } }
public static string GetName(HardwareType OperationEnum) { switch (OperationEnum) { case HardwareType.Ethernet: return "Ethernet"; default: return "Unknown"; } }
/// <summary> /// Инициализация ARP-пакета. /// </summary> /// <param name = "htype">Канальный уровень (тип).</param> /// <param name = "ptype">Сетевой уровень (тип).</param> /// <param name = "oper">Операция ARP.</param> /// <param name = "sha">Канальный адрес источника.</param> /// <param name = "spa">Сетевой адрес источника.</param> /// <param name = "tha">Канальный адрес назначения.</param> /// <param name = "tpa">Сетевой адрес назначения.</param> /// <exception cref = "ArgumentNullException"><paramref name = "sha" /> является <c>null</c>.</exception> /// <exception cref = "ArgumentNullException"><paramref name = "spa" /> является <c>null</c>.</exception> /// <exception cref = "ArgumentNullException"><paramref name = "tha" /> является <c>null</c>.</exception> /// <exception cref = "ArgumentNullException"><paramref name = "tpa" /> является <c>null</c>.</exception> /// <exception cref = "IncorrectFieldLengthException"><paramref name = "sha" /> имеет недопустимую длину.</exception> /// <exception cref = "IncorrectFieldLengthException"><paramref name = "spa" /> имеет недопустимую длину.</exception> /// <exception cref = "IncorrectFieldLengthException"><paramref name = "tha" /> имеет недопустимую длину.</exception> /// <exception cref = "IncorrectFieldLengthException"><paramref name = "tpa" /> имеет недопустимую длину.</exception> public ARPPacket(HardwareType htype, L3ProtocolType ptype, ARPOperation oper, IArray <byte> sha, IArray <byte> spa, IArray <byte> tha, IArray <byte> tpa) { var hlen = FieldLengthAttribute.GetLength (htype); var plen = FieldLengthAttribute.GetLength (ptype); if (sha == null) throw new ArgumentNullException ("sha"); if (spa == null) throw new ArgumentNullException ("spa"); if (tha == null) throw new ArgumentNullException ("tha"); if (tpa == null) throw new ArgumentNullException ("tpa"); if (sha.Length != hlen) throw new IncorrectFieldLengthException ("SHA", sha.Length, hlen); if (spa.Length != plen) throw new IncorrectFieldLengthException ("SPA", spa.Length, plen); if (tha.Length != hlen) throw new IncorrectFieldLengthException ("THA", sha.Length, hlen); if (tpa.Length != plen) throw new IncorrectFieldLengthException ("TPA", spa.Length, plen); this.Data = new Array <byte> (new byte[8 + sha.Length + spa.Length + tha.Length + tpa.Length]); this.HardwareType = htype; this.ProtocolType = ptype; this.HardwareLength = hlen; this.ProtocolLength = plen; this.Operation = oper; this.SenderHardwareAddress = sha; this.SenderProtocolAddress = spa; this.TargetHardwareAddress = tha; this.TargetProtocolAddress = tpa; }
public Form1() { // // Required for Windows Form Designer support // InitializeComponent(); // We set the variable to know which hardware is // currently selected (none!) // ActiveHardware = (HardwareType)(-1); // Create a list to store the displayed mesasges // LastMsgsList = new ArrayList(); }
public ArpPacket(byte[] bytes) : base(bytes) { _hardwareType = (HardwareType)IPAddress.HostToNetworkOrder(BitConverter.ToInt16(bytes, 14)); _internetProtocol = (InternetProtocol)IPAddress.HostToNetworkOrder(BitConverter.ToInt16(bytes, 16)); _hardwareSize = bytes[18]; _protocolSize = bytes[19]; _opcode = (ArpOpCode)IPAddress.HostToNetworkOrder(BitConverter.ToInt16(bytes, 20)); _senderMac = new PhysicalAddress(ReadBytes(22, _hardwareSize, bytes)); _senderIp = new IPAddress(ReadBytes(22 + _hardwareSize, _protocolSize, bytes)); _targetMac = new PhysicalAddress(ReadBytes(22 + _hardwareSize + _protocolSize, _hardwareSize, bytes)); _targetIp = new IPAddress(ReadBytes(22 + _hardwareSize + _protocolSize + _hardwareSize, _protocolSize, bytes)); }
public Image GetImage(HardwareType hardwareType) { Image image; if (images.TryGetValue(hardwareType, out image)) { return image; } else { switch (hardwareType) { case HardwareType.CPU: image = Utilities.EmbeddedResources.GetImage("cpu.png"); break; case HardwareType.GpuNvidia: image = Utilities.EmbeddedResources.GetImage("nvidia.png"); break; case HardwareType.GpuAti: image = Utilities.EmbeddedResources.GetImage("ati.png"); break; case HardwareType.HDD: image = Utilities.EmbeddedResources.GetImage("hdd.png"); break; case HardwareType.Heatmaster: image = Utilities.EmbeddedResources.GetImage("bigng.png"); break; case HardwareType.Mainboard: image = Utilities.EmbeddedResources.GetImage("mainboard.png"); break; case HardwareType.SuperIO: image = Utilities.EmbeddedResources.GetImage("chip.png"); break; case HardwareType.TBalancer: image = Utilities.EmbeddedResources.GetImage("bigng.png"); break; case HardwareType.RAM: image = Utilities.EmbeddedResources.GetImage("ram.png"); break; case HardwareType.NIC: image = Utilities.EmbeddedResources.GetImage("network.png"); break; default: image = new Bitmap(1, 1); break; } images.Add(hardwareType, image); return image; } }
/// <summary> /// PCANLight Write function /// This function Place a CAN message into the Transmit Queue of the CAN Hardware /// </summary> /// <param name="HWType">In which hardware should be written the CAN Message</param>3 /// <param name="MsgToSend">The TCLightMsg message to be written</param> /// <returns>A CANResult value - Error/status of the hardware after execute the function</returns> public static CANResult Write(HardwareType HWType, TCLightMsg MsgToSend) { PCAN_ISA.TPCANMsg MsgIsa; PCAN_2ISA.TPCANMsg MsgIsa2; PCAN_PCI.TPCANMsg MsgPci; PCAN_2PCI.TPCANMsg MsgPci2; PCAN_PCC.TPCANMsg MsgPcc; PCAN_2PCC.TPCANMsg MsgPcc2; PCAN_USB.TPCANMsg MsgUsb; PCAN_2USB.TPCANMsg MsgUsb2; PCAN_DNP.TPCANMsg MsgDnp; PCAN_DNG.TPCANMsg MsgDng; try { switch (HWType) { case HardwareType.ISA_1CH: MsgIsa = MsgToSend; return (CANResult)PCAN_ISA.Write(ref MsgIsa); case HardwareType.ISA_2CH: MsgIsa2 = MsgToSend; return (CANResult)PCAN_2ISA.Write(ref MsgIsa2); case HardwareType.PCI_1CH: MsgPci = MsgToSend; return (CANResult)PCAN_PCI.Write(ref MsgPci); case HardwareType.PCI_2CH: MsgPci2 = MsgToSend; return (CANResult)PCAN_2PCI.Write(ref MsgPci2); case HardwareType.PCC_1CH: MsgPcc = MsgToSend; return (CANResult)PCAN_PCC.Write(ref MsgPcc); case HardwareType.PCC_2CH: MsgPcc2 = MsgToSend; return (CANResult)PCAN_2PCC.Write(ref MsgPcc2); case HardwareType.USB_1CH: MsgUsb = MsgToSend; return (CANResult)PCAN_USB.Write(ref MsgUsb); case HardwareType.USB_2CH: MsgUsb2 = MsgToSend; return (CANResult)PCAN_2USB.Write(ref MsgUsb2); case HardwareType.DNP: MsgDnp = MsgToSend; return (CANResult)PCAN_DNP.Write(ref MsgDnp); case HardwareType.DNG: MsgDng = MsgToSend; return (CANResult)PCAN_DNG.Write(ref MsgDng); // Hardware is not valid for this function // default: return CANResult.ERR_ILLHW; } } catch (Exception Ex) { // Error: Dll does not exists or the function is not available // Tracer.WriteError(TraceGroup.CANBUS, null, "Write {0}", Ex.Message + "\""); return CANResult.ERR_NO_DLL; } }
/// <summary>Resets the emulated system and emulate a specific hardware.</summary> /// <remarks>In order to chaneg the emulated hardware, the emulation has to be reset.</remarks> /// <param name="hardwareType">Hardware to emulate.</param> public void Reset(HardwareType hardwareType) { // From now on, the hardware type can only be changed after a "hard" reset of the emulated machine HardwareType = hardwareType; #if WITH_THREADING SuspendEmulation(); #endif ResetThreading(); ResetBootRom(); ResetProcessor(); ResetTiming(); ResetTimer(); ResetInterrupt(); ResetMemory(); ResetRom(); ResetAudio(); ResetVideo(); ResetSuperGameBoy(); ResetJoypad(); ResetPorts(); ResetRendering(); ResetDebug(); ResetSnapshot(); #if WITH_THREADING ResumeEmulation(); #endif }
float AvgTemp(Computer computer, HardwareType type) { var gpus = computer.Hardware.Where(x => x.HardwareType == type).ToArray(); if (gpus.Any()) { int n = 0; float t = 0; foreach (var gpu in gpus) { var temps = gpu.Sensors.Where(x => x.SensorType == SensorType.Temperature).ToArray(); if (temps.Any()) { var temp = temps.Average(x => x.Value.Value); t += temp; n++; } foreach (var sh in gpu.SubHardware) { temps = sh.Sensors.Where(x => x.SensorType == SensorType.Temperature).ToArray(); if (temps.Any()) { var temp = temps.Average(x => x.Value.Value); t += temp; n++; } } } if (n > 0) return t / (float)n; else return 0; } else return 0; }
public DhcpMessage(byte[] data) { var offset = 0; _mOperation = (DhcpOperation) data[offset++]; _mHardware = (HardwareType) data[offset++]; HardwareAddressLength = data[offset++]; Hops = data[offset++]; SessionId = BitConverter.ToInt32(data, offset); offset += 4; var secondsElapsed = new byte[2]; Array.Copy(data, offset, secondsElapsed, 0, 2); SecondsElapsed = BitConverter.ToUInt16(ReverseByteOrder(secondsElapsed), 0); offset += 2; Flags = BitConverter.ToUInt16(data, offset); offset += 2; Array.Copy(data, offset, _mClientAddress, 0, 4); offset += 4; Array.Copy(data, offset, _mAssignedAddress, 0, 4); offset += 4; Array.Copy(data, offset, _mNextServerAddress, 0, 4); offset += 4; Array.Copy(data, offset, _mRelayAgentAddress, 0, 4); offset += 4; Array.Copy(data, offset, _mClientHardwareAddress, 0, 16); offset += 16; Array.Copy(data, offset, _mServerHostName, 0, 64); offset += 64; Array.Copy(data, offset, _mBootFileName, 0, 128); offset += 128; //Array.Copy(data, offset, this.m_VendorSpecificInformation, 0, 64); //offset += 64; //offset += 192; // Skip server host name and boot file if (offset + 4 < data.Length && (BitConverter.ToUInt32(data, offset) == DhcpOptionsMagicNumber || BitConverter.ToUInt32(data, offset) == WinDhcpOptionsMagicNumber)) { offset += 4; var end = false; while (!end && offset < data.Length) { var option = (DhcpOption) data[offset]; offset++; int optionLen; switch (option) { case DhcpOption.Pad: continue; case DhcpOption.End: end = true; continue; default: optionLen = data[offset]; offset++; break; } var optionData = new byte[optionLen]; Array.Copy(data, offset, optionData, 0, optionLen); offset += optionLen; _mOptions.Add(option, optionData); _mOptionDataSize += optionLen; } } }
float MaxTemp(Computer computer, HardwareType type) { var gpus = computer.Hardware.Where(x => x.HardwareType == type).ToArray(); if (gpus.Any()) { float t = 0; foreach (var gpu in gpus) { var temps = gpu.Sensors.Where(x => x.SensorType == SensorType.Temperature).ToArray(); if (temps.Any()) { var temp = temps.Max(x => x.Value.Value); t = Math.Max(temp, t); } foreach (var sh in gpu.SubHardware) { temps = sh.Sensors.Where(x => x.SensorType == SensorType.Temperature).ToArray(); if (temps.Any()) { var temp = temps.Max(x => x.Value.Value); t = Math.Max(temp, t); } } } return t; } else return 0; }
private IHardware[] GetHardware(HardwareType type) { return this.computer.Hardware.Where(x => x.HardwareType == type).ToArray(); }
/// <summary> /// /// </summary> /// <param name="hardwareType"></param> /// <param name="changedHardware"></param> /// <param name="changedType"></param> public void HardwareChanged(HardwareType hardwareType, object changedHardware, HardwareChangedType changedType) { //HardwareBuilderBase build = CommuniSoftFactory.HardwareBuilder; DBHardwareBuilderBase build = CommuniSoftFactory.HardwareBuilder as DBHardwareBuilderBase; Debug.Assert(build != null, "CommuniSoftFactory.HardwareBuilder is not DBHardwareBuilderBase"); if (hardwareType == HardwareType.Station) { Station station = changedHardware as Station; switch (changedType) { case HardwareChangedType.Add: build.AddStation(station); break; case HardwareChangedType.Edit : build.EditStation(station); break; case HardwareChangedType.Delete : // TODO: delete station // break; } } else if (hardwareType == HardwareType.Device) { Device device = changedHardware as Device; switch (changedType) { case HardwareChangedType.Add: build.AddDevice(device); break; case HardwareChangedType.Edit: build.EditDevice(device); break; case HardwareChangedType.Delete: // TODO: delete device // break; } } HardwareChangedEventArgs e = new HardwareChangedEventArgs(); e.HardwareType = hardwareType; e.ChangedHardware = changedHardware; e.ChangedType = changedType; OnHardwareChanged(e); }
/// <summary> /// PCANLight Read function /// This function get the next message or the next error from the Receive Queue of /// the CAN Hardware. /// REMARK: /// - Check always the type of the received Message (MSGTYPE_STANDARD,MSGTYPE_RTR, /// MSGTYPE_EXTENDED,MSGTYPE_STATUS) /// - The function will return ERR_OK always that you receive a CAN message successfully /// although if the messages is a MSGTYPE_STATUS message. /// - When a MSGTYPE_STATUS mesasge is got, the ID and Length information of the message /// will be treated as indefined values. Actually information of the received message /// should be interpreted using the first 4 data bytes as follow: /// * Data0 Data1 Data2 Data3 Kind of Error /// 0x00 0x00 0x00 0x02 CAN_ERR_OVERRUN 0x0002 CAN Controller was read to late /// 0x00 0x00 0x00 0x04 CAN_ERR_BUSLIGHT 0x0004 Bus Error: An error counter limit reached (96) /// 0x00 0x00 0x00 0x08 CAN_ERR_BUSHEAVY 0x0008 Bus Error: An error counter limit reached (128) /// 0x00 0x00 0x00 0x10 CAN_ERR_BUSOFF 0x0010 Bus Error: Can Controller went "Bus-Off" /// - If a CAN_ERR_BUSOFF status message is received, the CAN Controller must to be /// initialized again using the Init() function. Otherwise, will be not possible /// to send/receive more messages. /// </summary> /// <param name="HWType">From which hardware should be read a CAN Message</param> /// <param name="Msg">The TCLightMsg structure to store the CAN message</param> /// <returns>A CANResult value - Error/status of the hardware after execute the function</returns> public static CANResult Read(HardwareType HWType, out TCLightMsg Msg) { PCAN_ISA.TPCANMsg MsgIsa; PCAN_2ISA.TPCANMsg MsgIsa2; PCAN_PCI.TPCANMsg MsgPci; PCAN_2PCI.TPCANMsg MsgPci2; PCAN_PCC.TPCANMsg MsgPcc; PCAN_2PCC.TPCANMsg MsgPcc2; PCAN_USB.TPCANMsg MsgUsb; PCAN_2USB.TPCANMsg MsgUsb2; PCAN_DNP.TPCANMsg MsgDnp; PCAN_DNG.TPCANMsg MsgDng; CANResult resTemp; Msg = null; try { switch (HWType) { case HardwareType.ISA_1CH: resTemp = (CANResult)PCAN_ISA.Read(out MsgIsa); Msg = new TCLightMsg(MsgIsa); return resTemp; case HardwareType.ISA_2CH: resTemp = (CANResult)PCAN_2ISA.Read(out MsgIsa2); Msg = new TCLightMsg(MsgIsa2); return resTemp; case HardwareType.PCI_1CH: MsgPci = new PCAN_PCI.TPCANMsg(); MsgPci.DATA = new byte[8]; resTemp = (CANResult)PCAN_PCI.Read(out MsgPci); Msg = new TCLightMsg(MsgPci); return resTemp; case HardwareType.PCI_2CH: resTemp = (CANResult)PCAN_2PCI.Read(out MsgPci2); Msg = new TCLightMsg(MsgPci2); return resTemp; case HardwareType.PCC_1CH: resTemp = (CANResult)PCAN_PCC.Read(out MsgPcc); Msg = new TCLightMsg(MsgPcc); return resTemp; case HardwareType.PCC_2CH: resTemp = (CANResult)PCAN_2PCC.Read(out MsgPcc2); Msg = new TCLightMsg(MsgPcc2); return resTemp; case HardwareType.USB_1CH: resTemp = (CANResult)PCAN_USB.Read(out MsgUsb); Msg = new TCLightMsg(MsgUsb); return resTemp; case HardwareType.USB_2CH: resTemp = (CANResult)PCAN_2USB.Read(out MsgUsb2); Msg = new TCLightMsg(MsgUsb2); return resTemp; case HardwareType.DNP: resTemp = (CANResult)PCAN_DNP.Read(out MsgDnp); Msg = new TCLightMsg(MsgDnp); return resTemp; case HardwareType.DNG: resTemp = (CANResult)PCAN_DNG.Read(out MsgDng); Msg = new TCLightMsg(MsgDng); return resTemp; // Hardware is not valid for this function // default: return CANResult.ERR_ILLHW; } } catch (Exception Ex) { // Error: Dll does not exists or the function is not available // Tracer.WriteError(TraceGroup.CANBUS, null, "Read {0}", Ex.Message + "\""); return CANResult.ERR_NO_DLL; } }
/// <summary> /// Refresh sensors of a hardware device /// </summary> /// <param name="hardwareType">The HardwareType of the desired device</param> /// <param name="hardwareInstance">The instance number of the desired device</param> public static void RefreshSensors(HardwareType hardwareType, int hardwareInstance) { // First make sure HDD checking is enabled if (hardwareType == HardwareType.HDD && !ComputerSensors.HDDEnabled) { ComputerSensors.HDDEnabled = true; } foreach (IHardware hardwareElement in ComputerSensors.Hardware) { if (hardwareElement.HardwareType == hardwareType) { if (hardwareElement.Identifier.ToString().EndsWith(hardwareInstance.ToString())) { hardwareElement.Update(); } } } }
/// <summary> /// PCANLight DllVersionInfo function /// This function get the Version information of the used PCAN-Light DLL. (max. 255 characters) /// </summary> /// <param name="HWType">Which DLL (Hardware implementation) should be asked for its /// Version information</param> /// <param name="strInfo">String buffer to return the DLL information</param> /// <returns>A CANResult value generated after execute the function</returns> public static CANResult DllVersionInfo(HardwareType HWType, out string strInfo) { StringBuilder stbTemp; CANResult resTemp; strInfo = ""; try { stbTemp = new StringBuilder(256); switch (HWType) { case HardwareType.ISA_1CH: resTemp = (CANResult)PCAN_ISA.DLLVersionInfo(stbTemp); break; case HardwareType.ISA_2CH: resTemp = (CANResult)PCAN_2ISA.DLLVersionInfo(stbTemp); break; case HardwareType.PCI_1CH: resTemp = (CANResult)PCAN_PCI.DLLVersionInfo(stbTemp); break; case HardwareType.PCI_2CH: resTemp = (CANResult)PCAN_2PCI.DLLVersionInfo(stbTemp); break; case HardwareType.PCC_1CH: resTemp = (CANResult)PCAN_PCC.DLLVersionInfo(stbTemp); break; case HardwareType.PCC_2CH: resTemp = (CANResult)PCAN_2PCC.DLLVersionInfo(stbTemp); break; case HardwareType.USB_1CH: resTemp = (CANResult)PCAN_USB.DLLVersionInfo(stbTemp); break; case HardwareType.USB_2CH: resTemp = (CANResult)PCAN_2USB.DLLVersionInfo(stbTemp); break; case HardwareType.DNP: resTemp = (CANResult)PCAN_DNP.DLLVersionInfo(stbTemp); break; case HardwareType.DNG: resTemp = (CANResult)PCAN_DNG.DLLVersionInfo(stbTemp); break; // Hardware is not valid for this function // default: stbTemp = new StringBuilder(""); resTemp = CANResult.ERR_ILLHW; break; } strInfo = stbTemp.ToString(); return resTemp; } catch (EntryPointNotFoundException Ex) { // Function is not available in the loaded Dll // Tracer.WriteError(TraceGroup.CANBUS, null, "DllVersionInfo wrong version {0}", Ex.Message + "\""); return CANResult.ERR_NO_DLL; } catch (Exception Ex) { // Error: Dll does not exists or the function is not available // Tracer.WriteError(TraceGroup.CANBUS, null, "DllVersionInfo {0}", Ex.Message + "\""); return CANResult.ERR_NO_DLL; } }
private void btnInit_Click(object sender, System.EventArgs e) { CANResult Res; int majorVersion = 0; // Check version 2.x Dll is available // Res = DllMajorVersion((HardwareType)cbbHws.SelectedIndex, out majorVersion); if (Res == CANResult.ERR_OK) { // Sample must ONLY work if a 2.x or later version of the // PCAN-Light is installed // if (majorVersion < 2) { MessageBox.Show("DLL 2.x or later are required to run this program" + "\r\nPlease, download lastest DLL version on http://www.peak-system.com or refer to the documentation for more information.", "DLL Version", MessageBoxButtons.OK, MessageBoxIcon.Error); } else { // According with the active parameters/hardware, we // use one of the two possible "Init" PCANLight functions. // One is for Plug And Play hardware, and the other for // Not P&P. // if (cbbIO.Enabled) // Not P&P Hardware // Res = PCANLight.Init((HardwareType)cbbHws.SelectedIndex, (Baudrates)cbbBaudrates.Tag, (FramesType)cbbMsgType.SelectedIndex, Convert.ToUInt32(cbbIO.Text, 16), Convert.ToByte(cbbInterrupt.Text)); else // P&P Hardware // Res = PCANLight.Init((HardwareType)cbbHws.SelectedIndex, (Baudrates)cbbBaudrates.Tag, (FramesType)cbbMsgType.SelectedIndex); // The Hardware was successfully initiated // if (Res == CANResult.ERR_OK) { // We save the hardware type which is currently // initiated // ActiveHardware = (HardwareType)cbbHws.SelectedIndex; // We start to read from the CAN Queue // tmrRead.Enabled = true; // Set UI enable btnInit.Enabled = !(btnWrite.Enabled = btnSetFilter.Enabled = btnResetFilter.Enabled = btnRelease.Enabled = btnInfo.Enabled = btnDllInfo.Enabled = true); rdbTimer.Enabled = true; rdbEvent.Enabled = true; chbTimeStamp.Enabled = true; cbbHws_SelectedIndexChanged(this, new EventArgs()); // We show the information of the configured // and initiated hardware // txtInfo.Text = "Active Hardware: " + cbbHws.Text; txtInfo.Text += "\r\nBaud Rate: " + cbbBaudrates.Text; txtInfo.Text += "\r\nFrame Type: " + cbbMsgType.Text; // If was a no P&P Hardware, we show additional information // if (cbbIO.Enabled) { txtInfo.Text += "\r\nI/O Addr.: " + cbbIO.Text + "h"; txtInfo.Text += "\r\nInterrupt: " + cbbInterrupt.Text; } } // An error occurred. We show the error. // else txtInfo.Text = "Error: " + Res.ToString(); } } else txtInfo.Text = "Error: " + Res.ToString(); }
/// <summary> /// PCANLight ReadEx function /// This function get the next message or the next error from the Receive Queue of /// the CAN Hardware and the time when the message arrived. /// REMARK: /// - Check always the type of the received Message (MSGTYPE_STANDARD,MSGTYPE_RTR, /// MSGTYPE_EXTENDED,MSGTYPE_STATUS) /// - The function will return ERR_OK always that you receive a CAN message successfully /// although if the messages is a MSGTYPE_STATUS message. /// - When a MSGTYPE_STATUS mesasge is got, the ID and Length information of the message /// will be treated as indefined values. Actually information of the received message /// should be interpreted using the first 4 data bytes as follow: /// * Data0 Data1 Data2 Data3 Kind of Error /// 0x00 0x00 0x00 0x02 CAN_ERR_OVERRUN 0x0002 CAN Controller was read to late /// 0x00 0x00 0x00 0x04 CAN_ERR_BUSLIGHT 0x0004 Bus Error: An error counter limit reached (96) /// 0x00 0x00 0x00 0x08 CAN_ERR_BUSHEAVY 0x0008 Bus Error: An error counter limit reached (128) /// 0x00 0x00 0x00 0x10 CAN_ERR_BUSOFF 0x0010 Bus Error: Can Controller went "Bus-Off" /// - If a CAN_ERR_BUSOFF status message is received, the CAN Controller must to be /// initialized again using the Init() function. Otherwise, will be not possible /// to send/receive more messages. /// </summary> /// <param name="HWType">From which hardware should be read a CAN Message</param> /// <param name="Msg">The TCLightMsg structure to store the CAN message</param> /// <param name="RcvTime">The TCLightTimestamp structure to store the timestamp of the CAN message</param> /// <returns>A CANResult value - Error/status of the hardware after execute the function</returns> public static CANResult ReadEx(HardwareType HWType, out TCLightMsg Msg, out TCLightTimestamp RcvTime) { PCAN_ISA.TPCANMsg MsgIsa; PCAN_2ISA.TPCANMsg MsgIsa2; PCAN_PCI.TPCANMsg MsgPci; PCAN_2PCI.TPCANMsg MsgPci2; PCAN_PCC.TPCANMsg MsgPcc; PCAN_2PCC.TPCANMsg MsgPcc2; PCAN_USB.TPCANMsg MsgUsb; PCAN_2USB.TPCANMsg MsgUsb2; PCAN_DNP.TPCANMsg MsgDnp; PCAN_DNG.TPCANMsg MsgDng; PCAN_ISA.TPCANTimestamp RcvTimeIsa; PCAN_2ISA.TPCANTimestamp RcvTimeIsa2; PCAN_PCI.TPCANTimestamp RcvTimePci; PCAN_2PCI.TPCANTimestamp RcvTimePci2; PCAN_PCC.TPCANTimestamp RcvTimePcc; PCAN_2PCC.TPCANTimestamp RcvTimePcc2; PCAN_USB.TPCANTimestamp RcvTimeUsb; PCAN_2USB.TPCANTimestamp RcvTimeUsb2; PCAN_DNP.TPCANTimestamp RcvTimeDnp; PCAN_DNG.TPCANTimestamp RcvTimeDng; CANResult resTemp; Msg = null; RcvTime = null; try { switch (HWType) { case HardwareType.ISA_1CH: resTemp = (CANResult)PCAN_ISA.ReadEx(out MsgIsa, out RcvTimeIsa); Msg = new TCLightMsg(MsgIsa); RcvTime = new TCLightTimestamp(RcvTimeIsa); return resTemp; case HardwareType.ISA_2CH: resTemp = (CANResult)PCAN_2ISA.ReadEx(out MsgIsa2, out RcvTimeIsa2); Msg = new TCLightMsg(MsgIsa2); RcvTime = new TCLightTimestamp(RcvTimeIsa2); return resTemp; case HardwareType.PCI_1CH: resTemp = (CANResult)PCAN_PCI.ReadEx(out MsgPci, out RcvTimePci); Msg = new TCLightMsg(MsgPci); RcvTime = new TCLightTimestamp(RcvTimePci); return resTemp; case HardwareType.PCI_2CH: resTemp = (CANResult)PCAN_2PCI.ReadEx(out MsgPci2, out RcvTimePci2); Msg = new TCLightMsg(MsgPci2); RcvTime = new TCLightTimestamp(RcvTimePci2); return resTemp; case HardwareType.PCC_1CH: resTemp = (CANResult)PCAN_PCC.ReadEx(out MsgPcc, out RcvTimePcc); Msg = new TCLightMsg(MsgPcc); RcvTime = new TCLightTimestamp(RcvTimePcc); return resTemp; case HardwareType.PCC_2CH: resTemp = (CANResult)PCAN_2PCC.ReadEx(out MsgPcc2, out RcvTimePcc2); Msg = new TCLightMsg(MsgPcc2); RcvTime = new TCLightTimestamp(RcvTimePcc2); return resTemp; case HardwareType.USB_1CH: resTemp = (CANResult)PCAN_USB.ReadEx(out MsgUsb, out RcvTimeUsb); Msg = new TCLightMsg(MsgUsb); RcvTime = new TCLightTimestamp(RcvTimeUsb); return resTemp; case HardwareType.USB_2CH: resTemp = (CANResult)PCAN_2USB.ReadEx(out MsgUsb2, out RcvTimeUsb2); Msg = new TCLightMsg(MsgUsb2); RcvTime = new TCLightTimestamp(RcvTimeUsb2); return resTemp; case HardwareType.DNP: resTemp = (CANResult)PCAN_DNP.ReadEx(out MsgDnp, out RcvTimeDnp); Msg = new TCLightMsg(MsgDnp); RcvTime = new TCLightTimestamp(RcvTimeDnp); return resTemp; case HardwareType.DNG: resTemp = (CANResult)PCAN_DNG.ReadEx(out MsgDng, out RcvTimeDng); Msg = new TCLightMsg(MsgDng); RcvTime = new TCLightTimestamp(RcvTimeDng); return resTemp; // Hardware is not valid for this function // default: return CANResult.ERR_ILLHW; } } catch (EntryPointNotFoundException Ex) { // Function is not available in the loaded Dll // Tracer.WriteError(TraceGroup.CANBUS, null, "ReadEx wrong version {0}", Ex.Message + "\""); return CANResult.ERR_NO_DLL; } catch (Exception Ex) { // Error: Dll does not exists or the function is not available // Tracer.WriteError(TraceGroup.CANBUS, null, "ReadEx {0}", Ex.Message + "\""); return CANResult.ERR_NO_DLL; } }
/// <summary> /// PCANLight SetRcvEvent function /// This function read the device number of a USB CAN Hardware /// </summary> /// <param name="HWType">Hardware that will set the Event</param> /// <param name="EventHandle">The handle (ID) of the event to be set</param> /// <returns>A CANResult value - Error/status of the hardware after execute the function</returns> public static CANResult SetRcvEvent(HardwareType HWType, System.Threading.EventWaitHandle EventHandle) { IntPtr hHandle; try { // If the Event parameter is null, a value of IntPtr.Zero is set in order to clear the // Event on the driver. Otherwise we get the internal Handle value representing // the Receive-Event // hHandle = (EventHandle == null) ? IntPtr.Zero : EventHandle.SafeWaitHandle.DangerousGetHandle(); switch (HWType) { case HardwareType.ISA_1CH: return (CANResult)PCAN_ISA.SetRcvEvent(hHandle); case HardwareType.ISA_2CH: return (CANResult)PCAN_2ISA.SetRcvEvent(hHandle); case HardwareType.PCI_1CH: return (CANResult)PCAN_PCI.SetRcvEvent(hHandle); case HardwareType.PCI_2CH: return (CANResult)PCAN_2PCI.SetRcvEvent(hHandle); case HardwareType.PCC_1CH: return (CANResult)PCAN_PCC.SetRcvEvent(hHandle); case HardwareType.PCC_2CH: return (CANResult)PCAN_2PCC.SetRcvEvent(hHandle); case HardwareType.USB_1CH: return (CANResult)PCAN_USB.SetRcvEvent(hHandle); case HardwareType.USB_2CH: return (CANResult)PCAN_2USB.SetRcvEvent(hHandle); case HardwareType.DNP: return (CANResult)PCAN_DNP.SetRcvEvent(hHandle); case HardwareType.DNG: return (CANResult)PCAN_DNG.SetRcvEvent(hHandle); // Hardware is not valid for this function // default: return CANResult.ERR_ILLHW; } } catch (EntryPointNotFoundException Ex) { // Function is not available in the loaded Dll // Tracer.WriteError(TraceGroup.CANBUS, null, "SetRcvEvent wrong version {0}", Ex.Message + "\""); return CANResult.ERR_NO_DLL; } catch (Exception Ex) { // Error: Dll does not exists or the function is not available // Tracer.WriteError(TraceGroup.CANBUS, null, "SetRcvEvent {0}", Ex.Message + "\""); return CANResult.ERR_NO_DLL; } }
/// <summary> /// PCANLight GetUSBDeviceNr function /// This function read the device number of a USB CAN Hardware /// </summary> /// <param name="HWType">Hardware to get the Device Number</param> /// <param name="DeviceNumber">Variable to return the Device Number value</param> /// <returns>A CANResult value - Error/status of the hardware after execute the function</returns> public static CANResult GetUSBDeviceNr(HardwareType HWType, out uint DeviceNumber) { DeviceNumber = uint.MaxValue; try { switch (HWType) { case HardwareType.USB_1CH: return (CANResult)PCAN_USB.GetUSBDeviceNr(out DeviceNumber); case HardwareType.USB_2CH: return (CANResult)PCAN_2USB.GetUSBDeviceNr(out DeviceNumber); // Hardware is not valid for this function // default: return CANResult.ERR_ILLHW; } } catch (Exception Ex) { // Error: Dll does not exists or the function is not available // Tracer.WriteError(TraceGroup.CANBUS, null, "GetUSBDeviceNr {0}", Ex.Message + "\""); return CANResult.ERR_NO_DLL; } }
/// <summary> /// PCANLight Init function for Plug and Play Hardware. /// This function make the following: /// - Activate a Hardware /// - Make a Register Test of 82C200/SJA1000 /// - Allocate a Send buffer and a Hardware handle /// - Programs the configuration of the transmit/receive driver /// - Set the Baudrate register /// - Set the Controller in RESET condition /// </summary> /// <param name="HWType">Which hardware should be initialized</param> /// <param name="BTR0BTR1">BTR0-BTR1 baudrate register</param> /// <param name="MsgType">f the frame type is standard or extended</param> /// <returns>A CANResult value - Error/status of the hardware after execute the function</returns> public static CANResult Init(HardwareType HWType, Baudrates BTR0BTR1, FramesType MsgType) { try { switch (HWType) { case HardwareType.PCI_1CH: return (CANResult)PCAN_PCI.Init((ushort)BTR0BTR1, (int)MsgType); case HardwareType.PCI_2CH: return (CANResult)PCAN_2PCI.Init((ushort)BTR0BTR1, (int)MsgType); case HardwareType.PCC_1CH: return (CANResult)PCAN_PCC.Init((ushort)BTR0BTR1, (int)MsgType); case HardwareType.PCC_2CH: return (CANResult)PCAN_2PCC.Init((ushort)BTR0BTR1, (int)MsgType); case HardwareType.USB_1CH: return (CANResult)PCAN_USB.Init((ushort)BTR0BTR1, (int)MsgType); case HardwareType.USB_2CH: return (CANResult)PCAN_2USB.Init((ushort)BTR0BTR1, (int)MsgType); // Hardware is not valid for this function // default: return CANResult.ERR_ILLHW; } } catch (Exception Ex) { // Error: Dll does not exists or the function is not available // Tracer.WriteError(TraceGroup.CANBUS, null, "Init {0}", Ex.Message + "\""); return CANResult.ERR_NO_DLL; } }
/// <summary> /// PCANLight Init function for non Plug and Play Hardware. /// This function make the following: /// - Activate a Hardware /// - Make a Register Test of 82C200/SJA1000 /// - Allocate a Send buffer and a Hardware handle /// - Programs the configuration of the transmit/receive driver /// - Set the Baudrate register /// - Set the Controller in RESET condition /// </summary> /// <param name="HWType">Which hardware should be initialized</param> /// <param name="BTR0BTR1">BTR0-BTR1 baudrate register</param> /// <param name="MsgType">If the frame type is standard or extended</param> /// <param name="IO_Port">Input/output Port Address of the hardware</param> /// <param name="Interrupt">Interrupt number</param> /// <returns>A CANResult value - Error/status of the hardware after execute the function</returns> public static CANResult Init(HardwareType HWType, Baudrates BTR0BTR1, FramesType MsgType, uint IO_Port, ushort Interrupt) { try { switch (HWType) { case HardwareType.ISA_1CH: return (CANResult)PCAN_ISA.Init((ushort)BTR0BTR1, (int)MsgType, (int)Hardware.HW_ISA_SJA, IO_Port, Interrupt); case HardwareType.ISA_2CH: return (CANResult)PCAN_2ISA.Init((ushort)BTR0BTR1, (int)MsgType, (int)Hardware.HW_ISA_SJA, IO_Port, Interrupt); case HardwareType.DNG: return (CANResult)PCAN_DNG.Init((ushort)BTR0BTR1, (int)MsgType, (int)Hardware.HW_DONGLE_SJA, IO_Port, Interrupt); case HardwareType.DNP: return (CANResult)PCAN_DNP.Init((ushort)BTR0BTR1, (int)MsgType, (int)Hardware.HW_DONGLE_PRO, IO_Port, Interrupt); // Hardware is not valid for this function // default: return CANResult.ERR_ILLHW; } } catch (Exception Ex) { // Error: Dll does not exists or the function is not available // Tracer.WriteError(TraceGroup.CANBUS, null, "ppInit {0}", Ex.Message + "\""); return CANResult.ERR_NO_DLL; } }
/// <summary>Tries to load the specified bootsrap ROM from assembly resources.</summary> /// <remarks> /// The various known bootstrap ROMs can be embedded in the executable image during compilation. /// By default, the emulator will look for resources with these names: /// <list type="table"> /// <listheader> /// <term>Hardware</term> /// <description>Bootstrap ROM file name</description> /// </listheader> /// <item> /// <term>Game Boy</term> /// <description>dmg.rom</description> /// </item> /// <item> /// <term>Super Game Boy</term> /// <description>sgb.rom</description> /// </item> /// <item> /// <term>Game Boy Color</term> /// <description>cgb.rom</description> /// </item> /// </list> /// Embedding these ROMs post-build should be possible with the help of an external tool, /// but the easiest solution is probably to rebuild everything after having put the ROMs in the correct place. /// </remarks> /// <param name="hardwareType">Hardware whose bootstrap ROM should be loaded.</param> /// <param name="resourceName">Name of the resource which contain the ROM data.</param> private void TryLoadingRom(HardwareType hardwareType, string resourceName) { var stream = typeof(GameBoyMemoryBus).Assembly.GetManifestResourceStream(typeof(GameBoyMemoryBus), resourceName); if (stream == null) return; try { byte[] buffer = new byte[stream.Length]; if (stream.Read(buffer, 0, buffer.Length) == buffer.Length) LoadBootRom(hardwareType, buffer); } finally { stream.Close(); } }
/// <summary> /// PCANLight Close function. /// This function terminate and release all resources and the configured hardware: /// </summary> /// <param name="HWType">Which hardware should be finished</param> /// <returns>A CANResult value - Error/status of the hardware after execute the function</returns> public static CANResult Close(HardwareType HWType) { try { switch (HWType) { case HardwareType.ISA_1CH: return (CANResult)PCAN_ISA.Close(); case HardwareType.ISA_2CH: return (CANResult)PCAN_2ISA.Close(); case HardwareType.PCI_1CH: return (CANResult)PCAN_PCI.Close(); case HardwareType.PCI_2CH: return (CANResult)PCAN_2PCI.Close(); case HardwareType.PCC_1CH: return (CANResult)PCAN_PCC.Close(); case HardwareType.PCC_2CH: return (CANResult)PCAN_2PCC.Close(); case HardwareType.USB_1CH: return (CANResult)PCAN_USB.Close(); case HardwareType.USB_2CH: return (CANResult)PCAN_2USB.Close(); case HardwareType.DNP: return (CANResult)PCAN_DNP.Close(); case HardwareType.DNG: return (CANResult)PCAN_DNG.Close(); // Hardware is not valid for this function // default: return CANResult.ERR_ILLHW; } } catch (Exception Ex) { // Error: Dll does not exists or the function is not available // Tracer.WriteError(TraceGroup.CANBUS, null, "Close {0}", Ex.Message + "\""); return CANResult.ERR_NO_DLL; } }
/// <summary>Loads a bootstrap ROM with the specified data.</summary> /// <remarks>Data integrity will be checked to ensure a correct bootstrap ROM gets loaded.</remarks> /// <param name="hardwareType">Hardware whose bootstrap ROM should be loaded.</param> /// <param name="data">Data of the specified bootstrap ROM.</param> /// <exception cref="ArgumentOutOfRangeException">The value provided for harware type is not a valid one.</exception> /// <exception cref="NotSupportedException">Loading the bootstrap ROM the specified hardware is not supported.</exception> /// <exception cref="InvalidDataException">Data integrity check failed.</exception> public unsafe void LoadBootRom(HardwareType hardwareType, byte[] data) { if (data == null) throw new ArgumentNullException(); if (!Enum.IsDefined(typeof(HardwareType), hardwareType)) throw new ArgumentOutOfRangeException(); byte[] referenceHash; int requestedLength; byte* destination; // I finally found a use for C# undocumented keywords… Yeah ! // (There are other ways to do this if really needed, but in fact it feels kinda cleaner to use this rather than another switch statement here…) TypedReference romLoadedField; switch (hardwareType) { case HardwareType.GameBoy: requestedLength = 0x100; referenceHash = dmgRomHash; destination = dmgBootMemory; romLoadedField = __makeref(dmgBootRomLoaded); break; case HardwareType.SuperGameBoy: requestedLength = 0x100; referenceHash = sgbRomHash; destination = sgbBootMemory; romLoadedField = __makeref(sgbBootRomLoaded); break; case HardwareType.GameBoyColor: // Trim the GBC rom if needed (we don't need the "decorative" empty sapce) if (data.Length == 0x900) { byte[] tempData = new byte[0x800]; Buffer.BlockCopy(data, 0, tempData, 0, 0x100); Buffer.BlockCopy(data, 0x200, tempData, 0x100, 0x700); data = tempData; } requestedLength = 0x800; referenceHash = cgbRomHash; destination = cgbBootMemory; romLoadedField = __makeref(cgbBootRomLoaded); break; default: throw new NotSupportedException(); } var md5 = MD5.Create(); if (data.Length != requestedLength || !Equals(md5.ComputeHash(data), referenceHash)) throw new InvalidDataException(); fixed (byte* dataPointer = data) MemoryBlock.Copy((void*)destination, (void*)dataPointer, requestedLength); __refvalue(romLoadedField, bool) = true; }
private void cboHardwareType_SelectedIndexChanged(object sender, EventArgs e) { _HardwareType = (HardwareType)cboHardwareType.SelectedItem; }
/// <summary>Determines whether the bootstrap ROM for the specified hardware has been loaded.</summary> /// <param name="hardwareType">Type of hardware.</param> /// <returns><c>true</c> if the bootstrap ROM for the specified hardware has been loaded; otherwise, <c>false</c>.</returns> public bool IsBootRomLoaded(HardwareType hardwareType) { switch (hardwareType) { case HardwareType.GameBoy: return dmgBootRomLoaded; case HardwareType.SuperGameBoy: return sgbBootRomLoaded; case HardwareType.GameBoyColor: return cgbBootRomLoaded; default: return false; } }
private void btnRelease_Click(object sender, System.EventArgs e) { CANResult Res; // We choose Timer method by default // rdbTimer.Checked = true; // We stopt to read from tehe CAN Queue // tmrRead.Enabled = false; // We close the active hardware using the // "Close" function of the PCANLight using // as parameter the Hardware type. // Res = PCANLight.Close(ActiveHardware); // The Hardware was successfully closed // if(Res == CANResult.ERR_OK) txtInfo.Text = "Hardware was successfully Released.\r\n"; // An error occurred. We show the error. // else txtInfo.Text = "Error: " + Res.ToString(); // We set the varibale of active hardware to None // and activate/deactivate the corresponding buttons // ActiveHardware = (HardwareType)(-1); btnInit.Enabled = !(btnWrite.Enabled = btnSetFilter.Enabled = btnResetFilter.Enabled = btnRelease.Enabled = btnInfo.Enabled = btnDllInfo.Enabled = false); rdbTimer.Enabled = false; rdbEvent.Enabled = false; chbTimeStamp.Enabled = false; cbbHws_SelectedIndexChanged(this, new EventArgs()); }
private void SwitchHardware(HardwareType hardwareType) { if (!emulatedGameBoy.RomLoaded || MessageBox.Show(this, Resources.EmulationResetMessage, Resources.GenericMessageTitle, MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes) emulatedGameBoy.Reset(Settings.Default.HardwareType = hardwareType); }
// This helper function retrieve active Dll Major version number // private CANResult DllMajorVersion(HardwareType hType, out int majorVersion) { CANResult Res; String dllVersionStr = ""; // We execute the "DllVersionInfo" function of the PCANLight // using as parameter the Hardware type and a string // variable to get the info like "x.xx" // Res = PCANLight.DllVersionInfo(hType, out dllVersionStr); // We retrieve major version number // spliting versionNumberStr based on "." decimal symbol // String[] versionTabInfo = dllVersionStr.Split('.'); if (versionTabInfo.Length > 0) Int32.TryParse(versionTabInfo[0].ToString(), out majorVersion); else majorVersion = 0; return Res; }
/// <summary> /// Method for obtaining sensor information using OpenHardwareMonitorLib /// Courtesy of http://openhardwaremonitor.org/ /// </summary> /// <param name="hardwareType">The HardwareType of the desired device</param> /// <param name="hardwareInstance">The instance number of the desired device</param> /// <param name="sensorType">The SensorType of the desired sensor</param> /// <param name="sensorInstance">The instance number of the desired sensor</param> /// <returns>The value of the sensor</returns> public static float GetSensorValue(HardwareType hardwareType, int hardwareInstance, SensorType sensorType, int sensorInstance) { float result = 0; try { // Loop through hardware to find the one required foreach (IHardware hardwareElement in ComputerSensors.Hardware) { // If the hardware element's type is what we're looking for if (hardwareElement.HardwareType == hardwareType) { // And the instance is the same (/intelcpu/0 <= Check this number) if (hardwareElement.Identifier.ToString().EndsWith(hardwareInstance.ToString())) { // Then start looping the sensors foreach (ISensor sensor in hardwareElement.Sensors) { // If the sensor's type is what we're looking for if (sensor.SensorType == sensorType) { // And the instance is the same (/intelcpu/0/temperature/0 <= Check this number) if (sensor.Identifier.ToString().EndsWith(sensorInstance.ToString())) { // Get value and return it, skipping all the other elements result = (float)sensor.Value; return result; } } } } } } } catch (Exception) { } return result; }