A simple, low-ceremony GPIO library for all your IoT needs
Switch branches/tags
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
SimpleGPIO.Examples.CLI
SimpleGPIO.Examples.Components.Motor
SimpleGPIO.Examples.Components.RGBLED
SimpleGPIO.Examples.Components.RotaryEncoder
SimpleGPIO.Examples.Components.SevenSegmentDisplay
SimpleGPIO.Examples.Input
SimpleGPIO.Examples.Web
SimpleGPIO.Tests
SimpleGPIO
.gitignore
.travis.yml
CODE_OF_CONDUCT.md
LICENSE
README.md
SimpleGPIO.sln

README.md

SimpleGPIO Build Status

A simple, low-ceremony GPIO library for all your IoT needs

Overview

SimpleGPIO takes a high-level, object-oriented approach to IoT programming, in the same way that high-level programming languages provide features that help abstract what's happening on the metal away from the code.

Installation

Simply add the SimpleGPIO library to your project from NuGet.

Initialization

Instantiate a new board to be able to access its GPIO header:

var pi = new RaspberryPi();

If you're using a dependency injection container, you can register the board as a singleton to be used elsewhere in the application:

services.AddSingleton<RaspberryPi>();

Accessing GPIO pins

GPIO pins can be accessed by both their physical location on the board, and/or their Broadcom identifier GPIO#.

var redLED = pi.Pin16;
var sameRedLED = pi.GPIO23;

Moving electrons

SimpleGPIO provides many ways to turn power on or off, depending on your preferences.

The simplest way is to use the built-in helper methods:

redLED.TurnOn();
redLED.TurnOff();

If you prefer assigning values:

redLED.Power = PowerValue.On;
redLED.Power = PowerValue.Off;

At the lowest level, you can directly set the voltage going out of the pin:

redLED.Voltage = Voltage.High; //on
redLED.Voltage = Voltage.Low;  //off

Power Modes

All of the above examples assume the default Direct power mode, where the positive terminal of the LED is connected to the GPIO pin, and the negative terminal is connected to the ground pin.

If, instead, you want to supply constant power by, e.g. the 3v3 pin, and the have the GPIO pin supply (or not supply) resistance, you can use the Differential power mode, where PowerValue.On == Voltage.Low and PowerValue.Off == Voltage.High:

var yellowLED = pi.Pin18;
yellowLED.PowerMode = PowerMode.Differential;
yellowLED.TurnOn();

Timed Power

Pins can be turned on or off for specific lengths of time via the following:

var led = pi.Pin18;
led.TurnOnFor(TimeSpan.FromSeconds(1)); //will turn off after 1 second

led.TurnOn();
led.TurnOffFor(TimeSpan.FromSeconds(0.5)); //will turn back on after 0.5 seconds

Techno Dance Parties

There are some helper methods for toggling values. If power is currently on, toggling it will turn it off; if power is off, toggling will turn it on:

redLED.Toggle();

If you want to repeat the toggle at a given frequency, for a set amount of time, pass in the frequency and a TimeSpan as parameters:

redLED.Toggle(3, TimeSpan.FromSeconds(5));

This will flash the red LED 3 times per second, for 5 seconds.

Alternatively, you can toggle power a set number of times by passing in a number as the second parameter. The following will flash the red LED 3 times over 1.5 seconds:

redLED.Toggle(2, 3);

What about inputs?

Input components such as buttons can be declared the same way as output components, and the Power and Voltage can be read from the new variable:

var button = pi.Pin11;
var isPressed = button.Power == PowerValue.On;

The Direct Power Mode for an input component expects power from e.g. the 3v3 pin, so that electricity flows through to the GPIO pin when the button is depressed.

Reacting to Change

Three methods are provided on a pin that accept an Action as a parameter, so that when that pin's state changes, some subsequent steps can be performed:

var button = pi.Pin11;
var redLED = pi.Pin16;
var buzzer = pi.Pin18;

