/// <summary>
        /// Invoked when this page is about to be displayed in a Frame.
        ///
        /// We will enable/disable parts of the UI if the device doesn't support it.
        /// </summary>
        /// <param name="eventArgs">Event data that describes how this page was reached.  The Parameter
        /// property is typically used to configure the page.</param>
        private void Initialize()
        {
            if (EventHandlerForDevice.Current.Device == null)
            {
                SerialConfigureDeviceVisibility = Visibility.Collapsed;
                SerialMain.NotifyUser("Device is not connected", NotifyType.ErrorMessage);
            }
            else
            {
                if (EventHandlerForDevice.Current.Device.PortName != "")
                {
                    SerialMain.NotifyUser("Connected to " + EventHandlerForDevice.Current.Device.PortName,
                                          NotifyType.StatusMessage);
                }

                UpdateBaudRateView();
                UpdateParityView();
                UpdateHandShakeView();
                UpdateBreakStateSignalView();
                UpdateCarrierDetectStateView();
                UpdateDataBitsView();
                UpdateDataSetReadyStateView();
                UpdateDataTerminalReadyEnabledView();
                UpdateRequestToSendEnabledView();
                UpdateStopBitCountView();
            }
        }
        /// <summary>
        /// Invoked when this page is about to be displayed in a Frame.
        ///
        /// We will enable/disable parts of the UI if the device doesn't support it.
        /// </summary>
        /// <param name="eventArgs">Event data that describes how this page was reached.  The Parameter
        /// property is typically used to configure the page.</param>
        //protected override void OnNavigatedTo(NavigationEventArgs eventArgs)
        public void Initialize()
        {
            IsNavigatedAway = false;
            if (EventHandlerForDevice.Current.Device == null)
            {
                ReadWriteScollViewerVisibility = Visibility.Collapsed;
                SerialMain.NotifyUser("Device is not connected", NotifyType.ErrorMessage);
            }
            else
            {
                if (EventHandlerForDevice.Current.Device.PortName != "")
                {
                    SerialMain.NotifyUser("Connected to " + EventHandlerForDevice.Current.Device.PortName,
                                          NotifyType.StatusMessage);
                }

                // So we can reset future tasks

                ResetReadCancellationTokenSource();
                ResetWriteCancellationTokenSource();

                UpdateReadButtonStates();
                UpdateWriteButtonStates();

                UpdateReadBytesCounterView();
                UpdateReadTimeoutView();

                UpdateWriteBytesCounterView();
                UpdateWriteTimeoutView();
            }
        }
Пример #3
0
 /// <summary>
 /// We will remove the device from the UI
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="deviceInformationUpdate"></param>
 private async void OnDeviceRemoved(DeviceWatcher sender, DeviceInformationUpdate deviceInformationUpdate)
 {
     await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(
         CoreDispatcherPriority.Normal,
         new DispatchedHandler(() =>
     {
         SerialMain.NotifyUser("Device removed - " + deviceInformationUpdate.Id, NotifyType.StatusMessage);
         RemoveDeviceFromList(deviceInformationUpdate.Id);
     }));
 }
Пример #4
0
        /// <summary>
        /// This method opens the device using the WinRT Serial API. After the device is opened, save the device
        /// so that it can be used across scenarios.
        ///
        /// It is important that the FromIdAsync call is made on the UI thread because the consent prompt can only be displayed
        /// on the UI thread.
        ///
        /// This method is used to reopen the device after the device reconnects to the computer and when the app resumes.
        /// </summary>
        /// <param name="deviceInfo">Device information of the device to be opened</param>
        /// <param name="deviceSelector">The AQS used to find this device</param>
        /// <returns>True if the device was successfully opened, false if the device could not be opened for well known reasons.
        /// An exception may be thrown if the device could not be opened for extraordinary reasons.</returns>
        public async Task <Boolean> OpenDeviceAsync(DeviceInformation deviceInfo, String deviceSelector)
        {
            try
            {
                device = await SerialDevice.FromIdAsync(deviceInfo.Id);
            }
            catch (Exception)
            {
                throw;
            }

            Boolean    successfullyOpenedDevice = false;
            NotifyType notificationStatus;
            String     notificationMessage = null;

            // Device could have been blocked by user or the device has already been opened by another app.
            if (device != null)
            {
                successfullyOpenedDevice = true;

                deviceInformation   = deviceInfo;
                this.deviceSelector = deviceSelector;

                notificationStatus  = NotifyType.StatusMessage;
                notificationMessage = "Device " + deviceInformation.Id + " opened";

                // Notify registered callback handle that the device has been opened
                if (deviceConnectedCallback != null)
                {
                    deviceConnectedCallback(this, deviceInformation);
                }

                if (appSuspendEventHandler == null || appResumeEventHandler == null)
                {
                    RegisterForAppEvents();
                }

                // Register for DeviceAccessInformation.AccessChanged event and react to any changes to the
                // user access after the device handle was opened.
                if (deviceAccessEventHandler == null)
                {
                    RegisterForDeviceAccessStatusChange();
                }

                // Create and register device watcher events for the device to be opened unless we're reopening the device
                if (deviceWatcher == null)
                {
                    deviceWatcher = DeviceInformation.CreateWatcher(deviceSelector);

                    RegisterForDeviceWatcherEvents();
                }

                if (!watcherStarted)
                {
                    // Start the device watcher after we made sure that the device is opened.
                    StartDeviceWatcher();
                }
            }
            else
            {
                successfullyOpenedDevice = false;

                notificationStatus = NotifyType.ErrorMessage;

                var deviceAccessStatus = DeviceAccessInformation.CreateFromId(deviceInfo.Id).CurrentStatus;

                if (deviceAccessStatus == DeviceAccessStatus.DeniedByUser)
                {
                    notificationMessage = "Access to the device was blocked by the user : "******"Access to the device was blocked by the system : " + deviceInfo.Id;
                }
                else
                {
                    // Most likely the device is opened by another app, but cannot be sure
                    notificationMessage = "Unknown error, possibly opened by another app : " + deviceInfo.Id;
                }
            }

            SerialMain.NotifyUser(notificationMessage, notificationStatus);

            return(successfullyOpenedDevice);
        }