private void BuildConnectionString()
        {
            if (!SerialPort.GetPortNames().Contains(CommPortName.Text))
            {
                ConnectionString.Text = InvalidConfiguration;
                return;
            }
            var commPortName = CommPortName.Text;
            var endpoint     = new SerialDeviceEndpoint(
                commPortName,
                Settings.Default.CommDataRate,
                Settings.Default.CommParity,
                Settings.Default.CommDataBits,
                Settings.Default.CommStopBits,
                Settings.Default.CommDtrActive,
                Settings.Default.CommRtsActive);
            var builder = new StringBuilder(endpoint.ToString());

            // Due to a limitation in ASCOM.ReactiveCommunications, we have to add the DTR and RTS flags manually
            builder.Append(Settings.Default.CommDtrActive ? ",DTR" : ",NoDTR");
            builder.Append(Settings.Default.CommRtsActive ? ",RTS" : ",NoRTS");
            var connectionString = builder.ToString();

            Settings.Default.ConnectionString = connectionString;
            ConnectionString.Text             = connectionString;
        }
Esempio n. 2
0
        private string TalkWithAxis(AXISID axis, char cmd, string cmdDataStr)
        {
            string         response = string.Empty;
            DeviceEndpoint endPoint = SerialDeviceEndpoint.FromConnectionString(ConnectionString);

            const int     BufferSize = 20;
            StringBuilder sb         = new StringBuilder(BufferSize);

            sb.Append(cStartChar_Out);           // 0: Leading char
            sb.Append(cmd);                      // 1: Length of command( Source, distination, command char, data )

            // Target Device
            sb.Append(((int)axis + 1).ToString()); // 2: Target Axis
                                                   // Copy command data to buffer
            sb.Append(cmdDataStr);

            sb.Append(cEndChar); // CR Character

            string cmdString = sb.ToString();


            var cmdTransaction = new EQTransaction(cmdString)
            {
                Timeout = TimeSpan.FromSeconds(TimeOut)
            };


            using (ICommunicationChannel channel = new SerialCommunicationChannel(endPoint))
                using (var processor = new ReactiveTransactionProcessor())
                {
                    var transactionObserver = new TransactionObserver(channel);
                    processor.SubscribeTransactionObserver(transactionObserver);
                    try
                    {
                        channel.Open();

                        // prepare to communicate
                        for (int i = 0; i < Retry; i++)
                        {
                            Task.Run(() => processor.CommitTransaction(cmdTransaction));
                            cmdTransaction.WaitForCompletionOrTimeout();
                            if (!cmdTransaction.Failed)
                            {
                                response = cmdTransaction.Value;
                                break;
                            }
                            else
                            {
                                Trace.TraceError(cmdTransaction.ErrorMessage.Single());
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        Trace.TraceError("Connnection Lost");
                        throw new Exception("AstroEQ not responding", ex);
                    }
                    finally
                    {
                        // To clean up, we just need to dispose the TransactionObserver and the channel is closed automatically.
                        // Not strictly necessary, but good practice.
                        transactionObserver.OnCompleted(); // There will be no more transactions.
                        transactionObserver = null;        // not necessary, but good practice.
                        endPoint            = null;
                    }
                }
            return(response);
        }
        private void BuildSerialConnectionString()
        {
            var candidate = new SerialDeviceEndpoint(CommPortName.Text);

            Settings.Default.ConnectionString = candidate.ToString();
        }