HamBook – Rev 3

?pathlinks?

Rev 5 – Go to most recent revision – Blame – Compare with Previous – Last modification – View Log – Download

using HamBook.Radios.Generic;
using HamBook.Radios;
using System;
using System.Collections.Generic;
using System.IO.Ports;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Serilog;
using HamBook.Properties;
using Serilog.Events;

namespace HamBook
{
    public class BandScan
    {
        private CancellationTokenSource _scanningCancellationTokenSource;

        private CancellationToken _scanningCancellationToken;
        private Task _aiTask;
        private CatAssemblies _catAssemblies;
        private int _minFrequency;
        private int _maxFrequency;
        private SerialPort _serialPort;

        private BandScan() 
        {
        }

        public BandScan(CatAssemblies catAssemblies, int min, int max, SerialPort serialPort) : this()
        {
            _catAssemblies = catAssemblies;
            _minFrequency = min;
            _maxFrequency = max;
            _serialPort = serialPort;

        }

        public void Start()
        {
            if(_scanningCancellationTokenSource != null)
            {
                _scanningCancellationTokenSource.Cancel();
                
            }

            if(_aiTask != null) 
            {
                _aiTask.Wait();
            }

            _scanningCancellationTokenSource = new CancellationTokenSource();
            _scanningCancellationToken = _scanningCancellationTokenSource.Token;
            
            _aiTask = Task.Run(Ai, _scanningCancellationToken);
        }

        public void Stop()
        {
            if (_scanningCancellationTokenSource != null)
            {
                _scanningCancellationTokenSource.Cancel();
            }

            if (_aiTask != null)
            {
                _aiTask.Wait();
            }

            try
            {
                _catAssemblies.CatSet<ScanState>("SC", new object[] { ScanState.OFF });
            }
            catch(Exception exception)
            {
                Log.Warning(exception, Resources.Could_not_set_scan_state);
            }

            try
            {
                _catAssemblies.CatSet<InformationState>("AI", new object[] { InformationState.OFF });
            }
            catch(Exception exception)
            {
                Log.Warning(exception, Resources.Could_not_set_auto_information_state);
            }
        }

        private string ReadCat()
        {
            if (!_serialPort.IsOpen)
            {
                _serialPort.Open();
            }

            try
            {
                return _serialPort.ReadTo(Radios.Generic.Constants.EOT);
            }
            finally
            {
                if (_serialPort.IsOpen)
                {
                    _serialPort.Close();
                }
            }
        }

        private void Ai()
        {
            try
            {
                
                _catAssemblies.CatSet<ScanState>("SC", new object[] { ScanState.OFF });

                var squelch = _catAssemblies.CatRead<int>("SQ", new object[] { });
                if (squelch == 0)
                {
                    var @default = _catAssemblies.CatGetDefault<int>("SQ", new object[] { });

                    _catAssemblies.CatSet<int>("SQ", new object[] { @default });
                }

                _catAssemblies.CatSet<int>("FA", new object[] { _minFrequency });
                _catAssemblies.CatSet<ScanState>("SC", new object[] { ScanState.UP });
                _catAssemblies.CatSet<InformationState>("AI", new object[] { InformationState.ON });

                do
                {
                    var data = ReadCat();

                    var information = _catAssemblies.CatParse<Information>("AI", new object[] { data });

                    if(information == null)
                    {
                        continue;
                    }

                    if(information.Frequency > _maxFrequency)
                    {
                        _catAssemblies.CatSet<int>("FA", new object[] { _minFrequency });
                        continue;
                    }

                    if(information.Frequency < _minFrequency)
                    {
                        _catAssemblies.CatSet<int>("FA", new object[] { _minFrequency });
                        continue;
                    }
                } while (!_scanningCancellationToken.IsCancellationRequested);
            }
            catch(Exception exception)
            {
                Log.Error(exception, Resources.Scanning_aborted);
            }
        }
    }
}