Example #1
0
        public clsRinger(OutputPinConfiguration RingerPower, OutputPinConfiguration RingerOscillator, float[] RingPattern = null)
        {
            if (RingPattern==null) RingPattern = ringPattern_UK;
            ringPattern = RingPattern;

            RingerPowerPin = RingerPower;
            RingerOscillatorPin = RingerOscillator;

            var GPIOconfig = new GpioConnectionSettings();
            GPIO = new GpioConnection(GPIOconfig,RingerPowerPin,RingerOscillatorPin);

            RingerThread = new Thread(Ring);
            RingerThread.IsBackground = true;
            RingerThread.Name = "Ringer Thread";
        }
        public clsDialHookListener(InputPinConfiguration HookInput, InputPinConfiguration PulseDialInput)
        {
            HookIO = HookInput;
            DialIO = PulseDialInput;

            var config = new GpioConnectionSettings()
            {
                PollInterval = 5,
            };

            GPIO = new GpioConnection(config,HookIO,DialIO);

            GPIO.PinStatusChanged += (object sender, PinStatusEventArgs e) => {  //switch change event handler

                if (e.Configuration.Pin == HookIO.Pin)
                {
                        if (GPIO[HookIO]) HookPulseCount++;
                        HookWaitEvent.Set();
                }
                else if (e.Configuration.Pin == DialIO.Pin)
                {
                    if (GPIO[DialIO])
                    {
                        DialPulseCount++;
                        DialWaitEvent.Set();
                    }
                }
                else
                {
                    Console.WriteLine("Huh?! Wrong IO: "+e.Configuration.Name);
                }

            };

            DialListenerThread = new Thread(ListenDial)
            {
                Name = "DialListener",
                IsBackground = true,
            };
            DialListenerThread.Start();

            HookListenerThread = new Thread(ListenHookSwitch)
            {
                Name = "HookListener",
                IsBackground = true,
            };
            HookListenerThread.Start();
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="GpioConnection"/> class.
        /// </summary>
        /// <param name="settings">The settings.</param>
        /// <param name="pins">The pins.</param>
        public GpioConnection(GpioConnectionSettings settings, IEnumerable<PinConfiguration> pins)
        {
            this.settings = settings ?? new GpioConnectionSettings();
            Pins = new ConnectedPins(this);

            var pinList = pins.ToList();
            pinConfigurations = pinList.ToDictionary(p => p.Pin);

            namedPins = pinList.Where(p => !string.IsNullOrEmpty(p.Name)).ToDictionary(p => p.Name);
            
            timer = Timer.Create();

            timer.Interval = this.settings.PollInterval;
            timer.Action = CheckInputPins;

            if (this.settings.Opened)
                Open();
        }
Example #4
0
        static void Main(string[] args)
        {
            var pin1 = ConnectorPin.P1Pin22.Input();

            var driver = new GpioConnectionDriver();

            var settings = new GpioConnectionSettings();

            settings.Driver = driver;

            using (var hans = new GpioConnection(settings))
            {
                hans.Add(pin1);

                while (true)
                {
                    Console.WriteLine(settings.Driver.Read(pin1.Pin));
                    Thread.Sleep(100);
                }
            }
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="GpioConnection"/> class.
 /// </summary>
 /// <param name="settings">The settings.</param>
 /// <param name="pins">The pins.</param>
 public GpioConnection(GpioConnectionSettings settings, params PinConfiguration[] pins) : this(settings, (IEnumerable<PinConfiguration>) pins){}
Example #6
0
        static void Main(string[] args)
        {
            const ConnectorPin led1Pin = ConnectorPin.P1Pin26;
            const ConnectorPin led2Pin = ConnectorPin.P1Pin24;
            const ConnectorPin led3Pin = ConnectorPin.P1Pin22;
            const ConnectorPin led4Pin = ConnectorPin.P1Pin15;
            const ConnectorPin led5Pin = ConnectorPin.P1Pin13;
            const ConnectorPin led6Pin = ConnectorPin.P1Pin11;
            const ConnectorPin buttonPin = ConnectorPin.P1Pin03;

            Console.WriteLine("Chaser Sample: Sample a LED chaser with a switch to change behavior");
            Console.WriteLine();
            Console.WriteLine("\tLed 1: {0}", led1Pin);
            Console.WriteLine("\tLed 2: {0}", led2Pin);
            Console.WriteLine("\tLed 3: {0}", led3Pin);
            Console.WriteLine("\tLed 4: {0}", led4Pin);
            Console.WriteLine("\tLed 5: {0}", led5Pin);
            Console.WriteLine("\tLed 6: {0}", led6Pin);
            Console.WriteLine("\tSwitch: {0}", buttonPin);
            Console.WriteLine();

            var driver = args.GetDriver();

            // Declare outputs (leds)
            var leds = new PinConfiguration[]
                           {
                               led1Pin.Output().Name("Led1").Enable(),
                               led2Pin.Output().Name("Led2"),
                               led3Pin.Output().Name("Led3").Enable(),
                               led4Pin.Output().Name("Led4"),
                               led5Pin.Output().Name("Led5").Enable(),
                               led6Pin.Output().Name("Led6")
                           };

            // Assign a behavior to the leds
            var behavior = new ChaserBehavior(leds)
                               {
                                   Loop = args.GetLoop(),
                                   RoundTrip = args.GetRoundTrip(),
                                   Width = args.GetWidth(),
                                   Interval = TimeSpan.FromMilliseconds(args.GetSpeed())
                               };

            // Alternate behaviors...
            /*
            var random = new Random();
            var behavior = new PatternBehavior(leds, Enumerable.Range(0, 5).Select(i => random.Next(511)))
                               {
                                   Loop = Helpers.GetLoop(args),
                                   RoundTrip = Helpers.GetRoundTrip(args),
                                   Interval = Helpers.GetSpeed(args)
                               };*/

            /*
            var behavior = new BlinkBehavior(leds)
                               {
                                   Count = args.GetWidth(),
                                   Interval = args.GetSpeed()
                               };*/

            // Declare input (switchButton) interacting with the leds behavior
            var switchButton = buttonPin.Input()
                .Name("Switch")
                .Revert()
                .Switch()
                .Enable()
                .OnStatusChanged(b =>
                                     {
                                         behavior.RoundTrip = !behavior.RoundTrip;
                                         Console.WriteLine("Button switched {0}", b ? "on" : "off");
                                     });

            // Create connection
            var settings = new GpioConnectionSettings {Driver = driver};

            using (var connection = new GpioConnection(settings, leds))
            {
                Console.WriteLine("Using {0}, frequency {1:0.##}hz", settings.Driver.GetType().Name, 1000.0/args.GetSpeed());

                Thread.Sleep(1000);

                connection.Add(switchButton);
                connection.Start(behavior); // Starting the behavior automatically registers the pins to the connection, if needed.

                Console.ReadKey(true);

                connection.Stop(behavior);
            }
        }
Example #7
0
        static void Main(string[] args)
        {
            try
            {
                var driver = args.GetDriver();
                var mainboard = Board.Current;

                if (!mainboard.IsRaspberryPi)
                {
                    Console.WriteLine("'{0}' is not a valid processor for a Raspberry Pi.", mainboard.Processor);
                    return;
                }

                // Declare outputs (leds)
                var leds = new PinConfiguration[]
                               {
                                   ConnectorPin.P1Pin26.Output().Name("Led1").Enable(),
                                   ConnectorPin.P1Pin24.Output().Name("Led2"),
                                   ConnectorPin.P1Pin22.Output().Name("Led3").Enable(),
                                   ConnectorPin.P1Pin15.Output().Name("Led4"),
                                   ConnectorPin.P1Pin13.Output().Name("Led5").Enable(),
                                   ConnectorPin.P1Pin11.Output().Name("Led6")
                               };

                // Assign a behavior to the leds
                var behavior = new ChaserBehavior(leds)
                                   {
                                       Loop = args.GetLoop(),
                                       RoundTrip = args.GetRoundTrip(),
                                       Width = args.GetWidth(),
                                       Interval = args.GetSpeed()
                                   };

                // Alternate behaviors...
                /*
                var random = new Random();
                var behavior = new PatternBehavior(leds, Enumerable.Range(0, 5).Select(i => random.Next(511)))
                                   {
                                       Loop = Helpers.GetLoop(args),
                                       RoundTrip = Helpers.GetRoundTrip(args),
                                       Interval = Helpers.GetSpeed(args)
                                   };*/

                /*
                var behavior = new BlinkBehavior(leds)
                                   {
                                       Count = args.GetWidth(),
                                       Interval = args.GetSpeed()
                                   };*/

                // Declare input (switchButton) interacting with the leds behavior
                var switchButton = ConnectorPin.P1Pin03.Input()
                    .Name("Switch")
                    .Revert()
                    .Switch()
                    .Enable()
                    .OnStatusChanged(b =>
                                         {
                                             behavior.RoundTrip = !behavior.RoundTrip;
                                             Console.WriteLine("Button switched {0}", b ? "on" : "off");
                                         });

                // Create connection
                Console.WriteLine("Running on Raspberry firmware rev{0}, board rev{1}, processor {2}", mainboard.Firmware, mainboard.Revision, mainboard.Processor);

                var settings = new GpioConnectionSettings {Driver = driver};

                using (var connection = new GpioConnection(settings, leds))
                {
                    Console.WriteLine("Using {0}, frequency {1:0.##}hz", settings.Driver.GetType().Name, 1000.0/args.GetSpeed());

                    Thread.Sleep(1000);

                    connection.Add(switchButton);
                    connection.Start(behavior); // Starting the behavior automatically registers the pins to the connection, if needed.

                    Console.ReadKey(true);

                    connection.Stop(behavior);
                }
            }
            catch(Exception ex)
            {
                var currentException = ex;
                while (currentException != null)
                {
                    Console.WriteLine("{0}: {1}", currentException.GetType().Name, currentException.Message);
                    currentException = currentException.InnerException;
                }
            }
        }