/// <summary> /// Event handler for the OK button <c>Click</c> event. Updates the properties with the selected target logic and communication settings. /// </summary> /// <param name="sender">Reference to the object that raised the event.</param> /// <param name="e">Parameter passed from the object that raised the event.</param> private void m_BtnOK_Click(object sender, EventArgs e) { if (m_ListBoxAvailableLogicControllers.SelectedItems.Count == 0) { // No target was selected. MessageBox.Show(Resources.MBTSelectTarget, Resources.MBCaptionInformation, MessageBoxButtons.OK, MessageBoxIcon.Information); return; } int selectedLogic = m_ListBoxAvailableLogicControllers.SelectedIndex; m_TargetSelected = true; m_TargetConfiguration = m_TargetConfigurationList[selectedLogic]; m_CommunicationSetting = m_CommunicationSettingList[selectedLogic]; Close(); }
/// <summary> /// Scans each of the communication ports listed in the registry to determine if it is connected to target hardware and generates a list /// of the target configuration information and the communication settings for each target that is located. /// </summary> /// <param name="targetConfigurationList">The list containing the target configuration information for any targets connected to the PTU.</param> /// <param name="communicationSettingList">The communication settings associated with each target that was found.</param> /// <param name="listBoxTargetsFound">The <c>ListBox</c> control on which the target names are to be displayed.</param> /// <param name="statusInformation">The control on which the status information is to be displayed.</param> /// <returns>A flag to indicate whether one or more targets were found; true, if targets were found, otherwise, false.</returns> public bool GetTargets(ListBox listBoxTargetsFound, Control statusInformation, out List<TargetConfiguration_t> targetConfigurationList, out List<CommunicationSetting_t> communicationSettingList) { // Instantiate to output parameters. communicationSettingList = new List<CommunicationSetting_t>(); targetConfigurationList = new List<TargetConfiguration_t>(); CommunicationApplication communicationInterface; // Flag to indicate whether target hardware was found; true, if one or more targets were found, otherwise, false. bool targetFound = false; if (Parameter.CommunicationType == Parameter.CommunicationTypeEnum.Both || Parameter.CommunicationType == Parameter.CommunicationTypeEnum.RS232) { // ----------------------------------------------------------------- // Scan each serial communication (COM) port listed in the Registry. // ----------------------------------------------------------------- // Get the list of available serial COM ports from the registry. RegistryKey root = Registry.LocalMachine; CommunicationSetting_t communicationSetting = new CommunicationSetting_t(); // Set the protocol to serial communication. communicationSetting.Protocol = Protocol.RS232; // Initialize the serial communication parameters. communicationSetting.SerialCommunicationParameters.SetToDefault(); TargetConfiguration_t targetConfiguration; using (RegistryKey serialCommunication = root.OpenSubKey(RegistryKeySerialCommunication)) { // Scan each port in the Registry. foreach (string valueName in serialCommunication.GetValueNames()) { // Filter out those '\HKEY_LOCAL_MACHINE\HARDWARE\DEVICEMAP\SERIALCOMM' keys that are not to be included in the search. switch (valueName) { // Skip those registry keys defined here. case SerialCommRegistryKeyWinachsf0: continue; default: // Process the key. break; } string value = serialCommunication.GetValue(valueName).ToString(); communicationSetting.Port.Name = value; communicationSetting.Port.FullSpecification = value.PadRight(ComDeviceTotalCharacters) + " - " + valueName; communicationSetting.Port.Type = (communicationSetting.Port.FullSpecification.Contains(VirtualComPort)) ? PortType.VCP : PortType.COM; // Determine the port identifier, this is a 16 bit Unicode string representation of the serial port number e.g. for physical and virtual // COM ports this takes the form: 1, 2, 3 ... etc. switch (communicationSetting.Port.Type) { case PortType.COM: case PortType.VCP: communicationSetting.PortIdentifier = communicationSetting.Port.Name.Remove(0, communicationSetting.Port.Type.ToString().Length); break; default: throw new ArgumentException("FormSelectTargetLogic.LocateTargetHardware()", "communicationSetting.Port.Type"); } statusInformation.Text = Resources.TextSearchingForTargetOn + CommonConstants.Space + communicationSetting.Port.FullSpecification; statusInformation.Update(); // Instantiate the appropriate type of communication interface. communicationInterface = new CommunicationApplication(); try { if (communicationInterface.ScanPort(communicationSetting, out targetConfiguration) == true) { targetConfigurationList.Add(targetConfiguration); listBoxTargetsFound.Items.Add(targetConfiguration.SubSystemName + " - (COM" + communicationSetting.PortIdentifier + ")" ); listBoxTargetsFound.Update(); statusInformation.Text = Resources.TextTargetFoundOn + CommonConstants.Space + communicationSetting.Port.FullSpecification; statusInformation.Update(); communicationSettingList.Add(communicationSetting); targetFound = true; } } catch (Exception) { statusInformation.Text = Resources.TextNoTargetFoundOn + CommonConstants.Space + communicationSetting.Port.FullSpecification; statusInformation.Update(); continue; } } } } statusInformation.Text = string.Empty; statusInformation.Update(); if (Parameter.CommunicationType == Parameter.CommunicationTypeEnum.Both || Parameter.CommunicationType == Parameter.CommunicationTypeEnum.TCPIP) { // ----------------------------------------------------------------- // Scan each URI listed in the Data Dictionary. // ----------------------------------------------------------------- CommunicationSetting_t communicationSetting = new CommunicationSetting_t(); // Set the protocol to IP communication. communicationSetting.Protocol = Protocol.TCPIP; TargetConfiguration_t targetConfiguration; // Initialize the ProgressBar control. m_ProgressBarScan.Enabled = true; m_ProgressBarScan.Visible = true; m_LegendScanProgress.Visible = true; m_ProgressBarScan.Maximum = Parameter.URIList.Count; m_ProgressBarScan.Value = 0; m_BtnOK.Enabled = false; m_CancelSelected = false; // Scan each port in the Registry. foreach (string uRI in Parameter.URIList) { // Ensure that the form remains responsive during the asynchronous operation. Application.DoEvents(); // Check whether the Cancel button has been selected. if (m_CancelSelected == true) { // Yes - Terminate the scan. break; } // Update the progress bar. m_ProgressBarScan.Value++; communicationSetting.PortIdentifier = uRI; statusInformation.Text = Resources.TextSearchingForTargetOn + CommonConstants.Space + Resources.TextURI + CommonConstants.Colon + communicationSetting.PortIdentifier; statusInformation.Update(); // Instantiate the appropriate type of communication interface. communicationInterface = new CommunicationApplication(); try { if (communicationInterface.ScanPort(communicationSetting, out targetConfiguration) == true) { targetConfigurationList.Add(targetConfiguration); listBoxTargetsFound.Items.Add(targetConfiguration.SubSystemName + CommonConstants.BindingMessage + Resources.TextURI + CommonConstants.Colon + communicationSetting.PortIdentifier); listBoxTargetsFound.Update(); statusInformation.Text = Resources.TextTargetFoundOn + CommonConstants.Space + Resources.TextURI + CommonConstants.Colon + communicationSetting.PortIdentifier; statusInformation.Update(); communicationSettingList.Add(communicationSetting); targetFound = true; } } catch (Exception) { continue; } } m_BtnOK.Enabled = true; m_ProgressBarScan.Enabled = false; m_ProgressBarScan.Visible = false; m_LegendScanProgress.Visible = false; } if (targetFound == true) { statusInformation.Text = targetConfigurationList.Count.ToString() + CommonConstants.Space + Resources.TextTargetsFound; statusInformation.Update(); // Highlight the first logic controller that was found. listBoxTargetsFound.SetSelected(0, true); } else { statusInformation.Text = Resources.TextNoTargetsFound; statusInformation.Update(); } return targetFound; }
/// <summary> /// Initialize a new instance of the class and set the function delegates, properties and member variables. /// </summary> /// <param name="communicationInterface">Reference to the communication interface containing the properties and member variables that are to /// be used to initialize the class.</param> public CommunicationParent(ICommunicationParent communicationInterface) : this() { m_CommunicationSetting = communicationInterface.CommunicationSetting; m_CommDevice = communicationInterface.CommDevice; m_WatchClockMarshal = communicationInterface.WatchClockMarshall; }
/// <summary> /// Initialize the communication port. /// </summary> /// <param name="communicationsSetting">The communication settings.</param> /// <exception cref="CommunicationException">Thrown if the error code returned from the call to the PTUDLL32.InitCommunication() method is /// not CommunicationError.Success.</exception> public virtual void InitCommunication(CommunicationSetting_t communicationsSetting) { Int32 error = -1; CommunicationError errorCode = CommunicationError.UnknownError; try { String args = ""; if (communicationsSetting.Protocol == Protocol.RS232) { m_CommDevice = new Serial(); args = "COM" + communicationsSetting.PortIdentifier + "," + ((Int32)communicationsSetting.SerialCommunicationParameters.BaudRate).ToString() + "," + communicationsSetting.SerialCommunicationParameters.Parity.ToString() + "," + ((Int32)communicationsSetting.SerialCommunicationParameters.BitsPerCharacter).ToString() + "," + ((Int32)communicationsSetting.SerialCommunicationParameters.StopBits).ToString(); } else if (communicationsSetting.Protocol == Protocol.TCPIP) { m_CommDevice = new TCP(); args = communicationsSetting.PortIdentifier; } if (m_CommDevice != null) { error = m_CommDevice.Open(args); } } catch (Exception) { errorCode = CommunicationError.SystemException; throw new CommunicationException(Resources.EMPortInitializationFailed, errorCode); } if (DebugMode.Enabled == true) { DebugMode.InitCommunication_t initCommunication = new DebugMode.InitCommunication_t(communicationsSetting.Protocol, communicationsSetting.PortIdentifier, communicationsSetting.SerialCommunicationParameters.BaudRate, communicationsSetting.SerialCommunicationParameters.BitsPerCharacter, communicationsSetting.SerialCommunicationParameters.Parity, communicationsSetting.SerialCommunicationParameters.StopBits, errorCode); DebugMode.Write(initCommunication.ToXML()); } if (error >= 0) { errorCode = CommunicationError.Success; m_WatchClockMarshal = new WatchClockMarshal(m_CommDevice); } if (errorCode != CommunicationError.Success) { throw new CommunicationException(Resources.EMPortInitializationFailed, errorCode); } }
/// <summary> /// Initialize a new instance of the class and set the function delegates, properties and member variables. /// </summary> public CommunicationParent() { // Random number generator, used to simulate communication values. m_Random = new Random(); // Initialize the watch element array. m_WatchElements = new WatchElement_t[Parameter.WatchSize]; m_CommunicationSetting = new CommunicationSetting_t(); m_MutexCommuncationInterface = new Mutex(); }
/// <summary> /// Initialize a new instance of the class and set the function delegates, properties and member variables. /// </summary> /// <param name="communicationSetting">The communication setting that is to be used to initialize the <c>CommunicationSetting</c> /// property.</param> public CommunicationParent(CommunicationSetting_t communicationSetting) : this() { m_CommunicationSetting = communicationSetting; }
/// <summary> /// Initialize the target hardware communication port. /// </summary> /// <param name="communicationsSetting">The communication settings.</param> /// <exception cref="CommunicationException">Thrown if the error code returned from the call to the PTUDLL32.InitCommunication() method is not /// CommunicationError.Success.</exception> public virtual void InitCommunication(CommunicationSetting_t communicationsSetting) { }
/// <summary> /// Event handler for the off-line button <c>Click</c> event. Enter offline mode. /// </summary> /// <param name="sender">Reference to the object that raised the event.</param> /// <param name="e">Parameter passed from the object that raised the event.</param> private void m_TSBOffline_Click(object sender, EventArgs e) { // Skip, if the Dispose() method has been called. if (IsDisposed) { return; } // Skip, if the button isn't enabled. if (m_TSBOffline.Enabled == false) { return; } // If offline mode is already selected, toggle to configuration mode. if (m_TSBOffline.Checked) { #region - [Return to Configuration Mode] - // ------------------------------------------------------- // The PTU is already offline, go to configuration mode. // ------------------------------------------------------- try { this.Cursor = Cursors.WaitCursor; CommunicationInterface.CloseCommunication(CommunicationInterface.CommunicationSetting.Protocol); } catch (Exception) { MessageBox.Show(Resources.MBTPortCloseFailed, Resources.MBCaptionError, MessageBoxButtons.OK, MessageBoxIcon.Error); return; } finally { this.Cursor = Cursors.Default; } SetMode(Mode.Configuration); // Update the LogStatus StatusStrip. LogStatus = EventLogSavedStatus.NotApplicable; #endregion - [Return to Configuration Mode] - return; } this.Cursor = Cursors.WaitCursor; #region - [Go Offline] - // --------------------------------------------------------------------------------------------- // Enter offline mode. Instantiate a the communication interface which returns simulated values. // --------------------------------------------------------------------------------------------- CommunicationSetting_t communicationSetting = new CommunicationSetting_t(); communicationSetting.Port = new Port_t(); communicationSetting.PortIdentifier = string.Empty; communicationSetting.Protocol = Protocol.SIMULATOR; CommunicationInterface = new CommunicationParentOffline(communicationSetting); TargetConfiguration_t targetConfiguration; CommunicationInterface.GetEmbeddedInformation(out targetConfiguration); // Update the header information with the target configuration. Header_t header = new Header_t(); header = FileHeader.HeaderCurrent; header.TargetConfiguration = targetConfiguration; FileHeader.HeaderCurrent = header; SetMode(Mode.Offline); // Check whether the most recently downloaded event log was saved to disk and update the LogStatus StatusStrip. LogStatus = EventLogSavedStatus.Unknown; UpdateChartMode(); // Display the Watch Window only if the project doesn't use a Control Panel. if (this.Controls[CommonConstants.KeyControlPanel] == null) { m_MenuInterfaceWatch.ViewWatchWindow(); } #endregion - [Go Offline] - this.Cursor = Cursors.Default; }
/// <summary> /// Initialize a new instance of the class. /// </summary> public CommunicationParentOffline() { // Initialize the watch element array. m_WatchElements = new WatchElement_t[Parameter.WatchSize]; m_CommunicationSetting = new CommunicationSetting_t(); }
/// <summary> /// Initialize a new instance of the class and set the properties and member variables to those values associated with the specified /// communication interface. /// </summary> /// <param name="communicationInterface">Reference to the communication interface containing the properties and member variables that are to be /// used to initialize the class.</param> public CommunicationParentOffline(ICommunicationParent communicationInterface) { // Initialize the watch element array. m_WatchElements = new WatchElement_t[Parameter.WatchSize]; m_CommunicationSetting = communicationInterface.CommunicationSetting; }
/// <summary> /// Scan the specified serial communication port to determine if it is connected to a target logic controller. If a target is found /// the target configuration information is written to the output parameter <paramref name="targetConfiguration"/>. /// </summary> /// <param name="communicationSetting">The communication settings that are to be used to communicate with the target.</param> /// <param name="targetConfiguration">The target configuration information returned from the target hardware if a target is found.</param> /// <returns>A flag to indicate whether a target was found; true, if a target was found, otherwise, false.</returns> /// <exception cref="CommunicationException">Thrown if the error code returned from the call to the PTUDLL32.InitCommunication() method is not /// CommunicationError.Success.</exception> public bool ScanPort(CommunicationSetting_t communicationSetting, out TargetConfiguration_t targetConfiguration) { // Flag to indicate whether target hardware was found; true, if target was found, otherwise, false. bool targetFound = false; try { InitCommunication(communicationSetting); GetEmbeddedInformation(out targetConfiguration); targetFound = true; } catch (InvalidOperationException) { targetConfiguration = new TargetConfiguration_t(); return targetFound; } finally { CloseCommunication(communicationSetting.Protocol); } return targetFound; }
/// <summary> /// Initialize a new instance of the class and set the function delegates, properties and member variables. /// </summary> /// <param name="communicationInterface">Reference to the communication interface containing the properties and member variables that are to /// be used to initialize the class.</param> public CommunicationParent(ICommunicationParent communicationInterface) : this() { m_CommunicationSetting = communicationInterface.CommunicationSetting; }
/// <summary> /// Initialize a new instance of the class and set the function delegates, properties and member variables. /// </summary> public CommunicationParent() { // Random number generator, used to simulate communication values. m_Random = new Random(); // Initialize the watch element array. m_WatchElements = new WatchElement_t[Parameter.WatchSize]; m_CommunicationSetting = new CommunicationSetting_t(); m_MutexCommuncationInterface = new Mutex(); #region - [Initialize VcuCommunication.comm.cpp Function Delegates] - // ---------------------------------------------------------------------- // Initialize the function delegates to either the VcuCommunication32.dll // or VcuCommunication64.dll functions depending upon whether the // Windows operating system is 64 bit or 32 bit. // ---------------------------------------------------------------------- if (Environment.Is64BitOperatingSystem == true) { m_Is64BitOperatingSystem = true; // CommunicationParent m_InitCommunication = VcuCommunication64.InitCommunication; m_CloseCommunication = VcuCommunication64.CloseCommunication; m_GetEmbeddedInformation = VcuCommunication64.GetEmbeddedInformation; m_GetChartMode = VcuCommunication64.GetChartMode; m_SetChartMode = VcuCommunication64.SetChartMode; m_GetChartIndex = VcuCommunication64.GetChartIndex; m_SetChartIndex = VcuCommunication64.SetChartIndex; m_SetChartScale = VcuCommunication64.SetChartScale; m_SetWatchSize = VcuCommunication64.SetWatchSize; // CommunicationWatch m_SendVariable = VcuCommunication64.SendVariable; m_SetWatchElements = VcuCommunication64.SetWatchElements; m_UpdateWatchElements = VcuCommunication64.UpdateWatchElements; // CommunicationPTUApplication m_GetTimeDate = VcuCommunication64.GetTimeDate; m_SetTimeDate = VcuCommunication64.SetTimeDate; m_SetCarID = VcuCommunication64.SetCarID; // Not Used m_StartClock = VcuCommunication64.StartClock; m_StopClock = VcuCommunication64.StopClock; } else { // CommunicationParent m_InitCommunication = VcuCommunication32.InitCommunication; m_CloseCommunication = VcuCommunication32.CloseCommunication; m_GetEmbeddedInformation = VcuCommunication32.GetEmbeddedInformation; m_GetChartMode = VcuCommunication32.GetChartMode; m_SetChartMode = VcuCommunication32.SetChartMode; m_GetChartIndex = VcuCommunication32.GetChartIndex; m_SetChartIndex = VcuCommunication32.SetChartIndex; m_SetChartScale = VcuCommunication32.SetChartScale; m_SetWatchSize = VcuCommunication32.SetWatchSize; // CommunicationWatch m_SendVariable = VcuCommunication32.SendVariable; m_SetWatchElements = VcuCommunication32.SetWatchElements; m_UpdateWatchElements = VcuCommunication32.UpdateWatchElements; // CommunicationPTUApplication m_GetTimeDate = VcuCommunication32.GetTimeDate; m_SetTimeDate = VcuCommunication32.SetTimeDate; m_SetCarID = VcuCommunication32.SetCarID; // Not Used m_StartClock = VcuCommunication32.StartClock; m_StopClock = VcuCommunication32.StopClock; } #endregion - [Initialize VcuCommunication.comm.cpp Function Delegates] - }
/// <summary> /// Initialize the communication port. /// </summary> /// <param name="communicationsSetting">The communication settings.</param> /// <exception cref="CommunicationException">Thrown if the error code returned from the call to the PTUDLL32.InitCommunication() method is /// not CommunicationError.Success.</exception> public virtual void InitCommunication(CommunicationSetting_t communicationsSetting) { // Check that the function delegate has been initialized. Debug.Assert(m_InitCommunication != null, "CommunicationParent.InitCommunication() - [m_InitCommunication != null]"); CommunicationError errorCode = CommunicationError.UnknownError; try { errorCode = (CommunicationError)m_InitCommunication((short)communicationsSetting.Protocol, communicationsSetting.PortIdentifier, (int)communicationsSetting.SerialCommunicationParameters.BaudRate, (short)communicationsSetting.SerialCommunicationParameters.BitsPerCharacter, (short)communicationsSetting.SerialCommunicationParameters.Parity, (short)communicationsSetting.SerialCommunicationParameters.StopBits); } catch (Exception) { errorCode = CommunicationError.SystemException; throw new CommunicationException(Resources.EMPortInitializationFailed, errorCode); } if (DebugMode.Enabled == true) { DebugMode.InitCommunication_t initCommunication = new DebugMode.InitCommunication_t(communicationsSetting.Protocol, communicationsSetting.PortIdentifier, communicationsSetting.SerialCommunicationParameters.BaudRate, communicationsSetting.SerialCommunicationParameters.BitsPerCharacter, communicationsSetting.SerialCommunicationParameters.Parity, communicationsSetting.SerialCommunicationParameters.StopBits, errorCode); DebugMode.Write(initCommunication.ToXML()); } if (errorCode != CommunicationError.Success) { throw new CommunicationException(Resources.EMPortInitializationFailed, errorCode); } }
/// <summary> /// Provide dummy target configuration information and write it to the output parameter <paramref name="targetConfiguration"/>. /// </summary> /// <param name="communicationSetting">The communication settings that are to be used to communicate with the target. Ignored.</param> /// <param name="targetConfiguration">The target configuration information returned from the target hardware if a target is found.</param> /// <returns>A flag to indicate whether a target was found; true, if a target was found, otherwise, false.</returns> /// <exception cref="CommunicationException">Thrown if the error code returned from the call to the PTUDLL32.InitCommunication() method is not /// CommunicationError.Success.</exception> public bool ScanPort(CommunicationSetting_t communicationSetting, out TargetConfiguration_t targetConfiguration) { targetConfiguration.CarIdentifier = m_CarID; targetConfiguration.ConversionMask = ConversionMask; targetConfiguration.ProjectIdentifier = ProjectIdentifier; targetConfiguration.SubSystemName = SubSystemName; targetConfiguration.Version = Version; return true; }