button.OnPowerOn(() => redLED.TurnOn());
button.OnPowerOff(() => redLED.TurnOff());
redLED.OnPowerChange(() => buzzer.Toggle(1, 1));

Whenever the button is pressed down, the LED will turn on. When the button is released, the LED will turn off. Whenever the LED turns on or off, the buzzer will beep for half a second (reminder why: because Toggle will complete a single cycle at 1Hz, which means 0.5s on, then 0.5s off).

Cleaning up

If you want to turn off everything that was turned on while your application was running, simply Dispose() of your RaspberryPi at the end of your code.

pi.Dispose();

This will turn off and close all open GPIO pins. As with all IDisposables, this also works if you wrap the RaspberryPi you're using in a using(){} block.

Components

Several components have been implemented to help make development easier.

RGB LED

The RGB LED contains a separate pin for red, green, and blue, which can be combined to show different colors.

var redPin = pi.Pin11;
var greenPin = pi.Pin16;
var bluePin = pi.Pin18;

var rgbLED = new RGBLED(redPin, greenPin, bluePin);

rgbLED.TurnRed();
rgbLED.TurnOrange();
rgbLED.TurnYellow();
rgbLED.TurnGreen();
rgbLED.TurnCyan();
rgbLED.TurnBlue();
rgbLED.TurnPurple();
rgbLED.TurnWhite();
rgbLED.TurnOff();

Rotary Encoder

Rotary encoders have actions that can be performed when the dial is turned.

var dial = new RotaryEncoder(clockPin, dataPin);
dial.OnIncrease(() => Console.WriteLine("up"));
dial.OnDecrease(() => Console.WriteLine("down"));

Built-in button functionality is not yet supported.

Seven-Segment Display

Seven-segment displays are currently supported for direct connections to GPIO pins (support for bit-shift registers coming soon) and can be passed a character (all ASCII letters, numbers, and several other symbols)

var display = new SevenSegmentDisplay(centerPin, upperLeftPin, topPin, upperRightPin, lowerLeftPin, bottomPin, lowerRightPin, /*optional*/decimalPin);
display.Show('A');
display.Show('B');
display.Show('C');
display.Show('1');
display.Show('2');
display.Show('3');

Custom characters can also be displayed with:

//same order:          center,        upper-left,     top,           upper-right,    lower-left,    bottom,         lower-right,   decimal (optional)
display.SetPowerValues(PowerValue.On, PowerValue.Off, PowerValue.On, PowerValue.Off, PowerValue.On, PowerValue.Off, PowerValue.On, PowerValue.Off);

Bidirectional Motor

The wiring required to safely run a motor is rather complicated. The code, however, can be quite eloquent. The Motor component assumes an L293D-compatible driver.

var enabledPin = pi.Pin11;
var clockwisePin = pi.Pin13; //name assumes connected to L293D pin 1A
var counterclockwisePin = pi.Pin15; // name assumes connected to L293D pin 2A
var motor = new Motor(enabledPin, clockwisePin, counterclockwisePin);
motor.Direction = Rotation.Clockwise;
motor.Start();
motor.Stop();

motor.Direction = Rotation.Counterclockwise;
motor.Start();
motor.Coast();

motor.TurnClockwise();
motor.TurnCounterclockwise();
motor.TurnClockwiseFor(TimeSpan.FromSeconds(1));
motor.TurnCounterclockwiseFor(TimeSpan.FromSeconds(2), true); //optional parameter to coast instead of stop

If using all 4 inputs on a single driver, declare another Motor to handle inputs 3 and 4.

To drive a single-direction motor (by only having input 1 connected), simply pass null as the counterclockwisePin to the Motor constructor. Counterclockwise methods are not expected to function under this condition.

How can I help?

First, thank you for your enthusiasm! I'd love feedback on how you felt using this. If you had an awesome experience, let me know on Twitter. If you had any problems, feel free to file an issue.

If you're looking to contribute code, but don't have any ideas of your own, there are some specific things I'd love help with over in the Issues tab!